Make constructors explicit if they could lead to unintended implicit conversion

Eigen/src/Cholesky/LDLT.h

@@ -85,7 +85,7 @@ template<typename _MatrixType, int _UpLo> 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<typename _MatrixType, int _UpLo> 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<typename MatrixType> struct LDLT_Traits<MatrixType,Lower>
 {
   typedef const TriangularView<const MatrixType, UnitLower> MatrixL;
   typedef const TriangularView<const typename MatrixType::AdjointReturnType, UnitUpper> MatrixU;
-  static inline MatrixL getL(const MatrixType& m) { return m; }
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
-  static inline MatrixU getU(const MatrixType& m) { return m.adjoint(); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
 };
 
 template<typename MatrixType> struct LDLT_Traits<MatrixType,Upper>
 {
   typedef const TriangularView<const typename MatrixType::AdjointReturnType, UnitLower> MatrixL;
   typedef const TriangularView<const MatrixType, UnitUpper> MatrixU;
-  static inline MatrixL getL(const MatrixType& m) { return m.adjoint(); }
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
-  static inline MatrixU getU(const MatrixType& m) { return m; }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
 };
 
 } // end namespace internal

Eigen/src/Cholesky/LLT.h

@@ -83,10 +83,10 @@ template<typename _MatrixType, int _UpLo> 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<typename MatrixType> struct LLT_Traits<MatrixType,Lower>
 {
   typedef const TriangularView<const MatrixType, Lower> MatrixL;
   typedef const TriangularView<const typename MatrixType::AdjointReturnType, Upper> MatrixU;
-  static inline MatrixL getL(const MatrixType& m) { return m; }
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
-  static inline MatrixU getU(const MatrixType& m) { return m.adjoint(); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
   static bool inplace_decomposition(MatrixType& m)
   { return llt_inplace<typename MatrixType::Scalar, Lower>::blocked(m)==-1; }
 };
@@ -361,8 +361,8 @@ template<typename MatrixType> struct LLT_Traits<MatrixType,Upper>
 {
   typedef const TriangularView<const typename MatrixType::AdjointReturnType, Lower> MatrixL;
   typedef const TriangularView<const MatrixType, Upper> MatrixU;
-  static inline MatrixL getL(const MatrixType& m) { return m.adjoint(); }
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
-  static inline MatrixU getU(const MatrixType& m) { return m; }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
   static bool inplace_decomposition(MatrixType& m)
   { return llt_inplace<typename MatrixType::Scalar, Upper>::blocked(m)==-1; }
 };

Eigen/src/CholmodSupport/CholmodSupport.h

@@ -180,7 +180,7 @@ class CholmodBase : public SparseSolverBase<Derived>
       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);

Eigen/src/Core/ArrayBase.h

@@ -158,9 +158,9 @@ template<typename Derived> class ArrayBase
     /** \returns an \link Eigen::MatrixBase Matrix \endlink expression of this array
       * \sa MatrixBase::array() */
     EIGEN_DEVICE_FUNC
-    MatrixWrapper<Derived> matrix() { return derived(); }
+    MatrixWrapper<Derived> matrix() { return MatrixWrapper<Derived>(derived()); }
     EIGEN_DEVICE_FUNC
-    const MatrixWrapper<const Derived> matrix() const { return derived(); }
+    const MatrixWrapper<const Derived> matrix() const { return MatrixWrapper<const Derived>(derived()); }
 
 //     template<typename Dest>
 //     inline void evalTo(Dest& dst) const { dst = matrix(); }

Eigen/src/Core/ArrayWrapper.h

@@ -55,7 +55,7 @@ class ArrayWrapper : public ArrayBase<ArrayWrapper<ExpressionType> >
     typedef typename internal::nested<ExpressionType>::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<MatrixWrapper<ExpressionType> >
     typedef typename internal::nested<ExpressionType>::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(); }

Eigen/src/Core/BandMatrix.h

@@ -204,7 +204,7 @@ class BandMatrix : public BandMatrixBase<BandMatrix<_Scalar,Rows,Cols,Supers,Sub
     typedef typename internal::traits<BandMatrix>::Index Index;
     typedef typename internal::traits<BandMatrix>::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<BandMatrixWrapper<_CoefficientsT
     typedef typename internal::traits<BandMatrixWrapper>::CoefficientsType CoefficientsType;
     typedef typename internal::traits<BandMatrixWrapper>::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<Scalar,Size,Size,Options&SelfAdjoint
     typedef BandMatrix<Scalar,Size,Size,Options&SelfAdjoint?0:1,1,Options|RowMajor> 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>(); }

Eigen/src/Core/CoreEvaluators.h

@@ -34,6 +34,11 @@ template<typename StorageKind> struct storage_kind_to_shape;
 
 template<> struct storage_kind_to_shape<Dense> { typedef DenseShape Shape; };
 
+
+// FIXME Is this necessary? And why was it not before refactoring???
+template<> struct storage_kind_to_shape<PermutationStorage> { 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<typename T>
 struct evaluator : public unary_evaluator<T>
 {
   typedef unary_evaluator<T> Base;
-  evaluator(const T& xpr) : Base(xpr) {}
+  explicit evaluator(const T& xpr) : Base(xpr) {}
 };
 
 
@@ -150,7 +155,7 @@ struct evaluator<PlainObjectBase<Derived> >
                                            : 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<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> >
 
   evaluator() {}
   
-  evaluator(const XprType& m) 
+  explicit evaluator(const XprType& m)
     : evaluator<PlainObjectBase<XprType> >(m) 
   { }
 };
@@ -260,7 +265,7 @@ struct unary_evaluator<Transpose<ArgType>, IndexBased>
     Flags = evaluator<ArgType>::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<CwiseNullaryOp<NullaryOp,PlainObjectType> >
           | (functor_traits<NullaryOp>::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<CwiseUnaryOp<UnaryOp, ArgType>, IndexBased >
             | (functor_traits<UnaryOp>::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<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
   typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
   typedef binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > Base;
   
-  evaluator(const XprType& xpr) : Base(xpr) {}
+  explicit evaluator(const XprType& xpr) : Base(xpr) {}
 };
 
 template<typename BinaryOp, typename Lhs, typename Rhs>
@@ -461,7 +466,7 @@ struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, 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<CwiseUnaryView<UnaryOp, ArgType>, IndexBased>
     Flags = (evaluator<ArgType>::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<Derived>
     CoeffReadCost = NumTraits<Scalar>::ReadCost
   };
   
-  mapbase_evaluator(const XprType& map) 
+  explicit mapbase_evaluator(const XprType& map)
     : m_data(const_cast<PointerType>(map.data())),  
       m_xpr(map)
   {
@@ -663,7 +668,7 @@ struct evaluator<Map<PlainObjectType, MapOptions, StrideType> >
     Flags = KeepsPacketAccess ? int(Flags2) : (int(Flags2) & ~PacketAccessBit)
   };
 
-  evaluator(const XprType& map) 
+  explicit evaluator(const XprType& map)
     : mapbase_evaluator<XprType, PlainObjectType>(map) 
   { }
 };
@@ -680,7 +685,7 @@ struct evaluator<Ref<PlainObjectType, RefOptions, StrideType> >
     Flags = evaluator<Map<PlainObjectType, RefOptions, StrideType> >::Flags
   };
 
-  evaluator(const XprType& ref) 
+  explicit evaluator(const XprType& ref)
     : mapbase_evaluator<XprType, PlainObjectType>(ref) 
   { }
 };
