bump version number

: fix warnings with recent gcc(4.3.3)

CMakeLists.txt

@@ -1,5 +1,5 @@
 project(Eigen)
-set(EIGEN_VERSION_NUMBER "2.0.1")
+set(EIGEN_VERSION_NUMBER "2.0.2")
 
 #if the svnversion program is absent, this will leave the SVN_REVISION string empty,
 #but won't stop CMake.

Eigen/Core

@@ -7,11 +7,10 @@
 #ifdef _MSC_VER
   #include <malloc.h> // for _aligned_malloc -- need it regardless of whether vectorization is enabled
   #if (_MSC_VER >= 1500) // 2008 or later
-    // Remember that usage of defined() in a #define is undefined by the standard
+    // Remember that usage of defined() in a #define is undefined by the standard.
-    #ifdef _M_IX86_FP
+    // a user reported that in 64-bit mode, MSVC doesn't care to define _M_IX86_FP.
-      #if _M_IX86_FP >= 2
+    #if (defined(_M_IX86_FP) && (_M_IX86_FP >= 2)) || defined(_M_X64)
-        #define EIGEN_SSE2_ON_MSVC_2008_OR_LATER
+      #define EIGEN_SSE2_ON_MSVC_2008_OR_LATER
-      #endif
     #endif   
   #endif
 #endif

Eigen/LeastSquares

@@ -5,7 +5,6 @@
 
 #include "src/Core/util/DisableMSVCWarnings.h"
 
-#include "LU"
 #include "QR"
 #include "Geometry"
 

Eigen/src/Array/PartialRedux.h

@@ -61,7 +61,11 @@ struct ei_traits<PartialReduxExpr<MatrixType, MemberOp, Direction> >
     Flags = (unsigned int)_MatrixTypeNested::Flags & HereditaryBits,
     TraversalSize = Direction==Vertical ? RowsAtCompileTime : ColsAtCompileTime
   };
+  #if EIGEN_GNUC_AT_LEAST(3,4)
   typedef typename MemberOp::template Cost<InputScalar,int(TraversalSize)> CostOpType;
+  #else
+  typedef typename MemberOp::template Cost<InputScalar,TraversalSize> CostOpType;
+  #endif
   enum {
     CoeffReadCost = TraversalSize * ei_traits<_MatrixTypeNested>::CoeffReadCost + int(CostOpType::value)
   };
@@ -104,7 +108,7 @@ class PartialReduxExpr : ei_no_assignment_operator,
     { enum { value = COST }; };                                     \
     template<typename Derived>                                      \
     inline ResultType operator()(const MatrixBase<Derived>& mat) const     \
-    { return mat.MEMBER(); }                                        \
+    { return mat.MEMBER(); } \
   }
 
 EIGEN_MEMBER_FUNCTOR(squaredNorm, Size * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);

Eigen/src/Array/Random.h

@@ -110,7 +110,7 @@ MatrixBase<Derived>::Random()
   * Example: \include MatrixBase_setRandom.cpp
   * Output: \verbinclude MatrixBase_setRandom.out
   *
-  * \sa class CwiseNullaryOp, MatrixBase::setRandom(int,int)
+  * \sa class CwiseNullaryOp, setRandom(int), setRandom(int,int)
   */
 template<typename Derived>
 inline Derived& MatrixBase<Derived>::setRandom()
@@ -118,4 +118,39 @@ inline Derived& MatrixBase<Derived>::setRandom()
   return *this = Random(rows(), cols());
 }
 
