merge

Eigen/Sparse

@@ -84,7 +84,6 @@ namespace Eigen {
 
 #include "src/Sparse/SparseUtil.h"
 #include "src/Sparse/SparseMatrixBase.h"
-#include "src/Sparse/SparseNestByValue.h"
 #include "src/Sparse/CompressedStorage.h"
 #include "src/Sparse/AmbiVector.h"
 #include "src/Sparse/RandomSetter.h"

Eigen/src/Array/Select.h

@@ -131,11 +131,11 @@ MatrixBase<Derived>::select(const MatrixBase<ThenDerived>& thenMatrix,
   */
 template<typename Derived>
 template<typename ThenDerived>
-inline const Select<Derived,ThenDerived, NestByValue<typename ThenDerived::ConstantReturnType> >
+inline const Select<Derived,ThenDerived, typename ThenDerived::ConstantReturnType>
 MatrixBase<Derived>::select(const MatrixBase<ThenDerived>& thenMatrix,
                             typename ThenDerived::Scalar elseScalar) const
 {
-  return Select<Derived,ThenDerived,NestByValue<typename ThenDerived::ConstantReturnType> >(
+  return Select<Derived,ThenDerived,typename ThenDerived::ConstantReturnType>(
     derived(), thenMatrix.derived(), ThenDerived::Constant(rows(),cols(),elseScalar));
 }
 
@@ -148,11 +148,11 @@ MatrixBase<Derived>::select(const MatrixBase<ThenDerived>& thenMatrix,
   */
 template<typename Derived>
 template<typename ElseDerived>
-inline const Select<Derived, NestByValue<typename ElseDerived::ConstantReturnType>, ElseDerived >
+inline const Select<Derived, typename ElseDerived::ConstantReturnType, ElseDerived >
 MatrixBase<Derived>::select(typename ElseDerived::Scalar thenScalar,
                             const MatrixBase<ElseDerived>& elseMatrix) const
 {
-  return Select<Derived,NestByValue<typename ElseDerived::ConstantReturnType>,ElseDerived>(
+  return Select<Derived,typename ElseDerived::ConstantReturnType,ElseDerived>(
     derived(), ElseDerived::Constant(rows(),cols(),thenScalar), elseMatrix.derived());
 }
 

Eigen/src/Array/VectorwiseOp.h

@@ -436,22 +436,22 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
     template<typename OtherDerived>
     CwiseBinaryOp<ei_scalar_sum_op<Scalar>,
                   ExpressionType,
-                  NestByValue<typename ExtendedType<OtherDerived>::Type> >
+                  typename ExtendedType<OtherDerived>::Type>
     operator+(const MatrixBase<OtherDerived>& other) const
     {
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived);
-      return m_matrix + extendedTo(other).nestByValue();
+      return m_matrix + extendedTo(other);
     }
 
     /** Returns the expression of the difference between each subvector of \c *this and the vector \a other */
     template<typename OtherDerived>
     CwiseBinaryOp<ei_scalar_difference_op<Scalar>,
                   ExpressionType,
-                  NestByValue<typename ExtendedType<OtherDerived>::Type> >
+                  typename ExtendedType<OtherDerived>::Type>
     operator-(const MatrixBase<OtherDerived>& other) const
     {
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived);
-      return m_matrix - extendedTo(other).nestByValue();
+      return m_matrix - extendedTo(other);
     }
 
 /////////// Geometry module ///////////
@@ -478,10 +478,10 @@ template<typename ExpressionType, int Direction> class VectorwiseOp
                   Direction==Horizontal ? 1 : int(ei_traits<ExpressionType>::ColsAtCompileTime)>
             HNormalized_Factors;
     typedef CwiseBinaryOp<ei_scalar_quotient_op<typename ei_traits<ExpressionType>::Scalar>,
-                NestByValue<HNormalized_Block>,
+                HNormalized_Block,
-                NestByValue<Replicate<NestByValue<HNormalized_Factors>,
+                Replicate<HNormalized_Factors,
                   Direction==Vertical   ? HNormalized_SizeMinusOne : 1,
-                  Direction==Horizontal ? HNormalized_SizeMinusOne : 1> > >
+                  Direction==Horizontal ? HNormalized_SizeMinusOne : 1> >
             HNormalizedReturnType;
 
     const HNormalizedReturnType hnormalized() const;

Eigen/src/Cholesky/LLT.h

@@ -224,18 +224,18 @@ template<> struct ei_llt_inplace<UpperTriangular>
 template<typename MatrixType> struct LLT_Traits<MatrixType,LowerTriangular>
 {
   typedef TriangularView<MatrixType, LowerTriangular> MatrixL;
-  typedef TriangularView<NestByValue<typename MatrixType::AdjointReturnType>, UpperTriangular> MatrixU;
+  typedef TriangularView<typename MatrixType::AdjointReturnType, UpperTriangular> MatrixU;
   inline static MatrixL getL(const MatrixType& m) { return m; }
-  inline static MatrixU getU(const MatrixType& m) { return m.adjoint().nestByValue(); }
+  inline static MatrixU getU(const MatrixType& m) { return m.adjoint(); }
   static bool inplace_decomposition(MatrixType& m)
   { return ei_llt_inplace<LowerTriangular>::blocked(m); }
 };
 
 template<typename MatrixType> struct LLT_Traits<MatrixType,UpperTriangular>
 {
-  typedef TriangularView<NestByValue<typename MatrixType::AdjointReturnType>, LowerTriangular> MatrixL;
+  typedef TriangularView<typename MatrixType::AdjointReturnType, LowerTriangular> MatrixL;
   typedef TriangularView<MatrixType, UpperTriangular> MatrixU;
-  inline static MatrixL getL(const MatrixType& m) { return m.adjoint().nestByValue(); }
+  inline static MatrixL getL(const MatrixType& m) { return m.adjoint(); }
   inline static MatrixU getU(const MatrixType& m) { return m; }
   static bool inplace_decomposition(MatrixType& m)
   { return ei_llt_inplace<UpperTriangular>::blocked(m); }

Eigen/src/Core/BandMatrix.h

@@ -141,7 +141,7 @@ class BandMatrix : public AnyMatrixBase<BandMatrix<_Scalar,Rows,Cols,Supers,Subs
       };
       typedef Block<DataType,1, DiagonalSize> BuildType;
       typedef typename ei_meta_if<Conjugate,
-                 CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>,NestByValue<BuildType> >,
+                 CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>,BuildType >,
                  BuildType>::ret Type;
     };
 

Eigen/src/Core/Cwise.h

@@ -52,7 +52,7 @@
   * convenient macro to defined the return type of a cwise comparison to a scalar */
 #define EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(OP) \
     CwiseBinaryOp<OP<typename ei_traits<ExpressionType>::Scalar>, ExpressionType, \
-        NestByValue<typename ExpressionType::ConstantReturnType> >
+        typename ExpressionType::ConstantReturnType >
 
 /** \class Cwise
   *

Eigen/src/Core/ExpressionMaker.h

@@ -37,12 +37,6 @@ template<typename XprType> struct ei_shape_of
 // matrix. Unless we change the overall design, here is a workaround.
 // There is an example in unsuported/Eigen/src/AutoDiff/AutoDiffScalar.
 
-template<typename XprType, int Shape = ei_shape_of<XprType>::ret>
-struct MakeNestByValue
-{
-  typedef NestByValue<XprType> Type;
-};
-
 template<typename Func, typename XprType, int Shape = ei_shape_of<XprType>::ret>
 struct MakeCwiseUnaryOp
 {

Eigen/src/Core/MatrixBase.h

@@ -248,7 +248,7 @@ template<typename Derived> class MatrixBase
     typedef CwiseUnaryView<ei_scalar_imag_op<Scalar>, Derived> NonConstImagReturnType;
     /** \internal the return type of MatrixBase::adjoint() */
     typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex,
-                        CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<Derived> > >,
+                        CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Eigen::Transpose<Derived> >,
                         Transpose<Derived>
                      >::ret AdjointReturnType;
     /** \internal the return type of MatrixBase::eigenvalues() */
@@ -445,11 +445,11 @@ template<typename Derived> class MatrixBase
     Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,Transpose<DerivedB> >& other);
 
     template<typename OtherDerived>
-    Derived& lazyAssign(const CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<OtherDerived> > >& other);
+    Derived& lazyAssign(const CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Eigen::Transpose<OtherDerived> >& other);
     template<typename DerivedA, typename DerivedB>
-    Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedA> > >,DerivedB>& other);
+    Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Eigen::Transpose<DerivedA> >,DerivedB>& other);
     template<typename DerivedA, typename DerivedB>