@@ -731,7 +736,7 @@ struct evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel> >
     Flags = Flags0 | FlagsLinearAccessBit | FlagsRowMajorBit
   };
   typedef block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel> 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<ArgType, BlockRows, BlockCols, InnerPanel, /*HasDirectAcc
 {
   typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
 
-  block_evaluator(const XprType& block) 
+  explicit block_evaluator(const XprType& block)
     : unary_evaluator<XprType>(block) 
   {}
 };
@@ -752,7 +757,7 @@ struct unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>, IndexBa
 {
   typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> 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<ArgType, BlockRows, BlockCols, InnerPanel, /* HasDirectAc
 {
   typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
 
-  block_evaluator(const XprType& block) 
+  explicit block_evaluator(const XprType& block)
     : mapbase_evaluator<XprType, typename XprType::PlainObject>(block) 
   {
     // FIXME this should be an internal assertion
@@ -857,7 +862,7 @@ struct evaluator<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
     Flags = (unsigned int)evaluator<ThenMatrixType>::Flags & evaluator<ElseMatrixType>::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<Replicate<ArgType, RowFactor, ColFactor> >
     Flags = (evaluator<ArgTypeNestedCleaned>::Flags & HereditaryBits & ~RowMajorBit) | (traits<XprType>::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<PartialReduxExpr<ArgType, MemberOp, Direction> >
     Flags = (traits<XprType>::Flags&RowMajorBit) | (evaluator<ArgType>::Flags&HereditaryBits)
   };
 
-  evaluator(const XprType expr)
+  explicit evaluator(const XprType expr)
     : m_expr(expr)
   {}
 
@@ -1012,7 +1017,7 @@ struct evaluator_wrapper_base
     Flags = evaluator<ArgType>::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<MatrixWrapper<TArgType> >
 {
   typedef MatrixWrapper<TArgType> XprType;
 
-  unary_evaluator(const XprType& wrapper) 
+  explicit unary_evaluator(const XprType& wrapper)
     : evaluator_wrapper_base<MatrixWrapper<TArgType> >(wrapper.nestedExpression())
   { }
 };
@@ -1085,7 +1090,7 @@ struct unary_evaluator<ArrayWrapper<TArgType> >
 {
   typedef ArrayWrapper<TArgType> XprType;
 
-  unary_evaluator(const XprType& wrapper) 
+  explicit unary_evaluator(const XprType& wrapper)
     : evaluator_wrapper_base<ArrayWrapper<TArgType> >(wrapper.nestedExpression())
   { }
 };
@@ -1131,7 +1136,7 @@ struct unary_evaluator<Reverse<ArgType, Direction> >
   };
   typedef internal::reverse_packet_cond<PacketScalar,ReversePacket> 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<Diagonal<ArgType, DiagIndex> >
     Flags = (unsigned int)evaluator<ArgType>::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<EvalToTemp>::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<EvalToTemp<ArgType> >
   typedef evaluator type;
   typedef evaluator nestedType;
 
-  evaluator(const XprType& xpr) 
+  explicit evaluator(const XprType& xpr)
     : m_result(xpr.rows(), xpr.cols())
   {
     ::new (static_cast<Base*>(this)) Base(m_result);

Eigen/src/Core/CwiseUnaryOp.h

@@ -63,7 +63,7 @@ class CwiseUnaryOp : internal::no_assignment_operator,
     typedef typename internal::remove_all<XprType>::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

Eigen/src/Core/CwiseUnaryView.h

@@ -63,7 +63,7 @@ class CwiseUnaryView : public CwiseUnaryViewImpl<ViewOp, MatrixType, typename in
     EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryView)
     typedef typename internal::remove_all<MatrixType>::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)

Eigen/src/Core/DenseBase.h

@@ -275,6 +275,7 @@ template<typename Derived> class DenseBase
 
     // TODO flagged is temporarly disabled. It seems useless now
     template<unsigned int Added,unsigned int Removed>
+    EIGEN_DEPRECATED
     const Derived& flagged() const
     { return derived(); }
 
@@ -282,8 +283,9 @@ template<typename Derived> class DenseBase
     EIGEN_DEVICE_FUNC
     CommaInitializer<Derived> operator<< (const DenseBase<OtherDerived>& other);
 
+    typedef Transpose<Derived> TransposeReturnType;
     EIGEN_DEVICE_FUNC
-    Eigen::Transpose<Derived> transpose();
+    TransposeReturnType transpose();
     typedef typename internal::add_const<Transpose<const Derived> >::type ConstTransposeReturnType;
     EIGEN_DEVICE_FUNC
     ConstTransposeReturnType transpose() const;

Eigen/src/Core/DenseStorage.h

@@ -130,7 +130,7 @@ template<typename T, int Size, int _Rows, int _Cols, int _Options> 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<typename T, int _Rows, int _Cols, int _Options> class DenseStorage<T, 0
 {
   public:
     EIGEN_DEVICE_FUNC DenseStorage() {}
-    EIGEN_DEVICE_FUNC DenseStorage(internal::constructor_without_unaligned_array_assert) {}
+    EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_unaligned_array_assert) {}
     EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage&) {}
     EIGEN_DEVICE_FUNC DenseStorage& operator=(const DenseStorage&) { return *this; }
     EIGEN_DEVICE_FUNC DenseStorage(DenseIndex,DenseIndex,DenseIndex) {}
@@ -186,7 +186,7 @@ template<typename T, int Size, int _Options> class DenseStorage<T, Size, Dynamic
     DenseIndex m_cols;
   public:
     EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0), m_cols(0) {}
-    DenseStorage(internal::constructor_without_unaligned_array_assert)
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
       : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0), m_cols(0) {}
     DenseStorage(const DenseStorage& other) : m_data(other.m_data), m_rows(other.m_rows), m_cols(other.m_cols) {}
     DenseStorage& operator=(const DenseStorage& other) 
@@ -217,7 +217,7 @@ template<typename T, int Size, int _Cols, int _Options> class DenseStorage<T, Si
     DenseIndex m_rows;
   public:
     EIGEN_DEVICE_FUNC DenseStorage() : m_rows(0) {}
-    DenseStorage(internal::constructor_without_unaligned_array_assert)
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
       : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0) {}
     DenseStorage(const DenseStorage& other) : m_data(other.m_data), m_rows(other.m_rows) {}
     DenseStorage& operator=(const DenseStorage& other) 
@@ -246,7 +246,7 @@ template<typename T, int Size, int _Rows, int _Options> class DenseStorage<T, Si
     DenseIndex m_cols;
   public:
     EIGEN_DEVICE_FUNC DenseStorage() : m_cols(0) {}
-    DenseStorage(internal::constructor_without_unaligned_array_assert)
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
       : m_data(internal::constructor_without_unaligned_array_assert()), m_cols(0) {}
     DenseStorage(const DenseStorage& other) : m_data(other.m_data), m_cols(other.m_cols) {}
     DenseStorage& operator=(const DenseStorage& other)
@@ -276,7 +276,7 @@ template<typename T, int _Options> class DenseStorage<T, Dynamic, Dynamic, Dynam
     DenseIndex m_cols;
   public:
     EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_rows(0), m_cols(0) {}
-    DenseStorage(internal::constructor_without_unaligned_array_assert)
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert)
        : m_data(0), m_rows(0), m_cols(0) {}
     DenseStorage(DenseIndex size, DenseIndex nbRows, DenseIndex nbCols)
       : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_rows(nbRows), m_cols(nbCols)
@@ -350,7 +350,7 @@ template<typename T, int _Rows, int _Options> class DenseStorage<T, Dynamic, _Ro
     DenseIndex m_cols;
   public:
     EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_cols(0) {}
-    DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_cols(0) {}
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_cols(0) {}
     DenseStorage(DenseIndex size, DenseIndex, DenseIndex nbCols) : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_cols(nbCols)
     { EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN }
     DenseStorage(const DenseStorage& other)
@@ -416,7 +416,7 @@ template<typename T, int _Cols, int _Options> class DenseStorage<T, Dynamic, Dyn
     DenseIndex m_rows;
   public:
     EIGEN_DEVICE_FUNC DenseStorage() : m_data(0), m_rows(0) {}
-    DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_rows(0) {}
+    explicit DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_rows(0) {}
     DenseStorage(DenseIndex size, DenseIndex nbRows, DenseIndex) : m_data(internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size)), m_rows(nbRows)
     { EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN }
     DenseStorage(const DenseStorage& other)

Eigen/src/Core/Diagonal.h

@@ -70,7 +70,7 @@ template<typename MatrixType, int _DiagIndex> 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<typename Derived>
 inline typename MatrixBase<Derived>::DiagonalReturnType
 MatrixBase<Derived>::diagonal()
 {
-  return derived();
+  return DiagonalReturnType(derived());
 }
 
 /** This is the const version of diagonal(). */
@@ -238,20 +238,20 @@ MatrixBase<Derived>::diagonal(Index index) const
   *
   * \sa MatrixBase::diagonal(), class Diagonal */
 template<typename Derived>
-template<int Index>
+template<int Index_>
-inline typename MatrixBase<Derived>::template DiagonalIndexReturnType<Index>::Type
+inline typename MatrixBase<Derived>::template DiagonalIndexReturnType<Index_>::Type
 MatrixBase<Derived>::diagonal()
 {
-  return derived();
+  return typename DiagonalIndexReturnType<Index_>::Type(derived());
 }
 
 /** This is the const version of diagonal<int>(). */
 template<typename Derived>
-template<int Index>
+template<int Index_>
-inline typename MatrixBase<Derived>::template ConstDiagonalIndexReturnType<Index>::Type
+inline typename MatrixBase<Derived>::template ConstDiagonalIndexReturnType<Index_>::Type
 MatrixBase<Derived>::diagonal() const
 {
-  return derived();
+  return typename ConstDiagonalIndexReturnType<Index_>::Type(derived());
 }
 
 } // end namespace Eigen

Eigen/src/Core/DiagonalMatrix.h

@@ -63,24 +63,26 @@ class DiagonalBase : public EigenBase<Derived>
       return Product<Derived, MatrixDerived, LazyProduct>(derived(),matrix.derived());
     }
 
+    typedef DiagonalWrapper<const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const DiagonalVectorType> > InverseReturnType;
     EIGEN_DEVICE_FUNC
-    inline const DiagonalWrapper<const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const DiagonalVectorType> >
+    inline const InverseReturnType
     inverse() const
     {
-      return diagonal().cwiseInverse();
+      return InverseReturnType(diagonal().cwiseInverse());
     }
     
+    typedef DiagonalWrapper<const CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const DiagonalVectorType> > ScalarMultipleReturnType;
     EIGEN_DEVICE_FUNC