+/** Resizes to the given \a size, and sets all coefficients in this expression to random values.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include Matrix_setRandom_int.cpp
+  * Output: \verbinclude Matrix_setRandom_int.out
+  *
+  * \sa MatrixBase::setRandom(), setRandom(int,int), class CwiseNullaryOp, MatrixBase::Random()
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
+Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setRandom(int size)
+{
+  resize(size);
+  return setRandom();
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to random values.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setRandom_int_int.cpp
+  * Output: \verbinclude Matrix_setRandom_int_int.out
+  *
+  * \sa MatrixBase::setRandom(), setRandom(int), class CwiseNullaryOp, MatrixBase::Random()
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
+Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setRandom(int rows, int cols)
+{
+  resize(rows, cols);
+  return setRandom();
+}
+
 #endif // EIGEN_RANDOM_H

Eigen/src/Core/Block.h

@@ -72,12 +72,12 @@ struct ei_traits<Block<MatrixType, BlockRows, BlockCols, _PacketAccess, _DirectA
     RowsAtCompileTime = ei_traits<MatrixType>::RowsAtCompileTime == 1 ? 1 : BlockRows,
     ColsAtCompileTime = ei_traits<MatrixType>::ColsAtCompileTime == 1 ? 1 : BlockCols,
     MaxRowsAtCompileTime = RowsAtCompileTime == 1 ? 1
-      : (BlockRows==Dynamic ? ei_traits<MatrixType>::MaxRowsAtCompileTime : BlockRows),
+      : (BlockRows==Dynamic ? int(ei_traits<MatrixType>::MaxRowsAtCompileTime) : BlockRows),
     MaxColsAtCompileTime = ColsAtCompileTime == 1 ? 1
-      : (BlockCols==Dynamic ? ei_traits<MatrixType>::MaxColsAtCompileTime : BlockCols),
+      : (BlockCols==Dynamic ? int(ei_traits<MatrixType>::MaxColsAtCompileTime) : BlockCols),
     RowMajor = int(ei_traits<MatrixType>::Flags)&RowMajorBit,
-    InnerSize = RowMajor ? ColsAtCompileTime : RowsAtCompileTime,
+    InnerSize = RowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
-    InnerMaxSize = RowMajor ? MaxColsAtCompileTime : MaxRowsAtCompileTime,
+    InnerMaxSize = RowMajor ? int(MaxColsAtCompileTime) : int(MaxRowsAtCompileTime),
     MaskPacketAccessBit = (InnerMaxSize == Dynamic || (InnerSize >= ei_packet_traits<Scalar>::size))
                         ? PacketAccessBit : 0,
     FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1) ? LinearAccessBit : 0,
@@ -222,7 +222,7 @@ class Block<MatrixType,BlockRows,BlockCols,PacketAccess,HasDirectAccess>
 
     class InnerIterator;
     typedef typename ei_traits<Block>::AlignedDerivedType AlignedDerivedType;
-    friend class Block<MatrixType,BlockRows,BlockCols,AsRequested,HasDirectAccess>;
+    friend class Block<MatrixType,BlockRows,BlockCols,PacketAccess==AsRequested?ForceAligned:AsRequested,HasDirectAccess>;
 
     EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
 

Eigen/src/Core/CacheFriendlyProduct.h

@@ -361,13 +361,14 @@ static EIGEN_DONT_INLINE void ei_cache_friendly_product_colmajor_times_vector(
   #ifdef _EIGEN_ACCUMULATE_PACKETS
   #error _EIGEN_ACCUMULATE_PACKETS has already been defined
   #endif
-
+  #define _EIGEN_ACCUMULATE_PACKETS(A0,A13,A2) \
-  #define _EIGEN_ACCUMULATE_PACKETS(A0,A13,A2,OFFSET) \
+    ei_pstore(&res[j], \
-    ei_pstore(&res[j OFFSET], \
+      ei_padd(ei_pload(&res[j]), \
-      ei_padd(ei_pload(&res[j OFFSET]), \
         ei_padd( \
-          ei_padd(ei_pmul(ptmp0,ei_pload ## A0(&lhs0[j OFFSET])),ei_pmul(ptmp1,ei_pload ## A13(&lhs1[j OFFSET]))), \
+          ei_padd(ei_pmul(ptmp0,EIGEN_CAT(ei_ploa , A0)(&lhs0[j])), \
-          ei_padd(ei_pmul(ptmp2,ei_pload ## A2(&lhs2[j OFFSET])),ei_pmul(ptmp3,ei_pload ## A13(&lhs3[j OFFSET]))) )))
+                  ei_pmul(ptmp1,EIGEN_CAT(ei_ploa , A13)(&lhs1[j]))), \
+          ei_padd(ei_pmul(ptmp2,EIGEN_CAT(ei_ploa , A2)(&lhs2[j])), \
+                  ei_pmul(ptmp3,EIGEN_CAT(ei_ploa , A13)(&lhs3[j]))) )))
 
   typedef typename ei_packet_traits<Scalar>::type Packet;
   const int PacketSize = sizeof(Packet)/sizeof(Scalar);
@@ -397,7 +398,7 @@ static EIGEN_DONT_INLINE void ei_cache_friendly_product_colmajor_times_vector(
   if (PacketSize>1)
   {
     ei_internal_assert(size_t(lhs+lhsAlignmentOffset)%sizeof(Packet)==0 || size<PacketSize);
-    
+
     while (skipColumns<PacketSize &&
            alignedStart != ((lhsAlignmentOffset + alignmentStep*skipColumns)%PacketSize))
       ++skipColumns;
@@ -418,7 +419,7 @@ static EIGEN_DONT_INLINE void ei_cache_friendly_product_colmajor_times_vector(
 
   int offset1 = (FirstAligned && alignmentStep==1?3:1);
   int offset3 = (FirstAligned && alignmentStep==1?1:3);
-  
+
   int columnBound = ((rhs.size()-skipColumns)/columnsAtOnce)*columnsAtOnce + skipColumns;
   for (int i=skipColumns; i<columnBound; i+=columnsAtOnce)
   {
@@ -433,13 +434,8 @@ static EIGEN_DONT_INLINE void ei_cache_friendly_product_colmajor_times_vector(
     {
       /* explicit vectorization */
       // process initial unaligned coeffs