-    Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedB> > > >& other);
+    Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Eigen::Transpose<DerivedB> > >& other);
     #endif
 
     RowXpr row(int i);
@@ -622,7 +622,6 @@ template<typename Derived> class MatrixBase
 
     inline const NestByValue<Derived> nestByValue() const;
 
-
     ConjugateReturnType conjugate() const;
     RealReturnType real() const;
     NonConstRealReturnType real();
@@ -694,11 +693,11 @@ template<typename Derived> class MatrixBase
            const MatrixBase<ElseDerived>& elseMatrix) const;
 
     template<typename ThenDerived>
-    inline const Select<Derived,ThenDerived, NestByValue<typename ThenDerived::ConstantReturnType> >
+    inline const Select<Derived,ThenDerived, typename ThenDerived::ConstantReturnType>
     select(const MatrixBase<ThenDerived>& thenMatrix, typename ThenDerived::Scalar elseScalar) const;
 
     template<typename ElseDerived>
-    inline const Select<Derived, NestByValue<typename ElseDerived::ConstantReturnType>, ElseDerived >
+    inline const Select<Derived, typename ElseDerived::ConstantReturnType, ElseDerived >
     select(typename ElseDerived::Scalar thenScalar, const MatrixBase<ElseDerived>& elseMatrix) const;
 
     template<int p> RealScalar lpNorm() const;
@@ -766,7 +765,7 @@ template<typename Derived> class MatrixBase
                   ei_traits<Derived>::ColsAtCompileTime==1 ? SizeMinusOne : 1,
                   ei_traits<Derived>::ColsAtCompileTime==1 ? 1 : SizeMinusOne> StartMinusOne;
     typedef CwiseUnaryOp<ei_scalar_quotient1_op<typename ei_traits<Derived>::Scalar>,
-                NestByValue<StartMinusOne> > HNormalizedReturnType;
+                StartMinusOne > HNormalizedReturnType;
 
     const HNormalizedReturnType hnormalized() const;
     typedef Homogeneous<Derived,MatrixBase<Derived>::ColsAtCompileTime==1?Vertical:Horizontal> HomogeneousReturnType;

Eigen/src/Core/ProductBase.h

@@ -111,14 +111,6 @@ class ProductBase : public MatrixBase<Derived>
     template<typename Dest>
     inline void scaleAndAddTo(Dest& dst,Scalar alpha) const { derived().scaleAndAddTo(dst,alpha); }
 
-    PlainMatrixType eval() const
-    {
-      PlainMatrixType res(rows(), cols());
-      res.setZero();
-      derived().evalTo(res);
-      return res;
-    }
-
     EIGEN_DEPRECATED const Flagged<ProductBase, 0, EvalBeforeAssigningBit> lazy() const
     { return *this; }
 

Eigen/src/Core/Transpose.h

@@ -186,7 +186,7 @@ template<typename Derived>
 inline const typename MatrixBase<Derived>::AdjointReturnType
 MatrixBase<Derived>::adjoint() const
 {
-  return transpose().nestByValue();
+  return transpose();
 }
 
 /***************************************************************************
@@ -326,31 +326,31 @@ lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,Transpose<Deriv
 template<typename Derived>
 template<typename OtherDerived> Derived&
 MatrixBase<Derived>::
-lazyAssign(const CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<OtherDerived> > >& other)
+lazyAssign(const CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Eigen::Transpose<OtherDerived> >& other)
 {
   ei_assert(ei_extract_data(other) != ei_extract_data(derived())
             && "aliasing detected during tranposition, please use adjointInPlace()");
-  return lazyAssign(static_cast<const MatrixBase<CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<OtherDerived> > > >& >(other));
+  return lazyAssign(static_cast<const MatrixBase<CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Eigen::Transpose<OtherDerived> > >& >(other));
 }
 
 template<typename Derived>
 template<typename DerivedA, typename DerivedB>
 Derived& MatrixBase<Derived>::
-lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedA> > >,DerivedB>& other)
+lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Eigen::Transpose<DerivedA> >,DerivedB>& other)
 {
   ei_assert(ei_extract_data(derived()) != ei_extract_data(other.lhs())
             && "aliasing detected during tranposition, please evaluate your expression");
-  return lazyAssign(static_cast<const MatrixBase<CwiseBinaryOp<ei_scalar_sum_op<Scalar>,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedA> > >,DerivedB> >& >(other));
+  return lazyAssign(static_cast<const MatrixBase<CwiseBinaryOp<ei_scalar_sum_op<Scalar>,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Eigen::Transpose<DerivedA> >,DerivedB> >& >(other));
 }
 
 template<typename Derived>
 template<typename DerivedA, typename DerivedB>
 Derived& MatrixBase<Derived>::
-lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedB> > > >& other)
+lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Eigen::Transpose<DerivedB> > >& other)
 {
   ei_assert(ei_extract_data(derived()) != ei_extract_data(other.rhs())
             && "aliasing detected during tranposition, please evaluate your expression");
-  return lazyAssign(static_cast<const MatrixBase<CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedB> > > > >& >(other));
+  return lazyAssign(static_cast<const MatrixBase<CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Eigen::Transpose<DerivedB> > > >& >(other));
 }
 #endif
 

Eigen/src/Core/TriangularMatrix.h

@@ -222,18 +222,18 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularView
 
 
     /** \sa MatrixBase::adjoint() */
