From 36448c9e287935b8c408791bf88b2907292d6c80 Mon Sep 17 00:00:00 2001 From: Christoph Hertzberg Date: Tue, 23 Sep 2014 14:28:23 +0200 Subject: [PATCH] Make constructors explicit if they could lead to unintended implicit conversion --- Eigen/src/Cholesky/LDLT.h | 12 +-- Eigen/src/Cholesky/LLT.h | 12 +-- Eigen/src/CholmodSupport/CholmodSupport.h | 2 +- Eigen/src/Core/ArrayBase.h | 4 +- Eigen/src/Core/ArrayWrapper.h | 4 +- Eigen/src/Core/BandMatrix.h | 6 +- Eigen/src/Core/CoreEvaluators.h | 57 ++++++------ Eigen/src/Core/CwiseUnaryOp.h | 2 +- Eigen/src/Core/CwiseUnaryView.h | 2 +- Eigen/src/Core/DenseBase.h | 4 +- Eigen/src/Core/DenseStorage.h | 16 ++-- Eigen/src/Core/Diagonal.h | 16 ++-- Eigen/src/Core/DiagonalMatrix.h | 20 +++-- Eigen/src/Core/Flagged.h | 4 +- Eigen/src/Core/ForceAlignedAccess.h | 6 +- Eigen/src/Core/GlobalFunctions.h | 4 +- Eigen/src/Core/Inverse.h | 2 +- Eigen/src/Core/Map.h | 2 +- Eigen/src/Core/MapBase.h | 2 +- Eigen/src/Core/Matrix.h | 2 +- Eigen/src/Core/MatrixBase.h | 6 +- Eigen/src/Core/NestByValue.h | 2 +- Eigen/src/Core/NoAlias.h | 4 +- Eigen/src/Core/PermutationMatrix.h | 11 +-- Eigen/src/Core/PlainObjectBase.h | 2 +- Eigen/src/Core/ProductEvaluators.h | 18 ++-- Eigen/src/Core/Redux.h | 2 +- Eigen/src/Core/ReturnByValue.h | 2 +- Eigen/src/Core/Reverse.h | 6 +- Eigen/src/Core/SelfAdjointView.h | 6 +- Eigen/src/Core/Solve.h | 2 +- Eigen/src/Core/Stride.h | 4 +- Eigen/src/Core/Transpose.h | 7 +- Eigen/src/Core/Transpositions.h | 6 +- Eigen/src/Core/TriangularMatrix.h | 35 ++++---- Eigen/src/Core/VectorwiseOp.h | 88 +++++++++++-------- Eigen/src/Core/Visitor.h | 2 +- .../Core/products/SelfadjointRank2Update.h | 8 +- Eigen/src/Core/util/BlasUtil.h | 2 +- Eigen/src/Eigenvalues/ComplexEigenSolver.h | 4 +- Eigen/src/Eigenvalues/ComplexSchur.h | 4 +- Eigen/src/Eigenvalues/EigenSolver.h | 4 +- .../src/Eigenvalues/GeneralizedEigenSolver.h | 4 +- .../GeneralizedSelfAdjointEigenSolver.h | 2 +- .../src/Eigenvalues/HessenbergDecomposition.h | 4 +- Eigen/src/Eigenvalues/RealQZ.h | 4 +- Eigen/src/Eigenvalues/RealSchur.h | 4 +- .../src/Eigenvalues/SelfAdjointEigenSolver.h | 4 +- Eigen/src/Eigenvalues/Tridiagonalization.h | 4 +- Eigen/src/Geometry/Homogeneous.h | 8 +- Eigen/src/Geometry/Quaternion.h | 6 +- Eigen/src/Geometry/Rotation2D.h | 2 +- .../BasicPreconditioners.h | 4 +- Eigen/src/IterativeLinearSolvers/BiCGSTAB.h | 2 +- .../ConjugateGradient.h | 2 +- .../IterativeLinearSolvers/IncompleteLUT.h | 2 +- .../IterativeSolverBase.h | 2 +- Eigen/src/LU/FullPivLU.h | 2 +- Eigen/src/LU/PartialPivLU.h | 4 +- Eigen/src/PaStiXSupport/PaStiXSupport.h | 6 +- Eigen/src/PardisoSupport/PardisoSupport.h | 6 +- Eigen/src/QR/ColPivHouseholderQR.h | 2 +- Eigen/src/QR/FullPivHouseholderQR.h | 2 +- Eigen/src/QR/HouseholderQR.h | 2 +- Eigen/src/SPQRSupport/SuiteSparseQRSupport.h | 10 +-- Eigen/src/SVD/JacobiSVD.h | 4 +- Eigen/src/SVD/UpperBidiagonalization.h | 4 +- Eigen/src/SparseCholesky/SimplicialCholesky.h | 16 ++-- Eigen/src/SparseCore/AmbiVector.h | 4 +- Eigen/src/SparseCore/CompressedStorage.h | 2 +- Eigen/src/SparseCore/MappedSparseMatrix.h | 2 +- Eigen/src/SparseCore/SparseBlock.h | 4 +- Eigen/src/SparseCore/SparseCwiseBinaryOp.h | 8 +- Eigen/src/SparseCore/SparseCwiseUnaryOp.h | 4 +- Eigen/src/SparseCore/SparseDenseProduct.h | 9 +- Eigen/src/SparseCore/SparseDiagonalProduct.h | 4 +- Eigen/src/SparseCore/SparseMatrix.h | 6 +- Eigen/src/SparseCore/SparseMatrixBase.h | 15 ++-- Eigen/src/SparseCore/SparsePermutation.h | 4 +- Eigen/src/SparseCore/SparseProduct.h | 2 +- Eigen/src/SparseCore/SparseSelfAdjointView.h | 6 +- Eigen/src/SparseCore/SparseTranspose.h | 2 +- Eigen/src/SparseCore/SparseTriangularView.h | 4 +- Eigen/src/SparseCore/SparseVector.h | 12 +-- Eigen/src/SparseCore/SparseView.h | 6 +- Eigen/src/SparseLU/SparseLU.h | 6 +- Eigen/src/SparseQR/SparseQR.h | 6 +- Eigen/src/SuperLUSupport/SuperLUSupport.h | 2 +- Eigen/src/UmfPackSupport/UmfPackSupport.h | 2 +- Eigen/src/misc/Kernel.h | 2 +- Eigen/src/plugins/ArrayCwiseUnaryOps.h | 80 ++++++++++------- Eigen/src/plugins/CommonCwiseUnaryOps.h | 37 ++++---- Eigen/src/plugins/MatrixCwiseUnaryOps.h | 26 +++--- 93 files changed, 416 insertions(+), 355 deletions(-) diff --git a/Eigen/src/Cholesky/LDLT.h b/Eigen/src/Cholesky/LDLT.h index 32c770654..b4016cd6c 100644 --- a/Eigen/src/Cholesky/LDLT.h +++ b/Eigen/src/Cholesky/LDLT.h @@ -85,7 +85,7 @@ template class LDLT * according to the specified problem \a size. * \sa LDLT() */ - LDLT(Index size) + explicit LDLT(Index size) : m_matrix(size, size), m_transpositions(size), m_temporary(size), @@ -98,7 +98,7 @@ template class LDLT * This calculates the decomposition for the input \a matrix. * \sa LDLT(Index size) */ - LDLT(const MatrixType& matrix) + explicit LDLT(const MatrixType& matrix) : m_matrix(matrix.rows(), matrix.cols()), m_transpositions(matrix.rows()), m_temporary(matrix.rows()), @@ -406,16 +406,16 @@ template struct LDLT_Traits { typedef const TriangularView MatrixL; typedef const TriangularView MatrixU; - static inline MatrixL getL(const MatrixType& m) { return m; } - static inline MatrixU getU(const MatrixType& m) { return m.adjoint(); } + static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); } + static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); } }; template struct LDLT_Traits { typedef const TriangularView MatrixL; typedef const TriangularView MatrixU; - static inline MatrixL getL(const MatrixType& m) { return m.adjoint(); } - static inline MatrixU getU(const MatrixType& m) { return m; } + static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); } + static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); } }; } // end namespace internal diff --git a/Eigen/src/Cholesky/LLT.h b/Eigen/src/Cholesky/LLT.h index cb9e0eb7b..90194e64d 100644 --- a/Eigen/src/Cholesky/LLT.h +++ b/Eigen/src/Cholesky/LLT.h @@ -83,10 +83,10 @@ template class LLT * according to the specified problem \a size. * \sa LLT() */ - LLT(Index size) : m_matrix(size, size), + explicit LLT(Index size) : m_matrix(size, size), m_isInitialized(false) {} - LLT(const MatrixType& matrix) + explicit LLT(const MatrixType& matrix) : m_matrix(matrix.rows(), matrix.cols()), m_isInitialized(false) { @@ -351,8 +351,8 @@ template struct LLT_Traits { typedef const TriangularView MatrixL; typedef const TriangularView MatrixU; - static inline MatrixL getL(const MatrixType& m) { return m; } - static inline MatrixU getU(const MatrixType& m) { return m.adjoint(); } + static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); } + static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); } static bool inplace_decomposition(MatrixType& m) { return llt_inplace::blocked(m)==-1; } }; @@ -361,8 +361,8 @@ template struct LLT_Traits { typedef const TriangularView MatrixL; typedef const TriangularView MatrixU; - static inline MatrixL getL(const MatrixType& m) { return m.adjoint(); } - static inline MatrixU getU(const MatrixType& m) { return m; } + static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); } + static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); } static bool inplace_decomposition(MatrixType& m) { return llt_inplace::blocked(m)==-1; } }; diff --git a/Eigen/src/CholmodSupport/CholmodSupport.h b/Eigen/src/CholmodSupport/CholmodSupport.h index 3524ffb2d..0c3b86dd2 100644 --- a/Eigen/src/CholmodSupport/CholmodSupport.h +++ b/Eigen/src/CholmodSupport/CholmodSupport.h @@ -180,7 +180,7 @@ class CholmodBase : public SparseSolverBase cholmod_start(&m_cholmod); } - CholmodBase(const MatrixType& matrix) + explicit CholmodBase(const MatrixType& matrix) : m_cholmodFactor(0), m_info(Success) { m_shiftOffset[0] = m_shiftOffset[1] = RealScalar(0.0); diff --git a/Eigen/src/Core/ArrayBase.h b/Eigen/src/Core/ArrayBase.h index 48a0006d5..b37b49ac4 100644 --- a/Eigen/src/Core/ArrayBase.h +++ b/Eigen/src/Core/ArrayBase.h @@ -158,9 +158,9 @@ template class ArrayBase /** \returns an \link Eigen::MatrixBase Matrix \endlink expression of this array * \sa MatrixBase::array() */ EIGEN_DEVICE_FUNC - MatrixWrapper matrix() { return derived(); } + MatrixWrapper matrix() { return MatrixWrapper(derived()); } EIGEN_DEVICE_FUNC - const MatrixWrapper matrix() const { return derived(); } + const MatrixWrapper matrix() const { return MatrixWrapper(derived()); } // template // inline void evalTo(Dest& dst) const { dst = matrix(); } diff --git a/Eigen/src/Core/ArrayWrapper.h b/Eigen/src/Core/ArrayWrapper.h index ed5210272..0b89c58cb 100644 --- a/Eigen/src/Core/ArrayWrapper.h +++ b/Eigen/src/Core/ArrayWrapper.h @@ -55,7 +55,7 @@ class ArrayWrapper : public ArrayBase > typedef typename internal::nested::type NestedExpressionType; EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE ArrayWrapper(ExpressionType& matrix) : m_expression(matrix) {} + explicit EIGEN_STRONG_INLINE ArrayWrapper(ExpressionType& matrix) : m_expression(matrix) {} EIGEN_DEVICE_FUNC inline Index rows() const { return m_expression.rows(); } @@ -198,7 +198,7 @@ class MatrixWrapper : public MatrixBase > typedef typename internal::nested::type NestedExpressionType; EIGEN_DEVICE_FUNC - inline MatrixWrapper(ExpressionType& a_matrix) : m_expression(a_matrix) {} + explicit inline MatrixWrapper(ExpressionType& a_matrix) : m_expression(a_matrix) {} EIGEN_DEVICE_FUNC inline Index rows() const { return m_expression.rows(); } diff --git a/Eigen/src/Core/BandMatrix.h b/Eigen/src/Core/BandMatrix.h index b0ebe1160..e59ee3da9 100644 --- a/Eigen/src/Core/BandMatrix.h +++ b/Eigen/src/Core/BandMatrix.h @@ -204,7 +204,7 @@ class BandMatrix : public BandMatrixBase::Index Index; typedef typename internal::traits::CoefficientsType CoefficientsType; - inline BandMatrix(Index rows=Rows, Index cols=Cols, Index supers=Supers, Index subs=Subs) + explicit inline BandMatrix(Index rows=Rows, Index cols=Cols, Index supers=Supers, Index subs=Subs) : m_coeffs(1+supers+subs,cols), m_rows(rows), m_supers(supers), m_subs(subs) { @@ -266,7 +266,7 @@ class BandMatrixWrapper : public BandMatrixBase::CoefficientsType CoefficientsType; typedef typename internal::traits::Index Index; - inline BandMatrixWrapper(const CoefficientsType& coeffs, Index rows=_Rows, Index cols=_Cols, Index supers=_Supers, Index subs=_Subs) + explicit inline BandMatrixWrapper(const CoefficientsType& coeffs, Index rows=_Rows, Index cols=_Cols, Index supers=_Supers, Index subs=_Subs) : m_coeffs(coeffs), m_rows(rows), m_supers(supers), m_subs(subs) { @@ -314,7 +314,7 @@ class TridiagonalMatrix : public BandMatrix Base; typedef typename Base::Index Index; public: - TridiagonalMatrix(Index size = Size) : Base(size,size,Options&SelfAdjoint?0:1,1) {} + explicit TridiagonalMatrix(Index size = Size) : Base(size,size,Options&SelfAdjoint?0:1,1) {} inline typename Base::template DiagonalIntReturnType<1>::Type super() { return Base::template diagonal<1>(); } diff --git a/Eigen/src/Core/CoreEvaluators.h b/Eigen/src/Core/CoreEvaluators.h index 09a83a382..ab4320c2a 100644 --- a/Eigen/src/Core/CoreEvaluators.h +++ b/Eigen/src/Core/CoreEvaluators.h @@ -34,6 +34,11 @@ template struct storage_kind_to_shape; template<> struct storage_kind_to_shape { typedef DenseShape Shape; }; + +// FIXME Is this necessary? And why was it not before refactoring??? +template<> struct storage_kind_to_shape { typedef PermutationShape Shape; }; + + // Evaluators have to be specialized with respect to various criteria such as: // - storage/structure/shape // - scalar type @@ -87,7 +92,7 @@ template struct evaluator : public unary_evaluator { typedef unary_evaluator Base; - evaluator(const T& xpr) : Base(xpr) {} + explicit evaluator(const T& xpr) : Base(xpr) {} }; @@ -150,7 +155,7 @@ struct evaluator > : RowsAtCompileTime) {} - evaluator(const PlainObjectType& m) + explicit evaluator(const PlainObjectType& m) : m_data(m.data()), m_outerStride(IsVectorAtCompileTime ? 0 : m.outerStride()) { } @@ -242,7 +247,7 @@ struct evaluator > evaluator() {} - evaluator(const XprType& m) + explicit evaluator(const XprType& m) : evaluator >(m) { } }; @@ -260,7 +265,7 @@ struct unary_evaluator, IndexBased> Flags = evaluator::Flags ^ RowMajorBit }; - unary_evaluator(const XprType& t) : m_argImpl(t.nestedExpression()) {} + explicit unary_evaluator(const XprType& t) : m_argImpl(t.nestedExpression()) {} typedef typename XprType::Index Index; typedef typename XprType::Scalar Scalar; @@ -337,7 +342,7 @@ struct evaluator > | (functor_traits::IsRepeatable ? 0 : EvalBeforeNestingBit) // FIXME EvalBeforeNestingBit should be needed anymore }; - evaluator(const XprType& n) + explicit evaluator(const XprType& n) : m_functor(n.functor()) { } @@ -387,7 +392,7 @@ struct unary_evaluator, IndexBased > | (functor_traits::PacketAccess ? PacketAccessBit : 0)) }; - unary_evaluator(const XprType& op) + explicit unary_evaluator(const XprType& op) : m_functor(op.functor()), m_argImpl(op.nestedExpression()) { } @@ -433,7 +438,7 @@ struct evaluator > typedef CwiseBinaryOp XprType; typedef binary_evaluator > Base; - evaluator(const XprType& xpr) : Base(xpr) {} + explicit evaluator(const XprType& xpr) : Base(xpr) {} }; template @@ -461,7 +466,7 @@ struct binary_evaluator, IndexBased, IndexBase Flags = (Flags0 & ~RowMajorBit) | (LhsFlags & RowMajorBit) }; - binary_evaluator(const XprType& xpr) + explicit binary_evaluator(const XprType& xpr) : m_functor(xpr.functor()), m_lhsImpl(xpr.lhs()), m_rhsImpl(xpr.rhs()) @@ -515,7 +520,7 @@ struct unary_evaluator, IndexBased> Flags = (evaluator::Flags & (HereditaryBits | LinearAccessBit | DirectAccessBit)) }; - unary_evaluator(const XprType& op) + explicit unary_evaluator(const XprType& op) : m_unaryOp(op.functor()), m_argImpl(op.nestedExpression()) { } @@ -573,7 +578,7 @@ struct mapbase_evaluator : evaluator_base CoeffReadCost = NumTraits::ReadCost }; - mapbase_evaluator(const XprType& map) + explicit mapbase_evaluator(const XprType& map) : m_data(const_cast(map.data())), m_xpr(map) { @@ -663,7 +668,7 @@ struct evaluator > Flags = KeepsPacketAccess ? int(Flags2) : (int(Flags2) & ~PacketAccessBit) }; - evaluator(const XprType& map) + explicit evaluator(const XprType& map) : mapbase_evaluator(map) { } }; @@ -680,7 +685,7 @@ struct evaluator > Flags = evaluator >::Flags }; - evaluator(const XprType& ref) + explicit evaluator(const XprType& ref) : mapbase_evaluator(ref) { } }; @@ -731,7 +736,7 @@ struct evaluator > Flags = Flags0 | FlagsLinearAccessBit | FlagsRowMajorBit }; typedef block_evaluator block_evaluator_type; - evaluator(const XprType& block) : block_evaluator_type(block) {} + explicit evaluator(const XprType& block) : block_evaluator_type(block) {} }; // no direct-access => dispatch to a unary evaluator @@ -741,7 +746,7 @@ struct block_evaluator XprType; - block_evaluator(const XprType& block) + explicit block_evaluator(const XprType& block) : unary_evaluator(block) {} }; @@ -752,7 +757,7 @@ struct unary_evaluator, IndexBa { typedef Block XprType; - unary_evaluator(const XprType& block) + explicit unary_evaluator(const XprType& block) : m_argImpl(block.nestedExpression()), m_startRow(block.startRow()), m_startCol(block.startCol()) @@ -831,7 +836,7 @@ struct block_evaluator XprType; - block_evaluator(const XprType& block) + explicit block_evaluator(const XprType& block) : mapbase_evaluator(block) { // FIXME this should be an internal assertion @@ -857,7 +862,7 @@ struct evaluator > Flags = (unsigned int)evaluator::Flags & evaluator::Flags & HereditaryBits }; - evaluator(const XprType& select) + explicit evaluator(const XprType& select) : m_conditionImpl(select.conditionMatrix()), m_thenImpl(select.thenMatrix()), m_elseImpl(select.elseMatrix()) @@ -911,7 +916,7 @@ struct unary_evaluator > Flags = (evaluator::Flags & HereditaryBits & ~RowMajorBit) | (traits::Flags & RowMajorBit) }; - unary_evaluator(const XprType& replicate) + explicit unary_evaluator(const XprType& replicate) : m_arg(replicate.nestedExpression()), m_argImpl(m_arg), m_rows(replicate.nestedExpression().rows()), @@ -975,7 +980,7 @@ struct evaluator > Flags = (traits::Flags&RowMajorBit) | (evaluator::Flags&HereditaryBits) }; - evaluator(const XprType expr) + explicit evaluator(const XprType expr) : m_expr(expr) {} @@ -1012,7 +1017,7 @@ struct evaluator_wrapper_base Flags = evaluator::Flags }; - evaluator_wrapper_base(const ArgType& arg) : m_argImpl(arg) {} + explicit evaluator_wrapper_base(const ArgType& arg) : m_argImpl(arg) {} typedef typename ArgType::Index Index; typedef typename ArgType::Scalar Scalar; @@ -1074,7 +1079,7 @@ struct unary_evaluator > { typedef MatrixWrapper XprType; - unary_evaluator(const XprType& wrapper) + explicit unary_evaluator(const XprType& wrapper) : evaluator_wrapper_base >(wrapper.nestedExpression()) { } }; @@ -1085,7 +1090,7 @@ struct unary_evaluator > { typedef ArrayWrapper XprType; - unary_evaluator(const XprType& wrapper) + explicit unary_evaluator(const XprType& wrapper) : evaluator_wrapper_base >(wrapper.nestedExpression()) { } }; @@ -1131,7 +1136,7 @@ struct unary_evaluator > }; typedef internal::reverse_packet_cond reverse_packet; - unary_evaluator(const XprType& reverse) + explicit unary_evaluator(const XprType& reverse) : m_argImpl(reverse.nestedExpression()), m_rows(ReverseRow ? reverse.nestedExpression().rows() : 0), m_cols(ReverseCol ? reverse.nestedExpression().cols() : 0) @@ -1212,7 +1217,7 @@ struct evaluator > Flags = (unsigned int)evaluator::Flags & (HereditaryBits | LinearAccessBit | DirectAccessBit) & ~RowMajorBit }; - evaluator(const XprType& diagonal) + explicit evaluator(const XprType& diagonal) : m_argImpl(diagonal.nestedExpression()), m_index(diagonal.index()) { } @@ -1275,7 +1280,7 @@ class EvalToTemp typedef typename dense_xpr_base::type Base; EIGEN_GENERIC_PUBLIC_INTERFACE(EvalToTemp) - EvalToTemp(const ArgType& arg) + explicit EvalToTemp(const ArgType& arg) : m_arg(arg) { } @@ -1309,7 +1314,7 @@ struct evaluator > typedef evaluator type; typedef evaluator nestedType; - evaluator(const XprType& xpr) + explicit evaluator(const XprType& xpr) : m_result(xpr.rows(), xpr.cols()) { ::new (static_cast(this)) Base(m_result); diff --git a/Eigen/src/Core/CwiseUnaryOp.h b/Eigen/src/Core/CwiseUnaryOp.h index 79a872934..708e3e818 100644 --- a/Eigen/src/Core/CwiseUnaryOp.h +++ b/Eigen/src/Core/CwiseUnaryOp.h @@ -63,7 +63,7 @@ class CwiseUnaryOp : internal::no_assignment_operator, typedef typename internal::remove_all::type NestedExpression; EIGEN_DEVICE_FUNC - inline CwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp()) + explicit inline CwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp()) : m_xpr(xpr), m_functor(func) {} EIGEN_DEVICE_FUNC diff --git a/Eigen/src/Core/CwiseUnaryView.h b/Eigen/src/Core/CwiseUnaryView.h index 71249a39c..61fd8ee35 100644 --- a/Eigen/src/Core/CwiseUnaryView.h +++ b/Eigen/src/Core/CwiseUnaryView.h @@ -63,7 +63,7 @@ class CwiseUnaryView : public CwiseUnaryViewImpl::type NestedExpression; - inline CwiseUnaryView(const MatrixType& mat, const ViewOp& func = ViewOp()) + explicit inline CwiseUnaryView(const MatrixType& mat, const ViewOp& func = ViewOp()) : m_matrix(mat), m_functor(func) {} EIGEN_INHERIT_ASSIGNMENT_OPERATORS(CwiseUnaryView) diff --git a/Eigen/src/Core/DenseBase.h b/Eigen/src/Core/DenseBase.h index 6078af553..101ef6f20 100644 --- a/Eigen/src/Core/DenseBase.h +++ b/Eigen/src/Core/DenseBase.h @@ -275,6 +275,7 @@ template class DenseBase // TODO flagged is temporarly disabled. It seems useless now template + EIGEN_DEPRECATED const Derived& flagged() const { return derived(); } @@ -282,8 +283,9 @@ template class DenseBase EIGEN_DEVICE_FUNC CommaInitializer operator<< (const DenseBase& other); + typedef Transpose TransposeReturnType; EIGEN_DEVICE_FUNC - Eigen::Transpose transpose(); + TransposeReturnType transpose(); typedef typename internal::add_const >::type ConstTransposeReturnType; EIGEN_DEVICE_FUNC ConstTransposeReturnType transpose() const; diff --git a/Eigen/src/Core/DenseStorage.h b/Eigen/src/Core/DenseStorage.h index 59f515495..852648639 100644 --- a/Eigen/src/Core/DenseStorage.h +++ b/Eigen/src/Core/DenseStorage.h @@ -130,7 +130,7 @@ template class DenseSt public: EIGEN_DEVICE_FUNC DenseStorage() {} EIGEN_DEVICE_FUNC - DenseStorage(internal::constructor_without_unaligned_array_assert) + explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(internal::constructor_without_unaligned_array_assert()) {} EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other.m_data) {} @@ -155,7 +155,7 @@ template class DenseStorage class DenseStorage class DenseStorage class DenseStorage class DenseStorage(size)), m_rows(nbRows), m_cols(nbCols) @@ -350,7 +350,7 @@ template class DenseStorage(size)), m_cols(nbCols) { EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN } DenseStorage(const DenseStorage& other) @@ -416,7 +416,7 @@ template class DenseStorage(size)), m_rows(nbRows) { EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN } DenseStorage(const DenseStorage& other) diff --git a/Eigen/src/Core/Diagonal.h b/Eigen/src/Core/Diagonal.h index 1ffcd97f9..ba7ddbb14 100644 --- a/Eigen/src/Core/Diagonal.h +++ b/Eigen/src/Core/Diagonal.h @@ -70,7 +70,7 @@ template class Diagonal EIGEN_DENSE_PUBLIC_INTERFACE(Diagonal) EIGEN_DEVICE_FUNC - inline Diagonal(MatrixType& matrix, Index a_index = DiagIndex) : m_matrix(matrix), m_index(a_index) {} + explicit inline Diagonal(MatrixType& matrix, Index a_index = DiagIndex) : m_matrix(matrix), m_index(a_index) {} EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Diagonal) @@ -189,7 +189,7 @@ template inline typename MatrixBase::DiagonalReturnType MatrixBase::diagonal() { - return derived(); + return DiagonalReturnType(derived()); } /** This is the const version of diagonal(). */ @@ -238,20 +238,20 @@ MatrixBase::diagonal(Index index) const * * \sa MatrixBase::diagonal(), class Diagonal */ template -template -inline typename MatrixBase::template DiagonalIndexReturnType::Type +template +inline typename MatrixBase::template DiagonalIndexReturnType::Type MatrixBase::diagonal() { - return derived(); + return typename DiagonalIndexReturnType::Type(derived()); } /** This is the const version of diagonal(). */ template -template -inline typename MatrixBase::template ConstDiagonalIndexReturnType::Type +template +inline typename MatrixBase::template ConstDiagonalIndexReturnType::Type MatrixBase::diagonal() const { - return derived(); + return typename ConstDiagonalIndexReturnType::Type(derived()); } } // end namespace Eigen diff --git a/Eigen/src/Core/DiagonalMatrix.h b/Eigen/src/Core/DiagonalMatrix.h index 44c249aa6..e3dc71336 100644 --- a/Eigen/src/Core/DiagonalMatrix.h +++ b/Eigen/src/Core/DiagonalMatrix.h @@ -63,24 +63,26 @@ class DiagonalBase : public EigenBase return Product(derived(),matrix.derived()); } + typedef DiagonalWrapper, const DiagonalVectorType> > InverseReturnType; EIGEN_DEVICE_FUNC - inline const DiagonalWrapper, const DiagonalVectorType> > + inline const InverseReturnType inverse() const { - return diagonal().cwiseInverse(); + return InverseReturnType(diagonal().cwiseInverse()); } + typedef DiagonalWrapper, const DiagonalVectorType> > ScalarMultipleReturnType; EIGEN_DEVICE_FUNC - inline const DiagonalWrapper, const DiagonalVectorType> > + inline const ScalarMultipleReturnType operator*(const Scalar& scalar) const { - return diagonal() * scalar; + return ScalarMultipleReturnType(diagonal() * scalar); } EIGEN_DEVICE_FUNC - friend inline const DiagonalWrapper, const DiagonalVectorType> > + friend inline const ScalarMultipleReturnType operator*(const Scalar& scalar, const DiagonalBase& other) { - return other.diagonal() * scalar; + return ScalarMultipleReturnType(other.diagonal() * scalar); } }; @@ -144,7 +146,7 @@ class DiagonalMatrix /** Constructs a diagonal matrix with given dimension */ EIGEN_DEVICE_FUNC - inline DiagonalMatrix(Index dim) : m_diagonal(dim) {} + explicit inline DiagonalMatrix(Index dim) : m_diagonal(dim) {} /** 2D constructor. */ EIGEN_DEVICE_FUNC @@ -253,7 +255,7 @@ class DiagonalWrapper /** Constructor from expression of diagonal coefficients to wrap. */ EIGEN_DEVICE_FUNC - inline DiagonalWrapper(DiagonalVectorType& a_diagonal) : m_diagonal(a_diagonal) {} + explicit inline DiagonalWrapper(DiagonalVectorType& a_diagonal) : m_diagonal(a_diagonal) {} /** \returns a const reference to the wrapped expression of diagonal coefficients. */ EIGEN_DEVICE_FUNC @@ -276,7 +278,7 @@ template inline const DiagonalWrapper MatrixBase::asDiagonal() const { - return derived(); + return DiagonalWrapper(derived()); } /** \returns true if *this is approximately equal to a diagonal matrix, diff --git a/Eigen/src/Core/Flagged.h b/Eigen/src/Core/Flagged.h index 1f2955fc1..6ce11edf3 100644 --- a/Eigen/src/Core/Flagged.h +++ b/Eigen/src/Core/Flagged.h @@ -48,7 +48,7 @@ template clas ExpressionType, const ExpressionType&>::type ExpressionTypeNested; typedef typename ExpressionType::InnerIterator InnerIterator; - inline Flagged(const ExpressionType& matrix) : m_matrix(matrix) {} + explicit inline Flagged(const ExpressionType& matrix) : m_matrix(matrix) {} inline Index rows() const { return m_matrix.rows(); } inline Index cols() const { return m_matrix.cols(); } @@ -132,7 +132,7 @@ template inline const Flagged DenseBase::flagged() const { - return derived(); + return Flagged(derived()); } } // end namespace Eigen diff --git a/Eigen/src/Core/ForceAlignedAccess.h b/Eigen/src/Core/ForceAlignedAccess.h index 807c7a293..065acfa64 100644 --- a/Eigen/src/Core/ForceAlignedAccess.h +++ b/Eigen/src/Core/ForceAlignedAccess.h @@ -39,7 +39,7 @@ template class ForceAlignedAccess typedef typename internal::dense_xpr_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(ForceAlignedAccess) - inline ForceAlignedAccess(const ExpressionType& matrix) : m_expression(matrix) {} + explicit inline ForceAlignedAccess(const ExpressionType& matrix) : m_expression(matrix) {} inline Index rows() const { return m_expression.rows(); } inline Index cols() const { return m_expression.cols(); } @@ -127,7 +127,7 @@ template inline typename internal::add_const_on_value_type,Derived&>::type>::type MatrixBase::forceAlignedAccessIf() const { - return derived(); + return derived(); // FIXME This should not work but apparently is never used } /** \returns an expression of *this with forced aligned access if \a Enable is true. @@ -138,7 +138,7 @@ template inline typename internal::conditional,Derived&>::type MatrixBase::forceAlignedAccessIf() { - return derived(); + return derived(); // FIXME This should not work but apparently is never used } } // end namespace Eigen diff --git a/Eigen/src/Core/GlobalFunctions.h b/Eigen/src/Core/GlobalFunctions.h index 2067a2a6e..ee67b7d3c 100644 --- a/Eigen/src/Core/GlobalFunctions.h +++ b/Eigen/src/Core/GlobalFunctions.h @@ -15,7 +15,7 @@ template \ inline const Eigen::CwiseUnaryOp, const Derived> \ NAME(const Eigen::ArrayBase& x) { \ - return x.derived(); \ + return Eigen::CwiseUnaryOp, const Derived>(x.derived()); \ } #define EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(NAME,FUNCTOR) \ @@ -30,7 +30,7 @@ { \ static inline typename NAME##_retval >::type run(const Eigen::ArrayBase& x) \ { \ - return x.derived(); \ + return typename NAME##_retval >::type(x.derived()); \ } \ }; diff --git a/Eigen/src/Core/Inverse.h b/Eigen/src/Core/Inverse.h index 5cfa7e50c..706796b78 100644 --- a/Eigen/src/Core/Inverse.h +++ b/Eigen/src/Core/Inverse.h @@ -51,7 +51,7 @@ public: typedef typename internal::nested::type XprTypeNested; typedef typename internal::remove_all::type XprTypeNestedCleaned; - Inverse(const XprType &xpr) + explicit Inverse(const XprType &xpr) : m_xpr(xpr) {} diff --git a/Eigen/src/Core/Map.h b/Eigen/src/Core/Map.h index 87c1787bf..098f1c096 100644 --- a/Eigen/src/Core/Map.h +++ b/Eigen/src/Core/Map.h @@ -122,7 +122,7 @@ template class Ma * \param a_stride optional Stride object, passing the strides. */ EIGEN_DEVICE_FUNC - inline Map(PointerArgType dataPtr, const StrideType& a_stride = StrideType()) + explicit inline Map(PointerArgType dataPtr, const StrideType& a_stride = StrideType()) : Base(cast_to_pointer_type(dataPtr)), m_stride(a_stride) { PlainObjectType::Base::_check_template_params(); diff --git a/Eigen/src/Core/MapBase.h b/Eigen/src/Core/MapBase.h index 6d3b344e8..3e68b1e91 100644 --- a/Eigen/src/Core/MapBase.h +++ b/Eigen/src/Core/MapBase.h @@ -128,7 +128,7 @@ template class MapBase } EIGEN_DEVICE_FUNC - inline MapBase(PointerType dataPtr) : m_data(dataPtr), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime) + explicit inline MapBase(PointerType dataPtr) : m_data(dataPtr), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime) { EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) checkSanity(); diff --git a/Eigen/src/Core/Matrix.h b/Eigen/src/Core/Matrix.h index 8a5821548..bb6c75387 100644 --- a/Eigen/src/Core/Matrix.h +++ b/Eigen/src/Core/Matrix.h @@ -214,7 +214,7 @@ class Matrix // FIXME is it still needed EIGEN_DEVICE_FUNC - Matrix(internal::constructor_without_unaligned_array_assert) + explicit Matrix(internal::constructor_without_unaligned_array_assert) : Base(internal::constructor_without_unaligned_array_assert()) { Base::_check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED } diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h index 9dbbd6fb5..048060e6b 100644 --- a/Eigen/src/Core/MatrixBase.h +++ b/Eigen/src/Core/MatrixBase.h @@ -327,7 +327,7 @@ template class MatrixBase NoAlias noalias(); - // TODO forceAlignedAccess is temporarly disabled + // TODO forceAlignedAccess is temporarily disabled // Need to find a nicer workaround. inline const Derived& forceAlignedAccess() const { return derived(); } inline Derived& forceAlignedAccess() { return derived(); } @@ -343,10 +343,10 @@ template class MatrixBase /** \returns an \link Eigen::ArrayBase Array \endlink expression of this matrix * \sa ArrayBase::matrix() */ - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ArrayWrapper array() { return derived(); } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ArrayWrapper array() { return ArrayWrapper(derived()); } /** \returns a const \link Eigen::ArrayBase Array \endlink expression of this matrix * \sa ArrayBase::matrix() */ - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ArrayWrapper array() const { return derived(); } + EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ArrayWrapper array() const { return ArrayWrapper(derived()); } /////////// LU module /////////// diff --git a/Eigen/src/Core/NestByValue.h b/Eigen/src/Core/NestByValue.h index a893b1761..248dd8eb0 100644 --- a/Eigen/src/Core/NestByValue.h +++ b/Eigen/src/Core/NestByValue.h @@ -40,7 +40,7 @@ template class NestByValue typedef typename internal::dense_xpr_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(NestByValue) - inline NestByValue(const ExpressionType& matrix) : m_expression(matrix) {} + explicit inline NestByValue(const ExpressionType& matrix) : m_expression(matrix) {} inline Index rows() const { return m_expression.rows(); } inline Index cols() const { return m_expression.cols(); } diff --git a/Eigen/src/Core/NoAlias.h b/Eigen/src/Core/NoAlias.h index 097c9c062..0ade75255 100644 --- a/Eigen/src/Core/NoAlias.h +++ b/Eigen/src/Core/NoAlias.h @@ -33,7 +33,7 @@ class NoAlias public: typedef typename ExpressionType::Scalar Scalar; - NoAlias(ExpressionType& expression) : m_expression(expression) {} + explicit NoAlias(ExpressionType& expression) : m_expression(expression) {} template EIGEN_DEVICE_FUNC @@ -100,7 +100,7 @@ class NoAlias template NoAlias MatrixBase::noalias() { - return derived(); + return NoAlias(derived()); } } // end namespace Eigen diff --git a/Eigen/src/Core/PermutationMatrix.h b/Eigen/src/Core/PermutationMatrix.h index 200518173..98c83047a 100644 --- a/Eigen/src/Core/PermutationMatrix.h +++ b/Eigen/src/Core/PermutationMatrix.h @@ -73,6 +73,7 @@ class PermutationBase : public EigenBase typedef PermutationMatrix PlainPermutationType; using Base::derived; + typedef Transpose TransposeReturnType; #endif /** Copies the other permutation into *this */ @@ -198,14 +199,14 @@ class PermutationBase : public EigenBase * * \note \note_try_to_help_rvo */ - inline Transpose inverse() const - { return derived(); } + inline TransposeReturnType inverse() const + { return TransposeReturnType(derived()); } /** \returns the tranpose permutation matrix. * * \note \note_try_to_help_rvo */ - inline Transpose transpose() const - { return derived(); } + inline TransposeReturnType transpose() const + { return TransposeReturnType(derived()); } /**** multiplication helpers to hopefully get RVO ****/ @@ -301,7 +302,7 @@ class PermutationMatrix : public PermutationBase::type // FIXME is it still needed ? /** \internal */ EIGEN_DEVICE_FUNC - PlainObjectBase(internal::constructor_without_unaligned_array_assert) + explicit PlainObjectBase(internal::constructor_without_unaligned_array_assert) : m_storage(internal::constructor_without_unaligned_array_assert()) { // _check_template_params(); EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED diff --git a/Eigen/src/Core/ProductEvaluators.h b/Eigen/src/Core/ProductEvaluators.h index f880e7696..69e569908 100644 --- a/Eigen/src/Core/ProductEvaluators.h +++ b/Eigen/src/Core/ProductEvaluators.h @@ -35,7 +35,7 @@ struct evaluator > typedef evaluator type; typedef evaluator nestedType; - evaluator(const XprType& xpr) : Base(xpr) {} + explicit evaluator(const XprType& xpr) : Base(xpr) {} }; // Catch scalar * ( A * B ) and transform it to (A*scalar) * B @@ -50,7 +50,7 @@ struct evaluator, const Produ typedef evaluator type; typedef evaluator nestedType; - evaluator(const XprType& xpr) + explicit evaluator(const XprType& xpr) : Base(xpr.functor().m_other * xpr.nestedExpression().lhs() * xpr.nestedExpression().rhs()) {} }; @@ -66,7 +66,7 @@ struct evaluator, DiagIndex> > typedef evaluator type; typedef evaluator nestedType; - evaluator(const XprType& xpr) + explicit evaluator(const XprType& xpr) : Base(Diagonal, DiagIndex>( Product(xpr.nestedExpression().lhs(), xpr.nestedExpression().rhs()), xpr.index() )) @@ -103,7 +103,7 @@ struct product_evaluator, ProductTag, LhsShape typedef typename XprType::PlainObject PlainObject; typedef typename evaluator::type Base; - product_evaluator(const XprType& xpr) + explicit product_evaluator(const XprType& xpr) : m_result(xpr.rows(), xpr.cols()) { ::new (static_cast(this)) Base(m_result); @@ -242,7 +242,7 @@ struct generic_product_impl struct sub { template void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() -= src; } }; struct adds { Scalar m_scale; - adds(const Scalar& s) : m_scale(s) {} + explicit adds(const Scalar& s) : m_scale(s) {} template void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() += m_scale * src; } @@ -377,7 +377,7 @@ struct product_evaluator, ProductTag, DenseShape, typedef typename XprType::PacketScalar PacketScalar; typedef typename XprType::PacketReturnType PacketReturnType; - product_evaluator(const XprType& xpr) + explicit product_evaluator(const XprType& xpr) : m_lhs(xpr.lhs()), m_rhs(xpr.rhs()), m_lhsImpl(m_lhs), // FIXME the creation of the evaluator objects should result in a no-op, but check that! @@ -508,7 +508,7 @@ struct product_evaluator, LazyCoeffBasedProduc typedef Product XprType; typedef Product BaseProduct; typedef product_evaluator Base; - product_evaluator(const XprType& xpr) + explicit product_evaluator(const XprType& xpr) : Base(BaseProduct(xpr.lhs(),xpr.rhs())) {} }; @@ -739,7 +739,7 @@ struct product_evaluator, ProductTag, DiagonalSha StorageOrder = int(Rhs::Flags) & RowMajorBit ? RowMajor : ColMajor }; - product_evaluator(const XprType& xpr) + explicit product_evaluator(const XprType& xpr) : Base(xpr.rhs(), xpr.lhs().diagonal()) { } @@ -783,7 +783,7 @@ struct product_evaluator, ProductTag, DenseShape, enum { StorageOrder = int(Lhs::Flags) & RowMajorBit ? RowMajor : ColMajor }; - product_evaluator(const XprType& xpr) + explicit product_evaluator(const XprType& xpr) : Base(xpr.lhs(), xpr.rhs().diagonal()) { } diff --git a/Eigen/src/Core/Redux.h b/Eigen/src/Core/Redux.h index c6c355d43..14a2671e9 100644 --- a/Eigen/src/Core/Redux.h +++ b/Eigen/src/Core/Redux.h @@ -340,7 +340,7 @@ class redux_evaluator { public: typedef _XprType XprType; - redux_evaluator(const XprType &xpr) : m_evaluator(xpr), m_xpr(xpr) {} + explicit redux_evaluator(const XprType &xpr) : m_evaluator(xpr), m_xpr(xpr) {} typedef typename XprType::Index Index; typedef typename XprType::Scalar Scalar; diff --git a/Eigen/src/Core/ReturnByValue.h b/Eigen/src/Core/ReturnByValue.h index f4e12a93b..5fcd9e3fc 100644 --- a/Eigen/src/Core/ReturnByValue.h +++ b/Eigen/src/Core/ReturnByValue.h @@ -103,7 +103,7 @@ struct evaluator > typedef evaluator type; typedef evaluator nestedType; - evaluator(const XprType& xpr) + explicit evaluator(const XprType& xpr) : m_result(xpr.rows(), xpr.cols()) { ::new (static_cast(this)) Base(m_result); diff --git a/Eigen/src/Core/Reverse.h b/Eigen/src/Core/Reverse.h index 01de90800..9ba6ea2e6 100644 --- a/Eigen/src/Core/Reverse.h +++ b/Eigen/src/Core/Reverse.h @@ -89,7 +89,7 @@ template class Reverse typedef internal::reverse_packet_cond reverse_packet; public: - inline Reverse(const MatrixType& matrix) : m_matrix(matrix) { } + explicit inline Reverse(const MatrixType& matrix) : m_matrix(matrix) { } EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Reverse) @@ -184,7 +184,7 @@ template inline typename DenseBase::ReverseReturnType DenseBase::reverse() { - return derived(); + return ReverseReturnType(derived()); } /** This is the const version of reverse(). */ @@ -192,7 +192,7 @@ template inline const typename DenseBase::ConstReverseReturnType DenseBase::reverse() const { - return derived(); + return ConstReverseReturnType(derived()); } /** This is the "in place" version of reverse: it reverses \c *this. diff --git a/Eigen/src/Core/SelfAdjointView.h b/Eigen/src/Core/SelfAdjointView.h index 19cb232c9..f5fbd7215 100644 --- a/Eigen/src/Core/SelfAdjointView.h +++ b/Eigen/src/Core/SelfAdjointView.h @@ -67,7 +67,7 @@ template class SelfAdjointView typedef typename MatrixType::PlainObject PlainObject; EIGEN_DEVICE_FUNC - inline SelfAdjointView(MatrixType& matrix) : m_matrix(matrix) + explicit inline SelfAdjointView(MatrixType& matrix) : m_matrix(matrix) {} EIGEN_DEVICE_FUNC @@ -258,7 +258,7 @@ template typename MatrixBase::template ConstSelfAdjointViewReturnType::Type MatrixBase::selfadjointView() const { - return derived(); + return typename ConstSelfAdjointViewReturnType::Type(derived()); } template @@ -266,7 +266,7 @@ template typename MatrixBase::template SelfAdjointViewReturnType::Type MatrixBase::selfadjointView() { - return derived(); + return typename SelfAdjointViewReturnType::Type(derived()); } } // end namespace Eigen diff --git a/Eigen/src/Core/Solve.h b/Eigen/src/Core/Solve.h index 7b12be1e6..641ffa218 100644 --- a/Eigen/src/Core/Solve.h +++ b/Eigen/src/Core/Solve.h @@ -121,7 +121,7 @@ struct evaluator > typedef evaluator type; typedef evaluator nestedType; - evaluator(const SolveType& solve) + explicit evaluator(const SolveType& solve) : m_result(solve.rows(), solve.cols()) { ::new (static_cast(this)) Base(m_result); diff --git a/Eigen/src/Core/Stride.h b/Eigen/src/Core/Stride.h index 187774978..e46faad34 100644 --- a/Eigen/src/Core/Stride.h +++ b/Eigen/src/Core/Stride.h @@ -93,7 +93,7 @@ class InnerStride : public Stride<0, Value> public: typedef DenseIndex Index; EIGEN_DEVICE_FUNC InnerStride() : Base() {} - EIGEN_DEVICE_FUNC InnerStride(Index v) : Base(0, v) {} + EIGEN_DEVICE_FUNC InnerStride(Index v) : Base(0, v) {} // FIXME making this explicit could break valid code }; /** \brief Convenience specialization of Stride to specify only an outer stride @@ -105,7 +105,7 @@ class OuterStride : public Stride public: typedef DenseIndex Index; EIGEN_DEVICE_FUNC OuterStride() : Base() {} - EIGEN_DEVICE_FUNC OuterStride(Index v) : Base(v,0) {} + EIGEN_DEVICE_FUNC OuterStride(Index v) : Base(v,0) {} // FIXME making this explicit could break valid code }; } // end namespace Eigen diff --git a/Eigen/src/Core/Transpose.h b/Eigen/src/Core/Transpose.h index 144bb2c01..57d6fd2fe 100644 --- a/Eigen/src/Core/Transpose.h +++ b/Eigen/src/Core/Transpose.h @@ -64,7 +64,7 @@ template class Transpose typedef typename internal::remove_all::type NestedExpression; EIGEN_DEVICE_FUNC - inline Transpose(MatrixType& a_matrix) : m_matrix(a_matrix) {} + explicit inline Transpose(MatrixType& a_matrix) : m_matrix(a_matrix) {} EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Transpose) @@ -169,7 +169,7 @@ template inline Transpose DenseBase::transpose() { - return derived(); + return TransposeReturnType(derived()); } /** This is the const version of transpose(). @@ -207,8 +207,7 @@ template inline const typename MatrixBase::AdjointReturnType MatrixBase::adjoint() const { - return this->transpose(); // in the complex case, the .conjugate() is be implicit here - // due to implicit conversion to return type + return AdjointReturnType(this->transpose()); } /*************************************************************************** diff --git a/Eigen/src/Core/Transpositions.h b/Eigen/src/Core/Transpositions.h index 92261118f..77e7d6f45 100644 --- a/Eigen/src/Core/Transpositions.h +++ b/Eigen/src/Core/Transpositions.h @@ -240,7 +240,7 @@ class Map > typedef typename TranspositionType::IndicesType IndicesType; public: - Transpose(const TranspositionType& t) : m_transpositions(t) {} + explicit Transpose(const TranspositionType& t) : m_transpositions(t) {} inline int size() const { return m_transpositions.size(); } diff --git a/Eigen/src/Core/TriangularMatrix.h b/Eigen/src/Core/TriangularMatrix.h index 36f04a5e8..36bbd46e1 100644 --- a/Eigen/src/Core/TriangularMatrix.h +++ b/Eigen/src/Core/TriangularMatrix.h @@ -211,8 +211,9 @@ template class TriangularView IsVectorAtCompileTime = false }; + // FIXME This, combined with const_cast_derived in transpose() leads to a const-correctness loophole EIGEN_DEVICE_FUNC - inline TriangularView(const MatrixType& matrix) : m_matrix(matrix) + explicit inline TriangularView(const MatrixType& matrix) : m_matrix(matrix) {} using Base::operator=; @@ -229,32 +230,36 @@ template class TriangularView EIGEN_DEVICE_FUNC NestedExpression& nestedExpression() { return *const_cast(&m_matrix); } + typedef TriangularView ConjugateReturnType; /** \sa MatrixBase::conjugate() */ EIGEN_DEVICE_FUNC - inline TriangularView conjugate() - { return m_matrix.conjugate(); } + inline ConjugateReturnType conjugate() + { return ConjugateReturnType(m_matrix.conjugate()); } /** \sa MatrixBase::conjugate() const */ - EIGEN_DEVICE_FUNC - inline const TriangularView conjugate() const - { return m_matrix.conjugate(); } + EIGEN_DEVICE_FUNC + inline const ConjugateReturnType conjugate() const + { return ConjugateReturnType(m_matrix.conjugate()); } + + typedef TriangularView AdjointReturnType; /** \sa MatrixBase::adjoint() const */ EIGEN_DEVICE_FUNC - inline const TriangularView adjoint() const - { return m_matrix.adjoint(); } + inline const AdjointReturnType adjoint() const + { return AdjointReturnType(m_matrix.adjoint()); } - /** \sa MatrixBase::transpose() */ + typedef TriangularView,TransposeMode> TransposeReturnType; + /** \sa MatrixBase::transpose() */ EIGEN_DEVICE_FUNC - inline TriangularView,TransposeMode> transpose() + inline TransposeReturnType transpose() { EIGEN_STATIC_ASSERT_LVALUE(MatrixType) - return m_matrix.const_cast_derived().transpose(); + return TransposeReturnType(m_matrix.const_cast_derived().transpose()); } /** \sa MatrixBase::transpose() const */ EIGEN_DEVICE_FUNC - inline const TriangularView,TransposeMode> transpose() const + inline const TransposeReturnType transpose() const { - return m_matrix.transpose(); + return TransposeReturnType(m_matrix.transpose()); } template @@ -556,7 +561,7 @@ template typename MatrixBase::template TriangularViewReturnType::Type MatrixBase::triangularView() { - return derived(); + return typename TriangularViewReturnType::Type(derived()); } /** This is the const version of MatrixBase::triangularView() */ @@ -565,7 +570,7 @@ template typename MatrixBase::template ConstTriangularViewReturnType::Type MatrixBase::triangularView() const { - return derived(); + return typename ConstTriangularViewReturnType::Type(derived()); } /** \returns true if *this is approximately equal to an upper triangular matrix, diff --git a/Eigen/src/Core/VectorwiseOp.h b/Eigen/src/Core/VectorwiseOp.h index a8130e902..e340c1433 100644 --- a/Eigen/src/Core/VectorwiseOp.h +++ b/Eigen/src/Core/VectorwiseOp.h @@ -65,7 +65,7 @@ class PartialReduxExpr : internal::no_assignment_operator, typedef typename internal::traits::MatrixTypeNested MatrixTypeNested; typedef typename internal::traits::_MatrixTypeNested _MatrixTypeNested; - PartialReduxExpr(const MatrixType& mat, const MemberOp& func = MemberOp()) + explicit PartialReduxExpr(const MatrixType& mat, const MemberOp& func = MemberOp()) : m_matrix(mat), m_functor(func) {} Index rows() const { return (Direction==Vertical ? 1 : m_matrix.rows()); } @@ -128,7 +128,7 @@ struct member_redux { >::type result_type; template struct Cost { enum { value = (Size-1) * functor_traits::Cost }; }; - member_redux(const BinaryOp func) : m_functor(func) {} + member_redux(const BinaryOp func) : m_functor(func) {} // FIXME this should actually be explicit, but lets not exaggerate template inline result_type operator()(const DenseBase& mat) const { return mat.redux(m_functor); } @@ -249,7 +249,7 @@ template class VectorwiseOp public: - inline VectorwiseOp(ExpressionType& matrix) : m_matrix(matrix) {} + explicit inline VectorwiseOp(ExpressionType& matrix) : m_matrix(matrix) {} /** \internal */ inline const ExpressionType& _expression() const { return m_matrix; } @@ -266,6 +266,21 @@ template class VectorwiseOp redux(const BinaryOp& func = BinaryOp()) const { return typename ReduxReturnType::Type(_expression(), func); } + typedef typename ReturnType::Type MinCoeffReturnType; + typedef typename ReturnType::Type MaxCoeffReturnType; + typedef typename ReturnType::Type SquareNormReturnType; + typedef typename ReturnType::Type NormReturnType; + typedef typename ReturnType::Type BlueNormReturnType; + typedef typename ReturnType::Type StableNormReturnType; + typedef typename ReturnType::Type HypotNormReturnType; + typedef typename ReturnType::Type SumReturnType; + typedef typename ReturnType::Type MeanReturnType; + typedef typename ReturnType::Type AllReturnType; + typedef typename ReturnType::Type AnyReturnType; + typedef PartialReduxExpr, Direction> CountReturnType; + typedef typename ReturnType::Type ProdReturnType; + typedef Reverse ReverseReturnType; + /** \returns a row (or column) vector expression of the smallest coefficient * of each column (or row) of the referenced expression. * @@ -275,8 +290,8 @@ template class VectorwiseOp * Output: \verbinclude PartialRedux_minCoeff.out * * \sa DenseBase::minCoeff() */ - const typename ReturnType::Type minCoeff() const - { return _expression(); } + const MinCoeffReturnType minCoeff() const + { return MinCoeffReturnType(_expression()); } /** \returns a row (or column) vector expression of the largest coefficient * of each column (or row) of the referenced expression. @@ -287,8 +302,8 @@ template class VectorwiseOp * Output: \verbinclude PartialRedux_maxCoeff.out * * \sa DenseBase::maxCoeff() */ - const typename ReturnType::Type maxCoeff() const - { return _expression(); } + const MaxCoeffReturnType maxCoeff() const + { return MaxCoeffReturnType(_expression()); } /** \returns a row (or column) vector expression of the squared norm * of each column (or row) of the referenced expression. @@ -298,8 +313,8 @@ template class VectorwiseOp * Output: \verbinclude PartialRedux_squaredNorm.out * * \sa DenseBase::squaredNorm() */ - const typename ReturnType::Type squaredNorm() const - { return _expression(); } + const SquareNormReturnType squaredNorm() const + { return SquareNormReturnType(_expression()); } /** \returns a row (or column) vector expression of the norm * of each column (or row) of the referenced expression. @@ -309,8 +324,8 @@ template class VectorwiseOp * Output: \verbinclude PartialRedux_norm.out * * \sa DenseBase::norm() */ - const typename ReturnType::Type norm() const - { return _expression(); } + const NormReturnType norm() const + { return NormReturnType(_expression()); } /** \returns a row (or column) vector expression of the norm @@ -319,8 +334,8 @@ template class VectorwiseOp * This is a vector with real entries, even if the original matrix has complex entries. * * \sa DenseBase::blueNorm() */ - const typename ReturnType::Type blueNorm() const - { return _expression(); } + const BlueNormReturnType blueNorm() const + { return BlueNormReturnType(_expression()); } /** \returns a row (or column) vector expression of the norm @@ -329,8 +344,8 @@ template class VectorwiseOp * This is a vector with real entries, even if the original matrix has complex entries. * * \sa DenseBase::stableNorm() */ - const typename ReturnType::Type stableNorm() const - { return _expression(); } + const StableNormReturnType stableNorm() const + { return StableNormReturnType(_expression()); } /** \returns a row (or column) vector expression of the norm @@ -339,8 +354,8 @@ template class VectorwiseOp * This is a vector with real entries, even if the original matrix has complex entries. * * \sa DenseBase::hypotNorm() */ - const typename ReturnType::Type hypotNorm() const - { return _expression(); } + const HypotNormReturnType hypotNorm() const + { return HypotNormReturnType(_expression()); } /** \returns a row (or column) vector expression of the sum * of each column (or row) of the referenced expression. @@ -349,31 +364,31 @@ template class VectorwiseOp * Output: \verbinclude PartialRedux_sum.out * * \sa DenseBase::sum() */ - const typename ReturnType::Type sum() const - { return _expression(); } + const SumReturnType sum() const + { return SumReturnType(_expression()); } /** \returns a row (or column) vector expression of the mean * of each column (or row) of the referenced expression. * * \sa DenseBase::mean() */ - const typename ReturnType::Type mean() const - { return _expression(); } + const MeanReturnType mean() const + { return MeanReturnType(_expression()); } /** \returns a row (or column) vector expression representing * whether \b all coefficients of each respective column (or row) are \c true. * This expression can be assigned to a vector with entries of type \c bool. * * \sa DenseBase::all() */ - const typename ReturnType::Type all() const - { return _expression(); } + const AllReturnType all() const + { return AllReturnType(_expression()); } /** \returns a row (or column) vector expression representing * whether \b at \b least one coefficient of each respective column (or row) is \c true. * This expression can be assigned to a vector with entries of type \c bool. * * \sa DenseBase::any() */ - const typename ReturnType::Type any() const - { return _expression(); } + const AnyReturnType any() const + { return Any(_expression()); } /** \returns a row (or column) vector expression representing * the number of \c true coefficients of each respective column (or row). @@ -384,8 +399,8 @@ template class VectorwiseOp * Output: \verbinclude PartialRedux_count.out * * \sa DenseBase::count() */ - const PartialReduxExpr, Direction> count() const - { return _expression(); } + const CountReturnType count() const + { return CountReturnType(_expression()); } /** \returns a row (or column) vector expression of the product * of each column (or row) of the referenced expression. @@ -394,8 +409,8 @@ template class VectorwiseOp * Output: \verbinclude PartialRedux_prod.out * * \sa DenseBase::prod() */ - const typename ReturnType::Type prod() const - { return _expression(); } + const ProdReturnType prod() const + { return ProdReturnType(_expression()); } /** \returns a matrix expression @@ -405,8 +420,8 @@ template class VectorwiseOp * Output: \verbinclude Vectorwise_reverse.out * * \sa DenseBase::reverse() */ - const Reverse reverse() const - { return Reverse( _expression() ); } + const ReverseReturnType reverse() const + { return ReverseReturnType( _expression() ); } typedef Replicate ReplicateReturnType; const ReplicateReturnType replicate(Index factor) const; @@ -550,7 +565,8 @@ template class VectorwiseOp /////////// Geometry module /////////// - Homogeneous homogeneous() const; + typedef Homogeneous HomogeneousReturnType; + HomogeneousReturnType homogeneous() const; typedef typename ExpressionType::PlainObject CrossReturnType; template @@ -595,7 +611,7 @@ template inline const typename DenseBase::ConstColwiseReturnType DenseBase::colwise() const { - return derived(); + return ConstColwiseReturnType(derived()); } /** \returns a writable VectorwiseOp wrapper of *this providing additional partial reduction operations @@ -606,7 +622,7 @@ template inline typename DenseBase::ColwiseReturnType DenseBase::colwise() { - return derived(); + return ColwiseReturnType(derived()); } /** \returns a VectorwiseOp wrapper of *this providing additional partial reduction operations @@ -620,7 +636,7 @@ template inline const typename DenseBase::ConstRowwiseReturnType DenseBase::rowwise() const { - return derived(); + return ConstRowwiseReturnType(derived()); } /** \returns a writable VectorwiseOp wrapper of *this providing additional partial reduction operations @@ -631,7 +647,7 @@ template inline typename DenseBase::RowwiseReturnType DenseBase::rowwise() { - return derived(); + return RowwiseReturnType(derived()); } } // end namespace Eigen diff --git a/Eigen/src/Core/Visitor.h b/Eigen/src/Core/Visitor.h index 810ec28e7..02bd4eff3 100644 --- a/Eigen/src/Core/Visitor.h +++ b/Eigen/src/Core/Visitor.h @@ -58,7 +58,7 @@ template class visitor_evaluator { public: - visitor_evaluator(const XprType &xpr) : m_evaluator(xpr), m_xpr(xpr) {} + explicit visitor_evaluator(const XprType &xpr) : m_evaluator(xpr), m_xpr(xpr) {} typedef typename XprType::Index Index; typedef typename XprType::Scalar Scalar; diff --git a/Eigen/src/Core/products/SelfadjointRank2Update.h b/Eigen/src/Core/products/SelfadjointRank2Update.h index 8594a97ce..2ae364111 100644 --- a/Eigen/src/Core/products/SelfadjointRank2Update.h +++ b/Eigen/src/Core/products/SelfadjointRank2Update.h @@ -79,11 +79,11 @@ SelfAdjointView& SelfAdjointView if (IsRowMajor) actualAlpha = numext::conj(actualAlpha); - internal::selfadjoint_rank2_update_selector::type>::type, - typename internal::remove_all::type>::type, + typedef typename internal::remove_all::type>::type UType; + typedef typename internal::remove_all::type>::type VType; + internal::selfadjoint_rank2_update_selector - ::run(_expression().const_cast_derived().data(),_expression().outerStride(),actualU,actualV,actualAlpha); + ::run(_expression().const_cast_derived().data(),_expression().outerStride(),UType(actualU),VType(actualV),actualAlpha); return *this; } diff --git a/Eigen/src/Core/util/BlasUtil.h b/Eigen/src/Core/util/BlasUtil.h index 0d8e2705a..9f9115c2a 100644 --- a/Eigen/src/Core/util/BlasUtil.h +++ b/Eigen/src/Core/util/BlasUtil.h @@ -231,7 +231,7 @@ struct blas_traits > enum { IsTransposed = Base::IsTransposed ? 0 : 1 }; - static inline ExtractType extract(const XprType& x) { return Base::extract(x.nestedExpression()); } + static inline ExtractType extract(const XprType& x) { return ExtractType(Base::extract(x.nestedExpression())); } static inline Scalar extractScalarFactor(const XprType& x) { return Base::extractScalarFactor(x.nestedExpression()); } }; diff --git a/Eigen/src/Eigenvalues/ComplexEigenSolver.h b/Eigen/src/Eigenvalues/ComplexEigenSolver.h index af434bc9b..25082546e 100644 --- a/Eigen/src/Eigenvalues/ComplexEigenSolver.h +++ b/Eigen/src/Eigenvalues/ComplexEigenSolver.h @@ -104,7 +104,7 @@ template class ComplexEigenSolver * according to the specified problem \a size. * \sa ComplexEigenSolver() */ - ComplexEigenSolver(Index size) + explicit ComplexEigenSolver(Index size) : m_eivec(size, size), m_eivalues(size), m_schur(size), @@ -122,7 +122,7 @@ template class ComplexEigenSolver * * This constructor calls compute() to compute the eigendecomposition. */ - ComplexEigenSolver(const MatrixType& matrix, bool computeEigenvectors = true) + explicit ComplexEigenSolver(const MatrixType& matrix, bool computeEigenvectors = true) : m_eivec(matrix.rows(),matrix.cols()), m_eivalues(matrix.cols()), m_schur(matrix.rows()), diff --git a/Eigen/src/Eigenvalues/ComplexSchur.h b/Eigen/src/Eigenvalues/ComplexSchur.h index 89e6cade3..a3a5a4649 100644 --- a/Eigen/src/Eigenvalues/ComplexSchur.h +++ b/Eigen/src/Eigenvalues/ComplexSchur.h @@ -91,7 +91,7 @@ template class ComplexSchur * * \sa compute() for an example. */ - ComplexSchur(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime) + explicit ComplexSchur(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime) : m_matT(size,size), m_matU(size,size), m_hess(size), @@ -109,7 +109,7 @@ template class ComplexSchur * * \sa matrixT() and matrixU() for examples. */ - ComplexSchur(const MatrixType& matrix, bool computeU = true) + explicit ComplexSchur(const MatrixType& matrix, bool computeU = true) : m_matT(matrix.rows(),matrix.cols()), m_matU(matrix.rows(),matrix.cols()), m_hess(matrix.rows()), diff --git a/Eigen/src/Eigenvalues/EigenSolver.h b/Eigen/src/Eigenvalues/EigenSolver.h index d2563d470..8a83b85bb 100644 --- a/Eigen/src/Eigenvalues/EigenSolver.h +++ b/Eigen/src/Eigenvalues/EigenSolver.h @@ -118,7 +118,7 @@ template class EigenSolver * according to the specified problem \a size. * \sa EigenSolver() */ - EigenSolver(Index size) + explicit EigenSolver(Index size) : m_eivec(size, size), m_eivalues(size), m_isInitialized(false), @@ -143,7 +143,7 @@ template class EigenSolver * * \sa compute() */ - EigenSolver(const MatrixType& matrix, bool computeEigenvectors = true) + explicit EigenSolver(const MatrixType& matrix, bool computeEigenvectors = true) : m_eivec(matrix.rows(), matrix.cols()), m_eivalues(matrix.cols()), m_isInitialized(false), diff --git a/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h b/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h index dc240e13e..c20ea03e6 100644 --- a/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h +++ b/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h @@ -122,7 +122,7 @@ template class GeneralizedEigenSolver * according to the specified problem \a size. * \sa GeneralizedEigenSolver() */ - GeneralizedEigenSolver(Index size) + explicit GeneralizedEigenSolver(Index size) : m_eivec(size, size), m_alphas(size), m_betas(size), @@ -145,7 +145,7 @@ template class GeneralizedEigenSolver * * \sa compute() */ - GeneralizedEigenSolver(const MatrixType& A, const MatrixType& B, bool computeEigenvectors = true) + explicit GeneralizedEigenSolver(const MatrixType& A, const MatrixType& B, bool computeEigenvectors = true) : m_eivec(A.rows(), A.cols()), m_alphas(A.cols()), m_betas(A.cols()), diff --git a/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h b/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h index 07bf1ea09..1ce1f5f58 100644 --- a/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h +++ b/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h @@ -74,7 +74,7 @@ class GeneralizedSelfAdjointEigenSolver : public SelfAdjointEigenSolver<_MatrixT * * \sa compute() for an example */ - GeneralizedSelfAdjointEigenSolver(Index size) + explicit GeneralizedSelfAdjointEigenSolver(Index size) : Base(size) {} diff --git a/Eigen/src/Eigenvalues/HessenbergDecomposition.h b/Eigen/src/Eigenvalues/HessenbergDecomposition.h index 3db0c0106..2615a9f23 100644 --- a/Eigen/src/Eigenvalues/HessenbergDecomposition.h +++ b/Eigen/src/Eigenvalues/HessenbergDecomposition.h @@ -97,7 +97,7 @@ template class HessenbergDecomposition * * \sa compute() for an example. */ - HessenbergDecomposition(Index size = Size==Dynamic ? 2 : Size) + explicit HessenbergDecomposition(Index size = Size==Dynamic ? 2 : Size) : m_matrix(size,size), m_temp(size), m_isInitialized(false) @@ -115,7 +115,7 @@ template class HessenbergDecomposition * * \sa matrixH() for an example. */ - HessenbergDecomposition(const MatrixType& matrix) + explicit HessenbergDecomposition(const MatrixType& matrix) : m_matrix(matrix), m_temp(matrix.rows()), m_isInitialized(false) diff --git a/Eigen/src/Eigenvalues/RealQZ.h b/Eigen/src/Eigenvalues/RealQZ.h index 5706eeebe..ae10ff91e 100644 --- a/Eigen/src/Eigenvalues/RealQZ.h +++ b/Eigen/src/Eigenvalues/RealQZ.h @@ -83,7 +83,7 @@ namespace Eigen { * * \sa compute() for an example. */ - RealQZ(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime) : + explicit RealQZ(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime) : m_S(size, size), m_T(size, size), m_Q(size, size), @@ -101,7 +101,7 @@ namespace Eigen { * * This constructor calls compute() to compute the QZ decomposition. */ - RealQZ(const MatrixType& A, const MatrixType& B, bool computeQZ = true) : + explicit RealQZ(const MatrixType& A, const MatrixType& B, bool computeQZ = true) : m_S(A.rows(),A.cols()), m_T(A.rows(),A.cols()), m_Q(A.rows(),A.cols()), diff --git a/Eigen/src/Eigenvalues/RealSchur.h b/Eigen/src/Eigenvalues/RealSchur.h index 64d136341..10f5fb174 100644 --- a/Eigen/src/Eigenvalues/RealSchur.h +++ b/Eigen/src/Eigenvalues/RealSchur.h @@ -80,7 +80,7 @@ template class RealSchur * * \sa compute() for an example. */ - RealSchur(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime) + explicit RealSchur(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime) : m_matT(size, size), m_matU(size, size), m_workspaceVector(size), @@ -100,7 +100,7 @@ template class RealSchur * Example: \include RealSchur_RealSchur_MatrixType.cpp * Output: \verbinclude RealSchur_RealSchur_MatrixType.out */ - RealSchur(const MatrixType& matrix, bool computeU = true) + explicit RealSchur(const MatrixType& matrix, bool computeU = true) : m_matT(matrix.rows(),matrix.cols()), m_matU(matrix.rows(),matrix.cols()), m_workspaceVector(matrix.rows()), diff --git a/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h b/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h index a6bbdac6b..1dd2ab45b 100644 --- a/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h +++ b/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h @@ -133,7 +133,7 @@ template class SelfAdjointEigenSolver * \sa compute() for an example */ EIGEN_DEVICE_FUNC - SelfAdjointEigenSolver(Index size) + explicit SelfAdjointEigenSolver(Index size) : m_eivec(size, size), m_eivalues(size), m_subdiag(size > 1 ? size - 1 : 1), @@ -156,7 +156,7 @@ template class SelfAdjointEigenSolver * \sa compute(const MatrixType&, int) */ EIGEN_DEVICE_FUNC - SelfAdjointEigenSolver(const MatrixType& matrix, int options = ComputeEigenvectors) + explicit SelfAdjointEigenSolver(const MatrixType& matrix, int options = ComputeEigenvectors) : m_eivec(matrix.rows(), matrix.cols()), m_eivalues(matrix.cols()), m_subdiag(matrix.rows() > 1 ? matrix.rows() - 1 : 1), diff --git a/Eigen/src/Eigenvalues/Tridiagonalization.h b/Eigen/src/Eigenvalues/Tridiagonalization.h index e3a27f275..f20528f86 100644 --- a/Eigen/src/Eigenvalues/Tridiagonalization.h +++ b/Eigen/src/Eigenvalues/Tridiagonalization.h @@ -112,7 +112,7 @@ template class Tridiagonalization * * \sa compute() for an example. */ - Tridiagonalization(Index size = Size==Dynamic ? 2 : Size) + explicit Tridiagonalization(Index size = Size==Dynamic ? 2 : Size) : m_matrix(size,size), m_hCoeffs(size > 1 ? size-1 : 1), m_isInitialized(false) @@ -128,7 +128,7 @@ template class Tridiagonalization * Example: \include Tridiagonalization_Tridiagonalization_MatrixType.cpp * Output: \verbinclude Tridiagonalization_Tridiagonalization_MatrixType.out */ - Tridiagonalization(const MatrixType& matrix) + explicit Tridiagonalization(const MatrixType& matrix) : m_matrix(matrix), m_hCoeffs(matrix.cols() > 1 ? matrix.cols()-1 : 1), m_isInitialized(false) diff --git a/Eigen/src/Geometry/Homogeneous.h b/Eigen/src/Geometry/Homogeneous.h index d1881d84d..ede203ef9 100644 --- a/Eigen/src/Geometry/Homogeneous.h +++ b/Eigen/src/Geometry/Homogeneous.h @@ -68,7 +68,7 @@ template class Homogeneous typedef MatrixBase Base; EIGEN_DENSE_PUBLIC_INTERFACE(Homogeneous) - inline Homogeneous(const MatrixType& matrix) + explicit inline Homogeneous(const MatrixType& matrix) : m_matrix(matrix) {} @@ -128,7 +128,7 @@ inline typename MatrixBase::HomogeneousReturnType MatrixBase::homogeneous() const { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived); - return derived(); + return HomogeneousReturnType(derived()); } /** \geometry_module @@ -143,7 +143,7 @@ template inline Homogeneous VectorwiseOp::homogeneous() const { - return _expression(); + return HomogeneousReturnType(_expression()); } /** \geometry_module @@ -323,7 +323,7 @@ struct unary_evaluator, IndexBased> typedef evaluator type; typedef evaluator nestedType; - unary_evaluator(const XprType& op) + explicit unary_evaluator(const XprType& op) : Base(), m_temp(op) { ::new (static_cast(this)) Base(m_temp); diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h index 3f0067286..216e5b12f 100644 --- a/Eigen/src/Geometry/Quaternion.h +++ b/Eigen/src/Geometry/Quaternion.h @@ -251,7 +251,7 @@ public: inline Quaternion(const Scalar& w, const Scalar& x, const Scalar& y, const Scalar& z) : m_coeffs(x, y, z, w){} /** Constructs and initialize a quaternion from the array data */ - inline Quaternion(const Scalar* data) : m_coeffs(data) {} + explicit inline Quaternion(const Scalar* data) : m_coeffs(data) {} /** Copy constructor */ template EIGEN_STRONG_INLINE Quaternion(const QuaternionBase& other) { this->Base::operator=(other); } @@ -351,7 +351,7 @@ class Map, _Options > * \code *coeffs == {x, y, z, w} \endcode * * If the template parameter _Options is set to #Aligned, then the pointer coeffs must be aligned. */ - EIGEN_STRONG_INLINE Map(const Scalar* coeffs) : m_coeffs(coeffs) {} + explicit EIGEN_STRONG_INLINE Map(const Scalar* coeffs) : m_coeffs(coeffs) {} inline const Coefficients& coeffs() const { return m_coeffs;} @@ -388,7 +388,7 @@ class Map, _Options > * \code *coeffs == {x, y, z, w} \endcode * * If the template parameter _Options is set to #Aligned, then the pointer coeffs must be aligned. */ - EIGEN_STRONG_INLINE Map(Scalar* coeffs) : m_coeffs(coeffs) {} + explicit EIGEN_STRONG_INLINE Map(Scalar* coeffs) : m_coeffs(coeffs) {} inline Coefficients& coeffs() { return m_coeffs; } inline const Coefficients& coeffs() const { return m_coeffs; } diff --git a/Eigen/src/Geometry/Rotation2D.h b/Eigen/src/Geometry/Rotation2D.h index 1cac343a5..c82762acd 100644 --- a/Eigen/src/Geometry/Rotation2D.h +++ b/Eigen/src/Geometry/Rotation2D.h @@ -59,7 +59,7 @@ protected: public: /** Construct a 2D counter clock wise rotation from the angle \a a in radian. */ - inline Rotation2D(const Scalar& a) : m_angle(a) {} + explicit inline Rotation2D(const Scalar& a) : m_angle(a) {} /** \returns the rotation angle */ inline Scalar angle() const { return m_angle; } diff --git a/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h b/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h index 98b169868..3991afa8f 100644 --- a/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h +++ b/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h @@ -43,7 +43,7 @@ class DiagonalPreconditioner DiagonalPreconditioner() : m_isInitialized(false) {} template - DiagonalPreconditioner(const MatType& mat) : m_invdiag(mat.cols()) + explicit DiagonalPreconditioner(const MatType& mat) : m_invdiag(mat.cols()) { compute(mat); } @@ -114,7 +114,7 @@ class IdentityPreconditioner IdentityPreconditioner() {} template - IdentityPreconditioner(const MatrixType& ) {} + explicit IdentityPreconditioner(const MatrixType& ) {} template IdentityPreconditioner& analyzePattern(const MatrixType& ) { return *this; } diff --git a/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h b/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h index 42da7d14b..224fe913f 100644 --- a/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h +++ b/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h @@ -178,7 +178,7 @@ public: * this class becomes invalid. Call compute() to update it with the new * matrix A, or modify a copy of A. */ - BiCGSTAB(const MatrixType& A) : Base(A) {} + explicit BiCGSTAB(const MatrixType& A) : Base(A) {} ~BiCGSTAB() {} diff --git a/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h b/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h index f72cf86a5..b5ef6d60f 100644 --- a/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h +++ b/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h @@ -189,7 +189,7 @@ public: * this class becomes invalid. Call compute() to update it with the new * matrix A, or modify a copy of A. */ - ConjugateGradient(const MatrixType& A) : Base(A) {} + explicit ConjugateGradient(const MatrixType& A) : Base(A) {} ~ConjugateGradient() {} diff --git a/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h b/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h index 7adbbc489..8ed9bdecc 100644 --- a/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h +++ b/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h @@ -116,7 +116,7 @@ class IncompleteLUT : public SparseSolverBase > {} template - IncompleteLUT(const MatrixType& mat, const RealScalar& droptol=NumTraits::dummy_precision(), int fillfactor = 10) + explicit IncompleteLUT(const MatrixType& mat, const RealScalar& droptol=NumTraits::dummy_precision(), int fillfactor = 10) : m_droptol(droptol),m_fillfactor(fillfactor), m_analysisIsOk(false),m_factorizationIsOk(false) { diff --git a/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h b/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h index 1ca7e0561..f33c868bb 100644 --- a/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h +++ b/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h @@ -52,7 +52,7 @@ public: * this class becomes invalid. Call compute() to update it with the new * matrix A, or modify a copy of A. */ - IterativeSolverBase(const MatrixType& A) + explicit IterativeSolverBase(const MatrixType& A) { init(); compute(A); diff --git a/Eigen/src/LU/FullPivLU.h b/Eigen/src/LU/FullPivLU.h index fdf2e0642..96f2cebee 100644 --- a/Eigen/src/LU/FullPivLU.h +++ b/Eigen/src/LU/FullPivLU.h @@ -94,7 +94,7 @@ template class FullPivLU * \param matrix the matrix of which to compute the LU decomposition. * It is required to be nonzero. */ - FullPivLU(const MatrixType& matrix); + explicit FullPivLU(const MatrixType& matrix); /** Computes the LU decomposition of the given matrix. * diff --git a/Eigen/src/LU/PartialPivLU.h b/Eigen/src/LU/PartialPivLU.h index a4d22ce5f..d04e4191b 100644 --- a/Eigen/src/LU/PartialPivLU.h +++ b/Eigen/src/LU/PartialPivLU.h @@ -92,7 +92,7 @@ template class PartialPivLU * according to the specified problem \a size. * \sa PartialPivLU() */ - PartialPivLU(Index size); + explicit PartialPivLU(Index size); /** Constructor. * @@ -101,7 +101,7 @@ template class PartialPivLU * \warning The matrix should have full rank (e.g. if it's square, it should be invertible). * If you need to deal with non-full rank, use class FullPivLU instead. */ - PartialPivLU(const MatrixType& matrix); + explicit PartialPivLU(const MatrixType& matrix); PartialPivLU& compute(const MatrixType& matrix); diff --git a/Eigen/src/PaStiXSupport/PaStiXSupport.h b/Eigen/src/PaStiXSupport/PaStiXSupport.h index bb8e0d1a8..a96c27695 100644 --- a/Eigen/src/PaStiXSupport/PaStiXSupport.h +++ b/Eigen/src/PaStiXSupport/PaStiXSupport.h @@ -417,7 +417,7 @@ class PastixLU : public PastixBase< PastixLU<_MatrixType> > init(); } - PastixLU(const MatrixType& matrix):Base() + explicit PastixLU(const MatrixType& matrix):Base() { init(); compute(matrix); @@ -527,7 +527,7 @@ class PastixLLT : public PastixBase< PastixLLT<_MatrixType, _UpLo> > init(); } - PastixLLT(const MatrixType& matrix):Base() + explicit PastixLLT(const MatrixType& matrix):Base() { init(); compute(matrix); @@ -608,7 +608,7 @@ class PastixLDLT : public PastixBase< PastixLDLT<_MatrixType, _UpLo> > init(); } - PastixLDLT(const MatrixType& matrix):Base() + explicit PastixLDLT(const MatrixType& matrix):Base() { init(); compute(matrix); diff --git a/Eigen/src/PardisoSupport/PardisoSupport.h b/Eigen/src/PardisoSupport/PardisoSupport.h index e1b0e1818..054af6635 100644 --- a/Eigen/src/PardisoSupport/PardisoSupport.h +++ b/Eigen/src/PardisoSupport/PardisoSupport.h @@ -391,7 +391,7 @@ class PardisoLU : public PardisoImpl< PardisoLU > pardisoInit(Base::ScalarIsComplex ? 13 : 11); } - PardisoLU(const MatrixType& matrix) + explicit PardisoLU(const MatrixType& matrix) : Base() { pardisoInit(Base::ScalarIsComplex ? 13 : 11); @@ -442,7 +442,7 @@ class PardisoLLT : public PardisoImpl< PardisoLLT > pardisoInit(Base::ScalarIsComplex ? 4 : 2); } - PardisoLLT(const MatrixType& matrix) + explicit PardisoLLT(const MatrixType& matrix) : Base() { pardisoInit(Base::ScalarIsComplex ? 4 : 2); @@ -500,7 +500,7 @@ class PardisoLDLT : public PardisoImpl< PardisoLDLT > pardisoInit(Base::ScalarIsComplex ? ( bool(Options&Symmetric) ? 6 : -4 ) : -2); } - PardisoLDLT(const MatrixType& matrix) + explicit PardisoLDLT(const MatrixType& matrix) : Base() { pardisoInit(Base::ScalarIsComplex ? ( bool(Options&Symmetric) ? 6 : -4 ) : -2); diff --git a/Eigen/src/QR/ColPivHouseholderQR.h b/Eigen/src/QR/ColPivHouseholderQR.h index adf737276..de77e8411 100644 --- a/Eigen/src/QR/ColPivHouseholderQR.h +++ b/Eigen/src/QR/ColPivHouseholderQR.h @@ -117,7 +117,7 @@ template class ColPivHouseholderQR * * \sa compute() */ - ColPivHouseholderQR(const MatrixType& matrix) + explicit ColPivHouseholderQR(const MatrixType& matrix) : m_qr(matrix.rows(), matrix.cols()), m_hCoeffs((std::min)(matrix.rows(),matrix.cols())), m_colsPermutation(PermIndexType(matrix.cols())), diff --git a/Eigen/src/QR/FullPivHouseholderQR.h b/Eigen/src/QR/FullPivHouseholderQR.h index 710c64a45..5712d175c 100644 --- a/Eigen/src/QR/FullPivHouseholderQR.h +++ b/Eigen/src/QR/FullPivHouseholderQR.h @@ -120,7 +120,7 @@ template class FullPivHouseholderQR * * \sa compute() */ - FullPivHouseholderQR(const MatrixType& matrix) + explicit FullPivHouseholderQR(const MatrixType& matrix) : m_qr(matrix.rows(), matrix.cols()), m_hCoeffs((std::min)(matrix.rows(), matrix.cols())), m_rows_transpositions((std::min)(matrix.rows(), matrix.cols())), diff --git a/Eigen/src/QR/HouseholderQR.h b/Eigen/src/QR/HouseholderQR.h index 0b0c9d1bd..f22008494 100644 --- a/Eigen/src/QR/HouseholderQR.h +++ b/Eigen/src/QR/HouseholderQR.h @@ -91,7 +91,7 @@ template class HouseholderQR * * \sa compute() */ - HouseholderQR(const MatrixType& matrix) + explicit HouseholderQR(const MatrixType& matrix) : m_qr(matrix.rows(), matrix.cols()), m_hCoeffs((std::min)(matrix.rows(),matrix.cols())), m_temp(matrix.cols()), diff --git a/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h b/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h index bcdc981d7..44f6a1acb 100644 --- a/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h +++ b/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h @@ -65,7 +65,7 @@ class SPQR : public SparseSolverBase > typedef typename _MatrixType::RealScalar RealScalar; typedef UF_long Index ; typedef SparseMatrix MatrixType; - typedef PermutationMatrix PermutationType; + typedef Map > PermutationType; public: SPQR() : m_ordering(SPQR_ORDERING_DEFAULT), m_allow_tol(SPQR_DEFAULT_TOL), m_tolerance (NumTraits::epsilon()) @@ -73,7 +73,7 @@ class SPQR : public SparseSolverBase > cholmod_l_start(&m_cc); } - SPQR(const _MatrixType& matrix) + explicit SPQR(const _MatrixType& matrix) : m_ordering(SPQR_ORDERING_DEFAULT), m_allow_tol(SPQR_DEFAULT_TOL), m_tolerance (NumTraits::epsilon()) { cholmod_l_start(&m_cc); @@ -164,11 +164,7 @@ class SPQR : public SparseSolverBase > PermutationType colsPermutation() const { eigen_assert(m_isInitialized && "Decomposition is not initialized."); - Index n = m_cR->ncol; - PermutationType colsPerm(n); - for(Index j = 0; j ncol); } /** * Gets the rank of the matrix. diff --git a/Eigen/src/SVD/JacobiSVD.h b/Eigen/src/SVD/JacobiSVD.h index f2a72faa3..59f88a15a 100644 --- a/Eigen/src/SVD/JacobiSVD.h +++ b/Eigen/src/SVD/JacobiSVD.h @@ -550,7 +550,7 @@ template class JacobiSVD * according to the specified problem size. * \sa JacobiSVD() */ - JacobiSVD(Index rows, Index cols, unsigned int computationOptions = 0) + explicit JacobiSVD(Index rows, Index cols, unsigned int computationOptions = 0) { allocate(rows, cols, computationOptions); } @@ -565,7 +565,7 @@ template class JacobiSVD * Thin unitaries are only available if your matrix type has a Dynamic number of columns (for example MatrixXf). They also are not * available with the (non-default) FullPivHouseholderQR preconditioner. */ - JacobiSVD(const MatrixType& matrix, unsigned int computationOptions = 0) + explicit JacobiSVD(const MatrixType& matrix, unsigned int computationOptions = 0) { compute(matrix, computationOptions); } diff --git a/Eigen/src/SVD/UpperBidiagonalization.h b/Eigen/src/SVD/UpperBidiagonalization.h index 40b1237a0..eaa6bb86e 100644 --- a/Eigen/src/SVD/UpperBidiagonalization.h +++ b/Eigen/src/SVD/UpperBidiagonalization.h @@ -37,7 +37,7 @@ template class UpperBidiagonalization typedef Matrix SuperDiagVectorType; typedef HouseholderSequence< const MatrixType, - CwiseUnaryOp, const Diagonal > + const typename internal::remove_all::ConjugateReturnType>::type > HouseholderUSequenceType; typedef HouseholderSequence< const typename internal::remove_all::type, @@ -53,7 +53,7 @@ template class UpperBidiagonalization */ UpperBidiagonalization() : m_householder(), m_bidiagonal(), m_isInitialized(false) {} - UpperBidiagonalization(const MatrixType& matrix) + explicit UpperBidiagonalization(const MatrixType& matrix) : m_householder(matrix.rows(), matrix.cols()), m_bidiagonal(matrix.cols(), matrix.cols()), m_isInitialized(false) diff --git a/Eigen/src/SparseCholesky/SimplicialCholesky.h b/Eigen/src/SparseCholesky/SimplicialCholesky.h index 3c8cef5db..0e8fa6628 100644 --- a/Eigen/src/SparseCholesky/SimplicialCholesky.h +++ b/Eigen/src/SparseCholesky/SimplicialCholesky.h @@ -57,7 +57,7 @@ class SimplicialCholeskyBase : public SparseSolverBase : m_info(Success), m_shiftOffset(0), m_shiftScale(1) {} - SimplicialCholeskyBase(const MatrixType& matrix) + explicit SimplicialCholeskyBase(const MatrixType& matrix) : m_info(Success), m_shiftOffset(0), m_shiftScale(1) { derived().compute(matrix); @@ -239,8 +239,8 @@ template struct traits CholMatrixType; typedef TriangularView MatrixL; typedef TriangularView MatrixU; - static inline MatrixL getL(const MatrixType& m) { return m; } - static inline MatrixU getU(const MatrixType& m) { return m.adjoint(); } + static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); } + static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); } }; template struct traits > @@ -253,8 +253,8 @@ template struct traits CholMatrixType; typedef TriangularView MatrixL; typedef TriangularView MatrixU; - static inline MatrixL getL(const MatrixType& m) { return m; } - static inline MatrixU getU(const MatrixType& m) { return m.adjoint(); } + static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); } + static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); } }; template struct traits > @@ -303,7 +303,7 @@ public: /** Default constructor */ SimplicialLLT() : Base() {} /** Constructs and performs the LLT factorization of \a matrix */ - SimplicialLLT(const MatrixType& matrix) + explicit SimplicialLLT(const MatrixType& matrix) : Base(matrix) {} /** \returns an expression of the factor L */ @@ -393,7 +393,7 @@ public: SimplicialLDLT() : Base() {} /** Constructs and performs the LLT factorization of \a matrix */ - SimplicialLDLT(const MatrixType& matrix) + explicit SimplicialLDLT(const MatrixType& matrix) : Base(matrix) {} /** \returns a vector expression of the diagonal D */ @@ -473,7 +473,7 @@ public: public: SimplicialCholesky() : Base(), m_LDLT(true) {} - SimplicialCholesky(const MatrixType& matrix) + explicit SimplicialCholesky(const MatrixType& matrix) : Base(), m_LDLT(true) { compute(matrix); diff --git a/Eigen/src/SparseCore/AmbiVector.h b/Eigen/src/SparseCore/AmbiVector.h index 17fff96a7..5c9c3101e 100644 --- a/Eigen/src/SparseCore/AmbiVector.h +++ b/Eigen/src/SparseCore/AmbiVector.h @@ -27,7 +27,7 @@ class AmbiVector typedef _Index Index; typedef typename NumTraits::Real RealScalar; - AmbiVector(Index size) + explicit AmbiVector(Index size) : m_buffer(0), m_zero(0), m_size(0), m_allocatedSize(0), m_allocatedElements(0), m_mode(-1) { resize(size); @@ -288,7 +288,7 @@ class AmbiVector<_Scalar,_Index>::Iterator * In practice, all coefficients having a magnitude smaller than \a epsilon * are skipped. */ - Iterator(const AmbiVector& vec, const RealScalar& epsilon = 0) + explicit Iterator(const AmbiVector& vec, const RealScalar& epsilon = 0) : m_vector(vec) { using std::abs; diff --git a/Eigen/src/SparseCore/CompressedStorage.h b/Eigen/src/SparseCore/CompressedStorage.h index a667cb56e..a93550340 100644 --- a/Eigen/src/SparseCore/CompressedStorage.h +++ b/Eigen/src/SparseCore/CompressedStorage.h @@ -36,7 +36,7 @@ class CompressedStorage : m_values(0), m_indices(0), m_size(0), m_allocatedSize(0) {} - CompressedStorage(size_t size) + explicit CompressedStorage(size_t size) : m_values(0), m_indices(0), m_size(0), m_allocatedSize(0) { resize(size); diff --git a/Eigen/src/SparseCore/MappedSparseMatrix.h b/Eigen/src/SparseCore/MappedSparseMatrix.h index d9aabd049..2852c669a 100644 --- a/Eigen/src/SparseCore/MappedSparseMatrix.h +++ b/Eigen/src/SparseCore/MappedSparseMatrix.h @@ -192,7 +192,7 @@ struct evaluator > }; evaluator() : m_matrix(0) {} - evaluator(const MappedSparseMatrixType &mat) : m_matrix(&mat) {} + explicit evaluator(const MappedSparseMatrixType &mat) : m_matrix(&mat) {} operator MappedSparseMatrixType&() { return m_matrix->const_cast_derived(); } operator const MappedSparseMatrixType&() const { return *m_matrix; } diff --git a/Eigen/src/SparseCore/SparseBlock.h b/Eigen/src/SparseCore/SparseBlock.h index 635d58d86..f8b9d5ad6 100644 --- a/Eigen/src/SparseCore/SparseBlock.h +++ b/Eigen/src/SparseCore/SparseBlock.h @@ -443,7 +443,7 @@ namespace internal { Index m_end; public: - EIGEN_STRONG_INLINE GenericSparseBlockInnerIteratorImpl(const BlockType& block, Index outer = 0) + explicit EIGEN_STRONG_INLINE GenericSparseBlockInnerIteratorImpl(const BlockType& block, Index outer = 0) : m_block(block), m_outerPos( (IsRowMajor ? block.m_startCol.value() : block.m_startRow.value()) - 1), // -1 so that operator++ finds the first non-zero entry @@ -512,7 +512,7 @@ struct unary_evaluator, IteratorBa typedef typename internal::conditional::type InnerIterator; - unary_evaluator(const XprType& op) + explicit unary_evaluator(const XprType& op) : m_argImpl(op.nestedExpression()), m_block(op) {} diff --git a/Eigen/src/SparseCore/SparseCwiseBinaryOp.h b/Eigen/src/SparseCore/SparseCwiseBinaryOp.h index 5993c1caf..94ca9b1a4 100644 --- a/Eigen/src/SparseCore/SparseCwiseBinaryOp.h +++ b/Eigen/src/SparseCore/SparseCwiseBinaryOp.h @@ -117,7 +117,7 @@ public: Flags = XprType::Flags }; - binary_evaluator(const XprType& xpr) + explicit binary_evaluator(const XprType& xpr) : m_functor(xpr.functor()), m_lhsImpl(xpr.lhs()), m_rhsImpl(xpr.rhs()) @@ -195,7 +195,7 @@ public: Flags = XprType::Flags }; - binary_evaluator(const XprType& xpr) + explicit binary_evaluator(const XprType& xpr) : m_functor(xpr.functor()), m_lhsImpl(xpr.lhs()), m_rhsImpl(xpr.rhs()) @@ -260,7 +260,7 @@ public: Flags = XprType::Flags }; - binary_evaluator(const XprType& xpr) + explicit binary_evaluator(const XprType& xpr) : m_functor(xpr.functor()), m_lhsImpl(xpr.lhs()), m_rhsImpl(xpr.rhs()) @@ -326,7 +326,7 @@ public: Flags = XprType::Flags }; - binary_evaluator(const XprType& xpr) + explicit binary_evaluator(const XprType& xpr) : m_functor(xpr.functor()), m_lhsImpl(xpr.lhs()), m_rhsImpl(xpr.rhs()) diff --git a/Eigen/src/SparseCore/SparseCwiseUnaryOp.h b/Eigen/src/SparseCore/SparseCwiseUnaryOp.h index 6036fd0a7..32b7bc949 100644 --- a/Eigen/src/SparseCore/SparseCwiseUnaryOp.h +++ b/Eigen/src/SparseCore/SparseCwiseUnaryOp.h @@ -29,7 +29,7 @@ struct unary_evaluator, IteratorBased> Flags = XprType::Flags }; - unary_evaluator(const XprType& op) : m_functor(op.functor()), m_argImpl(op.nestedExpression()) {} + explicit unary_evaluator(const XprType& op) : m_functor(op.functor()), m_argImpl(op.nestedExpression()) {} protected: typedef typename evaluator::InnerIterator EvalIterator; @@ -104,7 +104,7 @@ struct unary_evaluator, IteratorBased> Flags = XprType::Flags }; - unary_evaluator(const XprType& op) : m_functor(op.functor()), m_argImpl(op.nestedExpression()) {} + explicit unary_evaluator(const XprType& op) : m_functor(op.functor()), m_argImpl(op.nestedExpression()) {} protected: typedef typename evaluator::InnerIterator EvalIterator; diff --git a/Eigen/src/SparseCore/SparseDenseProduct.h b/Eigen/src/SparseCore/SparseDenseProduct.h index 04c838a71..7af6a12a9 100644 --- a/Eigen/src/SparseCore/SparseDenseProduct.h +++ b/Eigen/src/SparseCore/SparseDenseProduct.h @@ -173,7 +173,8 @@ protected: typedef Product ProdXprType; // if the actual left-hand side is a dense vector, - // then build a sparse-view so that we can seamlessly iterator over it. + // then build a sparse-view so that we can seamlessly iterate over it. + // FIXME ActualLhs does not seem to be necessary typedef typename conditional::StorageKind,Sparse>::value, Lhs1, SparseView >::type ActualLhs; typedef typename conditional::StorageKind,Sparse>::value, @@ -228,7 +229,7 @@ public: Scalar m_factor; }; - sparse_dense_outer_product_evaluator(const ActualLhs &lhs, const ActualRhs &rhs) + sparse_dense_outer_product_evaluator(const Lhs1 &lhs, const ActualRhs &rhs) : m_lhs(lhs), m_lhsXprImpl(m_lhs), m_rhsXprImpl(rhs) {} @@ -253,7 +254,7 @@ struct product_evaluator, OuterProduct, Sparse typedef Product XprType; typedef typename XprType::PlainObject PlainObject; - product_evaluator(const XprType& xpr) + explicit product_evaluator(const XprType& xpr) : Base(xpr.lhs(), xpr.rhs()) {} @@ -268,7 +269,7 @@ struct product_evaluator, OuterProduct, DenseS typedef Product XprType; typedef typename XprType::PlainObject PlainObject; - product_evaluator(const XprType& xpr) + explicit product_evaluator(const XprType& xpr) : Base(xpr.lhs(), xpr.rhs()) {} diff --git a/Eigen/src/SparseCore/SparseDiagonalProduct.h b/Eigen/src/SparseCore/SparseDiagonalProduct.h index 0cb2bd572..be935e9f3 100644 --- a/Eigen/src/SparseCore/SparseDiagonalProduct.h +++ b/Eigen/src/SparseCore/SparseDiagonalProduct.h @@ -44,7 +44,7 @@ struct product_evaluator, ProductTag, Diagonal enum { CoeffReadCost = Dynamic, Flags = Rhs::Flags&RowMajorBit }; // FIXME CoeffReadCost & Flags typedef sparse_diagonal_product_evaluator Base; - product_evaluator(const XprType& xpr) : Base(xpr.rhs(), xpr.lhs().diagonal()) {} + explicit product_evaluator(const XprType& xpr) : Base(xpr.rhs(), xpr.lhs().diagonal()) {} }; template @@ -57,7 +57,7 @@ struct product_evaluator, ProductTag, SparseSh enum { CoeffReadCost = Dynamic, Flags = Lhs::Flags&RowMajorBit }; // FIXME CoeffReadCost & Flags typedef sparse_diagonal_product_evaluator, Lhs::Flags&RowMajorBit?SDP_AsCwiseProduct:SDP_AsScalarProduct> Base; - product_evaluator(const XprType& xpr) : Base(xpr.lhs(), xpr.rhs().diagonal()) {} + explicit product_evaluator(const XprType& xpr) : Base(xpr.lhs(), xpr.rhs().diagonal().transpose()) {} }; template diff --git a/Eigen/src/SparseCore/SparseMatrix.h b/Eigen/src/SparseCore/SparseMatrix.h index 9e7124ff2..7ccdd12a5 100644 --- a/Eigen/src/SparseCore/SparseMatrix.h +++ b/Eigen/src/SparseCore/SparseMatrix.h @@ -89,6 +89,8 @@ class SparseMatrix EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(SparseMatrix, -=) typedef MappedSparseMatrix Map; + typedef Diagonal DiagonalReturnType; + using Base::IsRowMajor; typedef internal::CompressedStorage Storage; enum { @@ -621,7 +623,7 @@ class SparseMatrix } /** \returns a const expression of the diagonal coefficients */ - const Diagonal diagonal() const { return *this; } + const DiagonalReturnType diagonal() const { return DiagonalReturnType(*this); } /** Default constructor yielding an empty \c 0 \c x \c 0 matrix */ inline SparseMatrix() @@ -1272,7 +1274,7 @@ struct evaluator > }; evaluator() : m_matrix(0) {} - evaluator(const SparseMatrixType &mat) : m_matrix(&mat) {} + explicit evaluator(const SparseMatrixType &mat) : m_matrix(&mat) {} operator SparseMatrixType&() { return m_matrix->const_cast_derived(); } operator const SparseMatrixType&() const { return *m_matrix; } diff --git a/Eigen/src/SparseCore/SparseMatrixBase.h b/Eigen/src/SparseCore/SparseMatrixBase.h index a438c6487..f96042f27 100644 --- a/Eigen/src/SparseCore/SparseMatrixBase.h +++ b/Eigen/src/SparseCore/SparseMatrixBase.h @@ -94,6 +94,9 @@ template class SparseMatrixBase : public EigenBase CwiseUnaryOp, Eigen::Transpose >, Transpose >::type AdjointReturnType; + typedef Transpose TransposeReturnType; + template struct SelfAdjointViewReturnType { typedef SelfAdjointView Type; }; + typedef typename internal::add_const >::type ConstTransposeReturnType; // FIXME storage order do not match evaluator storage order typedef SparseMatrix PlainObject; @@ -114,6 +117,8 @@ template class SparseMatrixBase : public EigenBase /** \internal Represents a matrix with all coefficients equal to one another*/ typedef CwiseNullaryOp,Matrix > ConstantReturnType; + /** type of the equivalent dense matrix */ + typedef Matrix DenseMatrixType; /** type of the equivalent square matrix */ typedef Matrix SquareMatrixType; @@ -303,9 +308,9 @@ template class SparseMatrixBase : public EigenBase RealScalar norm() const; RealScalar blueNorm() const; - Transpose transpose() { return derived(); } - const Transpose transpose() const { return derived(); } - const AdjointReturnType adjoint() const { return transpose(); } + TransposeReturnType transpose() { return TransposeReturnType(derived()); } + const ConstTransposeReturnType transpose() const { return ConstTransposeReturnType(derived()); } + const AdjointReturnType adjoint() const { return AdjointReturnType(transpose()); } // inner-vector typedef Block InnerVectorReturnType; @@ -317,9 +322,9 @@ template class SparseMatrixBase : public EigenBase Block innerVectors(Index outerStart, Index outerSize); const Block innerVectors(Index outerStart, Index outerSize) const; - Matrix toDense() const + DenseMatrixType toDense() const { - return derived(); + return DenseMatrixType(derived()); } template diff --git a/Eigen/src/SparseCore/SparsePermutation.h b/Eigen/src/SparseCore/SparsePermutation.h index 228796bf8..3bfa2ae1b 100644 --- a/Eigen/src/SparseCore/SparsePermutation.h +++ b/Eigen/src/SparseCore/SparsePermutation.h @@ -166,7 +166,7 @@ struct product_evaluator, ProductTag, Permutat typedef typename traits >::ReturnType PlainObject; typedef typename evaluator::type Base; - product_evaluator(const XprType& xpr) + explicit product_evaluator(const XprType& xpr) : m_result(xpr.rows(), xpr.cols()) { ::new (static_cast(this)) Base(m_result); @@ -185,7 +185,7 @@ struct product_evaluator, ProductTag, SparseSh typedef typename traits >::ReturnType PlainObject; typedef typename evaluator::type Base; - product_evaluator(const XprType& xpr) + explicit product_evaluator(const XprType& xpr) : m_result(xpr.rows(), xpr.cols()) { ::new (static_cast(this)) Base(m_result); diff --git a/Eigen/src/SparseCore/SparseProduct.h b/Eigen/src/SparseCore/SparseProduct.h index b68fe986a..ae707376a 100644 --- a/Eigen/src/SparseCore/SparseProduct.h +++ b/Eigen/src/SparseCore/SparseProduct.h @@ -59,7 +59,7 @@ struct evaluator > > typedef evaluator type; typedef evaluator nestedType; - evaluator(const XprType& xpr) + explicit evaluator(const XprType& xpr) : m_result(xpr.rows(), xpr.cols()) { using std::abs; diff --git a/Eigen/src/SparseCore/SparseSelfAdjointView.h b/Eigen/src/SparseCore/SparseSelfAdjointView.h index 69ac1a398..247d4e6d3 100644 --- a/Eigen/src/SparseCore/SparseSelfAdjointView.h +++ b/Eigen/src/SparseCore/SparseSelfAdjointView.h @@ -53,7 +53,7 @@ template class SparseSelfAdjointView typedef typename MatrixType::Nested MatrixTypeNested; typedef typename internal::remove_all::type _MatrixTypeNested; - inline SparseSelfAdjointView(const MatrixType& matrix) : m_matrix(matrix) + explicit inline SparseSelfAdjointView(const MatrixType& matrix) : m_matrix(matrix) { eigen_assert(rows()==cols() && "SelfAdjointView is only for squared matrices"); } @@ -172,14 +172,14 @@ template template const SparseSelfAdjointView SparseMatrixBase::selfadjointView() const { - return derived(); + return SparseSelfAdjointView(derived()); } template template SparseSelfAdjointView SparseMatrixBase::selfadjointView() { - return derived(); + return SparseSelfAdjointView(derived()); } /*************************************************************************** diff --git a/Eigen/src/SparseCore/SparseTranspose.h b/Eigen/src/SparseCore/SparseTranspose.h index fae7cae97..c3d2d1a16 100644 --- a/Eigen/src/SparseCore/SparseTranspose.h +++ b/Eigen/src/SparseCore/SparseTranspose.h @@ -62,7 +62,7 @@ struct unary_evaluator, IteratorBased> Flags = XprType::Flags }; - unary_evaluator(const XprType& op) :m_argImpl(op.nestedExpression()) {} + explicit unary_evaluator(const XprType& op) :m_argImpl(op.nestedExpression()) {} protected: typename evaluator::nestedType m_argImpl; diff --git a/Eigen/src/SparseCore/SparseTriangularView.h b/Eigen/src/SparseCore/SparseTriangularView.h index 744c3d730..e200bc815 100644 --- a/Eigen/src/SparseCore/SparseTriangularView.h +++ b/Eigen/src/SparseCore/SparseTriangularView.h @@ -185,7 +185,7 @@ public: Flags = XprType::Flags }; - unary_evaluator(const XprType &xpr) : m_argImpl(xpr.nestedExpression()) {} + explicit unary_evaluator(const XprType &xpr) : m_argImpl(xpr.nestedExpression()) {} class InnerIterator : public EvalIterator { @@ -269,7 +269,7 @@ template inline const TriangularView SparseMatrixBase::triangularView() const { - return derived(); + return TriangularView(derived()); } } // end namespace Eigen diff --git a/Eigen/src/SparseCore/SparseVector.h b/Eigen/src/SparseCore/SparseVector.h index c9f9d61e9..dfbb2be2e 100644 --- a/Eigen/src/SparseCore/SparseVector.h +++ b/Eigen/src/SparseCore/SparseVector.h @@ -221,7 +221,7 @@ class SparseVector inline SparseVector() : m_size(0) { check_template_parameters(); resize(0); } - inline SparseVector(Index size) : m_size(0) { check_template_parameters(); resize(size); } + explicit inline SparseVector(Index size) : m_size(0) { check_template_parameters(); resize(size); } inline SparseVector(Index rows, Index cols) : m_size(0) { check_template_parameters(); resize(rows,cols); } @@ -360,14 +360,14 @@ template class SparseVector::InnerIterator { public: - InnerIterator(const SparseVector& vec, Index outer=0) + explicit InnerIterator(const SparseVector& vec, Index outer=0) : m_data(vec.m_data), m_id(0), m_end(static_cast(m_data.size())) { EIGEN_UNUSED_VARIABLE(outer); eigen_assert(outer==0); } - InnerIterator(const internal::CompressedStorage& data) + explicit InnerIterator(const internal::CompressedStorage& data) : m_data(data), m_id(0), m_end(static_cast(m_data.size())) {} @@ -392,14 +392,14 @@ template class SparseVector::ReverseInnerIterator { public: - ReverseInnerIterator(const SparseVector& vec, Index outer=0) + explicit ReverseInnerIterator(const SparseVector& vec, Index outer=0) : m_data(vec.m_data), m_id(static_cast(m_data.size())), m_start(0) { EIGEN_UNUSED_VARIABLE(outer); eigen_assert(outer==0); } - ReverseInnerIterator(const internal::CompressedStorage& data) + explicit ReverseInnerIterator(const internal::CompressedStorage& data) : m_data(data), m_id(static_cast(m_data.size())), m_start(0) {} @@ -435,7 +435,7 @@ struct evaluator > Flags = SparseVectorType::Flags }; - evaluator(const SparseVectorType &mat) : m_matrix(mat) {} + explicit evaluator(const SparseVectorType &mat) : m_matrix(mat) {} operator SparseVectorType&() { return m_matrix.const_cast_derived(); } operator const SparseVectorType&() const { return m_matrix; } diff --git a/Eigen/src/SparseCore/SparseView.h b/Eigen/src/SparseCore/SparseView.h index d10cc5a35..40a3019fa 100644 --- a/Eigen/src/SparseCore/SparseView.h +++ b/Eigen/src/SparseCore/SparseView.h @@ -36,7 +36,7 @@ public: EIGEN_SPARSE_PUBLIC_INTERFACE(SparseView) typedef typename internal::remove_all::type NestedExpression; - SparseView(const MatrixType& mat, const Scalar& m_reference = Scalar(0), + explicit SparseView(const MatrixType& mat, const Scalar& m_reference = Scalar(0), RealScalar m_epsilon = NumTraits::dummy_precision()) : m_matrix(mat), m_reference(m_reference), m_epsilon(m_epsilon) {} @@ -111,7 +111,7 @@ struct unary_evaluator, IteratorBased> Flags = XprType::Flags }; - unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_view(xpr) {} + explicit unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_view(xpr) {} protected: typename evaluator::nestedType m_argImpl; @@ -180,7 +180,7 @@ struct unary_evaluator, IndexBased> Flags = XprType::Flags }; - unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_view(xpr) {} + explicit unary_evaluator(const XprType& xpr) : m_argImpl(xpr.nestedExpression()), m_view(xpr) {} protected: typename evaluator::nestedType m_argImpl; diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h index 14d7e713e..cd4ea5b13 100644 --- a/Eigen/src/SparseLU/SparseLU.h +++ b/Eigen/src/SparseLU/SparseLU.h @@ -95,7 +95,7 @@ class SparseLU : public SparseSolverBase >, { initperfvalues(); } - SparseLU(const MatrixType& matrix):m_lastError(""),m_Ustore(0,0,0,0,0,0),m_symmetricmode(false),m_diagpivotthresh(1.0),m_detPermR(1) + explicit SparseLU(const MatrixType& matrix):m_lastError(""),m_Ustore(0,0,0,0,0,0),m_symmetricmode(false),m_diagpivotthresh(1.0),m_detPermR(1) { initperfvalues(); compute(matrix); @@ -650,7 +650,7 @@ struct SparseLUMatrixLReturnType : internal::no_assignment_operator { typedef typename MappedSupernodalType::Index Index; typedef typename MappedSupernodalType::Scalar Scalar; - SparseLUMatrixLReturnType(const MappedSupernodalType& mapL) : m_mapL(mapL) + explicit SparseLUMatrixLReturnType(const MappedSupernodalType& mapL) : m_mapL(mapL) { } Index rows() { return m_mapL.rows(); } Index cols() { return m_mapL.cols(); } @@ -667,7 +667,7 @@ struct SparseLUMatrixUReturnType : internal::no_assignment_operator { typedef typename MatrixLType::Index Index; typedef typename MatrixLType::Scalar Scalar; - SparseLUMatrixUReturnType(const MatrixLType& mapL, const MatrixUType& mapU) + explicit SparseLUMatrixUReturnType(const MatrixLType& mapL, const MatrixUType& mapU) : m_mapL(mapL),m_mapU(mapU) { } Index rows() { return m_mapL.rows(); } diff --git a/Eigen/src/SparseQR/SparseQR.h b/Eigen/src/SparseQR/SparseQR.h index 6d85ea9be..f6a9af672 100644 --- a/Eigen/src/SparseQR/SparseQR.h +++ b/Eigen/src/SparseQR/SparseQR.h @@ -88,7 +88,7 @@ class SparseQR : public SparseSolverBase > * * \sa compute() */ - SparseQR(const MatrixType& mat) : m_analysisIsok(false), m_lastError(""), m_useDefaultThreshold(true),m_isQSorted(false),m_isEtreeOk(false) + explicit SparseQR(const MatrixType& mat) : m_analysisIsok(false), m_lastError(""), m_useDefaultThreshold(true),m_isQSorted(false),m_isEtreeOk(false) { compute(mat); } @@ -636,7 +636,7 @@ struct SparseQRMatrixQReturnType : public EigenBase DenseMatrix; - SparseQRMatrixQReturnType(const SparseQRType& qr) : m_qr(qr) {} + explicit SparseQRMatrixQReturnType(const SparseQRType& qr) : m_qr(qr) {} template SparseQR_QProduct operator*(const MatrixBase& other) { @@ -672,7 +672,7 @@ struct SparseQRMatrixQReturnType : public EigenBase struct SparseQRMatrixQTransposeReturnType { - SparseQRMatrixQTransposeReturnType(const SparseQRType& qr) : m_qr(qr) {} + explicit SparseQRMatrixQTransposeReturnType(const SparseQRType& qr) : m_qr(qr) {} template SparseQR_QProduct operator*(const MatrixBase& other) { diff --git a/Eigen/src/SuperLUSupport/SuperLUSupport.h b/Eigen/src/SuperLUSupport/SuperLUSupport.h index 0137585ca..ef73587a7 100644 --- a/Eigen/src/SuperLUSupport/SuperLUSupport.h +++ b/Eigen/src/SuperLUSupport/SuperLUSupport.h @@ -469,7 +469,7 @@ class SuperLU : public SuperLUBase<_MatrixType,SuperLU<_MatrixType> > SuperLU() : Base() { init(); } - SuperLU(const MatrixType& matrix) : Base() + explicit SuperLU(const MatrixType& matrix) : Base() { init(); Base::compute(matrix); diff --git a/Eigen/src/UmfPackSupport/UmfPackSupport.h b/Eigen/src/UmfPackSupport/UmfPackSupport.h index 7fada5567..1c5800ffa 100644 --- a/Eigen/src/UmfPackSupport/UmfPackSupport.h +++ b/Eigen/src/UmfPackSupport/UmfPackSupport.h @@ -142,7 +142,7 @@ class UmfPackLU : public SparseSolverBase > UmfPackLU() { init(); } - UmfPackLU(const MatrixType& matrix) + explicit UmfPackLU(const MatrixType& matrix) { init(); compute(matrix); diff --git a/Eigen/src/misc/Kernel.h b/Eigen/src/misc/Kernel.h index b9e1518fd..4b03e44c1 100644 --- a/Eigen/src/misc/Kernel.h +++ b/Eigen/src/misc/Kernel.h @@ -41,7 +41,7 @@ template struct kernel_retval_base typedef ReturnByValue Base; typedef typename Base::Index Index; - kernel_retval_base(const DecompositionType& dec) + explicit kernel_retval_base(const DecompositionType& dec) : m_dec(dec), m_rank(dec.rank()), m_cols(m_rank==dec.cols() ? 1 : dec.cols() - m_rank) diff --git a/Eigen/src/plugins/ArrayCwiseUnaryOps.h b/Eigen/src/plugins/ArrayCwiseUnaryOps.h index f6d7d8944..4e64826da 100644 --- a/Eigen/src/plugins/ArrayCwiseUnaryOps.h +++ b/Eigen/src/plugins/ArrayCwiseUnaryOps.h @@ -1,5 +1,24 @@ +// These are already defined in MatrixCwiseUnaryOps.h +//typedef CwiseUnaryOp, const Derived> AbsReturnType; +//typedef CwiseUnaryOp, const Derived> Abs2ReturnType; +//typedef CwiseUnaryOp, const Derived> SqrtReturnType; +//typedef CwiseUnaryOp, const Derived> CwiseInverseReturnType; +//typedef CwiseUnaryOp >, const Derived> CwiseScalarEqualReturnType; + +typedef CwiseUnaryOp, const Derived> ExpReturnType; +typedef CwiseUnaryOp, const Derived> LogReturnType; +typedef CwiseUnaryOp, const Derived> CosReturnType; +typedef CwiseUnaryOp, const Derived> SinReturnType; +typedef CwiseUnaryOp, const Derived> AcosReturnType; +typedef CwiseUnaryOp, const Derived> AsinReturnType; +typedef CwiseUnaryOp, const Derived> TanReturnType; +typedef CwiseUnaryOp, const Derived> AtanReturnType; +typedef CwiseUnaryOp, const Derived> PowReturnType; +typedef CwiseUnaryOp, const Derived> SquareReturnType; +typedef CwiseUnaryOp, const Derived> CubeReturnType; + /** \returns an expression of the coefficient-wise absolute value of \c *this * * Example: \include Cwise_abs.cpp @@ -8,10 +27,10 @@ * \sa abs2() */ EIGEN_DEVICE_FUNC -EIGEN_STRONG_INLINE const CwiseUnaryOp, const Derived> +EIGEN_STRONG_INLINE const AbsReturnType abs() const { - return derived(); + return AbsReturnType(derived()); } /** \returns an expression of the coefficient-wise squared absolute value of \c *this @@ -22,10 +41,10 @@ abs() const * \sa abs(), square() */ EIGEN_DEVICE_FUNC -EIGEN_STRONG_INLINE const CwiseUnaryOp, const Derived> +EIGEN_STRONG_INLINE const Abs2ReturnType abs2() const { - return derived(); + return Abs2ReturnType(derived()); } /** \returns an expression of the coefficient-wise exponential of *this. @@ -39,10 +58,10 @@ abs2() const * \sa pow(), log(), sin(), cos() */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp, const Derived> +inline const ExpReturnType exp() const { - return derived(); + return ExpReturnType(derived()); } /** \returns an expression of the coefficient-wise logarithm of *this. @@ -56,10 +75,10 @@ exp() const * \sa exp() */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp, const Derived> +inline const LogReturnType log() const { - return derived(); + return LogReturnType(derived()); } /** \returns an expression of the coefficient-wise square root of *this. @@ -73,10 +92,10 @@ log() const * \sa pow(), square() */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp, const Derived> +inline const SqrtReturnType sqrt() const { - return derived(); + return SqrtReturnType(derived()); } /** \returns an expression of the coefficient-wise cosine of *this. @@ -90,10 +109,10 @@ sqrt() const * \sa sin(), acos() */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp, const Derived> +inline const CosReturnType cos() const { - return derived(); + return CosReturnType(derived()); } @@ -108,10 +127,10 @@ cos() const * \sa cos(), asin() */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp, const Derived> +inline const SinReturnType sin() const { - return derived(); + return SinReturnType(derived()); } /** \returns an expression of the coefficient-wise arc cosine of *this. @@ -122,10 +141,10 @@ sin() const * \sa cos(), asin() */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp, const Derived> +inline const AcosReturnType acos() const { - return derived(); + return AcosReturnType(derived()); } /** \returns an expression of the coefficient-wise arc sine of *this. @@ -136,10 +155,10 @@ acos() const * \sa sin(), acos() */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp, const Derived> +inline const AsinReturnType asin() const { - return derived(); + return AsinReturnType(derived()); } /** \returns an expression of the coefficient-wise tan of *this. @@ -150,10 +169,10 @@ asin() const * \sa cos(), sin() */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp, Derived> +inline const TanReturnType tan() const { - return derived(); + return TanReturnType(derived()); } /** \returns an expression of the coefficient-wise arc tan of *this. @@ -163,10 +182,10 @@ tan() const * * \sa cos(), sin(), tan() */ -inline const CwiseUnaryOp, Derived> +inline const AtanReturnType atan() const { - return derived(); + return AtanReturnType(derived()); } /** \returns an expression of the coefficient-wise power of *this to the given exponent. @@ -180,11 +199,10 @@ atan() const * \sa exp(), log() */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp, const Derived> +inline const PowReturnType pow(const Scalar& exponent) const { - return CwiseUnaryOp, const Derived> - (derived(), internal::scalar_pow_op(exponent)); + return PowReturnType(derived(), internal::scalar_pow_op(exponent)); } @@ -196,10 +214,10 @@ pow(const Scalar& exponent) const * \sa operator/(), operator*() */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp, const Derived> +inline const CwiseInverseReturnType inverse() const { - return derived(); + return CwiseInverseReturnType(derived()); } /** \returns an expression of the coefficient-wise square of *this. @@ -210,10 +228,10 @@ inverse() const * \sa operator/(), operator*(), abs2() */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp, const Derived> +inline const SquareReturnType square() const { - return derived(); + return SquareReturnType(derived()); } /** \returns an expression of the coefficient-wise cube of *this. @@ -224,10 +242,10 @@ square() const * \sa square(), pow() */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp, const Derived> +inline const CubeReturnType cube() const { - return derived(); + return CubeReturnType(derived()); } #define EIGEN_MAKE_SCALAR_CWISE_UNARY_OP(METHOD_NAME,FUNCTOR) \ diff --git a/Eigen/src/plugins/CommonCwiseUnaryOps.h b/Eigen/src/plugins/CommonCwiseUnaryOps.h index a17153e64..050bce03c 100644 --- a/Eigen/src/plugins/CommonCwiseUnaryOps.h +++ b/Eigen/src/plugins/CommonCwiseUnaryOps.h @@ -14,6 +14,8 @@ /** \internal Represents a scalar multiple of an expression */ typedef CwiseUnaryOp, const Derived> ScalarMultipleReturnType; +typedef CwiseUnaryOp >, const Derived> ScalarComplexMultipleReturnType; + /** \internal Represents a quotient of an expression by a scalar*/ typedef CwiseUnaryOp, const Derived> ScalarQuotient1ReturnType; /** \internal the return type of conjugate() */ @@ -36,13 +38,16 @@ typedef CwiseUnaryOp, const Derived> ImagReturn /** \internal the return type of imag() */ typedef CwiseUnaryView, Derived> NonConstImagReturnType; +typedef CwiseUnaryOp, const Derived> NegativeReturnType; +//typedef CwiseUnaryOp, const Derived> + #endif // not EIGEN_PARSED_BY_DOXYGEN /** \returns an expression of the opposite of \c *this */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp::Scalar>, const Derived> -operator-() const { return derived(); } +inline const NegativeReturnType +operator-() const { return NegativeReturnType(derived()); } /** \returns an expression of \c *this scaled by the scalar factor \a scalar */ @@ -50,8 +55,7 @@ EIGEN_DEVICE_FUNC inline const ScalarMultipleReturnType operator*(const Scalar& scalar) const { - return CwiseUnaryOp, const Derived> - (derived(), internal::scalar_multiple_op(scalar)); + return ScalarMultipleReturnType(derived(), internal::scalar_multiple_op(scalar)); } #ifdef EIGEN_PARSED_BY_DOXYGEN @@ -60,20 +64,18 @@ const ScalarMultipleReturnType operator*(const RealScalar& scalar) const; /** \returns an expression of \c *this divided by the scalar value \a scalar */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp::Scalar>, const Derived> +inline const ScalarQuotient1ReturnType operator/(const Scalar& scalar) const { - return CwiseUnaryOp, const Derived> - (derived(), internal::scalar_quotient1_op(scalar)); + return ScalarQuotient1ReturnType(derived(), internal::scalar_quotient1_op(scalar)); } /** Overloaded for efficient real matrix times complex scalar value */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp >, const Derived> +inline const ScalarComplexMultipleReturnType operator*(const std::complex& scalar) const { - return CwiseUnaryOp >, const Derived> - (*static_cast(this), internal::scalar_multiple2_op >(scalar)); + return ScalarComplexMultipleReturnType(derived(), internal::scalar_multiple2_op >(scalar)); } EIGEN_DEVICE_FUNC @@ -86,6 +88,9 @@ inline friend const CwiseUnaryOp& scalar, const StorageBaseType& matrix) { return matrix*scalar; } + +template struct CastXpr { typedef typename internal::cast_return_type, const Derived> >::type Type; }; + /** \returns an expression of *this with the \a Scalar type casted to * \a NewScalar. * @@ -95,10 +100,10 @@ operator*(const std::complex& scalar, const StorageBaseType& matrix) */ template EIGEN_DEVICE_FUNC -typename internal::cast_return_type::Scalar, NewType>, const Derived> >::type +typename CastXpr::Type cast() const { - return derived(); + return typename CastXpr::Type(derived()); } /** \returns an expression of the complex conjugate of \c *this. @@ -116,14 +121,14 @@ conjugate() const * \sa imag() */ EIGEN_DEVICE_FUNC inline RealReturnType -real() const { return derived(); } +real() const { return RealReturnType(derived()); } /** \returns an read-only expression of the imaginary part of \c *this. * * \sa real() */ EIGEN_DEVICE_FUNC inline const ImagReturnType -imag() const { return derived(); } +imag() const { return ImagReturnType(derived()); } /** \brief Apply a unary operator coefficient-wise * \param[in] func Functor implementing the unary operator @@ -176,11 +181,11 @@ unaryViewExpr(const CustomViewOp& func = CustomViewOp()) const * \sa imag() */ EIGEN_DEVICE_FUNC inline NonConstRealReturnType -real() { return derived(); } +real() { return NonConstRealReturnType(derived()); } /** \returns a non const expression of the imaginary part of \c *this. * * \sa real() */ EIGEN_DEVICE_FUNC inline NonConstImagReturnType -imag() { return derived(); } +imag() { return NonConstImagReturnType(derived()); } diff --git a/Eigen/src/plugins/MatrixCwiseUnaryOps.h b/Eigen/src/plugins/MatrixCwiseUnaryOps.h index 1bb15f862..045a2ebb2 100644 --- a/Eigen/src/plugins/MatrixCwiseUnaryOps.h +++ b/Eigen/src/plugins/MatrixCwiseUnaryOps.h @@ -10,6 +10,11 @@ // This file is a base class plugin containing matrix specifics coefficient wise functions. +typedef CwiseUnaryOp, const Derived> AbsReturnType; +typedef CwiseUnaryOp, const Derived> Abs2ReturnType; +typedef CwiseUnaryOp, const Derived> SqrtReturnType; +typedef CwiseUnaryOp, const Derived> CwiseInverseReturnType; +typedef CwiseUnaryOp >, const Derived> CwiseScalarEqualReturnType; /** \returns an expression of the coefficient-wise absolute value of \c *this * * Example: \include MatrixBase_cwiseAbs.cpp @@ -18,8 +23,8 @@ * \sa cwiseAbs2() */ EIGEN_DEVICE_FUNC -EIGEN_STRONG_INLINE const CwiseUnaryOp, const Derived> -cwiseAbs() const { return derived(); } +EIGEN_STRONG_INLINE const AbsReturnType +cwiseAbs() const { return AbsReturnType(derived()); } /** \returns an expression of the coefficient-wise squared absolute value of \c *this * @@ -29,8 +34,8 @@ cwiseAbs() const { return derived(); } * \sa cwiseAbs() */ EIGEN_DEVICE_FUNC -EIGEN_STRONG_INLINE const CwiseUnaryOp, const Derived> -cwiseAbs2() const { return derived(); } +EIGEN_STRONG_INLINE const Abs2ReturnType +cwiseAbs2() const { return Abs2ReturnType(derived()); } /** \returns an expression of the coefficient-wise square root of *this. * @@ -40,8 +45,8 @@ cwiseAbs2() const { return derived(); } * \sa cwisePow(), cwiseSquare() */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp, const Derived> -cwiseSqrt() const { return derived(); } +inline const SqrtReturnType +cwiseSqrt() const { return SqrtReturnType(derived()); } /** \returns an expression of the coefficient-wise inverse of *this. * @@ -51,8 +56,8 @@ cwiseSqrt() const { return derived(); } * \sa cwiseProduct() */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp, const Derived> -cwiseInverse() const { return derived(); } +inline const CwiseInverseReturnType +cwiseInverse() const { return CwiseInverseReturnType(derived()); } /** \returns an expression of the coefficient-wise == operator of \c *this and a scalar \a s * @@ -64,9 +69,8 @@ cwiseInverse() const { return derived(); } * \sa cwiseEqual(const MatrixBase &) const */ EIGEN_DEVICE_FUNC -inline const CwiseUnaryOp >, const Derived> +inline const CwiseScalarEqualReturnType cwiseEqual(const Scalar& s) const { - return CwiseUnaryOp >,const Derived> - (derived(), std::bind1st(std::equal_to(), s)); + return CwiseScalarEqualReturnType(derived(), std::bind1st(std::equal_to(), s)); }