-      for (int j=0; j<alignedStart; ++j) {
+      for (int j=0; j<alignedStart; ++j)
-        Scalar s = ei_pfirst(ptmp0)*lhs0[j];
+        res[j] += ei_pfirst(ptmp0)*lhs0[j] + ei_pfirst(ptmp1)*lhs1[j] + ei_pfirst(ptmp2)*lhs2[j] + ei_pfirst(ptmp3)*lhs3[j];
-        s += ei_pfirst(ptmp1)*lhs1[j]; 
-        s += ei_pfirst(ptmp2)*lhs2[j];
-        s += ei_pfirst(ptmp3)*lhs3[j];
-        res[j] += s;
-      }
 
       if (alignedSize>alignedStart)
       {
@@ -447,11 +443,11 @@ static EIGEN_DONT_INLINE void ei_cache_friendly_product_colmajor_times_vector(
         {
           case AllAligned:
             for (int j = alignedStart; j<alignedSize; j+=PacketSize)
-              _EIGEN_ACCUMULATE_PACKETS(,,,);
+              _EIGEN_ACCUMULATE_PACKETS(d,d,d);
             break;
           case EvenAligned:
             for (int j = alignedStart; j<alignedSize; j+=PacketSize)
-              _EIGEN_ACCUMULATE_PACKETS(,u,,);
+              _EIGEN_ACCUMULATE_PACKETS(d,du,d);
             break;
           case FirstAligned:
             if(peels>1)
@@ -487,11 +483,11 @@ static EIGEN_DONT_INLINE void ei_cache_friendly_product_colmajor_times_vector(
               }
             }
             for (int j = peeledSize; j<alignedSize; j+=PacketSize)
-              _EIGEN_ACCUMULATE_PACKETS(,u,u,);
+              _EIGEN_ACCUMULATE_PACKETS(d,du,du);
             break;
           default:
             for (int j = alignedStart; j<alignedSize; j+=PacketSize)
-              _EIGEN_ACCUMULATE_PACKETS(u,u,u,);
+              _EIGEN_ACCUMULATE_PACKETS(du,du,du);
             break;
         }
       }
@@ -499,7 +495,7 @@ static EIGEN_DONT_INLINE void ei_cache_friendly_product_colmajor_times_vector(
 
     /* process remaining coeffs (or all if there is no explicit vectorization) */
     for (int j=alignedSize; j<size; ++j)
-	  res[j] += ei_pfirst(ptmp0)*lhs0[j] + ei_pfirst(ptmp1)*lhs1[j] + ei_pfirst(ptmp2)*lhs2[j] + ei_pfirst(ptmp3)*lhs3[j];
+      res[j] += ei_pfirst(ptmp0)*lhs0[j] + ei_pfirst(ptmp1)*lhs1[j] + ei_pfirst(ptmp2)*lhs2[j] + ei_pfirst(ptmp3)*lhs3[j];
   }
 
   // process remaining first and last columns (at most columnsAtOnce-1)