-    inline TriangularView<NestByValue<typename MatrixType::AdjointReturnType>,TransposeMode> adjoint()
+    inline TriangularView<typename MatrixType::AdjointReturnType,TransposeMode> adjoint()
-    { return m_matrix.adjoint().nestByValue(); }
+    { return m_matrix.adjoint(); }
     /** \sa MatrixBase::adjoint() const */
-    inline const TriangularView<NestByValue<typename MatrixType::AdjointReturnType>,TransposeMode> adjoint() const
+    inline const TriangularView<typename MatrixType::AdjointReturnType,TransposeMode> adjoint() const
-    { return m_matrix.adjoint().nestByValue(); }
+    { return m_matrix.adjoint(); }
 
     /** \sa MatrixBase::transpose() */
-    inline TriangularView<NestByValue<Transpose<MatrixType> >,TransposeMode> transpose()
+    inline TriangularView<Transpose<MatrixType>,TransposeMode> transpose()
-    { return m_matrix.transpose().nestByValue(); }
+    { return m_matrix.transpose(); }
     /** \sa MatrixBase::transpose() const */
-    inline const TriangularView<NestByValue<Transpose<MatrixType> >,TransposeMode> transpose() const
+    inline const TriangularView<Transpose<MatrixType>,TransposeMode> transpose() const
-    { return m_matrix.transpose().nestByValue(); }
+    { return m_matrix.transpose(); }
 
     DenseMatrixType toDenseMatrix() const
     {

Eigen/src/Core/util/BlasUtil.h

@@ -214,20 +214,6 @@ struct ei_blas_traits<CwiseUnaryOp<ei_scalar_opposite_op<Scalar>, NestedXpr> >
   { return - Base::extractScalarFactor(x._expression()); }
 };
 
-// pop NestByValue
-template<typename NestedXpr>
-struct ei_blas_traits<NestByValue<NestedXpr> >
- : ei_blas_traits<NestedXpr>
-{
-  typedef typename NestedXpr::Scalar Scalar;
-  typedef ei_blas_traits<NestedXpr> Base;
-  typedef NestByValue<NestedXpr> XprType;
-  typedef typename Base::ExtractType ExtractType;
-  static inline ExtractType extract(const XprType& x) { return Base::extract(static_cast<const NestedXpr&>(x)); }
-  static inline Scalar extractScalarFactor(const XprType& x)
-  { return Base::extractScalarFactor(static_cast<const NestedXpr&>(x)); }
-};
-
 // pop/push transpose
 template<typename NestedXpr>
 struct ei_blas_traits<Transpose<NestedXpr> >

Eigen/src/Core/util/XprHelper.h

@@ -168,8 +168,35 @@ template<typename T> struct ei_plain_matrix_type_row_major
           > type;
 };
 
+// we should be able to get rid of this one too
 template<typename T> struct ei_must_nest_by_value { enum { ret = false }; };
-template<typename T> struct ei_must_nest_by_value<NestByValue<T> > { enum { ret = true }; };
+
+/**
+* The reference selector for template expressions. The idea is that we don't
+* need to use references for expressions since they are light weight proxy
+* objects which should generate no copying overhead.
+**/
+template <typename T>
+struct ei_ref_selector
+{
+  typedef T type;
+};
+
+/**
+* Matrices on the other hand side should only be copied, when it is sure
+* we gain by copying (see arithmetic cost check and eval before nesting flag).
+* Note: This is an optimization measure that comprises potential (though little)
+*       to create erroneous code. Any user, utilizing ei_nested outside of
+*       Eigen needs to take care that no references to temporaries are
+*       stored or that this potential danger is at least communicated
+*       to the user.
+**/
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct ei_ref_selector< Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > 
+{
+  typedef Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> MatrixType;
+  typedef MatrixType const& type;
+};
 
 /** \internal Determines how a given expression should be nested into another one.
   * For example, when you do a * (b+c), Eigen will determine how the expression b+c should be
@@ -195,15 +222,12 @@ template<typename T, int n=1, typename PlainMatrixType = typename ei_eval<T>::ty
     CostEval   = (n+1) * int(NumTraits<typename ei_traits<T>::Scalar>::ReadCost),
     CostNoEval = (n-1) * int(ei_traits<T>::CoeffReadCost)
   };
+
   typedef typename ei_meta_if<
-    ei_must_nest_by_value<T>::ret,
+    ( int(ei_traits<T>::Flags) & EvalBeforeNestingBit ) || 
-    T,
+    ( int(CostEval) <= int(CostNoEval) ),
-    typename ei_meta_if<
-      (int(ei_traits<T>::Flags) & EvalBeforeNestingBit)
-      || ( int(CostEval) <= int(CostNoEval) ),
       PlainMatrixType,
-      const T&
+      typename ei_ref_selector<T>::type
-    >::ret
   >::ret type;
 };
 
@@ -256,7 +280,7 @@ template<typename ExpressionType> struct HNormalizedReturnType {
                 ei_traits<ExpressionType>::ColsAtCompileTime==1 ? SizeMinusOne : 1,
                 ei_traits<ExpressionType>::ColsAtCompileTime==1 ? 1 : SizeMinusOne> StartMinusOne;
   typedef CwiseUnaryOp<ei_scalar_quotient1_op<typename ei_traits<ExpressionType>::Scalar>,
-              NestByValue<StartMinusOne> > Type;
+              StartMinusOne > Type;
 };
 
 template<typename XprType, typename CastType> struct ei_cast_return_type

Eigen/src/Eigenvalues/HessenbergDecomposition.h

@@ -58,10 +58,10 @@ template<typename _MatrixType> class HessenbergDecomposition
     typedef Matrix<RealScalar, Size, 1> DiagonalType;
     typedef Matrix<RealScalar, SizeMinusOne, 1> SubDiagonalType;
 
-    typedef typename NestByValue<Diagonal<MatrixType,0> >::RealReturnType DiagonalReturnType;
+    typedef typename Diagonal<MatrixType,0>::RealReturnType DiagonalReturnType;
 
-    typedef typename NestByValue<Diagonal<
+    typedef typename Diagonal<
-        NestByValue<Block<MatrixType,SizeMinusOne,SizeMinusOne> >,0 > >::RealReturnType SubDiagonalReturnType;
+        Block<MatrixType,SizeMinusOne,SizeMinusOne>,0 >::RealReturnType SubDiagonalReturnType;
 
     /** This constructor initializes a HessenbergDecomposition object for
       * further use with HessenbergDecomposition::compute()

Eigen/src/Eigenvalues/Tridiagonalization.h

@@ -61,15 +61,15 @@ template<typename _MatrixType> class Tridiagonalization
     typedef Matrix<RealScalar, SizeMinusOne, 1> SubDiagonalType;
 
     typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex,
-              typename NestByValue<Diagonal<MatrixType,0> >::RealReturnType,
+              typename Diagonal<MatrixType,0>::RealReturnType,
               Diagonal<MatrixType,0>
             >::ret DiagonalReturnType;
 
     typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex,
-              typename NestByValue<Diagonal<
+              typename Diagonal<
-                NestByValue<Block<MatrixType,SizeMinusOne,SizeMinusOne> >,0 > >::RealReturnType,
+                Block<MatrixType,SizeMinusOne,SizeMinusOne>,0 >::RealReturnType,
               Diagonal<
-                NestByValue<Block<MatrixType,SizeMinusOne,SizeMinusOne> >,0 >
+                Block<MatrixType,SizeMinusOne,SizeMinusOne>,0 >
             >::ret SubDiagonalReturnType;
 
     /** This constructor initializes a Tridiagonalization object for
@@ -144,7 +144,7 @@ template<typename MatrixType>
 const typename Tridiagonalization<MatrixType>::DiagonalReturnType
 Tridiagonalization<MatrixType>::diagonal(void) const
 {
-  return m_matrix.diagonal().nestByValue();
+  return m_matrix.diagonal();
 }
 
 /** \returns an expression of the sub-diagonal vector */
