bump

(matrix-vector product did not use the nesting rules....)

CMakeLists.txt

@@ -7,7 +7,7 @@ set(INCLUDE_INSTALL_DIR
     "The directory where we install the header files"
     FORCE)
 
-set(EIGEN_VERSION_NUMBER "2.0.15")
+set(EIGEN_VERSION_NUMBER "2.0.17")
 set(EIGEN_VERSION "${EIGEN_VERSION_NUMBER}")
 
 set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)

Eigen/Core

@@ -52,6 +52,7 @@
   #endif
 #endif
 
+#include <cstddef>
 #include <cstdlib>
 #include <cmath>
 #include <complex>

Eigen/src/Core/Product.h

@@ -187,6 +187,17 @@ template<typename LhsNested, typename RhsNested, int ProductMode> class Product
                                   _LhsNested, _RhsNested, Scalar> ScalarCoeffImpl;
 
   public:
+    typedef typename ei_nested<_LhsNested,_RhsNested::ColsAtCompileTime>::type LhsNestedX;
+    typedef typename ei_nested<_RhsNested,_LhsNested::RowsAtCompileTime>::type RhsNestedX;
+    typedef typename ei_cleantype<LhsNestedX>::type _LhsNestedX;
+    typedef typename ei_cleantype<RhsNestedX>::type _RhsNestedX;
+  
+    
+    enum {
+      LhsNestedFlags = _LhsNestedX::Flags,
+      RhsNestedFlags = _RhsNestedX::Flags
+    };
+    
 
     template<typename Lhs, typename Rhs>
     inline Product(const Lhs& lhs, const Rhs& rhs)
@@ -522,11 +533,11 @@ static void ei_cache_friendly_product_rowmajor_times_vector(
 
 template<typename ProductType,
   int LhsRows  = ei_traits<ProductType>::RowsAtCompileTime,
-  int LhsOrder = int(ei_traits<ProductType>::LhsFlags)&RowMajorBit ? RowMajor : ColMajor,
-  int LhsHasDirectAccess = int(ei_traits<ProductType>::LhsFlags)&DirectAccessBit? HasDirectAccess : NoDirectAccess,
-  int RhsCols  = ei_traits<ProductType>::ColsAtCompileTime,
-  int RhsOrder = int(ei_traits<ProductType>::RhsFlags)&RowMajorBit ? RowMajor : ColMajor,
-  int RhsHasDirectAccess = int(ei_traits<ProductType>::RhsFlags)&DirectAccessBit? HasDirectAccess : NoDirectAccess>
+  int LhsOrder = int(ProductType::LhsNestedFlags)&RowMajorBit ? RowMajor : ColMajor,
+  int LhsHasDirectAccess = int(ProductType::LhsNestedFlags)&DirectAccessBit? HasDirectAccess : NoDirectAccess,
+  int RhsCols  = ProductType::ColsAtCompileTime,
+  int RhsOrder = int(ProductType::RhsNestedFlags)&RowMajorBit ? RowMajor : ColMajor,
+  int RhsHasDirectAccess = int(ProductType::RhsNestedFlags)&DirectAccessBit? HasDirectAccess : NoDirectAccess>
 struct ei_cache_friendly_product_selector
 {
   template<typename DestDerived>
@@ -543,9 +554,12 @@ struct ei_cache_friendly_product_selector<ProductType,LhsRows,ColMajor,NoDirectA
   template<typename DestDerived>
   inline static void run(DestDerived& res, const ProductType& product)
   {
-    const int size = product.rhs().rows();
+    typename ProductType::LhsNestedX lhs(product.lhs());
+    typename ProductType::RhsNestedX rhs(product.rhs());
+    
+    const int size = rhs.rows();
     for (int k=0; k<size; ++k)
-        res += product.rhs().coeff(k) * product.lhs().col(k);
+        res += rhs.coeff(k) * lhs.col(k);
   }
 };
 
@@ -559,6 +573,9 @@ struct ei_cache_friendly_product_selector<ProductType,LhsRows,ColMajor,HasDirect
   template<typename DestDerived>
   inline static void run(DestDerived& res, const ProductType& product)
   {
+    typename ProductType::LhsNestedX lhs(product.lhs());
+    typename ProductType::RhsNestedX rhs(product.rhs());
+    
     enum {
       EvalToRes = (ei_packet_traits<Scalar>::size==1)
                 ||((DestDerived::Flags&ActualPacketAccessBit) && (!(DestDerived::Flags & RowMajorBit))) };
@@ -571,8 +588,8 @@ struct ei_cache_friendly_product_selector<ProductType,LhsRows,ColMajor,HasDirect
       Map<Matrix<Scalar,DestDerived::RowsAtCompileTime,1,ColMajor> >(_res, res.size()) = res;
     }
     ei_cache_friendly_product_colmajor_times_vector(res.size(),
-      &product.lhs().const_cast_derived().coeffRef(0,0), product.lhs().stride(),
-      product.rhs(), _res);
+      &lhs.const_cast_derived().coeffRef(0,0), lhs.stride(),
+      rhs, _res);
 
     if (!EvalToRes)
     {
@@ -589,9 +606,12 @@ struct ei_cache_friendly_product_selector<ProductType,1,LhsOrder,LhsAccess,RhsCo
   template<typename DestDerived>
   inline static void run(DestDerived& res, const ProductType& product)
   {
-    const int cols = product.lhs().cols();
+    typename ProductType::LhsNestedX lhs(product.lhs());
+    typename ProductType::RhsNestedX rhs(product.rhs());
+    
+    const int cols = lhs.cols();
     for (int j=0; j<cols; ++j)
-      res += product.lhs().coeff(j) * product.rhs().row(j);
+      res += lhs.coeff(j) * rhs.row(j);
   }
 };
 