-    inline const DiagonalWrapper<const CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, 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 CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, 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<typename Derived>
 inline const DiagonalWrapper<const Derived>
 MatrixBase<Derived>::asDiagonal() const
 {
-  return derived();
+  return DiagonalWrapper<const Derived>(derived());
 }
 
 /** \returns true if *this is approximately equal to a diagonal matrix,

Eigen/src/Core/Flagged.h

@@ -48,7 +48,7 @@ template<typename ExpressionType, unsigned int Added, unsigned int Removed> 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<unsigned int Added,unsigned int Removed>
 inline const Flagged<Derived, Added, Removed>
 DenseBase<Derived>::flagged() const
 {
-  return derived();
+  return Flagged<Derived, Added, Removed>(derived());
 }
 
 } // end namespace Eigen

Eigen/src/Core/ForceAlignedAccess.h

@@ -39,7 +39,7 @@ template<typename ExpressionType> class ForceAlignedAccess
     typedef typename internal::dense_xpr_base<ForceAlignedAccess>::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<bool Enable>
 inline typename internal::add_const_on_value_type<typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type>::type
 MatrixBase<Derived>::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<bool Enable>
 inline typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type
 MatrixBase<Derived>::forceAlignedAccessIf()
 {
-  return derived();
+  return derived();  // FIXME This should not work but apparently is never used
 }
 
 } // end namespace Eigen

Eigen/src/Core/GlobalFunctions.h

@@ -15,7 +15,7 @@
   template<typename Derived> \
   inline const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived> \
   NAME(const Eigen::ArrayBase<Derived>& x) { \
-    return x.derived(); \
+    return Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, const Derived>(x.derived()); \
   }
 
 #define EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(NAME,FUNCTOR) \
@@ -30,7 +30,7 @@
   { \
     static inline typename NAME##_retval<ArrayBase<Derived> >::type run(const Eigen::ArrayBase<Derived>& x) \
     { \
-      return x.derived(); \
+      return typename NAME##_retval<ArrayBase<Derived> >::type(x.derived()); \
     } \
   };
 

Eigen/src/Core/Inverse.h

@@ -51,7 +51,7 @@ public:
   typedef typename internal::nested<XprType>::type            XprTypeNested;
   typedef typename internal::remove_all<XprTypeNested>::type  XprTypeNestedCleaned;
   
-  Inverse(const XprType &xpr)
+  explicit Inverse(const XprType &xpr)
     : m_xpr(xpr)
   {}
   

Eigen/src/Core/Map.h

@@ -122,7 +122,7 @@ template<typename PlainObjectType, int MapOptions, typename StrideType> 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();

Eigen/src/Core/MapBase.h

@@ -128,7 +128,7 @@ template<typename Derived> class MapBase<Derived, ReadOnlyAccessors>
     }
 
     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();

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 }
 

Eigen/src/Core/MatrixBase.h

@@ -327,7 +327,7 @@ template<typename Derived> class MatrixBase
 
     NoAlias<Derived,Eigen::MatrixBase > 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<typename Derived> class MatrixBase
 
     /** \returns an \link Eigen::ArrayBase Array \endlink expression of this matrix
       * \sa ArrayBase::matrix() */
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ArrayWrapper<Derived> array() { return derived(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ArrayWrapper<Derived> array() { return ArrayWrapper<Derived>(derived()); }
     /** \returns a const \link Eigen::ArrayBase Array \endlink expression of this matrix
       * \sa ArrayBase::matrix() */
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ArrayWrapper<const Derived> array() const { return derived(); }
+    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ArrayWrapper<const Derived> array() const { return ArrayWrapper<const Derived>(derived()); }
 
 /////////// LU module ///////////
 

Eigen/src/Core/NestByValue.h

@@ -40,7 +40,7 @@ template<typename ExpressionType> class NestByValue
     typedef typename internal::dense_xpr_base<NestByValue>::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(); }

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<typename OtherDerived>
     EIGEN_DEVICE_FUNC
@@ -100,7 +100,7 @@ class NoAlias
 template<typename Derived>
 NoAlias<Derived,MatrixBase> MatrixBase<Derived>::noalias()
 {
-  return derived();
+  return NoAlias<Derived, Eigen::MatrixBase >(derived());
 }
 
 } // end namespace Eigen

Eigen/src/Core/PermutationMatrix.h

@@ -73,6 +73,7 @@ class PermutationBase : public EigenBase<Derived>
     typedef PermutationMatrix<IndicesType::SizeAtCompileTime,IndicesType::MaxSizeAtCompileTime,StorageIndexType>
             PlainPermutationType;
     using Base::derived;
+    typedef Transpose<PermutationBase> TransposeReturnType;
     #endif
 
     /** Copies the other permutation into *this */
@@ -198,14 +199,14 @@ class PermutationBase : public EigenBase<Derived>
       *
       * \note \note_try_to_help_rvo
       */
-    inline Transpose<PermutationBase> inverse() const
+    inline TransposeReturnType inverse() const
-    { return derived(); }
+    { return TransposeReturnType(derived()); }
     /** \returns the tranpose permutation matrix.
       *
       * \note \note_try_to_help_rvo
       */
-    inline Transpose<PermutationBase> transpose() const
+    inline TransposeReturnType transpose() const
-    { return derived(); }
+    { return TransposeReturnType(derived()); }
 
     /**** multiplication helpers to hopefully get RVO ****/
 
@@ -301,7 +302,7 @@ class PermutationMatrix : public PermutationBase<PermutationMatrix<SizeAtCompile
 
     /** Constructs an uninitialized permutation matrix of given size.
       */
-    inline PermutationMatrix(Index size) : m_indices(size)
+    explicit inline PermutationMatrix(Index size) : m_indices(size)
     {}
 
     /** Copy constructor. */

Eigen/src/Core/PlainObjectBase.h

@@ -457,7 +457,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::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

Eigen/src/Core/ProductEvaluators.h

@@ -35,7 +35,7 @@ struct evaluator<Product<Lhs, Rhs, Options> >
   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<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>,  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<Diagonal<const Product<Lhs, Rhs, DefaultProduct>, DiagIndex> >
   typedef evaluator type;
   typedef evaluator nestedType;
 
-  evaluator(const XprType& xpr)
+  explicit evaluator(const XprType& xpr)
     : Base(Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagIndex>(
         Product<Lhs, Rhs, LazyProduct>(xpr.nestedExpression().lhs(), xpr.nestedExpression().rhs()),
         xpr.index() ))
@@ -103,7 +103,7 @@ struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, LhsShape
   typedef typename XprType::PlainObject PlainObject;
   typedef typename evaluator<PlainObject>::type Base;
 