@@ -153,8 +153,7 @@ const typename Tridiagonalization<MatrixType>::SubDiagonalReturnType
 Tridiagonalization<MatrixType>::subDiagonal(void) const
 {
   int n = m_matrix.rows();
-  return Block<MatrixType,SizeMinusOne,SizeMinusOne>(m_matrix, 1, 0, n-1,n-1)
+  return Block<MatrixType,SizeMinusOne,SizeMinusOne>(m_matrix, 1, 0, n-1,n-1).diagonal();
-    .nestByValue().diagonal().nestByValue();
 }
 
 /** constructs and returns the tridiagonal matrix T.

Eigen/src/Geometry/Homogeneous.h

@@ -175,7 +175,7 @@ MatrixBase<Derived>::hnormalized() const
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
   return StartMinusOne(derived(),0,0,
     ColsAtCompileTime==1?size()-1:1,
-    ColsAtCompileTime==1?1:size()-1).nestByValue() / coeff(size()-1);
+    ColsAtCompileTime==1?1:size()-1) / coeff(size()-1);
 }
 
 /** \geometry_module
@@ -192,18 +192,17 @@ VectorwiseOp<ExpressionType,Direction>::hnormalized() const
 {
   return HNormalized_Block(_expression(),0,0,
       Direction==Vertical   ? _expression().rows()-1 : _expression().rows(),
-      Direction==Horizontal ? _expression().cols()-1 : _expression().cols()).nestByValue()
+      Direction==Horizontal ? _expression().cols()-1 : _expression().cols()).cwise()/
-    .cwise()/
+      Replicate<HNormalized_Factors,
-      Replicate<NestByValue<HNormalized_Factors>,
                 Direction==Vertical   ? HNormalized_SizeMinusOne : 1,
                 Direction==Horizontal ? HNormalized_SizeMinusOne : 1>
         (HNormalized_Factors(_expression(),
           Direction==Vertical    ? _expression().rows()-1:0,
           Direction==Horizontal  ? _expression().cols()-1:0,
           Direction==Vertical    ? 1 : _expression().rows(),
-          Direction==Horizontal  ? 1 : _expression().cols()).nestByValue(),
+          Direction==Horizontal  ? 1 : _expression().cols()),
          Direction==Vertical   ? _expression().rows()-1 : 1,
-         Direction==Horizontal ? _expression().cols()-1 : 1).nestByValue();
+         Direction==Horizontal ? _expression().cols()-1 : 1);
 }
 
 template<typename MatrixType,typename Lhs>

Eigen/src/Geometry/Transform.h

@@ -187,7 +187,7 @@ public:
   /** type of read/write reference to the affine part of the transformation */
   typedef typename ei_meta_if<int(Mode)==int(AffineCompact),
                               MatrixType&,
-                              NestByValue<Block<MatrixType,Dim,HDim> > >::ret AffinePartNested;
+                              Block<MatrixType,Dim,HDim> >::ret AffinePartNested;
   /** type of a vector */
   typedef Matrix<Scalar,Dim,1> VectorType;
   /** type of a read/write reference to the translation part of the rotation */

Eigen/src/Householder/HouseholderSequence.h

@@ -69,7 +69,7 @@ template<typename VectorsType, typename CoeffsType> class HouseholderSequence
 
     typedef HouseholderSequence<VectorsType,
       typename ei_meta_if<NumTraits<Scalar>::IsComplex,
-        NestByValue<typename ei_cleantype<typename CoeffsType::ConjugateReturnType>::type >,
+        typename ei_cleantype<typename CoeffsType::ConjugateReturnType>::type,
         CoeffsType>::ret> ConjugateReturnType;
 
     HouseholderSequence(const VectorsType& v, const CoeffsType& h, bool trans = false)

Eigen/src/LU/FullPivLU.h

@@ -352,12 +352,12 @@ template<typename _MatrixType> class FullPivLU
       *
       * \sa MatrixBase::inverse()
       */
-    inline const ei_solve_retval<FullPivLU,NestByValue<typename MatrixType::IdentityReturnType> > inverse() const
+    inline const ei_solve_retval<FullPivLU,typename MatrixType::IdentityReturnType> inverse() const
     {
       ei_assert(m_isInitialized && "LU is not initialized.");
       ei_assert(m_lu.rows() == m_lu.cols() && "You can't take the inverse of a non-square matrix!");
-      return ei_solve_retval<FullPivLU,NestByValue<typename MatrixType::IdentityReturnType> >
+      return ei_solve_retval<FullPivLU,typename MatrixType::IdentityReturnType>
-               (*this, MatrixType::Identity(m_lu.rows(), m_lu.cols()).nestByValue());
+               (*this, MatrixType::Identity(m_lu.rows(), m_lu.cols()));
     }
 
     inline int rows() const { return m_lu.rows(); }

Eigen/src/LU/PartialPivLU.h

@@ -143,11 +143,11 @@ template<typename _MatrixType> class PartialPivLU
       *
       * \sa MatrixBase::inverse(), LU::inverse()
       */
-    inline const ei_solve_retval<PartialPivLU,NestByValue<typename MatrixType::IdentityReturnType> > inverse() const
+    inline const ei_solve_retval<PartialPivLU,typename MatrixType::IdentityReturnType> inverse() const
     {
       ei_assert(m_isInitialized && "PartialPivLU is not initialized.");
-      return ei_solve_retval<PartialPivLU,NestByValue<typename MatrixType::IdentityReturnType> >
+      return ei_solve_retval<PartialPivLU,typename MatrixType::IdentityReturnType>
-               (*this, MatrixType::Identity(m_lu.rows(), m_lu.cols()).nestByValue());
+               (*this, MatrixType::Identity(m_lu.rows(), m_lu.cols()));
     }
 
     /** \returns the determinant of the matrix of which

Eigen/src/QR/ColPivHouseholderQR.h

@@ -224,12 +224,12 @@ template<typename _MatrixType> class ColPivHouseholderQR
       *       Use isInvertible() to first determine whether this matrix is invertible.
       */
     inline const