@@ -605,6 +625,9 @@ struct ei_cache_friendly_product_selector<ProductType,1,LhsOrder,LhsAccess,RhsCo
   template<typename DestDerived>
   inline static void run(DestDerived& res, const ProductType& product)
   {
+    typename ProductType::LhsNestedX lhs(product.lhs());
+    typename ProductType::RhsNestedX rhs(product.rhs());
+    
     enum {
       EvalToRes = (ei_packet_traits<Scalar>::size==1)
                 ||((DestDerived::Flags & ActualPacketAccessBit) && (DestDerived::Flags & RowMajorBit)) };
@@ -617,8 +640,8 @@ struct ei_cache_friendly_product_selector<ProductType,1,LhsOrder,LhsAccess,RhsCo
       Map<Matrix<Scalar,1,DestDerived::SizeAtCompileTime,ColMajor> >(_res, res.size()) = res;
     }
     ei_cache_friendly_product_colmajor_times_vector(res.size(),
-      &product.rhs().const_cast_derived().coeffRef(0,0), product.rhs().stride(),
-      product.lhs().transpose(), _res);
+      &rhs.const_cast_derived().coeffRef(0,0), rhs.stride(),
+      lhs.transpose(), _res);
 
     if (!EvalToRes)
     {
@@ -635,25 +658,28 @@ struct ei_cache_friendly_product_selector<ProductType,LhsRows,RowMajor,HasDirect
   typedef typename ProductType::Scalar Scalar;
   typedef typename ei_traits<ProductType>::_RhsNested Rhs;
   enum {
-      UseRhsDirectly = ((ei_packet_traits<Scalar>::size==1) || (Rhs::Flags&ActualPacketAccessBit))
-                     && (Rhs::Flags&DirectAccessBit)
-                     && (!(Rhs::Flags & RowMajorBit)) };
+      UseRhsDirectly = ((ei_packet_traits<Scalar>::size==1) || (ProductType::RhsNestedFlags&ActualPacketAccessBit))
+                     && (ProductType::RhsNestedFlags&DirectAccessBit)
+                     && (!(ProductType::RhsNestedFlags & RowMajorBit)) };
 
   template<typename DestDerived>
   inline static void run(DestDerived& res, const ProductType& product)
   {
+    typename ProductType::LhsNestedX lhs(product.lhs());
+    typename ProductType::RhsNestedX rhs(product.rhs());
+  
     Scalar* EIGEN_RESTRICT _rhs;
     if (UseRhsDirectly)
-       _rhs = &product.rhs().const_cast_derived().coeffRef(0);
+       _rhs = &rhs.const_cast_derived().coeffRef(0);
     else
     {
-      _rhs = ei_aligned_stack_new(Scalar, product.rhs().size());
-      Map<Matrix<Scalar,Rhs::SizeAtCompileTime,1,ColMajor> >(_rhs, product.rhs().size()) = product.rhs();
+      _rhs = ei_aligned_stack_new(Scalar, rhs.size());
+      Map<Matrix<Scalar,Rhs::SizeAtCompileTime,1,ColMajor> >(_rhs, rhs.size()) = rhs;
     }
-    ei_cache_friendly_product_rowmajor_times_vector(&product.lhs().const_cast_derived().coeffRef(0,0), product.lhs().stride(),
-                                                    _rhs, product.rhs().size(), res);
+    ei_cache_friendly_product_rowmajor_times_vector(&lhs.const_cast_derived().coeffRef(0,0), lhs.stride(),
+                                                    _rhs, rhs.size(), res);
 
-    if (!UseRhsDirectly) ei_aligned_stack_delete(Scalar, _rhs, product.rhs().size());
+    if (!UseRhsDirectly) ei_aligned_stack_delete(Scalar, _rhs, rhs.size());
   }
 };
 