-  product_evaluator(const XprType& xpr)
+  explicit product_evaluator(const XprType& xpr)
     : m_result(xpr.rows(), xpr.cols())
   {
     ::new (static_cast<Base*>(this)) Base(m_result);
@@ -242,7 +242,7 @@ struct generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,OuterProduct>
   struct sub  { template<typename Dst, typename Src> 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<typename Dst, typename Src> void operator()(const Dst& dst, const Src& src) const {
       dst.const_cast_derived() += m_scale * src;
     }
@@ -377,7 +377,7 @@ struct product_evaluator<Product<Lhs, Rhs, LazyProduct>, 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<Product<Lhs, Rhs, DefaultProduct>, LazyCoeffBasedProduc
   typedef Product<Lhs, Rhs, DefaultProduct> XprType;
   typedef Product<Lhs, Rhs, LazyProduct> BaseProduct;
   typedef product_evaluator<BaseProduct, CoeffBasedProductMode, DenseShape, DenseShape, typename Lhs::Scalar, typename Rhs::Scalar > 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<Product<Lhs, Rhs, ProductKind>, 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<Product<Lhs, Rhs, ProductKind>, 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())
   {
   }

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;

Eigen/src/Core/ReturnByValue.h

@@ -103,7 +103,7 @@ struct evaluator<ReturnByValue<Derived> >
   typedef evaluator type;
   typedef evaluator nestedType;
 
-  evaluator(const XprType& xpr) 
+  explicit evaluator(const XprType& xpr)
     : m_result(xpr.rows(), xpr.cols())
   {
     ::new (static_cast<Base*>(this)) Base(m_result);

Eigen/src/Core/Reverse.h

@@ -89,7 +89,7 @@ template<typename MatrixType, int Direction> class Reverse
     typedef internal::reverse_packet_cond<PacketScalar,ReversePacket> 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<typename Derived>
 inline typename DenseBase<Derived>::ReverseReturnType
 DenseBase<Derived>::reverse()
 {
-  return derived();
+  return ReverseReturnType(derived());
 }
 
 /** This is the const version of reverse(). */
@@ -192,7 +192,7 @@ template<typename Derived>
 inline const typename DenseBase<Derived>::ConstReverseReturnType
 DenseBase<Derived>::reverse() const
 {
-  return derived();
+  return ConstReverseReturnType(derived());
 }
 
 /** This is the "in place" version of reverse: it reverses \c *this.

Eigen/src/Core/SelfAdjointView.h

@@ -67,7 +67,7 @@ template<typename _MatrixType, unsigned int UpLo> 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<unsigned int UpLo>
 typename MatrixBase<Derived>::template ConstSelfAdjointViewReturnType<UpLo>::Type
 MatrixBase<Derived>::selfadjointView() const
 {
-  return derived();
+  return typename ConstSelfAdjointViewReturnType<UpLo>::Type(derived());
 }
 
 template<typename Derived>
@@ -266,7 +266,7 @@ template<unsigned int UpLo>
 typename MatrixBase<Derived>::template SelfAdjointViewReturnType<UpLo>::Type
 MatrixBase<Derived>::selfadjointView()
 {
-  return derived();
+  return typename SelfAdjointViewReturnType<UpLo>::Type(derived());
 }
 
 } // end namespace Eigen

Eigen/src/Core/Solve.h

@@ -121,7 +121,7 @@ struct evaluator<Solve<Decomposition,RhsType> >
   typedef evaluator type;
   typedef evaluator nestedType;
 
-  evaluator(const SolveType& solve)
+  explicit evaluator(const SolveType& solve)
     : m_result(solve.rows(), solve.cols())
   {
     ::new (static_cast<Base*>(this)) Base(m_result);

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<Value, 0>
   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

Eigen/src/Core/Transpose.h

@@ -64,7 +64,7 @@ template<typename MatrixType> class Transpose
     typedef typename internal::remove_all<MatrixType>::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<typename Derived>
 inline Transpose<Derived>
 DenseBase<Derived>::transpose()
 {
-  return derived();
+  return TransposeReturnType(derived());
 }
 
 /** This is the const version of transpose().
@@ -207,8 +207,7 @@ template<typename Derived>
 inline const typename MatrixBase<Derived>::AdjointReturnType
 MatrixBase<Derived>::adjoint() const
 {
-  return this->transpose(); // in the complex case, the .conjugate() is be implicit here
+  return AdjointReturnType(this->transpose());
-                            // due to implicit conversion to return type
 }
 
 /***************************************************************************

Eigen/src/Core/Transpositions.h

@@ -240,7 +240,7 @@ class Map<Transpositions<SizeAtCompileTime,MaxSizeAtCompileTime,_StorageIndexTyp
     typedef typename IndicesType::Scalar StorageIndexType;
     typedef typename IndicesType::Index  Index;
 
-    inline Map(const StorageIndexType* indicesPtr)
+    explicit inline Map(const StorageIndexType* indicesPtr)
       : m_indices(indicesPtr)
     {}
 
@@ -299,7 +299,7 @@ class TranspositionsWrapper
     typedef typename IndicesType::Scalar StorageIndexType;
     typedef typename IndicesType::Index  Index;
 
-    inline TranspositionsWrapper(IndicesType& a_indices)
+    explicit inline TranspositionsWrapper(IndicesType& a_indices)
       : m_indices(a_indices)
     {}
 
@@ -414,7 +414,7 @@ class Transpose<TranspositionsBase<TranspositionsDerived> >
     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(); }
 

Eigen/src/Core/TriangularMatrix.h

@@ -211,8 +211,9 @@ template<typename _MatrixType, unsigned int _Mode> 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<typename _MatrixType, unsigned int _Mode> class TriangularView
     EIGEN_DEVICE_FUNC
     NestedExpression& nestedExpression() { return *const_cast<NestedExpression*>(&m_matrix); }
 
+    typedef TriangularView<MatrixConjugateReturnType,Mode> ConjugateReturnType;
     /** \sa MatrixBase::conjugate() */
     EIGEN_DEVICE_FUNC
-    inline TriangularView<MatrixConjugateReturnType,Mode> conjugate()
+    inline ConjugateReturnType conjugate()
-    { return m_matrix.conjugate(); }
+    { return ConjugateReturnType(m_matrix.conjugate()); }
     /** \sa MatrixBase::conjugate() const */
-    EIGEN_DEVICE_FUNC
-    inline const TriangularView<MatrixConjugateReturnType,Mode> conjugate() const
-    { return m_matrix.conjugate(); }
 
+    EIGEN_DEVICE_FUNC
+    inline const ConjugateReturnType conjugate() const
+    { return ConjugateReturnType(m_matrix.conjugate()); }
+
+    typedef TriangularView<const typename MatrixType::AdjointReturnType,TransposeMode> AdjointReturnType;
     /** \sa MatrixBase::adjoint() const */
     EIGEN_DEVICE_FUNC
-    inline const TriangularView<const typename MatrixType::AdjointReturnType,TransposeMode> adjoint() const
+    inline const AdjointReturnType adjoint() const
-    { return m_matrix.adjoint(); }
+    { return AdjointReturnType(m_matrix.adjoint()); }
 
-    /** \sa MatrixBase::transpose() */
+    typedef TriangularView<Transpose<MatrixType>,TransposeMode> TransposeReturnType;
+     /** \sa MatrixBase::transpose() */
     EIGEN_DEVICE_FUNC
-    inline TriangularView<Transpose<MatrixType>,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<Transpose<MatrixType>,TransposeMode> transpose() const
+    inline const TransposeReturnType transpose() const
     {
-      return m_matrix.transpose();
+      return TransposeReturnType(m_matrix.transpose());
     }
 
     template<typename Other>
@@ -556,7 +561,7 @@ template<unsigned int Mode>
 typename MatrixBase<Derived>::template TriangularViewReturnType<Mode>::Type
 MatrixBase<Derived>::triangularView()
 {
-  return derived();
+  return typename TriangularViewReturnType<Mode>::Type(derived());
 }
 
 /** This is the const version of MatrixBase::triangularView() */
@@ -565,7 +570,7 @@ template<unsigned int Mode>
 typename MatrixBase<Derived>::template ConstTriangularViewReturnType<Mode>::Type
 MatrixBase<Derived>::triangularView() const
 {
-  return derived();
+  return typename ConstTriangularViewReturnType<Mode>::Type(derived());
 }
 
 /** \returns true if *this is approximately equal to an upper triangular matrix,

Eigen/src/Core/VectorwiseOp.h

@@ -65,7 +65,7 @@ class PartialReduxExpr : internal::no_assignment_operator,
     typedef typename internal::traits<PartialReduxExpr>::MatrixTypeNested MatrixTypeNested;
     typedef typename internal::traits<PartialReduxExpr>::_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<typename _Scalar, int Size> struct Cost
   { enum { value = (Size-1) * functor_traits<BinaryOp>::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<typename Derived>
   inline result_type operator()(const DenseBase<Derived>& mat) const
   { return mat.redux(m_functor); }
@@ -249,7 +249,7 @@ template<typename ExpressionType, int Direction> 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<typename ExpressionType, int Direction> class VectorwiseOp
     redux(const BinaryOp& func = BinaryOp()) const
     { return typename ReduxReturnType<BinaryOp>::Type(_expression(), func); }
 
+    typedef typename ReturnType<internal::member_minCoeff>::Type MinCoeffReturnType;
+    typedef typename ReturnType<internal::member_maxCoeff>::Type MaxCoeffReturnType;
+    typedef typename ReturnType<internal::member_squaredNorm,RealScalar>::Type SquareNormReturnType;
+    typedef typename ReturnType<internal::member_norm,RealScalar>::Type NormReturnType;
+    typedef typename ReturnType<internal::member_blueNorm,RealScalar>::Type BlueNormReturnType;
+    typedef typename ReturnType<internal::member_stableNorm,RealScalar>::Type StableNormReturnType;
+    typedef typename ReturnType<internal::member_hypotNorm,RealScalar>::Type HypotNormReturnType;
+    typedef typename ReturnType<internal::member_sum>::Type SumReturnType;
+    typedef typename ReturnType<internal::member_mean>::Type MeanReturnType;
+    typedef typename ReturnType<internal::member_all>::Type AllReturnType;
+    typedef typename ReturnType<internal::member_any>::Type AnyReturnType;
+    typedef PartialReduxExpr<ExpressionType, internal::member_count<Index>, Direction> CountReturnType;
+    typedef typename ReturnType<internal::member_prod>::Type ProdReturnType;
+    typedef Reverse<ExpressionType, Direction> 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<typename ExpressionType, int Direction> class VectorwiseOp
       * Output: \verbinclude PartialRedux_minCoeff.out
       *
       * \sa DenseBase::minCoeff() */
-    const typename ReturnType<internal::member_minCoeff>::Type minCoeff() const
+    const MinCoeffReturnType minCoeff() const
-    { return _expression(); }
+    { 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<typename ExpressionType, int Direction> class VectorwiseOp
       * Output: \verbinclude PartialRedux_maxCoeff.out
       *
       * \sa DenseBase::maxCoeff() */
-    const typename ReturnType<internal::member_maxCoeff>::Type maxCoeff() const
+    const MaxCoeffReturnType maxCoeff() const
-    { return _expression(); }
+    { 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<typename ExpressionType, int Direction> class VectorwiseOp
       * Output: \verbinclude PartialRedux_squaredNorm.out
       *
       * \sa DenseBase::squaredNorm() */
-    const typename ReturnType<internal::member_squaredNorm,RealScalar>::Type squaredNorm() const
+    const SquareNormReturnType squaredNorm() const
-    { return _expression(); }
+    { 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<typename ExpressionType, int Direction> class VectorwiseOp
       * Output: \verbinclude PartialRedux_norm.out
       *
       * \sa DenseBase::norm() */
-    const typename ReturnType<internal::member_norm,RealScalar>::Type norm() const
+    const NormReturnType norm() const
-    { return _expression(); }
+    { return NormReturnType(_expression()); }
 
 
     /** \returns a row (or column) vector expression of the norm
@@ -319,8 +334,8 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
       * This is a vector with real entries, even if the original matrix has complex entries.
       *
       * \sa DenseBase::blueNorm() */
-    const typename ReturnType<internal::member_blueNorm,RealScalar>::Type blueNorm() const
+    const BlueNormReturnType blueNorm() const
-    { return _expression(); }
+    { return BlueNormReturnType(_expression()); }
 
 
     /** \returns a row (or column) vector expression of the norm
@@ -329,8 +344,8 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
       * This is a vector with real entries, even if the original matrix has complex entries.
       *
       * \sa DenseBase::stableNorm() */
-    const typename ReturnType<internal::member_stableNorm,RealScalar>::Type stableNorm() const
+    const StableNormReturnType stableNorm() const
-    { return _expression(); }
+    { return StableNormReturnType(_expression()); }
 
 
     /** \returns a row (or column) vector expression of the norm
@@ -339,8 +354,8 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
       * This is a vector with real entries, even if the original matrix has complex entries.
       *
       * \sa DenseBase::hypotNorm() */
-    const typename ReturnType<internal::member_hypotNorm,RealScalar>::Type hypotNorm() const
+    const HypotNormReturnType hypotNorm() const
-    { return _expression(); }
+    { 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<typename ExpressionType, int Direction> class VectorwiseOp
       * Output: \verbinclude PartialRedux_sum.out
       *
       * \sa DenseBase::sum() */
-    const typename ReturnType<internal::member_sum>::Type sum() const
+    const SumReturnType sum() const
-    { return _expression(); }
+    { 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<internal::member_mean>::Type mean() const
+    const MeanReturnType mean() const
-    { return _expression(); }
+    { 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<internal::member_all>::Type all() const
+    const AllReturnType all() const
-    { return _expression(); }
+    { 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<internal::member_any>::Type any() const
+    const AnyReturnType any() const
-    { return _expression(); }
+    { 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<typename ExpressionType, int Direction> class VectorwiseOp
       * Output: \verbinclude PartialRedux_count.out
       *
       * \sa DenseBase::count() */
-    const PartialReduxExpr<ExpressionType, internal::member_count<Index>, Direction> count() const
+    const CountReturnType count() const
-    { return _expression(); }
+    { 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<typename ExpressionType, int Direction> class VectorwiseOp
       * Output: \verbinclude PartialRedux_prod.out
       *
       * \sa DenseBase::prod() */
-    const typename ReturnType<internal::member_prod>::Type prod() const
+    const ProdReturnType prod() const
-    { return _expression(); }
+    { return ProdReturnType(_expression()); }
 
 
     /** \returns a matrix expression
@@ -405,8 +420,8 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
       * Output: \verbinclude Vectorwise_reverse.out
       *
       * \sa DenseBase::reverse() */
-    const Reverse<ExpressionType, Direction> reverse() const
+    const ReverseReturnType reverse() const
-    { return Reverse<ExpressionType, Direction>( _expression() ); }
+    { return ReverseReturnType( _expression() ); }
 
     typedef Replicate<ExpressionType,Direction==Vertical?Dynamic:1,Direction==Horizontal?Dynamic:1> ReplicateReturnType;
     const ReplicateReturnType replicate(Index factor) const;
@@ -550,7 +565,8 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
 
 /////////// Geometry module ///////////
 
-    Homogeneous<ExpressionType,Direction> homogeneous() const;
+    typedef Homogeneous<ExpressionType,Direction> HomogeneousReturnType;
+    HomogeneousReturnType homogeneous() const;
 
     typedef typename ExpressionType::PlainObject CrossReturnType;
     template<typename OtherDerived>
@@ -595,7 +611,7 @@ template<typename Derived>
 inline const typename DenseBase<Derived>::ConstColwiseReturnType
 DenseBase<Derived>::colwise() const
 {
-  return derived();
+  return ConstColwiseReturnType(derived());
 }
 
 /** \returns a writable VectorwiseOp wrapper of *this providing additional partial reduction operations
@@ -606,7 +622,7 @@ template<typename Derived>
 inline typename DenseBase<Derived>::ColwiseReturnType
 DenseBase<Derived>::colwise()
 {
-  return derived();
+  return ColwiseReturnType(derived());
 }
 
 /** \returns a VectorwiseOp wrapper of *this providing additional partial reduction operations
@@ -620,7 +636,7 @@ template<typename Derived>
 inline const typename DenseBase<Derived>::ConstRowwiseReturnType
 DenseBase<Derived>::rowwise() const
 {
-  return derived();
+  return ConstRowwiseReturnType(derived());
 }
 
 /** \returns a writable VectorwiseOp wrapper of *this providing additional partial reduction operations
@@ -631,7 +647,7 @@ template<typename Derived>
 inline typename DenseBase<Derived>::RowwiseReturnType
 DenseBase<Derived>::rowwise()
 {
-  return derived();
+  return RowwiseReturnType(derived());
 }
 
 } // end namespace Eigen

Eigen/src/Core/Visitor.h

@@ -58,7 +58,7 @@ template<typename XprType>
 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;

Eigen/src/Core/products/SelfadjointRank2Update.h

@@ -79,11 +79,11 @@ SelfAdjointView<MatrixType,UpLo>& SelfAdjointView<MatrixType,UpLo>
   if (IsRowMajor)
     actualAlpha = numext::conj(actualAlpha);
 
-  internal::selfadjoint_rank2_update_selector<Scalar, Index,
+  typedef typename internal::remove_all<typename internal::conj_expr_if<IsRowMajor ^ UBlasTraits::NeedToConjugate,_ActualUType>::type>::type UType;
-    typename internal::remove_all<typename internal::conj_expr_if<IsRowMajor ^ UBlasTraits::NeedToConjugate,_ActualUType>::type>::type,
+  typedef typename internal::remove_all<typename internal::conj_expr_if<IsRowMajor ^ VBlasTraits::NeedToConjugate,_ActualVType>::type>::type VType;
-    typename internal::remove_all<typename internal::conj_expr_if<IsRowMajor ^ VBlasTraits::NeedToConjugate,_ActualVType>::type>::type,
+  internal::selfadjoint_rank2_update_selector<Scalar, Index, UType, VType,
     (IsRowMajor ? int(UpLo==Upper ? Lower : Upper) : UpLo)>
-    ::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;
 }

Eigen/src/Core/util/BlasUtil.h

@@ -231,7 +231,7 @@ struct blas_traits<Transpose<NestedXpr> >
   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()); }
 };
 

Eigen/src/Eigenvalues/ComplexEigenSolver.h

@@ -104,7 +104,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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()),

Eigen/src/Eigenvalues/ComplexSchur.h

@@ -91,7 +91,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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()),

Eigen/src/Eigenvalues/EigenSolver.h

@@ -118,7 +118,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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),

Eigen/src/Eigenvalues/GeneralizedEigenSolver.h

@@ -122,7 +122,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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()),

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)
     {}
 

Eigen/src/Eigenvalues/HessenbergDecomposition.h

@@ -97,7 +97,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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)

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()),

Eigen/src/Eigenvalues/RealSchur.h

@@ -80,7 +80,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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()),

Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h

@@ -133,7 +133,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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),

Eigen/src/Eigenvalues/Tridiagonalization.h

@@ -112,7 +112,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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)

Eigen/src/Geometry/Homogeneous.h

@@ -68,7 +68,7 @@ template<typename MatrixType,int _Direction> class Homogeneous
     typedef MatrixBase<Homogeneous> 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<Derived>::HomogeneousReturnType
 MatrixBase<Derived>::homogeneous() const
 {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
-  return derived();
+  return HomogeneousReturnType(derived());
 }
 
 /** \geometry_module
@@ -143,7 +143,7 @@ template<typename ExpressionType, int Direction>
 inline Homogeneous<ExpressionType,Direction>
 VectorwiseOp<ExpressionType,Direction>::homogeneous() const
 {
-  return _expression();
+  return HomogeneousReturnType(_expression());
 }
 
 /** \geometry_module
@@ -323,7 +323,7 @@ struct unary_evaluator<Homogeneous<ArgType,Direction>, IndexBased>
   typedef evaluator<XprType> type;
   typedef evaluator<XprType> nestedType;
 
-  unary_evaluator(const XprType& op) 
+  explicit unary_evaluator(const XprType& op)
     : Base(), m_temp(op)
   {
     ::new (static_cast<Base*>(this)) Base(m_temp);

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<class Derived> EIGEN_STRONG_INLINE Quaternion(const QuaternionBase<Derived>& other) { this->Base::operator=(other); }
@@ -351,7 +351,7 @@ class Map<const Quaternion<_Scalar>, _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<Quaternion<_Scalar>, _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; }

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; }

Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h

@@ -43,7 +43,7 @@ class DiagonalPreconditioner
     DiagonalPreconditioner() : m_isInitialized(false) {}
 
     template<typename MatType>
-    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<typename MatrixType>
-    IdentityPreconditioner(const MatrixType& ) {}
+    explicit IdentityPreconditioner(const MatrixType& ) {}
     
     template<typename MatrixType>
     IdentityPreconditioner& analyzePattern(const MatrixType& ) { return *this; }

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() {}
 

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() {}
 

Eigen/src/IterativeLinearSolvers/IncompleteLUT.h

@@ -116,7 +116,7 @@ class IncompleteLUT : public SparseSolverBase<IncompleteLUT<_Scalar> >
     {}
     
     template<typename MatrixType>
-    IncompleteLUT(const MatrixType& mat, const RealScalar& droptol=NumTraits<Scalar>::dummy_precision(), int fillfactor = 10)
+    explicit IncompleteLUT(const MatrixType& mat, const RealScalar& droptol=NumTraits<Scalar>::dummy_precision(), int fillfactor = 10)
       : m_droptol(droptol),m_fillfactor(fillfactor),
         m_analysisIsOk(false),m_factorizationIsOk(false)
     {

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);

Eigen/src/LU/FullPivLU.h

@@ -94,7 +94,7 @@ template<typename _MatrixType> 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.
       *

Eigen/src/LU/PartialPivLU.h

@@ -92,7 +92,7 @@ template<typename _MatrixType> class PartialPivLU
       * according to the specified problem \a size.
       * \sa PartialPivLU()
       */
-    PartialPivLU(Index size);
+    explicit PartialPivLU(Index size);
 
     /** Constructor.
       *
@@ -101,7 +101,7 @@ template<typename _MatrixType> 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);
 

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);

Eigen/src/PardisoSupport/PardisoSupport.h

@@ -391,7 +391,7 @@ class PardisoLU : public PardisoImpl< PardisoLU<MatrixType> >
       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<MatrixType,_UpLo> >
       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<MatrixType,Options> >
       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);

Eigen/src/QR/ColPivHouseholderQR.h

@@ -117,7 +117,7 @@ template<typename _MatrixType> 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())),

Eigen/src/QR/FullPivHouseholderQR.h

@@ -120,7 +120,7 @@ template<typename _MatrixType> 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())),

Eigen/src/QR/HouseholderQR.h

@@ -91,7 +91,7 @@ template<typename _MatrixType> 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()),

Eigen/src/SPQRSupport/SuiteSparseQRSupport.h

@@ -65,7 +65,7 @@ class SPQR : public SparseSolverBase<SPQR<_MatrixType> >
     typedef typename _MatrixType::RealScalar RealScalar;
     typedef UF_long Index ; 
     typedef SparseMatrix<Scalar, ColMajor, Index> MatrixType;
-    typedef PermutationMatrix<Dynamic, Dynamic> PermutationType;
+    typedef Map<PermutationMatrix<Dynamic, Dynamic, Index> > PermutationType;
   public:
     SPQR() 
       : m_ordering(SPQR_ORDERING_DEFAULT), m_allow_tol(SPQR_DEFAULT_TOL), m_tolerance (NumTraits<Scalar>::epsilon())
@@ -73,7 +73,7 @@ class SPQR : public SparseSolverBase<SPQR<_MatrixType> >
       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<Scalar>::epsilon())
     {
       cholmod_l_start(&m_cc);
@@ -164,11 +164,7 @@ class SPQR : public SparseSolverBase<SPQR<_MatrixType> >
     PermutationType colsPermutation() const
     { 
       eigen_assert(m_isInitialized && "Decomposition is not initialized.");
-      Index n = m_cR->ncol;
+      return PermutationType(m_E, m_cR->ncol);
-      PermutationType colsPerm(n);
-      for(Index j = 0; j <n; j++) colsPerm.indices()(j) = m_E[j];
-      return colsPerm; 
-      
     }
     /**
      * Gets the rank of the matrix. 

Eigen/src/SVD/JacobiSVD.h

@@ -550,7 +550,7 @@ template<typename _MatrixType, int QRPreconditioner> 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<typename _MatrixType, int QRPreconditioner> 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);
     }

Eigen/src/SVD/UpperBidiagonalization.h

@@ -37,7 +37,7 @@ template<typename _MatrixType> class UpperBidiagonalization
     typedef Matrix<Scalar, ColsAtCompileTimeMinusOne, 1> SuperDiagVectorType;
     typedef HouseholderSequence<
               const MatrixType,
-              CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, const Diagonal<const MatrixType,0> >
+              const typename internal::remove_all<typename Diagonal<const MatrixType,0>::ConjugateReturnType>::type
             > HouseholderUSequenceType;
     typedef HouseholderSequence<
               const typename internal::remove_all<typename MatrixType::ConjugateReturnType>::type,
@@ -53,7 +53,7 @@ template<typename _MatrixType> 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)

Eigen/src/SparseCholesky/SimplicialCholesky.h

@@ -57,7 +57,7 @@ class SimplicialCholeskyBase : public SparseSolverBase<Derived>
       : 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<typename _MatrixType, int _UpLo, typename _Ordering> struct traits<Simp
   typedef SparseMatrix<Scalar, ColMajor, Index>               CholMatrixType;
   typedef TriangularView<CholMatrixType, Eigen::Lower>  MatrixL;
   typedef TriangularView<typename CholMatrixType::AdjointReturnType, Eigen::Upper>   MatrixU;
-  static inline MatrixL getL(const MatrixType& m) { return m; }
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
-  static inline MatrixU getU(const MatrixType& m) { return m.adjoint(); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
 };
 
 template<typename _MatrixType,int _UpLo, typename _Ordering> struct traits<SimplicialLDLT<_MatrixType,_UpLo,_Ordering> >
@@ -253,8 +253,8 @@ template<typename _MatrixType,int _UpLo, typename _Ordering> struct traits<Simpl
   typedef SparseMatrix<Scalar, ColMajor, Index>                   CholMatrixType;
   typedef TriangularView<CholMatrixType, Eigen::UnitLower>  MatrixL;
   typedef TriangularView<typename CholMatrixType::AdjointReturnType, Eigen::UnitUpper> MatrixU;
-  static inline MatrixL getL(const MatrixType& m) { return m; }
+  static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
-  static inline MatrixU getU(const MatrixType& m) { return m.adjoint(); }
+  static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
 };
 
 template<typename _MatrixType, int _UpLo, typename _Ordering> struct traits<SimplicialCholesky<_MatrixType,_UpLo,_Ordering> >
@@ -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);

Eigen/src/SparseCore/AmbiVector.h

@@ -27,7 +27,7 @@ class AmbiVector
     typedef _Index Index;
     typedef typename NumTraits<Scalar>::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;

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);

Eigen/src/SparseCore/MappedSparseMatrix.h

@@ -192,7 +192,7 @@ struct evaluator<MappedSparseMatrix<_Scalar,_Options,_Index> >
   };
   
   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; }

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<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBa
     
     typedef typename internal::conditional<OuterVector,OuterVectorInnerIterator,InnerVectorInnerIterator>::type InnerIterator;
     
-    unary_evaluator(const XprType& op)
+    explicit unary_evaluator(const XprType& op)
       : m_argImpl(op.nestedExpression()), m_block(op)
     {}
 

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())  

Eigen/src/SparseCore/SparseCwiseUnaryOp.h

@@ -29,7 +29,7 @@ struct unary_evaluator<CwiseUnaryOp<UnaryOp,ArgType>, 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<ArgType>::InnerIterator        EvalIterator;
@@ -104,7 +104,7 @@ struct unary_evaluator<CwiseUnaryView<ViewOp,ArgType>, 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<ArgType>::InnerIterator        EvalIterator;

Eigen/src/SparseCore/SparseDenseProduct.h

@@ -173,7 +173,8 @@ protected:
   typedef Product<LhsT,RhsT,DefaultProduct> 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<is_same<typename internal::traits<Lhs1>::StorageKind,Sparse>::value,
             Lhs1, SparseView<Lhs1> >::type ActualLhs;
   typedef typename conditional<is_same<typename internal::traits<Lhs1>::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<Product<Lhs, Rhs, DefaultProduct>, OuterProduct, Sparse
   typedef Product<Lhs, Rhs> 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<Product<Lhs, Rhs, DefaultProduct>, OuterProduct, DenseS
   typedef Product<Lhs, Rhs> XprType;
   typedef typename XprType::PlainObject PlainObject;
 
-  product_evaluator(const XprType& xpr)
+  explicit product_evaluator(const XprType& xpr)
     : Base(xpr.lhs(), xpr.rhs())
   {}
   

Eigen/src/SparseCore/SparseDiagonalProduct.h

@@ -44,7 +44,7 @@ struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, Diagonal
   enum { CoeffReadCost = Dynamic, Flags = Rhs::Flags&RowMajorBit }; // FIXME CoeffReadCost & Flags
   
   typedef sparse_diagonal_product_evaluator<Rhs, typename Lhs::DiagonalVectorType, Rhs::Flags&RowMajorBit?SDP_AsScalarProduct:SDP_AsCwiseProduct> 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<typename Lhs, typename Rhs, int ProductTag>
@@ -57,7 +57,7 @@ struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, SparseSh
   enum { CoeffReadCost = Dynamic, Flags = Lhs::Flags&RowMajorBit }; // FIXME CoeffReadCost & Flags
   
   typedef sparse_diagonal_product_evaluator<Lhs, Transpose<const typename Rhs::DiagonalVectorType>, 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<typename SparseXprType, typename DiagonalCoeffType>

Eigen/src/SparseCore/SparseMatrix.h

@@ -89,6 +89,8 @@ class SparseMatrix
     EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(SparseMatrix, -=)
 
     typedef MappedSparseMatrix<Scalar,Flags> Map;
+    typedef Diagonal<const SparseMatrix> DiagonalReturnType;
+
     using Base::IsRowMajor;
     typedef internal::CompressedStorage<Scalar,Index> Storage;
     enum {
@@ -621,7 +623,7 @@ class SparseMatrix
     }
 
     /** \returns a const expression of the diagonal coefficients */
-    const Diagonal<const SparseMatrix> 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<SparseMatrix<_Scalar,_Options,_Index> >
   };
   
   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; }

Eigen/src/SparseCore/SparseMatrixBase.h

@@ -94,6 +94,9 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived>
                         CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, Eigen::Transpose<const Derived> >,
                         Transpose<const Derived>
                      >::type AdjointReturnType;
+    typedef Transpose<Derived> TransposeReturnType;
+    template<unsigned int UpLo> struct SelfAdjointViewReturnType { typedef SelfAdjointView<Derived, UpLo> Type; };
+    typedef typename internal::add_const<Transpose<const Derived> >::type ConstTransposeReturnType;
 
     // FIXME storage order do not match evaluator storage order
     typedef SparseMatrix<Scalar, Flags&RowMajorBit ? RowMajor : ColMajor, Index> PlainObject;
@@ -114,6 +117,8 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived>
     /** \internal Represents a matrix with all coefficients equal to one another*/
     typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,Matrix<Scalar,Dynamic,Dynamic> > ConstantReturnType;
 
+    /** type of the equivalent dense matrix */
+    typedef Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime> DenseMatrixType;
     /** type of the equivalent square matrix */
     typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime),
                           EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime)> SquareMatrixType;
@@ -303,9 +308,9 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived>
     RealScalar norm()  const;
     RealScalar blueNorm() const;
 
-    Transpose<Derived> transpose() { return derived(); }
+    TransposeReturnType transpose() { return TransposeReturnType(derived()); }
-    const Transpose<const Derived> transpose() const { return derived(); }
+    const ConstTransposeReturnType transpose() const { return ConstTransposeReturnType(derived()); }
-    const AdjointReturnType adjoint() const { return transpose(); }
+    const AdjointReturnType adjoint() const { return AdjointReturnType(transpose()); }
 
     // inner-vector
     typedef Block<Derived,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true>       InnerVectorReturnType;
@@ -317,9 +322,9 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived>
     Block<Derived,Dynamic,Dynamic,true> innerVectors(Index outerStart, Index outerSize);
     const Block<const Derived,Dynamic,Dynamic,true> innerVectors(Index outerStart, Index outerSize) const;
 
-    Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime> toDense() const
+    DenseMatrixType toDense() const
     {
-      return derived();
+      return DenseMatrixType(derived());
     }
 
     template<typename OtherDerived>

Eigen/src/SparseCore/SparsePermutation.h

@@ -166,7 +166,7 @@ struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, Permutat
   typedef typename traits<permut_sparsematrix_product_retval<Lhs,Rhs,OnTheRight,false> >::ReturnType PlainObject;
   typedef typename evaluator<PlainObject>::type Base;
 
-  product_evaluator(const XprType& xpr)
+  explicit product_evaluator(const XprType& xpr)
     : m_result(xpr.rows(), xpr.cols())
   {
     ::new (static_cast<Base*>(this)) Base(m_result);
@@ -185,7 +185,7 @@ struct product_evaluator<Product<Lhs, Rhs, DefaultProduct>, ProductTag, SparseSh
   typedef typename traits<permut_sparsematrix_product_retval<Rhs,Lhs,OnTheRight,false> >::ReturnType PlainObject;
   typedef typename evaluator<PlainObject>::type Base;
 
-  product_evaluator(const XprType& xpr)
+  explicit product_evaluator(const XprType& xpr)
     : m_result(xpr.rows(), xpr.cols())
   {
     ::new (static_cast<Base*>(this)) Base(m_result);

Eigen/src/SparseCore/SparseProduct.h

@@ -59,7 +59,7 @@ struct evaluator<SparseView<Product<Lhs, Rhs, Options> > >
   typedef evaluator type;
   typedef evaluator nestedType;
   
-  evaluator(const XprType& xpr)
+  explicit evaluator(const XprType& xpr)
     : m_result(xpr.rows(), xpr.cols())
   {
     using std::abs;

Eigen/src/SparseCore/SparseSelfAdjointView.h

@@ -53,7 +53,7 @@ template<typename MatrixType, unsigned int _Mode> class SparseSelfAdjointView
     typedef typename MatrixType::Nested MatrixTypeNested;
     typedef typename internal::remove_all<MatrixTypeNested>::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<typename Derived>
 template<unsigned int Mode>
 const SparseSelfAdjointView<Derived, Mode> SparseMatrixBase<Derived>::selfadjointView() const
 {
-  return derived();
+  return SparseSelfAdjointView<Derived, Mode>(derived());
 }
 
 template<typename Derived>
 template<unsigned int Mode>
 SparseSelfAdjointView<Derived, Mode> SparseMatrixBase<Derived>::selfadjointView()
 {
-  return derived();
+  return SparseSelfAdjointView<Derived, Mode>(derived());
 }
 
 /***************************************************************************

Eigen/src/SparseCore/SparseTranspose.h

@@ -62,7 +62,7 @@ struct unary_evaluator<Transpose<ArgType>, 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<ArgType>::nestedType m_argImpl;

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<int Mode>
 inline const TriangularView<Derived, Mode>
 SparseMatrixBase<Derived>::triangularView() const
 {
-  return derived();
+  return TriangularView<Derived, Mode>(derived());
 }
 
 } // end namespace Eigen

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<typename Scalar, int _Options, typename _Index>
 class SparseVector<Scalar,_Options,_Index>::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<Index>(m_data.size()))
     {
       EIGEN_UNUSED_VARIABLE(outer);
       eigen_assert(outer==0);
     }
 
-    InnerIterator(const internal::CompressedStorage<Scalar,Index>& data)
+	explicit InnerIterator(const internal::CompressedStorage<Scalar,Index>& data)
       : m_data(data), m_id(0), m_end(static_cast<Index>(m_data.size()))
     {}
 
@@ -392,14 +392,14 @@ template<typename Scalar, int _Options, typename _Index>
 class SparseVector<Scalar,_Options,_Index>::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<Index>(m_data.size())), m_start(0)
     {
       EIGEN_UNUSED_VARIABLE(outer);
       eigen_assert(outer==0);
     }
 
-    ReverseInnerIterator(const internal::CompressedStorage<Scalar,Index>& data)
+	explicit ReverseInnerIterator(const internal::CompressedStorage<Scalar,Index>& data)
       : m_data(data), m_id(static_cast<Index>(m_data.size())), m_start(0)
     {}
 
@@ -435,7 +435,7 @@ struct evaluator<SparseVector<_Scalar,_Options,_Index> >
     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; }

Eigen/src/SparseCore/SparseView.h

@@ -36,7 +36,7 @@ public:
   EIGEN_SPARSE_PUBLIC_INTERFACE(SparseView)
   typedef typename internal::remove_all<MatrixType>::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<Scalar>::dummy_precision()) : 
     m_matrix(mat), m_reference(m_reference), m_epsilon(m_epsilon) {}
 
@@ -111,7 +111,7 @@ struct unary_evaluator<SparseView<ArgType>, 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<ArgType>::nestedType m_argImpl;
@@ -180,7 +180,7 @@ struct unary_evaluator<SparseView<ArgType>, 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<ArgType>::nestedType m_argImpl;

Eigen/src/SparseLU/SparseLU.h

@@ -95,7 +95,7 @@ class SparseLU : public SparseSolverBase<SparseLU<_MatrixType,_OrderingType> >,
     {
       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(); }

Eigen/src/SparseQR/SparseQR.h

@@ -88,7 +88,7 @@ class SparseQR : public SparseSolverBase<SparseQR<_MatrixType,_OrderingType> >
       * 
       * \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<SparseQRMatrixQReturnType<Sp
   typedef typename SparseQRType::Index Index;
   typedef typename SparseQRType::Scalar Scalar;
   typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix;
-  SparseQRMatrixQReturnType(const SparseQRType& qr) : m_qr(qr) {}
+  explicit SparseQRMatrixQReturnType(const SparseQRType& qr) : m_qr(qr) {}
   template<typename Derived>
   SparseQR_QProduct<SparseQRType, Derived> operator*(const MatrixBase<Derived>& other)
   {
@@ -672,7 +672,7 @@ struct SparseQRMatrixQReturnType : public EigenBase<SparseQRMatrixQReturnType<Sp
 template<typename SparseQRType>
 struct SparseQRMatrixQTransposeReturnType
 {
-  SparseQRMatrixQTransposeReturnType(const SparseQRType& qr) : m_qr(qr) {}
+  explicit SparseQRMatrixQTransposeReturnType(const SparseQRType& qr) : m_qr(qr) {}
   template<typename Derived>
   SparseQR_QProduct<SparseQRType,Derived> operator*(const MatrixBase<Derived>& other)
   {

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);

Eigen/src/UmfPackSupport/UmfPackSupport.h

@@ -142,7 +142,7 @@ class UmfPackLU : public SparseSolverBase<UmfPackLU<_MatrixType> >
 
     UmfPackLU() { init(); }
 
-    UmfPackLU(const MatrixType& matrix)
+    explicit UmfPackLU(const MatrixType& matrix)
     {
       init();
       compute(matrix);

Eigen/src/misc/Kernel.h

@@ -41,7 +41,7 @@ template<typename _DecompositionType> struct kernel_retval_base
   typedef ReturnByValue<kernel_retval_base> 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)

Eigen/src/plugins/ArrayCwiseUnaryOps.h

@@ -1,5 +1,24 @@
 
 
+// These are already defined in MatrixCwiseUnaryOps.h
+//typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> AbsReturnType;
+//typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> Abs2ReturnType;
+//typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> SqrtReturnType;
+//typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> CwiseInverseReturnType;
+//typedef CwiseUnaryOp<std::binder1st<std::equal_to<Scalar> >, const Derived> CwiseScalarEqualReturnType;
+
+typedef CwiseUnaryOp<internal::scalar_exp_op<Scalar>, const Derived> ExpReturnType;
+typedef CwiseUnaryOp<internal::scalar_log_op<Scalar>, const Derived> LogReturnType;
+typedef CwiseUnaryOp<internal::scalar_cos_op<Scalar>, const Derived> CosReturnType;
+typedef CwiseUnaryOp<internal::scalar_sin_op<Scalar>, const Derived> SinReturnType;
+typedef CwiseUnaryOp<internal::scalar_acos_op<Scalar>, const Derived> AcosReturnType;
+typedef CwiseUnaryOp<internal::scalar_asin_op<Scalar>, const Derived> AsinReturnType;
+typedef CwiseUnaryOp<internal::scalar_tan_op<Scalar>, const Derived> TanReturnType;
+typedef CwiseUnaryOp<internal::scalar_atan_op<Scalar>, const Derived> AtanReturnType;
+typedef CwiseUnaryOp<internal::scalar_pow_op<Scalar>, const Derived> PowReturnType;
+typedef CwiseUnaryOp<internal::scalar_square_op<Scalar>, const Derived> SquareReturnType;
+typedef CwiseUnaryOp<internal::scalar_cube_op<Scalar>, 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<internal::scalar_abs_op<Scalar>, 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<internal::scalar_abs2_op<Scalar>, 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<internal::scalar_exp_op<Scalar>, 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<internal::scalar_log_op<Scalar>, 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<internal::scalar_sqrt_op<Scalar>, 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<internal::scalar_cos_op<Scalar>, 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<internal::scalar_sin_op<Scalar>, 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<internal::scalar_acos_op<Scalar>, 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<internal::scalar_asin_op<Scalar>, 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<internal::scalar_tan_op<Scalar>, 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<internal::scalar_atan_op<Scalar>, 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<internal::scalar_pow_op<Scalar>, const Derived>
+inline const PowReturnType
 pow(const Scalar& exponent) const
 {
-  return CwiseUnaryOp<internal::scalar_pow_op<Scalar>, const Derived>
+  return PowReturnType(derived(), internal::scalar_pow_op<Scalar>(exponent));
-          (derived(), internal::scalar_pow_op<Scalar>(exponent));
 }
 
 
@@ -196,10 +214,10 @@ pow(const Scalar& exponent) const
   * \sa operator/(), operator*()
   */
 EIGEN_DEVICE_FUNC
-inline const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, 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<internal::scalar_square_op<Scalar>, 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<internal::scalar_cube_op<Scalar>, const Derived>
+inline const CubeReturnType
 cube() const
 {
-  return derived();
+  return CubeReturnType(derived());
 }
 
 #define EIGEN_MAKE_SCALAR_CWISE_UNARY_OP(METHOD_NAME,FUNCTOR) \

Eigen/src/plugins/CommonCwiseUnaryOps.h

@@ -14,6 +14,8 @@
 
 /** \internal Represents a scalar multiple of an expression */
 typedef CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const Derived> ScalarMultipleReturnType;
+typedef CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >, const Derived> ScalarComplexMultipleReturnType;
+
 /** \internal Represents a quotient of an expression by a scalar*/
 typedef CwiseUnaryOp<internal::scalar_quotient1_op<Scalar>, const Derived> ScalarQuotient1ReturnType;
 /** \internal the return type of conjugate() */
@@ -36,13 +38,16 @@ typedef CwiseUnaryOp<internal::scalar_imag_op<Scalar>, const Derived> ImagReturn
 /** \internal the return type of imag() */
 typedef CwiseUnaryView<internal::scalar_imag_ref_op<Scalar>, Derived> NonConstImagReturnType;
 
+typedef CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, const Derived> NegativeReturnType;
+//typedef CwiseUnaryOp<internal::scalar_quotient1_op<Scalar>, const Derived>
+
 #endif // not EIGEN_PARSED_BY_DOXYGEN
 
 /** \returns an expression of the opposite of \c *this
   */
 EIGEN_DEVICE_FUNC
-inline const CwiseUnaryOp<internal::scalar_opposite_op<typename internal::traits<Derived>::Scalar>, const Derived>
+inline const NegativeReturnType
-operator-() const { return derived(); }
+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<internal::scalar_multiple_op<Scalar>, const Derived>
+  return ScalarMultipleReturnType(derived(), internal::scalar_multiple_op<Scalar>(scalar));
-    (derived(), internal::scalar_multiple_op<Scalar>(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<internal::scalar_quotient1_op<typename internal::traits<Derived>::Scalar>, const Derived>
+inline const ScalarQuotient1ReturnType
 operator/(const Scalar& scalar) const
 {
-  return CwiseUnaryOp<internal::scalar_quotient1_op<Scalar>, const Derived>
+  return ScalarQuotient1ReturnType(derived(), internal::scalar_quotient1_op<Scalar>(scalar));
-    (derived(), internal::scalar_quotient1_op<Scalar>(scalar));
 }
 
 /** Overloaded for efficient real matrix times complex scalar value */
 EIGEN_DEVICE_FUNC
-inline const CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >, const Derived>
+inline const ScalarComplexMultipleReturnType
 operator*(const std::complex<Scalar>& scalar) const
 {
-  return CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >, const Derived>
+  return ScalarComplexMultipleReturnType(derived(), internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >(scalar));
-    (*static_cast<const Derived*>(this), internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >(scalar));
 }
 
 EIGEN_DEVICE_FUNC
@@ -86,6 +88,9 @@ inline friend const CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::compl
 operator*(const std::complex<Scalar>& scalar, const StorageBaseType& matrix)
 { return matrix*scalar; }
 
+
+template<class NewType> struct CastXpr { typedef typename internal::cast_return_type<Derived,const CwiseUnaryOp<internal::scalar_cast_op<Scalar, NewType>, 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>& scalar, const StorageBaseType& matrix)
   */
 template<typename NewType>
 EIGEN_DEVICE_FUNC
-typename internal::cast_return_type<Derived,const CwiseUnaryOp<internal::scalar_cast_op<typename internal::traits<Derived>::Scalar, NewType>, const Derived> >::type
+typename CastXpr<NewType>::Type
 cast() const
 {
-  return derived();
+  return typename CastXpr<NewType>::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()); }

Eigen/src/plugins/MatrixCwiseUnaryOps.h

@@ -10,6 +10,11 @@
 
 // This file is a base class plugin containing matrix specifics coefficient wise functions.
 
+typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> AbsReturnType;
+typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> Abs2ReturnType;
+typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> SqrtReturnType;
+typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> CwiseInverseReturnType;
+typedef CwiseUnaryOp<std::binder1st<std::equal_to<Scalar> >, 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<internal::scalar_abs_op<Scalar>, const Derived>
+EIGEN_STRONG_INLINE const AbsReturnType
-cwiseAbs() const { return derived(); }
+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<internal::scalar_abs2_op<Scalar>, const Derived>
+EIGEN_STRONG_INLINE const Abs2ReturnType
-cwiseAbs2() const { return derived(); }
+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<internal::scalar_sqrt_op<Scalar>, const Derived>
+inline const SqrtReturnType
-cwiseSqrt() const { return derived(); }
+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<internal::scalar_inverse_op<Scalar>, const Derived>
+inline const CwiseInverseReturnType
-cwiseInverse() const { return derived(); }
+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<OtherDerived> &) const
   */
 EIGEN_DEVICE_FUNC
-inline const CwiseUnaryOp<std::binder1st<std::equal_to<Scalar> >, const Derived>
+inline const CwiseScalarEqualReturnType
 cwiseEqual(const Scalar& s) const
 {
-  return CwiseUnaryOp<std::binder1st<std::equal_to<Scalar> >,const Derived>
+  return CwiseScalarEqualReturnType(derived(), std::bind1st(std::equal_to<Scalar>(), s));
-          (derived(), std::bind1st(std::equal_to<Scalar>(), s));
 }