-    ei_solve_retval<ColPivHouseholderQR, NestByValue<typename MatrixType::IdentityReturnType> >
+    ei_solve_retval<ColPivHouseholderQR, typename MatrixType::IdentityReturnType>
     inverse() const
     {
       ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
-      return ei_solve_retval<ColPivHouseholderQR,NestByValue<typename MatrixType::IdentityReturnType> >
+      return ei_solve_retval<ColPivHouseholderQR,typename MatrixType::IdentityReturnType>
-               (*this, MatrixType::Identity(m_qr.rows(), m_qr.cols()).nestByValue());
+               (*this, MatrixType::Identity(m_qr.rows(), m_qr.cols()));
     }
 
     inline int rows() const { return m_qr.rows(); }

Eigen/src/QR/FullPivHouseholderQR.h

@@ -216,12 +216,12 @@ template<typename _MatrixType> class FullPivHouseholderQR
       * \note If this matrix is not invertible, the returned matrix has undefined coefficients.
       *       Use isInvertible() to first determine whether this matrix is invertible.
       */    inline const
-    ei_solve_retval<FullPivHouseholderQR, NestByValue<typename MatrixType::IdentityReturnType> >
+    ei_solve_retval<FullPivHouseholderQR, typename MatrixType::IdentityReturnType>
     inverse() const
     {
       ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
-      return ei_solve_retval<FullPivHouseholderQR,NestByValue<typename MatrixType::IdentityReturnType> >
+      return ei_solve_retval<FullPivHouseholderQR,typename MatrixType::IdentityReturnType>
-               (*this, MatrixType::Identity(m_qr.rows(), m_qr.cols()).nestByValue());
+               (*this, MatrixType::Identity(m_qr.rows(), m_qr.cols()));
     }
 
     inline int rows() const { return m_qr.rows(); }

Eigen/src/Sparse/DynamicSparseMatrix.h

@@ -57,6 +57,13 @@ struct ei_traits<DynamicSparseMatrix<_Scalar, _Flags> >
   };
 };
 
+template<typename _Scalar, int _Options>
+struct ei_ref_selector< DynamicSparseMatrix<_Scalar, _Options> >
+{
+  typedef DynamicSparseMatrix<_Scalar, _Options> MatrixType;
+  typedef MatrixType const& type;
+};
+
 template<typename _Scalar, int _Flags>
 class DynamicSparseMatrix
   : public SparseMatrixBase<DynamicSparseMatrix<_Scalar, _Flags> >

Eigen/src/Sparse/SparseCwise.h

@@ -52,7 +52,7 @@
   * convenient macro to defined the return type of a cwise comparison to a scalar */
 /*#define EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(OP) \
     CwiseBinaryOp<OP<typename ei_traits<ExpressionType>::Scalar>, ExpressionType, \
-        NestByValue<typename ExpressionType::ConstantReturnType> >*/
+        typename ExpressionType::ConstantReturnType >*/
 
 template<typename ExpressionType> class SparseCwise
 {

Eigen/src/Sparse/SparseDiagonalProduct.h

@@ -85,8 +85,7 @@ class SparseDiagonalProduct
     typedef ei_sparse_diagonal_product_inner_iterator_selector
                 <_LhsNested,_RhsNested,SparseDiagonalProduct,LhsMode,RhsMode> InnerIterator;
 
-    template<typename _Lhs, typename _Rhs>
+    EIGEN_STRONG_INLINE SparseDiagonalProduct(const Lhs& lhs, const Rhs& rhs)
-    EIGEN_STRONG_INLINE SparseDiagonalProduct(const _Lhs& lhs, const _Rhs& rhs)
       : m_lhs(lhs), m_rhs(rhs)
     {
       ei_assert(lhs.cols() == rhs.rows() && "invalid sparse matrix * diagonal matrix product");
@@ -155,16 +154,16 @@ class ei_sparse_diagonal_product_inner_iterator_selector
   : public SparseCwiseBinaryOp<
       ei_scalar_product_op<typename Rhs::Scalar>,
       SparseInnerVectorSet<Lhs,1>,
-      NestByValue<Transpose<typename Rhs::DiagonalVectorType> > >::InnerIterator
+      Transpose<typename Rhs::DiagonalVectorType> >::InnerIterator
 {
     typedef typename SparseCwiseBinaryOp<
       ei_scalar_product_op<typename Rhs::Scalar>,
       SparseInnerVectorSet<Lhs,1>,
-      NestByValue<Transpose<typename Rhs::DiagonalVectorType> > >::InnerIterator Base;
+      Transpose<typename Rhs::DiagonalVectorType> >::InnerIterator Base;
   public:
     inline ei_sparse_diagonal_product_inner_iterator_selector(
               const SparseDiagonalProductType& expr, int outer)
-      : Base(expr.lhs().innerVector(outer) .cwise()* expr.rhs().diagonal().transpose().nestByValue(), 0)
+      : Base(expr.lhs().innerVector(outer) .cwise()* expr.rhs().diagonal().transpose(), 0)
     {}
 };
 

Eigen/src/Sparse/SparseExpressionMaker.h

@@ -25,12 +25,6 @@
 #ifndef EIGEN_SPARSE_EXPRESSIONMAKER_H
 #define EIGEN_SPARSE_EXPRESSIONMAKER_H
 
-template<typename XprType>
-struct MakeNestByValue<XprType,IsSparse>
-{
-  typedef SparseNestByValue<XprType> Type;
-};
-
 template<typename Func, typename XprType>
 struct MakeCwiseUnaryOp<Func,XprType,IsSparse>
 {

Eigen/src/Sparse/SparseMatrix.h

@@ -56,6 +56,13 @@ struct ei_traits<SparseMatrix<_Scalar, _Options> >
   };
 };
 
+template<typename _Scalar, int _Options>
+struct ei_ref_selector<SparseMatrix<_Scalar, _Options> >
+{
+  typedef SparseMatrix<_Scalar, _Options> MatrixType;
+  typedef MatrixType const& type;
+};
+
 template<typename _Scalar, int _Options>
 class SparseMatrix
   : public SparseMatrixBase<SparseMatrix<_Scalar, _Options> >

Eigen/src/Sparse/SparseMatrixBase.h

@@ -100,7 +100,7 @@ template<typename Derived> class SparseMatrixBase : public AnyMatrixBase<Derived
     typedef SparseCwiseUnaryOp<ei_scalar_imag_op<Scalar>, Derived> ImagReturnType;
     /** \internal the return type of MatrixBase::adjoint() */
     typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex,
-                        SparseCwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, SparseNestByValue<Eigen::SparseTranspose<Derived> > >,
+                        SparseCwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Eigen::SparseTranspose<Derived> >,
                         SparseTranspose<Derived>
                      >::ret AdjointReturnType;
 
@@ -356,7 +356,7 @@ template<typename Derived> class SparseMatrixBase : public AnyMatrixBase<Derived
     SparseTranspose<Derived> transpose() { return derived(); }
     const SparseTranspose<Derived> transpose() const { return derived(); }
     // void transposeInPlace();
-    const AdjointReturnType adjoint() const { return transpose().nestByValue(); }
+    const AdjointReturnType adjoint() const { return transpose(); }
 
     // sub-vector
     SparseInnerVectorSet<Derived,1> row(int i);
@@ -528,9 +528,6 @@ template<typename Derived> class SparseMatrixBase : public AnyMatrixBase<Derived
       */
 //     inline int stride(void) const { return derived().stride(); }
 
-    inline const SparseNestByValue<Derived> nestByValue() const;
-
-
     ConjugateReturnType conjugate() const;
     const RealReturnType real() const;
     const ImagReturnType imag() const;
@@ -583,11 +580,11 @@ template<typename Derived> class SparseMatrixBase : public AnyMatrixBase<Derived
            const MatrixBase<ElseDerived>& elseMatrix) const;
 
     template<typename ThenDerived>