@@ -555,12 +551,12 @@ static EIGEN_DONT_INLINE void ei_cache_friendly_product_rowmajor_times_vector(
   #error _EIGEN_ACCUMULATE_PACKETS has already been defined
   #endif
 
-  #define _EIGEN_ACCUMULATE_PACKETS(A0,A13,A2,OFFSET) {\
+  #define _EIGEN_ACCUMULATE_PACKETS(A0,A13,A2) {\
     Packet b = ei_pload(&rhs[j]); \
-    ptmp0 = ei_pmadd(b, ei_pload##A0 (&lhs0[j]), ptmp0); \
+    ptmp0 = ei_pmadd(b, EIGEN_CAT(ei_ploa,A0) (&lhs0[j]), ptmp0); \
-    ptmp1 = ei_pmadd(b, ei_pload##A13(&lhs1[j]), ptmp1); \
+    ptmp1 = ei_pmadd(b, EIGEN_CAT(ei_ploa,A13)(&lhs1[j]), ptmp1); \
-    ptmp2 = ei_pmadd(b, ei_pload##A2 (&lhs2[j]), ptmp2); \
+    ptmp2 = ei_pmadd(b, EIGEN_CAT(ei_ploa,A2) (&lhs2[j]), ptmp2); \
-    ptmp3 = ei_pmadd(b, ei_pload##A13(&lhs3[j]), ptmp3); }
+    ptmp3 = ei_pmadd(b, EIGEN_CAT(ei_ploa,A13)(&lhs3[j]), ptmp3); }
 
   typedef typename ei_packet_traits<Scalar>::type Packet;
   const int PacketSize = sizeof(Packet)/sizeof(Scalar);
@@ -585,13 +581,13 @@ static EIGEN_DONT_INLINE void ei_cache_friendly_product_rowmajor_times_vector(
 
   // we cannot assume the first element is aligned because of sub-matrices
   const int lhsAlignmentOffset = ei_alignmentOffset(lhs,size);
-  
+
   // find how many rows do we have to skip to be aligned with rhs (if possible)
   int skipRows = 0;
   if (PacketSize>1)
   {
     ei_internal_assert(size_t(lhs+lhsAlignmentOffset)%sizeof(Packet)==0  || size<PacketSize);
-    
+
     while (skipRows<PacketSize &&
            alignedStart != ((lhsAlignmentOffset + alignmentStep*skipRows)%PacketSize))
       ++skipRows;
@@ -612,7 +608,7 @@ static EIGEN_DONT_INLINE void ei_cache_friendly_product_rowmajor_times_vector(
 
   int offset1 = (FirstAligned && alignmentStep==1?3:1);
   int offset3 = (FirstAligned && alignmentStep==1?1:3);
-  
+
   int rowBound = ((res.size()-skipRows)/rowsAtOnce)*rowsAtOnce + skipRows;
   for (int i=skipRows; i<rowBound; i+=rowsAtOnce)
   {
@@ -626,7 +622,7 @@ static EIGEN_DONT_INLINE void ei_cache_friendly_product_rowmajor_times_vector(
     {
       /* explicit vectorization */
       Packet ptmp0 = ei_pset1(Scalar(0)), ptmp1 = ei_pset1(Scalar(0)), ptmp2 = ei_pset1(Scalar(0)), ptmp3 = ei_pset1(Scalar(0));
-      
+
       // process initial unaligned coeffs
       // FIXME this loop get vectorized by the compiler !
       for (int j=0; j<alignedStart; ++j)
@@ -641,11 +637,11 @@ static EIGEN_DONT_INLINE void ei_cache_friendly_product_rowmajor_times_vector(
         {
           case AllAligned:
             for (int j = alignedStart; j<alignedSize; j+=PacketSize)
-              _EIGEN_ACCUMULATE_PACKETS(,,,);
+              _EIGEN_ACCUMULATE_PACKETS(d,d,d);
             break;
           case EvenAligned:
             for (int j = alignedStart; j<alignedSize; j+=PacketSize)
-              _EIGEN_ACCUMULATE_PACKETS(,u,,);
+              _EIGEN_ACCUMULATE_PACKETS(d,du,d);
             break;
           case FirstAligned:
             if (peels>1)
@@ -684,11 +680,11 @@ static EIGEN_DONT_INLINE void ei_cache_friendly_product_rowmajor_times_vector(
               }
             }
             for (int j = peeledSize; j<alignedSize; j+=PacketSize)
-              _EIGEN_ACCUMULATE_PACKETS(,u,u,);
+              _EIGEN_ACCUMULATE_PACKETS(d,du,du);
             break;
           default:
             for (int j = alignedStart; j<alignedSize; j+=PacketSize)
-              _EIGEN_ACCUMULATE_PACKETS(u,u,u,);
+              _EIGEN_ACCUMULATE_PACKETS(du,du,du);
             break;
         }
         tmp0 += ei_predux(ptmp0);

Eigen/src/Core/CwiseNullaryOp.h

@@ -146,6 +146,7 @@ template<typename CustomNullaryOp>
 EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, Derived>
 MatrixBase<Derived>::NullaryExpr(int size, const CustomNullaryOp& func)
 {
+  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
   ei_assert(IsVectorAtCompileTime);
   if(RowsAtCompileTime == 1) return CwiseNullaryOp<CustomNullaryOp, Derived>(1, size, func);
   else return CwiseNullaryOp<CustomNullaryOp, Derived>(size, 1, func);
@@ -227,6 +228,7 @@ MatrixBase<Derived>::Constant(const Scalar& value)
   return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, ei_scalar_constant_op<Scalar>(value));
 }
 
+/** \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */
 template<typename Derived>
 bool MatrixBase<Derived>::isApproxToConstant
 (const Scalar& value, RealScalar prec) const
@@ -238,6 +240,16 @@ bool MatrixBase<Derived>::isApproxToConstant
   return true;
 }
 
+/** This is just an alias for isApproxToConstant().
+  *
+  * \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */
+template<typename Derived>
+bool MatrixBase<Derived>::isConstant
+(const Scalar& value, RealScalar prec) const
+{
+  return isApproxToConstant(value, prec);
+}
+
 /** Alias for setConstant(): sets all coefficients in this expression to \a value.
   *
   * \sa setConstant(), Constant(), class CwiseNullaryOp
@@ -250,7 +262,7 @@ EIGEN_STRONG_INLINE void MatrixBase<Derived>::fill(const Scalar& value)
 
 /** Sets all coefficients in this expression to \a value.
   *
-  * \sa fill(), Constant(), class CwiseNullaryOp, setZero(), setOnes()
+  * \sa fill(), setConstant(int,const Scalar&), setConstant(int,int,const Scalar&), setZero(), setOnes(), Constant(), class CwiseNullaryOp, setZero(), setOnes()
   */
 template<typename Derived>
 EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setConstant(const Scalar& value)
@@ -258,6 +270,42 @@ EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setConstant(const Scalar& valu
   return derived() = Constant(rows(), cols(), value);
 }
 
+/** Resizes to the given \a size, and sets all coefficients in this expression to the given \a value.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include Matrix_set_int.cpp
+  * Output: \verbinclude Matrix_setConstant_int.out
+  *
+  * \sa MatrixBase::setConstant(const Scalar&), setConstant(int,int,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
+Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setConstant(int size, const Scalar& value)
+{
+  resize(size);
+  return setConstant(value);
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to the given \a value.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setConstant_int_int.cpp
+  * Output: \verbinclude Matrix_setConstant_int_int.out
+  *
+  * \sa MatrixBase::setConstant(const Scalar&), setConstant(int,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
+Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setConstant(int rows, int cols, const Scalar& value)
+{
+  resize(rows, cols);
+  return setConstant(value);
+}
+
+
 // zero:
 
 /** \returns an expression of a zero matrix.
@@ -354,6 +402,41 @@ EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setZero()
   return setConstant(Scalar(0));
 }
 
+/** Resizes to the given \a size, and sets all coefficients in this expression to zero.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include Matrix_setZero_int.cpp
+  * Output: \verbinclude Matrix_setZero_int.out
+  *
+  * \sa MatrixBase::setZero(), setZero(int,int), class CwiseNullaryOp, MatrixBase::Zero()
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
+Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setZero(int size)
+{
+  resize(size);
+  return setConstant(Scalar(0));
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to zero.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setZero_int_int.cpp
+  * Output: \verbinclude Matrix_setZero_int_int.out
+  *
+  * \sa MatrixBase::setZero(), setZero(int), class CwiseNullaryOp, MatrixBase::Zero()
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
+Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setZero(int rows, int cols)
+{
+  resize(rows, cols);
+  return setConstant(Scalar(0));
+}
+
 // ones:
 
 /** \returns an expression of a matrix where all coefficients equal one.
@@ -447,6 +530,41 @@ EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setOnes()
   return setConstant(Scalar(1));
 }
 
+/** Resizes to the given \a size, and sets all coefficients in this expression to one.
+  *
+  * \only_for_vectors
+  *
+  * Example: \include Matrix_setOnes_int.cpp
+  * Output: \verbinclude Matrix_setOnes_int.out
+  *
+  * \sa MatrixBase::setOnes(), setOnes(int,int), class CwiseNullaryOp, MatrixBase::Ones()
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
+Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setOnes(int size)
+{
+  resize(size);
+  return setConstant(Scalar(1));
+}
+
+/** Resizes to the given size, and sets all coefficients in this expression to one.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setOnes_int_int.cpp
+  * Output: \verbinclude Matrix_setOnes_int_int.out
+  *
+  * \sa MatrixBase::setOnes(), setOnes(int), class CwiseNullaryOp, MatrixBase::Ones()
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
+Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setOnes(int rows, int cols)
+{
+  resize(rows, cols);
+  return setConstant(Scalar(1));
+}
+
 // Identity:
 
 /** \returns an expression of the identity matrix (not necessarily square).
@@ -556,6 +674,24 @@ EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setIdentity()
   return ei_setIdentity_impl<Derived>::run(derived());
 }
 
+/** Resizes to the given size, and writes the identity expression (not necessarily square) into *this.
+  *
+  * \param rows the new number of rows
+  * \param cols the new number of columns
+  *
+  * Example: \include Matrix_setIdentity_int_int.cpp
+  * Output: \verbinclude Matrix_setIdentity_int_int.out
+  *
+  * \sa MatrixBase::setIdentity(), class CwiseNullaryOp, MatrixBase::Identity()
+  */
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
+Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setIdentity(int rows, int cols)
+{
+  resize(rows, cols);
+  return setIdentity();
+}
+
 /** \returns an expression of the i-th unit (basis) vector.
   *
   * \only_for_vectors

Eigen/src/Core/Matrix.h

@@ -438,6 +438,25 @@ class Matrix
     { return AlignedMapType(data, rows, cols); }
     //@}
 
+    using Base::setConstant;
+    Matrix& setConstant(int size, const Scalar& value);
+    Matrix& setConstant(int rows, int cols, const Scalar& value);
+
+    using Base::setZero;
+    Matrix& setZero(int size);
+    Matrix& setZero(int rows, int cols);
+
+    using Base::setOnes;
+    Matrix& setOnes(int size);
+    Matrix& setOnes(int rows, int cols);
+
+    using Base::setRandom;
+    Matrix& setRandom(int size);
+    Matrix& setRandom(int rows, int cols);
+
+    using Base::setIdentity;
+    Matrix& setIdentity(int rows, int cols);
+
 /////////// Geometry module ///////////
 
     template<typename OtherDerived>

Eigen/src/Core/MatrixBase.h

@@ -463,6 +463,7 @@ template<typename Derived> class MatrixBase
                            RealScalar prec = precision<Scalar>()) const;
 
     bool isApproxToConstant(const Scalar& value, RealScalar prec = precision<Scalar>()) const;
+    bool isConstant(const Scalar& value, RealScalar prec = precision<Scalar>()) const;
     bool isZero(RealScalar prec = precision<Scalar>()) const;
     bool isOnes(RealScalar prec = precision<Scalar>()) const;
     bool isIdentity(RealScalar prec = precision<Scalar>()) const;

Eigen/src/Core/Part.h

@@ -26,7 +26,7 @@
 #ifndef EIGEN_PART_H
 #define EIGEN_PART_H
 
-/** \nonstableyet 
+/** \nonstableyet
   * \class Part
   *
   * \brief Expression of a triangular matrix extracted from a given matrix
@@ -117,10 +117,10 @@ template<typename MatrixType, unsigned int Mode> class Part
     const Block<Part, RowsAtCompileTime, 1> col(int i) { return Base::col(i); }
     const Block<Part, RowsAtCompileTime, 1> col(int i) const { return Base::col(i); }
 
-    template<typename OtherDerived/*, int OtherMode*/>
+    template<typename OtherDerived>
     void swap(const MatrixBase<OtherDerived>& other)
     {
-      Part<SwapWrapper<MatrixType>,Mode>(SwapWrapper<MatrixType>(const_cast<MatrixType&>(m_matrix))).lazyAssign(other.derived());
+      Part<SwapWrapper<MatrixType>,Mode>(const_cast<MatrixType&>(m_matrix)).lazyAssign(other.derived());
     }
 
   protected:
@@ -128,7 +128,7 @@ template<typename MatrixType, unsigned int Mode> class Part
     const typename MatrixType::Nested m_matrix;
 };
 
-/** \nonstableyet 
+/** \nonstableyet
   * \returns an expression of a triangular matrix extracted from the current matrix
   *
   * The parameter \a Mode can have the following values: \c UpperTriangular, \c StrictlyUpperTriangular, \c UnitUpperTriangular,
@@ -280,7 +280,7 @@ void Part<MatrixType, Mode>::lazyAssign(const Other& other)
     >::run(m_matrix.const_cast_derived(), other.derived());
 }
 
-/** \nonstableyet 
+/** \nonstableyet
   * \returns a lvalue pseudo-expression allowing to perform special operations on \c *this.
   *
   * The \a Mode parameter can have the following values: \c UpperTriangular, \c StrictlyUpperTriangular, \c LowerTriangular,

Eigen/src/Core/util/Macros.h

@@ -30,7 +30,7 @@
 
 #define EIGEN_WORLD_VERSION 2
 #define EIGEN_MAJOR_VERSION 0
-#define EIGEN_MINOR_VERSION 1
+#define EIGEN_MINOR_VERSION 2
 
 #define EIGEN_VERSION_AT_LEAST(x,y,z) (EIGEN_WORLD_VERSION>x || (EIGEN_WORLD_VERSION>=x && \
                                       (EIGEN_MAJOR_VERSION>y || (EIGEN_MAJOR_VERSION>=y && \
@@ -236,4 +236,15 @@ _EIGEN_GENERIC_PUBLIC_INTERFACE(Derived, Eigen::MatrixBase<Derived>)
 #define EIGEN_ENUM_MIN(a,b) (((int)a <= (int)b) ? (int)a : (int)b)
 #define EIGEN_ENUM_MAX(a,b) (((int)a >= (int)b) ? (int)a : (int)b)
 
+// just an empty macro !
+#define EIGEN_EMPTY
+
+// concatenate two tokens
+#define EIGEN_CAT2(a,b) a ## b
+#define EIGEN_CAT(a,b) EIGEN_CAT2(a,b)
+
+// convert a token to a string
+#define EIGEN_MAKESTRING2(a) #a
+#define EIGEN_MAKESTRING(a) EIGEN_MAKESTRING2(a)
+
 #endif // EIGEN_MACROS_H

Eigen/src/Core/util/Memory.h

@@ -33,7 +33,7 @@
   #define EIGEN_MALLOC_ALREADY_ALIGNED 0
 #endif
 
-#if (defined _GNU_SOURCE) || ((defined _XOPEN_SOURCE) && (_XOPEN_SOURCE >= 600))
+#if ((defined _GNU_SOURCE) || ((defined _XOPEN_SOURCE) && (_XOPEN_SOURCE >= 600))) && (defined _POSIX_ADVISORY_INFO) && (_POSIX_ADVISORY_INFO > 0)
   #define EIGEN_HAS_POSIX_MEMALIGN 1
 #else
   #define EIGEN_HAS_POSIX_MEMALIGN 0

Eigen/src/LeastSquares/LeastSquares.h

@@ -1,7 +1,7 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra. Eigen itself is part of the KDE project.
 //
-// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
+// Copyright (C) 2006-2009 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
@@ -57,7 +57,7 @@
     Vector3d coeffs; // will store the coefficients a, b, c
     linearRegression(
       5,
-      points,
+      &points,
       &coeffs,
       1 // the coord to express as a function of
         // the other ones. 0 means x, 1 means y, 2 means z.
@@ -80,11 +80,11 @@
                   This vector must be of the same type and size as the
                   data points. The meaning of its coords is as follows.
                   For brevity, let \f$n=Size\f$,
-                  \f$r_i=retCoefficients[i]\f$,
+                  \f$r_i=result[i]\f$,
                   and \f$f=funcOfOthers\f$. Denote by
                   \f$x_0,\ldots,x_{n-1}\f$
                   the n coordinates in the n-dimensional space.
-                  Then the result equation is:
+                  Then the resulting equation is:
                   \f[ x_f = r_0 x_0 + \cdots + r_{f-1}x_{f-1}
                    + r_{f+1}x_{f+1} + \cdots + r_{n-1}x_{n-1} + r_n. \f]
   * @param funcOfOthers Determines which coord to express as a function of the
@@ -101,31 +101,15 @@ void linearRegression(int numPoints,
                       int funcOfOthers )
 {
   typedef typename VectorType::Scalar Scalar;
-  EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorType)
+  typedef Hyperplane<Scalar, VectorType::SizeAtCompileTime> HyperplaneType;
-  ei_assert(numPoints >= 1);
+  const int size = points[0]->size();
-  int size = points[0]->size();
-  ei_assert(funcOfOthers >= 0 && funcOfOthers < size);
   result->resize(size);
-
+  HyperplaneType h(size);
-  Matrix<Scalar, Dynamic, VectorType::SizeAtCompileTime,
+  fitHyperplane(numPoints, points, &h);
-         Dynamic, VectorType::MaxSizeAtCompileTime, RowMajorBit>
+  for(int i = 0; i < funcOfOthers; i++)
-    m(numPoints, size);
+    result->coeffRef(i) = - h.coeffs()[i] / h.coeffs()[funcOfOthers];
-  if(funcOfOthers>0)
+  for(int i = funcOfOthers; i < size; i++)
-    for(int i = 0; i < numPoints; ++i)
+    result->coeffRef(i) = - h.coeffs()[i+1] / h.coeffs()[funcOfOthers];
-      m.row(i).start(funcOfOthers) = points[i]->start(funcOfOthers);
-  if(funcOfOthers<size-1)
-    for(int i = 0; i < numPoints; ++i)
-      m.row(i).block(funcOfOthers, size-funcOfOthers-1)
-        = points[i]->end(size-funcOfOthers-1);
-  for(int i = 0; i < numPoints; ++i)
-    m.row(i).coeffRef(size-1) = Scalar(1);
-
-  VectorType v(size);
-  v.setZero();
-  for(int i = 0; i < numPoints; ++i)
-    v += m.row(i).adjoint() * points[i]->coeff(funcOfOthers);
-
-  ei_assert((m.adjoint()*m).lu().solve(v, result));
 }
 
 /** \ingroup LeastSquares_Module

test/cwiseop.cpp

@@ -54,7 +54,9 @@ template<typename MatrixType> void cwiseops(const MatrixType& m)
              square = Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime>::Random(rows, rows);
   VectorType v1 = VectorType::Random(rows),
              v2 = VectorType::Random(rows),
-             vzero = VectorType::Zero(rows);
+             vzero = VectorType::Zero(rows),
+             vones = VectorType::Ones(rows),
+             v3(rows);
 
   int r = ei_random<int>(0, rows-1),
       c = ei_random<int>(0, cols-1);
@@ -70,12 +72,22 @@ template<typename MatrixType> void cwiseops(const MatrixType& m)
       VERIFY_IS_APPROX(mones(i,j), Scalar(1));
       VERIFY_IS_APPROX(m3(i,j), s1);
     }
+  VERIFY(mzero.isZero());
+  VERIFY(mones.isOnes());
+  VERIFY(m3.isConstant(s1));
+  VERIFY(identity.isIdentity());
   VERIFY_IS_APPROX(m4.setConstant(s1), m3);
+  VERIFY_IS_APPROX(m4.setConstant(rows,cols,s1), m3);
   VERIFY_IS_APPROX(m4.setZero(), mzero);
+  VERIFY_IS_APPROX(m4.setZero(rows,cols), mzero);
   VERIFY_IS_APPROX(m4.setOnes(), mones);
+  VERIFY_IS_APPROX(m4.setOnes(rows,cols), mones);
   m4.fill(s1);
   VERIFY_IS_APPROX(m4, m3);
   
+  VERIFY_IS_APPROX(v3.setConstant(rows, s1), VectorType::Constant(rows,s1));
+  VERIFY_IS_APPROX(v3.setZero(rows), vzero);
+  VERIFY_IS_APPROX(v3.setOnes(rows), vones);
 
   m2 = m2.template binaryExpr<AddIfNull<Scalar> >(mones);
 

test/regression.cpp

@@ -62,6 +62,20 @@ void makeNoisyCohyperplanarPoints(int numPoints,
     *(points[i]) += noiseAmplitude * VectorType::Random(size);
 }
 
+template<typename VectorType>
+void check_linearRegression(int numPoints,
+                            VectorType **points,
+                            const VectorType& original,
+                            typename VectorType::Scalar tolerance)
+{
+  int size = points[0]->size();
+  assert(size==2);
+  VectorType result(size);
+  linearRegression(numPoints, points, &result, 1);
+  typename VectorType::Scalar error = (result - original).norm() / original.norm();
+  VERIFY(ei_abs(error) < ei_abs(tolerance));
+}
+
 template<typename VectorType,
          typename HyperplaneType>
 void check_fitHyperplane(int numPoints,
@@ -81,6 +95,20 @@ void test_regression()
 {
   for(int i = 0; i < g_repeat; i++)
   {
+    {
+      Vector2f points2f [1000];
+      Vector2f *points2f_ptrs [1000];
+      for(int i = 0; i < 1000; i++) points2f_ptrs[i] = &(points2f[i]);
+      Vector2f coeffs2f;
+      Hyperplane<float,2> coeffs3f;
+      makeNoisyCohyperplanarPoints(1000, points2f_ptrs, &coeffs3f, 0.01f);
+      coeffs2f[0] = -coeffs3f.coeffs()[0]/coeffs3f.coeffs()[1];
+      coeffs2f[1] = -coeffs3f.coeffs()[2]/coeffs3f.coeffs()[1];
+      CALL_SUBTEST(check_linearRegression(10, points2f_ptrs, coeffs2f, 0.05f));
+      CALL_SUBTEST(check_linearRegression(100, points2f_ptrs, coeffs2f, 0.01f));
+      CALL_SUBTEST(check_linearRegression(1000, points2f_ptrs, coeffs2f, 0.002f));
+    }
+    
     {
       Vector2f points2f [1000];
       Vector2f *points2f_ptrs [1000];

test/triangular.cpp

@@ -114,6 +114,14 @@ template<typename MatrixType> void triangular(const MatrixType& m)
 
   VERIFY((m1.template part<Eigen::UpperTriangular>() * m2.template part<Eigen::UpperTriangular>()).isUpperTriangular());
 
+  // test swap
+  m1.setOnes();
+  m2.setZero();
+  m2.template part<Eigen::UpperTriangular>().swap(m1);
+  m3.setZero();
+  m3.template part<Eigen::UpperTriangular>().setOnes();
+  VERIFY_IS_APPROX(m2,m3);
+
 }
 
 void test_triangular()