@@ -664,25 +690,28 @@ struct ei_cache_friendly_product_selector<ProductType,1,LhsOrder,LhsAccess,RhsCo
   typedef typename ProductType::Scalar Scalar;
   typedef typename ei_traits<ProductType>::_LhsNested Lhs;
   enum {
-      UseLhsDirectly = ((ei_packet_traits<Scalar>::size==1) || (Lhs::Flags&ActualPacketAccessBit))
-                     && (Lhs::Flags&DirectAccessBit)
-                     && (Lhs::Flags & RowMajorBit) };
+      UseLhsDirectly = ((ei_packet_traits<Scalar>::size==1) || (ProductType::LhsNestedFlags&ActualPacketAccessBit))
+                     && (ProductType::LhsNestedFlags&DirectAccessBit)
+                     && (ProductType::LhsNestedFlags & RowMajorBit) };
 
   template<typename DestDerived>
   inline static void run(DestDerived& res, const ProductType& product)
   {
+    typename ProductType::LhsNestedX lhs(product.lhs());
+    typename ProductType::RhsNestedX rhs(product.rhs());
+  
     Scalar* EIGEN_RESTRICT _lhs;
     if (UseLhsDirectly)
-       _lhs = &product.lhs().const_cast_derived().coeffRef(0);
+       _lhs = &lhs.const_cast_derived().coeffRef(0);
     else
     {
-      _lhs = ei_aligned_stack_new(Scalar, product.lhs().size());
-      Map<Matrix<Scalar,1,Lhs::SizeAtCompileTime,ColMajor> >(_lhs, product.lhs().size()) = product.lhs();
+      _lhs = ei_aligned_stack_new(Scalar, lhs.size());
+      Map<Matrix<Scalar,1,Lhs::SizeAtCompileTime,ColMajor> >(_lhs, lhs.size()) = lhs;
     }
-    ei_cache_friendly_product_rowmajor_times_vector(&product.rhs().const_cast_derived().coeffRef(0,0), product.rhs().stride(),
-                                                    _lhs, product.lhs().size(), res);
+    ei_cache_friendly_product_rowmajor_times_vector(&rhs.const_cast_derived().coeffRef(0,0), rhs.stride(),
+                                                    _lhs, lhs.size(), res);
 
-    if(!UseLhsDirectly) ei_aligned_stack_delete(Scalar, _lhs, product.lhs().size());
+    if(!UseLhsDirectly) ei_aligned_stack_delete(Scalar, _lhs, lhs.size());
   }
 };
 