-    inline const Select<Derived,ThenDerived, NestByValue<typename ThenDerived::ConstantReturnType> >
+    inline const Select<Derived,ThenDerived, typename ThenDerived::ConstantReturnType>
     select(const MatrixBase<ThenDerived>& thenMatrix, typename ThenDerived::Scalar elseScalar) const;
 
     template<typename ElseDerived>
-    inline const Select<Derived, NestByValue<typename ElseDerived::ConstantReturnType>, ElseDerived >
+    inline const Select<Derived, typename ElseDerived::ConstantReturnType, ElseDerived >
     select(typename ElseDerived::Scalar thenScalar, const MatrixBase<ElseDerived>& elseMatrix) const;
 
     template<int p> RealScalar lpNorm() const;

Eigen/src/Sparse/SparseNestByValue.h

@@ -1,84 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008-2009 Gael Guennebaud <g.gael@free.fr>
-// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
-//
-// Eigen is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 3 of the License, or (at your option) any later version.
-//
-// Alternatively, you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of
-// the License, or (at your option) any later version.
-//
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
-// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License and a copy of the GNU General Public License along with
-// Eigen. If not, see <http://www.gnu.org/licenses/>.
-
-#ifndef EIGEN_SPARSENESTBYVALUE_H
-#define EIGEN_SPARSENESTBYVALUE_H
-
-/** \class SparseNestByValue
-  *
-  * \brief Expression which must be nested by value
-  *
-  * \param ExpressionType the type of the object of which we are requiring nesting-by-value
-  *
-  * This class is the return type of MatrixBase::nestByValue()
-  * and most of the time this is the only way it is used.
-  *
-  * \sa SparseMatrixBase::nestByValue(), class NestByValue
-  */
-template<typename ExpressionType>
-struct ei_traits<SparseNestByValue<ExpressionType> > : public ei_traits<ExpressionType>
-{};
-
-template<typename ExpressionType> class SparseNestByValue
-  : public SparseMatrixBase<SparseNestByValue<ExpressionType> >
-{
-  public:
-
-    typedef typename ExpressionType::InnerIterator InnerIterator;
-
-    EIGEN_SPARSE_GENERIC_PUBLIC_INTERFACE(SparseNestByValue)
-
-    inline SparseNestByValue(const ExpressionType& matrix) : m_expression(matrix) {}
-
-    EIGEN_STRONG_INLINE int rows() const { return m_expression.rows(); }
-    EIGEN_STRONG_INLINE int cols() const { return m_expression.cols(); }
-
-    operator const ExpressionType&() const { return m_expression; }
-
-  protected:
-    const ExpressionType m_expression;
-};
-
-/** \returns an expression of the temporary version of *this.
-  */
-template<typename Derived>
-inline const SparseNestByValue<Derived>
-SparseMatrixBase<Derived>::nestByValue() const
-{
-  return SparseNestByValue<Derived>(derived());
-}
-
-// template<typename MatrixType>
-// class SparseNestByValue<MatrixType>::InnerIterator : public MatrixType::InnerIterator
-// {
-//     typedef typename MatrixType::InnerIterator Base;
-//   public:
-// 
-//     EIGEN_STRONG_INLINE InnerIterator(const SparseNestByValue& expr, int outer)
-//       : Base(expr.m_expression, outer)
-//     {}
-// };
-
-#endif // EIGEN_SPARSENESTBYVALUE_H

Eigen/src/Sparse/SparseUtil.h

@@ -106,7 +106,6 @@ template<typename _Scalar, int _Flags = 0> class DynamicSparseMatrix;
 template<typename _Scalar, int _Flags = 0> class SparseVector;
 template<typename _Scalar, int _Flags = 0> class MappedSparseMatrix;
 
-template<typename MatrixType>                            class SparseNestByValue;
 template<typename MatrixType>                            class SparseTranspose;
 template<typename MatrixType, int Size>                  class SparseInnerVectorSet;
 template<typename Derived>                               class SparseCwise;
@@ -147,6 +146,4 @@ template<typename T> class ei_eval<T,IsSparse>
     typedef SparseMatrix<_Scalar, _Flags> type;
 };
 
-template<typename T> struct ei_must_nest_by_value<SparseNestByValue<T> > { enum { ret = true }; };
-
 #endif // EIGEN_SPARSEUTIL_H

Eigen/src/Sparse/SparseVector.h

@@ -51,6 +51,13 @@ struct ei_traits<SparseVector<_Scalar, _Options> >
   };
 };
 
+template<typename _Scalar, int _Options>
+struct ei_ref_selector< SparseVector<_Scalar, _Options> >
+{
+  typedef SparseVector<_Scalar, _Options> MatrixType;
+  typedef MatrixType const& type;
+};
+
 template<typename _Scalar, int _Options>
 class SparseVector
   : public SparseMatrixBase<SparseVector<_Scalar, _Options> >

bench/BenchTimer.h

@@ -26,12 +26,13 @@
 #ifndef EIGEN_BENCH_TIMER_H
 #define EIGEN_BENCH_TIMER_H
 
-#ifndef WIN32
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define NOMINMAX
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#else
 #include <time.h>
 #include <unistd.h>
-#else
-#define NOMINMAX
-#include <windows.h>
 #endif
 
 #include <cstdlib>
@@ -53,7 +54,7 @@ public:
 
   BenchTimer() 
   { 
-#ifdef WIN32
+#if defined(_WIN32) || defined(__CYGWIN__)
     LARGE_INTEGER freq;
     QueryPerformanceFrequency(&freq);
     m_frequency = (double)freq.QuadPart;
@@ -77,7 +78,7 @@ public:
     return m_best;
   }
 
-#ifdef WIN32
+#if defined(_WIN32) || defined(__CYGWIN__)
   inline double getTime(void)
 #else
   static inline double getTime(void)
@@ -95,7 +96,7 @@ public:
   }
 
 protected:
-#ifdef WIN32
+#if defined(_WIN32) || defined(__CYGWIN__)
   double m_frequency;
 #endif
   double m_best, m_start;

blas/common.h

@@ -76,17 +76,17 @@ extern "C"
 using namespace Eigen;
 
 template<typename T>
-Block<NestByValue<Map<Matrix<T,Dynamic,Dynamic> > >, Dynamic, Dynamic>
+Block<Map<Matrix<T,Dynamic,Dynamic> >, Dynamic, Dynamic>
 matrix(T* data, int rows, int cols, int stride)
 {
-  return Map<Matrix<T,Dynamic,Dynamic> >(data, stride, cols).nestByValue().block(0,0,rows,cols);
+  return Map<Matrix<T,Dynamic,Dynamic> >(data, stride, cols).block(0,0,rows,cols);
 }
 
 template<typename T>
-Block<NestByValue<Map<Matrix<T,Dynamic,Dynamic,RowMajor> > >, Dynamic, 1>
+Block<Map<Matrix<T,Dynamic,Dynamic,RowMajor> >, Dynamic, 1>
 vector(T* data, int size, int incr)
 {
-  return Map<Matrix<T,Dynamic,Dynamic,RowMajor> >(data, size, incr).nestByValue().col(0);
+  return Map<Matrix<T,Dynamic,Dynamic,RowMajor> >(data, size, incr).col(0);
 }
 
 template<typename T>
@@ -106,8 +106,8 @@ enum
   Conj = IsComplex
 };
 
-typedef Block<NestByValue<Map<Matrix<Scalar,Dynamic,Dynamic> > >, Dynamic, Dynamic> MatrixType;
+typedef Block<Map<Matrix<Scalar,Dynamic,Dynamic> >, Dynamic, Dynamic> MatrixType;
-typedef Block<NestByValue<Map<Matrix<Scalar,Dynamic,Dynamic, RowMajor> > >, Dynamic, 1> StridedVectorType;
+typedef Block<Map<Matrix<Scalar,Dynamic,Dynamic, RowMajor> >, Dynamic, 1> StridedVectorType;
 typedef Map<Matrix<Scalar,Dynamic,1> > CompactVectorType;
 
 #define EIGEN_BLAS_FUNC(X) EIGEN_CAT(SCALAR_SUFFIX,X##_)

test/geo_quaternion.cpp

@@ -43,7 +43,7 @@ template<typename Scalar> void quaternion(void)
   if (ei_is_same_type<Scalar,float>::ret)
     largeEps = 1e-3f;
 
-  Scalar eps = ei_random<Scalar>() * 1e-2;
+  Scalar eps = ei_random<Scalar>() * Scalar(1e-2);
 
   Vector3 v0 = Vector3::Random(),
           v1 = Vector3::Random(),

unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h

@@ -212,33 +212,33 @@ class AutoDiffScalar
 
     template<typename OtherDerType>
     inline const AutoDiffScalar<typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>,