@@ -735,7 +764,7 @@ inline Derived& MatrixBase<Derived>::lazyAssign(const Product<Lhs,Rhs,CacheFrien
   {
     typedef typename ei_cleantype<Lhs>::type _Lhs;
     typedef typename ei_cleantype<Rhs>::type _Rhs;
-
+    
     typedef typename ei_nested<_Lhs,_Rhs::ColsAtCompileTime>::type LhsNested;
     typedef typename ei_nested<_Rhs,_Lhs::RowsAtCompileTime>::type RhsNested;
 

Eigen/src/Core/util/Macros.h

@@ -30,7 +30,7 @@
 
 #define EIGEN_WORLD_VERSION 2
 #define EIGEN_MAJOR_VERSION 0
-#define EIGEN_MINOR_VERSION 15
+#define EIGEN_MINOR_VERSION 17
 
 #define EIGEN_VERSION_AT_LEAST(x,y,z) (EIGEN_WORLD_VERSION>x || (EIGEN_WORLD_VERSION>=x && \
                                       (EIGEN_MAJOR_VERSION>y || (EIGEN_MAJOR_VERSION>=y && \

Eigen/src/Core/util/Memory.h

@@ -386,7 +386,7 @@ public:
         return std::numeric_limits<size_type>::max();
     }
 
-    pointer allocate( size_type num, const_pointer* hint = 0 )
+    pointer allocate( size_type num, const void* hint = 0 )
     {
         static_cast<void>( hint ); // suppress unused variable warning
         return static_cast<pointer>( ei_aligned_malloc( num * sizeof(T) ) );

Eigen/src/Core/util/XprHelper.h

@@ -120,7 +120,7 @@ template<int _Rows, int _Cols> struct ei_size_at_compile_time
  * in order to avoid a useless copy
  */
 
-template<typename T, int Sparseness = ei_traits<T>::Flags&SparseBit> class ei_eval;
+template<typename T, int Sparseness = ei_traits<T>::Flags&SparseBit> struct ei_eval;
 
 template<typename T> struct ei_eval<T,IsDense>
 {

Eigen/src/Geometry/ParametrizedLine.h

@@ -34,7 +34,7 @@
   *
   * A parametrized line is defined by an origin point \f$ \mathbf{o} \f$ and a unit
   * direction vector \f$ \mathbf{d} \f$ such that the line corresponds to
-  * the set \f$ l(t) = \mathbf{o} + t \mathbf{d} \f$, \f$ l \in \mathbf{R} \f$.
+  * the set \f$ l(t) = \mathbf{o} + t \mathbf{d} \f$, \f$ t \in \mathbf{R} \f$.
   *
   * \param _Scalar the scalar type, i.e., the type of the coefficients
   * \param _AmbientDim the dimension of the ambient space, can be a compile time value or Dynamic.

Eigen/src/LeastSquares/LeastSquares.h

@@ -54,10 +54,13 @@
   * constants \f$a,b,c\f$ so that the plane of equation \f$y=ax+bz+c\f$ fits
   * best the five above points. To do that, call this function as follows:
   * @code
+    // create a vector of pointers to the points
+    std::vector<Vector3d> points_ptrs(5);
+    for(int k=0; k<5; ++k) points_ptrs[k] = &points[k];
     Vector3d coeffs; // will store the coefficients a, b, c
     linearRegression(
       5,
-      &points,
+      &(points_ptrs[0]),
       &coeffs,
       1 // the coord to express as a function of
         // the other ones. 0 means x, 1 means y, 2 means z.

Eigen/src/QR/Tridiagonalization.h

@@ -391,7 +391,7 @@ void Tridiagonalization<MatrixType>::_decomposeInPlace3x3(MatrixType& mat, Diago
 {
   diag[0] = ei_real(mat(0,0));
   RealScalar v1norm2 = ei_abs2(mat(0,2));
-  if (ei_isMuchSmallerThan(v1norm2, RealScalar(1)))
+  if (v1norm2==RealScalar(0))
   {
     diag[1] = ei_real(mat(1,1));
     diag[2] = ei_real(mat(2,2));

Eigen/src/Sparse/SparseLU.h

@@ -96,8 +96,8 @@ class SparseLU
 
     void setOrderingMethod(int m)
     {
-      ei_assert(m&~OrderingMask == 0 && m!=0 && "invalid ordering method");
-      m_flags = m_flags&~OrderingMask | m&OrderingMask;
+      ei_assert((m&~OrderingMask) == 0 && m!=0 && "invalid ordering method");
+      m_flags = (m_flags&~OrderingMask) | (m&OrderingMask);
     }
 
     int orderingMethod() const

test/triangular.cpp

@@ -121,11 +121,40 @@ template<typename MatrixType> void triangular(const MatrixType& m)
   m3.setZero();
   m3.template part<Eigen::UpperTriangular>().setOnes();
   VERIFY_IS_APPROX(m2,m3);
+}
 
+void selfadjoint()
+{
+  Matrix2i m;
+  m << 1, 2,
+       3, 4;
+  VERIFY(m.part<SelfAdjoint>() == m);
+  
+  Matrix2i m1 = Matrix2i::Zero();
+  m1.part<SelfAdjoint>() = m;
+  Matrix2i ref1;
+  ref1 << 1, 2,
+          2, 4;
+  VERIFY(m1 == ref1);
+  
+  Matrix2i m2 = Matrix2i::Zero();
+  m2.part<SelfAdjoint>() = m.part<UpperTriangular>();
+  Matrix2i ref2;
+  ref2 << 1, 2,
+          2, 4;
+  VERIFY(m2 == ref2);
+ 
+  Matrix2i m3 = Matrix2i::Zero();
+  m3.part<SelfAdjoint>() = m.part<LowerTriangular>();
+  Matrix2i ref3;
+  ref3 << 1, 0,
+          0, 4;
+  VERIFY(m3 == ref3);
 }
 
 void test_triangular()
 {
+  CALL_SUBTEST( selfadjoint() );
   for(int i = 0; i < g_repeat ; i++) {
     CALL_SUBTEST( triangular(Matrix<float, 1, 1>()) );
     CALL_SUBTEST( triangular(Matrix<float, 2, 2>()) );