-        typename MakeNestByValue<typename MakeCwiseBinaryOp<ei_scalar_difference_op<Scalar>,
+        typename MakeCwiseBinaryOp<ei_scalar_difference_op<Scalar>,
-          typename MakeNestByValue<typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType>::Type>::Type,
+          typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType>::Type,
-          typename MakeNestByValue<typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, typename ei_cleantype<OtherDerType>::type>::Type>::Type >::Type >::Type >::Type >
+          typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, typename ei_cleantype<OtherDerType>::type>::Type>::Type >::Type >
     operator/(const AutoDiffScalar<OtherDerType>& other) const
     {
       ei_make_coherent(m_derivatives, other.derivatives());
       return AutoDiffScalar<typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>,
-        typename MakeNestByValue<typename MakeCwiseBinaryOp<ei_scalar_difference_op<Scalar>,
+        typename MakeCwiseBinaryOp<ei_scalar_difference_op<Scalar>,
-          typename MakeNestByValue<typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType>::Type>::Type,
+          typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType>::Type,
-          typename MakeNestByValue<typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, typename ei_cleantype<OtherDerType>::type>::Type>::Type >::Type >::Type >::Type >(
+          typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, typename ei_cleantype<OtherDerType>::type>::Type>::Type >::Type >(
         m_value / other.value(),
-          ((m_derivatives * other.value()).nestByValue() - (m_value * other.derivatives()).nestByValue()).nestByValue()
+          ((m_derivatives * other.value()) - (m_value * other.derivatives()))
         * (Scalar(1)/(other.value()*other.value())));
     }
 
     template<typename OtherDerType>
     inline const AutoDiffScalar<typename MakeCwiseBinaryOp<ei_scalar_sum_op<Scalar>,
-        typename MakeNestByValue<typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType>::Type>::Type,
+        typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType>::Type,
-        typename MakeNestByValue<typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, typename ei_cleantype<OtherDerType>::type>::Type>::Type >::Type >
+        typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, typename ei_cleantype<OtherDerType>::type>::Type>::Type >
     operator*(const AutoDiffScalar<OtherDerType>& other) const
     {
       ei_make_coherent(m_derivatives, other.derivatives());
       return AutoDiffScalar<typename MakeCwiseBinaryOp<ei_scalar_sum_op<Scalar>,
-        typename MakeNestByValue<typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType>::Type>::Type,
+        typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType>::Type,
-        typename MakeNestByValue<typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, typename ei_cleantype<OtherDerType>::type>::Type>::Type >::Type >(
+        typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, typename ei_cleantype<OtherDerType>::type>::Type>::Type >(
         m_value * other.value(),
-        (m_derivatives * other.value()).nestByValue() + (m_value * other.derivatives()).nestByValue());
+        (m_derivatives * other.value()) + (m_value * other.derivatives()));
     }
 
     inline AutoDiffScalar& operator*=(const Scalar& other)

unsupported/Eigen/src/AutoDiff/AutoDiffVector.h

@@ -196,17 +196,17 @@ class AutoDiffVector
 //     inline const AutoDiffVector<
 //       CwiseBinaryOp<ei_scalar_multiple_op<Scalar>, ValueType, OtherValueType>
 //       CwiseBinaryOp<ei_scalar_sum_op<Scalar>,
-//         NestByValue<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, JacobianType> >,
+//         CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, JacobianType>,
-//         NestByValue<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, OtherJacobianType> > > >
+//         CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, OtherJacobianType> > >
 //     operator*(const AutoDiffVector<OtherValueType,OtherJacobianType>& other) const
 //     {
 //       return AutoDiffVector<
 //         CwiseBinaryOp<ei_scalar_multiple_op<Scalar>, ValueType, OtherValueType>
 //         CwiseBinaryOp<ei_scalar_sum_op<Scalar>,
-//           NestByValue<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, JacobianType> >,
+//           CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, JacobianType>,
-//           NestByValue<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, OtherJacobianType> > > >(
+//           CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, OtherJacobianType> > >(
 //             m_values.cwise() * other.values(),
-//             (m_jacobian * other.values()).nestByValue() + (m_values * other.jacobian()).nestByValue());
+//             (m_jacobian * other.values()) + (m_values * other.jacobian()));
 //     }
 
     inline AutoDiffVector& operator*=(const Scalar& other)

unsupported/Eigen/src/CMakeLists.txt

@@ -2,6 +2,6 @@ ADD_SUBDIRECTORY(IterativeSolvers)
 ADD_SUBDIRECTORY(BVH)
 ADD_SUBDIRECTORY(AutoDiff)
 ADD_SUBDIRECTORY(MoreVectorization)
-ADD_SUBDIRECTORY(FFT)
+# ADD_SUBDIRECTORY(FFT)
-ADD_SUBDIRECTORY(Skyline)
+# ADD_SUBDIRECTORY(Skyline)
 ADD_SUBDIRECTORY(MatrixFunctions)

unsupported/test/CMakeLists.txt

@@ -17,6 +17,7 @@ ei_add_test(BVH)
 ei_add_test(matrixExponential)
 ei_add_test(alignedvector3)
 ei_add_test(FFT)
+ei_add_test(nesting_profiling)
 
 find_package(FFTW)
 if(FFTW_FOUND)

unsupported/test/nesting_profiling.cpp

@@ -0,0 +1,199 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Hauke Heibel <hauke.heibel@gmail.com>
+//
+// Eigen is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 3 of the License, or (at your option) any later version.
+//
+// Alternatively, you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of
+// the License, or (at your option) any later version.
+//
+// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License and a copy of the GNU General Public License along with
+// Eigen. If not, see <http://www.gnu.org/licenses/>.
+
+#include "main.h"
+
+#define EIGEN_OLD_NESTED
+
+#include "Eigen/Core"
+#include "Eigen/Array"
+#include "Eigen/Geometry"
+
+#include "Bench/BenchTimer.h"
+
+using namespace Eigen;
+
+struct Transform2D
+{
+  static void run(int num_runs)
+  {
+    const Matrix2d T = Matrix2d::Random();
+    const Vector2d t = Vector2d::Random();
+    const Matrix2Xd pts = Matrix2Xd::Random(2,100);
+
+    Matrix2Xd res;
+    for (int i=0; i<num_runs; ++i)
+    {
+      run(res, T, pts, t);
+    }
+  }
+
+  EIGEN_DONT_INLINE static void run(Matrix2Xd& res, const Matrix2d& T, const Matrix2Xd& pts, const Vector2d& t)
+  {
+    res = T * pts + Replicate<Vector2d,1,100>(t);
+  }
+};
+
+struct ColwiseTransform2D
+{
+  static void run(int num_runs)
+  {
+    const Matrix2d T = Matrix2d::Random();
+    const Vector2d t = Vector2d::Random();
+    const Matrix2Xd pts = Matrix2Xd::Random(2,100);
+
+    Matrix2Xd res;
+    for (int i=0; i<num_runs; ++i)
+    {
+      run(res, T, pts, t);
+    }
+  }
+
+  EIGEN_DONT_INLINE static void run(Matrix2Xd& res, const Matrix2d& T, const Matrix2Xd& pts, const Vector2d& t)
+  {
+    res = T * pts + Replicate<Vector2d,1,100>(t);
+  }
+};
+
+struct LinearCombination
+{
+  typedef Eigen::Matrix<double,2,4> Matrix2x4d;
+
+  static void run(int num_runs)
+  {
+    const Matrix2Xd pts = Matrix2Xd::Random(2,100);
+    const Matrix2x4d coefs = Matrix2x4d::Random();
+
+    Matrix2x4d linear_combined = Matrix2x4d::Zero();
+    for (int i=0; i<num_runs; ++i)
+    {
+      for (int r=0; r<coefs.rows(); ++r)
+      {
+        for (int c=0; c<pts.cols()-coefs.cols()+1; ++c)
+        {
+          run(linear_combined, pts, coefs, r, c);
+        }
+      }
+    }
+  }
+
+  EIGEN_DONT_INLINE static void run(Matrix2x4d& res, const Matrix2Xd& pts, const Matrix2x4d& coefs, int r, int c)
+  {
+    res += pts.block(0,c,2,coefs.cols()).cwise() * Replicate<Matrix2x4d::RowXpr,2,1>(coefs.row(r));
+  }
+};
+
+template <typename VectorType>
+struct VectorAddition
+{
+  typedef VectorType ReturnType;
+  EIGEN_DONT_INLINE static VectorType run(int)
+  {
+    VectorType a,b,c,d;
+    return a+b+c+d;
+  }
+};
+
+template <typename MatrixType>
+struct MatrixProduct
+{
+  typedef MatrixType ReturnType;
+  EIGEN_DONT_INLINE static MatrixType run(int num_runs)
+  {
+    MatrixType a,b;
+    return a*b;
+  }
+};
+
+template <typename MatrixType>
+struct MatrixScaling
+{
+  typedef MatrixType ReturnType;
+  EIGEN_DONT_INLINE static MatrixType run(int num_runs)
+  {
+      typename ei_traits<MatrixType>::Scalar s;
+      MatrixType a,b;
+      return s*a;
+  }
+};
+
+template<typename TestFunction>
+EIGEN_DONT_INLINE void run(int num_runs)
+{
+  for (int outer_runs=0; outer_runs<30; ++outer_runs)
+  {
+    //BenchTimer timer;
+    //const double start = timer.getTime();
+    {
+      TestFunction::run(num_runs);
+    }
+    //const double stop = timer.getTime();
+    //std::cout << (stop-start)*1000.0 << " ms" << std::endl;
+  }
+}
+
+template<typename TestFunction>
+EIGEN_DONT_INLINE void run_direct(int num_runs = 1)
+{
+  for (int outer_runs=0; outer_runs<30; ++outer_runs)
+  {
+    // required to prevent that the compiler replaces the run-call by nop
+    typename TestFunction::ReturnType return_type;
+    for (int i=0; i<num_runs; ++i)
+    {
+      return_type += TestFunction::run(num_runs);
+    }
+  }
+}
+
+void test_nesting_profiling()
+{
+  const int num_runs = 10000;
+
+  BenchTimer timer;
+  const double start = timer.getTime();
+  {
+    // leads to better run-time
+    run<Transform2D>(num_runs);
+    run<ColwiseTransform2D>(num_runs);
+    run<LinearCombination>(num_runs);
+  }
+  const double stop = timer.getTime();
+  std::cout << (stop-start)*1000.0 << " ms" << std::endl;
+
+  // leads to identical assembly
+  run_direct< MatrixProduct<Matrix2d> >();
+  run_direct< MatrixProduct<Matrix3d> >();
+  run_direct< MatrixProduct<Matrix4d> >();
+
+  // leads to identical assembly
+  run_direct< MatrixScaling<Matrix2d> >();
+  run_direct< MatrixScaling<Matrix3d> >();
+  run_direct< MatrixScaling<Matrix4d> >();
+
+  // leads to better assembly
+  run_direct< VectorAddition<Vector4f> >();
+  run_direct< VectorAddition<Vector4d> >();
+  run_direct< VectorAddition<Vector4i> >();
+}