From b25eb5fdaade6c20457a411fd08e17acc54f3349 Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Mon, 16 Nov 2009 09:39:07 -0500 Subject: PermutationMatrix: add inverse() and product of permutations --- Eigen/src/Core/PermutationMatrix.h | 30 +++++++++++++++++++++++++++--- 1 file changed, 27 insertions(+), 3 deletions(-) (limited to 'Eigen/src/Core') diff --git a/Eigen/src/Core/PermutationMatrix.h b/Eigen/src/Core/PermutationMatrix.h index aaccb4e7b..1c66cde8e 100644 --- a/Eigen/src/Core/PermutationMatrix.h +++ b/Eigen/src/Core/PermutationMatrix.h @@ -105,10 +105,10 @@ class PermutationMatrix : public AnyMatrixBase @@ -126,7 +126,31 @@ class PermutationMatrix : public AnyMatrixBase + inline PermutationMatrix operator*(const PermutationMatrix& other) const + { return PermutationMatrix(Product, *this, other); } + protected: IndicesType m_indices; -- cgit v1.2.3 From 8a1bada43d64820f5e973d1692cc51eaf865bf76 Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Mon, 16 Nov 2009 13:45:06 -0500 Subject: initialize-by-zero: remember that when the newsize==oldsize, resize() must remain a NOP --- Eigen/src/Core/Matrix.h | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) (limited to 'Eigen/src/Core') diff --git a/Eigen/src/Core/Matrix.h b/Eigen/src/Core/Matrix.h index 11d73f0c4..290247978 100644 --- a/Eigen/src/Core/Matrix.h +++ b/Eigen/src/Core/Matrix.h @@ -259,8 +259,14 @@ class Matrix && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows) && (MaxColsAtCompileTime == Dynamic || MaxColsAtCompileTime >= cols) && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)); - m_storage.resize(rows * cols, rows, cols); - EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED + #ifdef EIGEN_INITIALIZE_MATRICES_BY_ZERO + int size = rows*cols; + bool size_changed = size != this->size(); + m_storage.resize(size, rows, cols); + if(size_changed) EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED + #else + m_storage.resize(rows*cols, rows, cols); + #endif } /** Resizes \c *this to a vector of length \a size @@ -278,11 +284,16 @@ class Matrix { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Matrix) ei_assert(SizeAtCompileTime == Dynamic || SizeAtCompileTime == size); + #ifdef EIGEN_INITIALIZE_MATRICES_BY_ZERO + bool size_changed = size != this->size(); + #endif if(RowsAtCompileTime == 1) m_storage.resize(size, 1, size); else m_storage.resize(size, size, 1); - EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED + #ifdef EIGEN_INITIALIZE_MATRICES_BY_ZERO + if(size_changed) EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED + #endif } /** Resizes the matrix, changing only the number of columns. For the parameter of type NoChange_t, just pass the special value \c NoChange -- cgit v1.2.3 From e8d0dbf82e224fa57f0741bef58c3f57ec9f7895 Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Mon, 16 Nov 2009 15:07:33 -0500 Subject: PermutationMatrix: * make multiplication order not be reversed * release-quality documentation --- Eigen/src/Core/PermutationMatrix.h | 72 ++++++++++++++++++++++++++++++-------- doc/Doxyfile.in | 3 +- test/permutationmatrices.cpp | 4 +-- 3 files changed, 61 insertions(+), 18 deletions(-) (limited to 'Eigen/src/Core') diff --git a/Eigen/src/Core/PermutationMatrix.h b/Eigen/src/Core/PermutationMatrix.h index 1c66cde8e..f2bde0e71 100644 --- a/Eigen/src/Core/PermutationMatrix.h +++ b/Eigen/src/Core/PermutationMatrix.h @@ -25,18 +25,24 @@ #ifndef EIGEN_PERMUTATIONMATRIX_H #define EIGEN_PERMUTATIONMATRIX_H -/** \nonstableyet - * \class PermutationMatrix +/** \class PermutationMatrix * * \brief Permutation matrix * * \param SizeAtCompileTime the number of rows/cols, or Dynamic - * \param MaxSizeAtCompileTime the maximum number of rows/cols, or Dynamic. This optional parameter defaults to SizeAtCompileTime. + * \param MaxSizeAtCompileTime the maximum number of rows/cols, or Dynamic. This optional parameter defaults to SizeAtCompileTime. Most of the time, you should not have to specify it. * * This class represents a permutation matrix, internally stored as a vector of integers. - * The convention followed here is the same as on Wikipedia, - * namely: the matrix of permutation \a p is the matrix such that on each row \a i, the only nonzero coefficient is - * in column p(i). + * The convention followed here is that if \f$ \sigma \f$ is a permutation, the corresponding permutation matrix + * \f$ P_\sigma \f$ is such that if \f$ (e_1,\ldots,e_p) \f$ is the canonical basis, we have: + * \f[ P_\sigma(e_i) = e_{\sigma(i)}. \f] + * This convention ensures that for any two permutations \f$ \sigma, \tau \f$, we have: + * \f[ P_{\sigma\circ\tau} = P_\sigma P_\tau. \f] + * + * Permutation matrices are square and invertible. + * + * Notice that in addition to the member functions and operators listed here, there also are non-member + * operator* to multiply a PermutationMatrix with any kind of matrix expression (MatrixBase) on either side. * * \sa class DiagonalMatrix */ @@ -53,6 +59,7 @@ class PermutationMatrix : public AnyMatrixBase Traits; typedef Matrix DenseMatrixType; @@ -65,25 +72,37 @@ class PermutationMatrix : public AnyMatrixBase IndicesType; + typedef Matrix IndicesType; inline PermutationMatrix() { } + /** Copy constructor. */ template inline PermutationMatrix(const PermutationMatrix& other) : m_indices(other.indices()) {} - /** copy constructor. prevent a default copy constructor from hiding the other templated constructor */ + #ifndef EIGEN_PARSED_BY_DOXYGEN + /** Standard copy constructor. Defined only to prevent a default copy constructor + * from hiding the other templated constructor */ inline PermutationMatrix(const PermutationMatrix& other) : m_indices(other.indices()) {} - - /** generic constructor from expression of the indices */ + #endif + + /** Generic constructor from expression of the indices. The indices + * array has the meaning that the permutations sends each integer i to indices[i]. + * + * \warning It is your responsibility to check that the indices array that you passes actually + * describes a permutation, \ie each value between 0 and n-1 occurs exactly once, where n is the + * array's size. + */ template - explicit inline PermutationMatrix(const MatrixBase& other) : m_indices(other) + explicit inline PermutationMatrix(const MatrixBase& indices) : m_indices(indices) {} + /** Copies the other permutation into *this */ template PermutationMatrix& operator=(const PermutationMatrix& other) { @@ -91,6 +110,7 @@ class PermutationMatrix : public AnyMatrixBase void evalTo(MatrixBase& other) const { other.setZero(); for (int i=0; i inline PermutationMatrix operator*(const PermutationMatrix& other) const { return PermutationMatrix(Product, *this, other); } @@ -209,7 +251,7 @@ struct ei_permut_matrix_product_retval Dest, Side==OnTheLeft ? 1 : Dest::RowsAtCompileTime, Side==OnTheRight ? 1 : Dest::ColsAtCompileTime - >(dst, Side==OnTheRight ? m_permutation.indices().coeff(i) : i) + >(dst, Side==OnTheLeft ? m_permutation.indices().coeff(i) : i) = @@ -217,7 +259,7 @@ struct ei_permut_matrix_product_retval MatrixTypeNestedCleaned, Side==OnTheLeft ? 1 : MatrixType::RowsAtCompileTime, Side==OnTheRight ? 1 : MatrixType::ColsAtCompileTime - >(m_matrix, Side==OnTheLeft ? m_permutation.indices().coeff(i) : i); + >(m_matrix, Side==OnTheRight ? m_permutation.indices().coeff(i) : i); } } diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in index da99d3592..82ebf6aa0 100644 --- a/doc/Doxyfile.in +++ b/doc/Doxyfile.in @@ -218,7 +218,8 @@ ALIASES = "only_for_vectors=This is only for vectors (either row- "nonstableyet=\warning This is not considered to be part of the stable public API yet. Changes may happen in future releases. See \ref Experimental \"Experimental parts of Eigen\"" \ "note_about_arbitrary_choice_of_solution=If there exists more than one solution, this method will arbitrarily choose one." \ "note_about_using_kernel_to_study_multiple_solutions=If you need a complete analysis of the space of solutions, take the one solution obtained by this method and add to it elements of the kernel, as determined by kernel()." \ - "note_about_checking_solutions=This method just tries to find as good a solution as possible. If you want to check whether a solution exists or if it is accurate, just call this function to get a result and then compute the error of this result, or use MatrixBase::isApprox() directly, for instance like this: \code bool a_solution_exists = (A*result).isApprox(b, precision); \endcode This method avoids dividing by zero, so that the non-existence of a solution doesn't by itself mean that you'll get \c inf or \c nan values." + "note_about_checking_solutions=This method just tries to find as good a solution as possible. If you want to check whether a solution exists or if it is accurate, just call this function to get a result and then compute the error of this result, or use MatrixBase::isApprox() directly, for instance like this: \code bool a_solution_exists = (A*result).isApprox(b, precision); \endcode This method avoids dividing by zero, so that the non-existence of a solution doesn't by itself mean that you'll get \c inf or \c nan values." \ + "note_try_to_help_rvo=This function returns the result by value. In order to make that efficient, it is implemented as just a return statement using a special constructor, hopefully allowing the compiler to perform a RVO (return value optimization)." # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C # sources only. Doxygen will then generate output that is more tailored for C. diff --git a/test/permutationmatrices.cpp b/test/permutationmatrices.cpp index ec3a8541c..c4affc795 100644 --- a/test/permutationmatrices.cpp +++ b/test/permutationmatrices.cpp @@ -66,7 +66,7 @@ template void permutationmatrices(const MatrixType& m) for (int i=0; i lm(lp); Matrix rm(rp); @@ -80,7 +80,7 @@ template void permutationmatrices(const MatrixType& m) randomPermutationVector(lv2, rows); LeftPermutationType lp2(lv2); Matrix lm2(lp2); - VERIFY_IS_APPROX((lp*lp2).toDenseMatrix().template cast(), lm2*lm); + VERIFY_IS_APPROX((lp*lp2).toDenseMatrix().template cast(), lm*lm2); } void test_permutationmatrices() -- cgit v1.2.3 From eb6df28c6cab95c98c34898a3a0aa92d406493f6 Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Mon, 16 Nov 2009 15:25:58 -0500 Subject: DiagonalMatrix: release-quality documentation BandMatrix: rename toDense() ---> toDenseMatrix() for consistency --- Eigen/src/Core/BandMatrix.h | 2 +- Eigen/src/Core/DiagonalMatrix.h | 47 ++++++++++++++++++++++++++++------------- test/bandmatrix.cpp | 4 ++-- 3 files changed, 35 insertions(+), 18 deletions(-) (limited to 'Eigen/src/Core') diff --git a/Eigen/src/Core/BandMatrix.h b/Eigen/src/Core/BandMatrix.h index 841d1786a..b67f60691 100644 --- a/Eigen/src/Core/BandMatrix.h +++ b/Eigen/src/Core/BandMatrix.h @@ -171,7 +171,7 @@ class BandMatrix : public AnyMatrixBase(m_data, supers()-i, std::max(0,i), 1, diagonalLength(i)); } - PlainMatrixType toDense() const + PlainMatrixType toDenseMatrix() const { PlainMatrixType res(rows(),cols()); res.setZero(); diff --git a/Eigen/src/Core/DiagonalMatrix.h b/Eigen/src/Core/DiagonalMatrix.h index 1dec82229..e3e2120ea 100644 --- a/Eigen/src/Core/DiagonalMatrix.h +++ b/Eigen/src/Core/DiagonalMatrix.h @@ -26,6 +26,7 @@ #ifndef EIGEN_DIAGONALMATRIX_H #define EIGEN_DIAGONALMATRIX_H +#ifndef EIGEN_PARSED_BY_DOXYGEN template class DiagonalBase : public AnyMatrixBase { @@ -44,10 +45,8 @@ class DiagonalBase : public AnyMatrixBase typedef Matrix DenseMatrixType; - #ifndef EIGEN_PARSED_BY_DOXYGEN inline const Derived& derived() const { return *static_cast(this); } inline Derived& derived() { return *static_cast(this); } - #endif // not EIGEN_PARSED_BY_DOXYGEN DenseMatrixType toDenseMatrix() const { return derived(); } template @@ -77,16 +76,18 @@ void DiagonalBase::evalTo(MatrixBase &other) const other.setZero(); other.diagonal() = diagonal(); } +#endif /** \class DiagonalMatrix - * \nonstableyet * * \brief Represents a diagonal matrix with its storage * * \param _Scalar the type of coefficients - * \param _Size the dimension of the matrix, or Dynamic + * \param SizeAtCompileTime the dimension of the matrix, or Dynamic + * \param MaxSizeAtCompileTime the dimension of the matrix, or Dynamic. This parameter is optional and defaults + * to SizeAtCompileTime. Most of the time, you do not need to specify it. * - * \sa class Matrix + * \sa class DiagonalWrapper */ template struct ei_traits > @@ -100,10 +101,11 @@ class DiagonalMatrix : public DiagonalBase > { public: - + #ifndef EIGEN_PARSED_BY_DOXYGEN typedef typename ei_traits::DiagonalVectorType DiagonalVectorType; typedef const DiagonalMatrix& Nested; typedef _Scalar Scalar; + #endif protected: @@ -111,7 +113,9 @@ class DiagonalMatrix public: + /** const version of diagonal(). */ inline const DiagonalVectorType& diagonal() const { return m_diagonal; } + /** \returns a reference to the stored vector of diagonal coefficients. */ inline DiagonalVectorType& diagonal() { return m_diagonal; } /** Default constructor without initialization */ @@ -120,23 +124,27 @@ class DiagonalMatrix /** Constructs a diagonal matrix with given dimension */ inline DiagonalMatrix(int dim) : m_diagonal(dim) {} - /** 2D only */ + /** 2D constructor. */ inline DiagonalMatrix(const Scalar& x, const Scalar& y) : m_diagonal(x,y) {} - /** 3D only */ + /** 3D constructor. */ inline DiagonalMatrix(const Scalar& x, const Scalar& y, const Scalar& z) : m_diagonal(x,y,z) {} + /** Copy constructor. */ template inline DiagonalMatrix(const DiagonalBase& other) : m_diagonal(other.diagonal()) {} + #ifndef EIGEN_PARSED_BY_DOXYGEN /** copy constructor. prevent a default copy constructor from hiding the other templated constructor */ inline DiagonalMatrix(const DiagonalMatrix& other) : m_diagonal(other.diagonal()) {} + #endif /** generic constructor from expression of the diagonal coefficients */ template explicit inline DiagonalMatrix(const MatrixBase& other) : m_diagonal(other) {} + /** Copy operator. */ template DiagonalMatrix& operator=(const DiagonalBase& other) { @@ -144,6 +152,7 @@ class DiagonalMatrix return *this; } + #ifndef EIGEN_PARSED_BY_DOXYGEN /** This is a special case of the templated operator=. Its purpose is to * prevent a default operator= from hiding the templated operator=. */ @@ -152,23 +161,28 @@ class DiagonalMatrix m_diagonal = other.m_diagonal(); return *this; } + #endif + /** Resizes to given size. */ inline void resize(int size) { m_diagonal.resize(size); } + /** Sets all coefficients to zero. */ inline void setZero() { m_diagonal.setZero(); } + /** Resizes and sets all coefficients to zero. */ inline void setZero(int size) { m_diagonal.setZero(size); } + /** Sets this matrix to be the identity matrix of the current size. */ inline void setIdentity() { m_diagonal.setOnes(); } + /** Sets this matrix to be the identity matrix of the given size. */ inline void setIdentity(int size) { m_diagonal.setOnes(size); } }; /** \class DiagonalWrapper - * \nonstableyet * * \brief Expression of a diagonal matrix * * \param _DiagonalVectorType the type of the vector of diagonal coefficients * - * This class is an expression of a diagonal matrix with given vector of diagonal - * coefficients. It is the return type of MatrixBase::asDiagonal() + * This class is an expression of a diagonal matrix, but not storing its own vector of diagonal coefficients, + * instead wrapping an existing vector expression. It is the return type of MatrixBase::asDiagonal() * and most of the time this is the only way that it is used. * * \sa class DiagonalMatrix, class DiagonalBase, MatrixBase::asDiagonal() @@ -192,18 +206,22 @@ class DiagonalWrapper : public DiagonalBase >, ei_no_assignment_operator { public: + #ifndef EIGEN_PARSED_BY_DOXYGEN typedef _DiagonalVectorType DiagonalVectorType; typedef DiagonalWrapper Nested; + #endif + /** Constructor from expression of diagonal coefficients to wrap. */ inline DiagonalWrapper(const DiagonalVectorType& diagonal) : m_diagonal(diagonal) {} + + /** \returns a const reference to the wrapped expression of diagonal coefficients. */ const DiagonalVectorType& diagonal() const { return m_diagonal; } protected: const typename DiagonalVectorType::Nested m_diagonal; }; -/** \nonstableyet - * \returns a pseudo-expression of a diagonal matrix with *this as vector of diagonal coefficients +/** \returns a pseudo-expression of a diagonal matrix with *this as vector of diagonal coefficients * * \only_for_vectors * @@ -219,8 +237,7 @@ MatrixBase::asDiagonal() const return derived(); } -/** \nonstableyet - * \returns true if *this is approximately equal to a diagonal matrix, +/** \returns true if *this is approximately equal to a diagonal matrix, * within the precision given by \a prec. * * Example: \include MatrixBase_isDiagonal.cpp diff --git a/test/bandmatrix.cpp b/test/bandmatrix.cpp index ecb7304db..e243dffe5 100644 --- a/test/bandmatrix.cpp +++ b/test/bandmatrix.cpp @@ -53,7 +53,7 @@ template void bandmatrix(const MatrixType& _m) dm1.diagonal(-i).setConstant(-static_cast(i)); } //std::cerr << m.m_data << "\n\n" << m.toDense() << "\n\n" << dm1 << "\n\n\n\n"; - VERIFY_IS_APPROX(dm1,m.toDense()); + VERIFY_IS_APPROX(dm1,m.toDenseMatrix()); for (int i=0; i void bandmatrix(const MatrixType& _m) dm1.block(subs+1,0,rows-subs-1-b,rows-subs-1-b).template triangularView().setZero(); if(b>0) dm1.block(d+subs,0,b,cols).setZero(); //std::cerr << m.m_data << "\n\n" << m.toDense() << "\n\n" << dm1 << "\n\n"; - VERIFY_IS_APPROX(dm1,m.toDense()); + VERIFY_IS_APPROX(dm1,m.toDenseMatrix()); } -- cgit v1.2.3 From 76c614f9bd8e80a530a4aa685f1ae7506b64b8dd Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Mon, 16 Nov 2009 15:36:07 -0500 Subject: PartialPivLU: port to PermutationMatrix PermutationMatrix: add resize() --- Eigen/src/Core/PermutationMatrix.h | 3 +++ Eigen/src/LU/PartialPivLU.h | 18 ++++++++---------- 2 files changed, 11 insertions(+), 10 deletions(-) (limited to 'Eigen/src/Core') diff --git a/Eigen/src/Core/PermutationMatrix.h b/Eigen/src/Core/PermutationMatrix.h index f2bde0e71..b2acdb50d 100644 --- a/Eigen/src/Core/PermutationMatrix.h +++ b/Eigen/src/Core/PermutationMatrix.h @@ -159,6 +159,9 @@ class PermutationMatrix : public AnyMatrixBase class PartialPivLU typedef _MatrixType MatrixType; typedef typename MatrixType::Scalar Scalar; typedef typename NumTraits::Real RealScalar; - typedef Matrix IntRowVectorType; - typedef Matrix IntColVectorType; - typedef Matrix RowVectorType; - typedef Matrix ColVectorType; + typedef Matrix PermutationVectorType; + typedef PermutationMatrix PermutationType; enum { MaxSmallDimAtCompileTime = EIGEN_ENUM_MIN( MatrixType::MaxColsAtCompileTime, @@ -109,7 +107,7 @@ template class PartialPivLU * representing the P permutation i.e. the permutation of the rows. For its precise meaning, * see the examples given in the documentation of class FullPivLU. */ - inline const IntColVectorType& permutationP() const + inline const PermutationType& permutationP() const { ei_assert(m_isInitialized && "PartialPivLU is not initialized."); return m_p; @@ -174,7 +172,7 @@ template class PartialPivLU protected: MatrixType m_lu; - IntColVectorType m_p; + PermutationType m_p; int m_det_p; bool m_isInitialized; }; @@ -384,15 +382,15 @@ PartialPivLU& PartialPivLU::compute(const MatrixType& ma ei_assert(matrix.rows() == matrix.cols() && "PartialPivLU is only for square (and moreover invertible) matrices"); const int size = matrix.rows(); - IntColVectorType rows_transpositions(size); + PermutationVectorType rows_transpositions(size); int nb_transpositions; ei_partial_lu_inplace(m_lu, rows_transpositions, nb_transpositions); m_det_p = (nb_transpositions%2) ? -1 : 1; - for(int k = 0; k < size; ++k) m_p.coeffRef(k) = k; + for(int k = 0; k < size; ++k) m_p.indices().coeffRef(k) = k; for(int k = size-1; k >= 0; --k) - std::swap(m_p.coeffRef(k), m_p.coeffRef(rows_transpositions.coeff(k))); + std::swap(m_p.indices().coeffRef(k), m_p.indices().coeffRef(rows_transpositions.coeff(k))); m_isInitialized = true; return *this; @@ -428,7 +426,7 @@ struct ei_solve_retval, Rhs> dst.resize(size, rhs().cols()); // Step 1 - for(int i = 0; i < size; ++i) dst.row(dec().permutationP().coeff(i)) = rhs().row(i); + dst = dec().permutationP() * rhs(); // Step 2 dec().matrixLU().template triangularView().solveInPlace(dst); -- cgit v1.2.3 From 07412b2075a0d2924ae302f4af7ca54c923c9115 Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Mon, 16 Nov 2009 21:28:26 -0500 Subject: PermutationMatrix: add setIdentity and transpositions methods LU: make use of that --- Eigen/src/Core/PermutationMatrix.h | 69 +++++++++++++++++++++++++++++++++----- Eigen/src/LU/FullPivLU.h | 10 +++--- Eigen/src/LU/PartialPivLU.h | 5 ++- test/permutationmatrices.cpp | 24 +++++++++++++ 4 files changed, 90 insertions(+), 18 deletions(-) (limited to 'Eigen/src/Core') diff --git a/Eigen/src/Core/PermutationMatrix.h b/Eigen/src/Core/PermutationMatrix.h index b2acdb50d..147c48734 100644 --- a/Eigen/src/Core/PermutationMatrix.h +++ b/Eigen/src/Core/PermutationMatrix.h @@ -116,18 +116,15 @@ class PermutationMatrix : public AnyMatrixBase=0 && j>=0 && i=0 && j>=0 && i& FullPivLU::compute(const MatrixType& matrix) { m_isInitialized = true; m_lu = matrix; - m_p.resize(matrix.rows()); - m_q.resize(matrix.cols()); const int size = matrix.diagonalSize(); const int rows = matrix.rows(); @@ -459,13 +457,13 @@ FullPivLU& FullPivLU::compute(const MatrixType& matrix) // the main loop is over, we still have to accumulate the transpositions to find the // permutations P and Q - for(int k = 0; k < matrix.rows(); ++k) m_p.indices().coeffRef(k) = k; + m_p.setIdentity(rows); for(int k = size-1; k >= 0; --k) - std::swap(m_p.indices().coeffRef(k), m_p.indices().coeffRef(rows_transpositions.coeff(k))); + m_p.applyTranspositionOnTheRight(k, rows_transpositions.coeff(k)); - for(int k = 0; k < matrix.cols(); ++k) m_q.indices().coeffRef(k) = k; + m_q.setIdentity(cols); for(int k = 0; k < size; ++k) - std::swap(m_q.indices().coeffRef(k), m_q.indices().coeffRef(cols_transpositions.coeff(k))); + m_q.applyTranspositionOnTheRight(k, cols_transpositions.coeff(k)); m_det_pq = (number_of_transpositions%2) ? -1 : 1; return *this; diff --git a/Eigen/src/LU/PartialPivLU.h b/Eigen/src/LU/PartialPivLU.h index 4eb1162c1..975f79287 100644 --- a/Eigen/src/LU/PartialPivLU.h +++ b/Eigen/src/LU/PartialPivLU.h @@ -375,7 +375,6 @@ template PartialPivLU& PartialPivLU::compute(const MatrixType& matrix) { m_lu = matrix; - m_p.resize(matrix.rows()); ei_assert(matrix.rows() == matrix.cols() && "PartialPivLU is only for square (and moreover invertible) matrices"); const int size = matrix.rows(); @@ -386,9 +385,9 @@ PartialPivLU& PartialPivLU::compute(const MatrixType& ma ei_partial_lu_inplace(m_lu, rows_transpositions, nb_transpositions); m_det_p = (nb_transpositions%2) ? -1 : 1; - for(int k = 0; k < size; ++k) m_p.indices().coeffRef(k) = k; + m_p.setIdentity(size); for(int k = size-1; k >= 0; --k) - std::swap(m_p.indices().coeffRef(k), m_p.indices().coeffRef(rows_transpositions.coeff(k))); + m_p.applyTranspositionOnTheRight(k, rows_transpositions.coeff(k)); m_isInitialized = true; return *this; diff --git a/test/permutationmatrices.cpp b/test/permutationmatrices.cpp index c4affc795..0ef0a371a 100644 --- a/test/permutationmatrices.cpp +++ b/test/permutationmatrices.cpp @@ -81,6 +81,30 @@ template void permutationmatrices(const MatrixType& m) LeftPermutationType lp2(lv2); Matrix lm2(lp2); VERIFY_IS_APPROX((lp*lp2).toDenseMatrix().template cast(), lm*lm2); + + LeftPermutationType identityp; + identityp.setIdentity(rows); + VERIFY_IS_APPROX(m_original, identityp*m_original); + + if(rows>1 && cols>1) + { + lp2 = lp; + int i = ei_random(0, rows-1); + int j; + do j = ei_random(0, rows-1); while(j==i); + lp2.applyTranspositionOnTheLeft(i, j); + lm = lp; + lm.row(i).swap(lm.row(j)); + VERIFY_IS_APPROX(lm, lp2.toDenseMatrix().template cast()); + + RightPermutationType rp2 = rp; + i = ei_random(0, cols-1); + do j = ei_random(0, cols-1); while(j==i); + rp2.applyTranspositionOnTheRight(i, j); + rm = rp; + rm.col(i).swap(rm.col(j)); + VERIFY_IS_APPROX(rm, rp2.toDenseMatrix().template cast()); + } } void test_permutationmatrices() -- cgit v1.2.3 From 984c00077878382a5b49c0cbbe150e488a801940 Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Mon, 16 Nov 2009 21:33:41 -0500 Subject: addToDense ---> addTo subToDense ---> subTo --- Eigen/src/Core/AnyMatrixBase.h | 8 ++++---- Eigen/src/Core/DiagonalMatrix.h | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) (limited to 'Eigen/src/Core') diff --git a/Eigen/src/Core/AnyMatrixBase.h b/Eigen/src/Core/AnyMatrixBase.h index 58b425740..eddf2d232 100644 --- a/Eigen/src/Core/AnyMatrixBase.h +++ b/Eigen/src/Core/AnyMatrixBase.h @@ -52,7 +52,7 @@ template struct AnyMatrixBase { derived().evalTo(dst); } /** \internal Don't use it, but do the equivalent: \code dst += *this; \endcode */ - template inline void addToDense(Dest& dst) const + template inline void addTo(Dest& dst) const { // This is the default implementation, // derived class can reimplement it in a more optimized way. @@ -62,7 +62,7 @@ template struct AnyMatrixBase } /** \internal Don't use it, but do the equivalent: \code dst -= *this; \endcode */ - template inline void subToDense(Dest& dst) const + template inline void subTo(Dest& dst) const { // This is the default implementation, // derived class can reimplement it in a more optimized way. @@ -109,7 +109,7 @@ template template Derived& MatrixBase::operator+=(const AnyMatrixBase &other) { - other.derived().addToDense(derived()); + other.derived().addTo(derived()); return derived(); } @@ -117,7 +117,7 @@ template template Derived& MatrixBase::operator-=(const AnyMatrixBase &other) { - other.derived().subToDense(derived()); + other.derived().subTo(derived()); return derived(); } diff --git a/Eigen/src/Core/DiagonalMatrix.h b/Eigen/src/Core/DiagonalMatrix.h index e3e2120ea..360f03dd2 100644 --- a/Eigen/src/Core/DiagonalMatrix.h +++ b/Eigen/src/Core/DiagonalMatrix.h @@ -52,10 +52,10 @@ class DiagonalBase : public AnyMatrixBase template void evalTo(MatrixBase &other) const; template - void addToDense(MatrixBase &other) const + void addTo(MatrixBase &other) const { other.diagonal() += diagonal(); } template - void subToDense(MatrixBase &other) const + void subTo(MatrixBase &other) const { other.diagonal() -= diagonal(); } inline const DiagonalVectorType& diagonal() const { return derived().diagonal(); } -- cgit v1.2.3 From ac00902f8448156b85e29d8a9351b3f0ab700ae2 Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Mon, 16 Nov 2009 21:43:15 -0500 Subject: for consistency: PlainMatrixType ---> DenseMatrixType --- Eigen/src/Core/BandMatrix.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'Eigen/src/Core') diff --git a/Eigen/src/Core/BandMatrix.h b/Eigen/src/Core/BandMatrix.h index b67f60691..320981fa6 100644 --- a/Eigen/src/Core/BandMatrix.h +++ b/Eigen/src/Core/BandMatrix.h @@ -70,7 +70,7 @@ class BandMatrix : public AnyMatrixBase::MaxColsAtCompileTime }; typedef typename ei_traits::Scalar Scalar; - typedef Matrix PlainMatrixType; + typedef Matrix DenseMatrixType; protected: enum { @@ -171,9 +171,9 @@ class BandMatrix : public AnyMatrixBase(m_data, supers()-i, std::max(0,i), 1, diagonalLength(i)); } - PlainMatrixType toDenseMatrix() const + DenseMatrixType toDenseMatrix() const { - PlainMatrixType res(rows(),cols()); + DenseMatrixType res(rows(),cols()); res.setZero(); res.diagonal() = diagonal(); for (int i=1; i<=supers();++i) -- cgit v1.2.3 From 30b610a10f764529c7f93b6b7cd3cbf86a36e73d Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Mon, 16 Nov 2009 21:45:01 -0500 Subject: vade retro --- Eigen/src/Core/BandMatrix.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'Eigen/src/Core') diff --git a/Eigen/src/Core/BandMatrix.h b/Eigen/src/Core/BandMatrix.h index 320981fa6..85bd8dba7 100644 --- a/Eigen/src/Core/BandMatrix.h +++ b/Eigen/src/Core/BandMatrix.h @@ -87,7 +87,7 @@ class BandMatrix : public AnyMatrixBase Date: Wed, 18 Nov 2009 11:57:07 -0500 Subject: Assign.h: add LinearTraversal (non-vectorized index-based traversal) Rename some constants to make names match more closely what they mean. --- Eigen/src/Core/Assign.h | 143 ++++++++++++++++++++---------- Eigen/src/Core/Dot.h | 26 +++--- Eigen/src/Core/Redux.h | 28 +++--- Eigen/src/Core/products/GeneralUnrolled.h | 28 +++--- Eigen/src/Core/util/Constants.h | 11 ++- test/vectorization_logic.cpp | 55 +++++++----- 6 files changed, 176 insertions(+), 115 deletions(-) (limited to 'Eigen/src/Core') diff --git a/Eigen/src/Core/Assign.h b/Eigen/src/Core/Assign.h index 8dc015715..86ba45481 100644 --- a/Eigen/src/Core/Assign.h +++ b/Eigen/src/Core/Assign.h @@ -57,40 +57,46 @@ private: && ((int(Derived::Flags)&RowMajorBit)==(int(OtherDerived::Flags)&RowMajorBit)), MayInnerVectorize = MightVectorize && int(InnerSize)!=Dynamic && int(InnerSize)%int(PacketSize)==0 && int(DstIsAligned) && int(SrcIsAligned), - MayLinearVectorize = MightVectorize && (int(Derived::Flags) & int(OtherDerived::Flags) & LinearAccessBit) - && (DstIsAligned || InnerMaxSize == Dynamic),/* If the destination isn't aligned, - we have to do runtime checks and we don't unroll, so it's only good for large enough sizes. See remark below - about InnerMaxSize. */ - MaySliceVectorize = MightVectorize && int(InnerMaxSize)>=3*PacketSize /* slice vectorization can be slow, so we only - want it if the slices are big, which is indicated by InnerMaxSize rather than InnerSize, think of the case - of a dynamic block in a fixed-size matrix */ + MayLinearize = (int(Derived::Flags) & int(OtherDerived::Flags) & LinearAccessBit), + MayLinearVectorize = MightVectorize && MayLinearize + && (DstIsAligned || InnerMaxSize == Dynamic), + /* If the destination isn't aligned, we have to do runtime checks and we don't unroll, + so it's only good for large enough sizes. See remark below about InnerMaxSize. */ + MaySliceVectorize = MightVectorize && int(InnerMaxSize)>=3*PacketSize + /* slice vectorization can be slow, so we only want it if the slices are big, which is + indicated by InnerMaxSize rather than InnerSize, think of the case of a dynamic block + in a fixed-size matrix */ }; public: enum { - Vectorization = int(MayInnerVectorize) ? int(InnerVectorization) - : int(MayLinearVectorize) ? int(LinearVectorization) - : int(MaySliceVectorize) ? int(SliceVectorization) - : int(NoVectorization) + Traversal = int(MayInnerVectorize) ? int(InnerVectorizedTraversal) + : int(MayLinearVectorize) ? int(LinearVectorizedTraversal) + : int(MaySliceVectorize) ? int(SliceVectorizedTraversal) + : int(MayLinearize) ? int(LinearTraversal) + : int(DefaultTraversal), + Vectorized = int(Traversal) != LinearTraversal && int(Traversal) == DefaultTraversal }; private: enum { - UnrollingLimit = EIGEN_UNROLLING_LIMIT * (int(Vectorization) == int(NoVectorization) ? 1 : int(PacketSize)), + UnrollingLimit = EIGEN_UNROLLING_LIMIT * (Vectorized ? 1 : int(PacketSize)), MayUnrollCompletely = int(Derived::SizeAtCompileTime) * int(OtherDerived::CoeffReadCost) <= int(UnrollingLimit), MayUnrollInner = int(InnerSize * OtherDerived::CoeffReadCost) <= int(UnrollingLimit) }; public: enum { - Unrolling = (int(Vectorization) == int(InnerVectorization) || int(Vectorization) == int(NoVectorization)) - ? ( - int(MayUnrollCompletely) ? int(CompleteUnrolling) - : int(MayUnrollInner) ? int(InnerUnrolling) - : int(NoUnrolling) - ) - : int(Vectorization) == int(LinearVectorization) - ? ( int(MayUnrollCompletely) && int(DstIsAligned) ? int(CompleteUnrolling) : int(NoUnrolling) ) + Unrolling = (int(Traversal) == int(InnerVectorizedTraversal) || int(Traversal) == int(DefaultTraversal)) + ? ( + int(MayUnrollCompletely) ? int(CompleteUnrolling) + : int(MayUnrollInner) ? int(InnerUnrolling) + : int(NoUnrolling) + ) + : int(Traversal) == int(LinearVectorizedTraversal) + ? ( int(MayUnrollCompletely) && int(DstIsAligned) ? int(CompleteUnrolling) : int(NoUnrolling) ) + : int(Traversal) == int(LinearTraversal) + ? ( int(MayUnrollCompletely) ? int(CompleteUnrolling) : int(NoUnrolling) ) : int(NoUnrolling) }; @@ -106,7 +112,7 @@ public: EIGEN_DEBUG_VAR(MayInnerVectorize) EIGEN_DEBUG_VAR(MayLinearVectorize) EIGEN_DEBUG_VAR(MaySliceVectorize) - EIGEN_DEBUG_VAR(Vectorization) + EIGEN_DEBUG_VAR(Traversal) EIGEN_DEBUG_VAR(UnrollingLimit) EIGEN_DEBUG_VAR(MayUnrollCompletely) EIGEN_DEBUG_VAR(MayUnrollInner) @@ -118,12 +124,12 @@ public: * Part 2 : meta-unrollers ***************************************************************************/ -/*********************** -*** No vectorization *** -***********************/ +/************************ +*** Default traversal *** +************************/ template -struct ei_assign_novec_CompleteUnrolling +struct ei_assign_DefaultTraversal_CompleteUnrolling { enum { row = int(Derived1::Flags)&RowMajorBit @@ -137,18 +143,18 @@ struct ei_assign_novec_CompleteUnrolling EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { dst.copyCoeff(row, col, src); - ei_assign_novec_CompleteUnrolling::run(dst, src); + ei_assign_DefaultTraversal_CompleteUnrolling::run(dst, src); } }; template -struct ei_assign_novec_CompleteUnrolling +struct ei_assign_DefaultTraversal_CompleteUnrolling { EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &) {} }; template -struct ei_assign_novec_InnerUnrolling +struct ei_assign_DefaultTraversal_InnerUnrolling { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src, int row_or_col) { @@ -156,16 +162,36 @@ struct ei_assign_novec_InnerUnrolling const int row = rowMajor ? row_or_col : Index; const int col = rowMajor ? Index : row_or_col; dst.copyCoeff(row, col, src); - ei_assign_novec_InnerUnrolling::run(dst, src, row_or_col); + ei_assign_DefaultTraversal_InnerUnrolling::run(dst, src, row_or_col); } }; template -struct ei_assign_novec_InnerUnrolling +struct ei_assign_DefaultTraversal_InnerUnrolling { EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &, int) {} }; +/*********************** +*** Linear traversal *** +***********************/ + +template +struct ei_assign_LinearTraversal_CompleteUnrolling +{ + EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) + { + dst.copyCoeff(Index, src); + ei_assign_LinearTraversal_CompleteUnrolling::run(dst, src); + } +}; + +template +struct ei_assign_LinearTraversal_CompleteUnrolling +{ + EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &) {} +}; + /************************** *** Inner vectorization *** **************************/ @@ -221,16 +247,16 @@ struct ei_assign_innervec_InnerUnrolling ***************************************************************************/ template::Vectorization, + int Traversal = ei_assign_traits::Traversal, int Unrolling = ei_assign_traits::Unrolling> struct ei_assign_impl; -/*********************** -*** No vectorization *** -***********************/ +/************************ +*** Default traversal *** +************************/ template -struct ei_assign_impl +struct ei_assign_impl { inline static void run(Derived1 &dst, const Derived2 &src) { @@ -248,17 +274,17 @@ struct ei_assign_impl }; template -struct ei_assign_impl +struct ei_assign_impl { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { - ei_assign_novec_CompleteUnrolling + ei_assign_DefaultTraversal_CompleteUnrolling ::run(dst, src); } }; template -struct ei_assign_impl +struct ei_assign_impl { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { @@ -266,17 +292,42 @@ struct ei_assign_impl const int innerSize = rowMajor ? Derived1::ColsAtCompileTime : Derived1::RowsAtCompileTime; const int outerSize = dst.outerSize(); for(int j = 0; j < outerSize; ++j) - ei_assign_novec_InnerUnrolling + ei_assign_DefaultTraversal_InnerUnrolling ::run(dst, src, j); } }; +/*********************** +*** Linear traversal *** +***********************/ + +template +struct ei_assign_impl +{ + inline static void run(Derived1 &dst, const Derived2 &src) + { + const int size = dst.size(); + for(int i = 0; i < size; ++i) + dst.copyCoeff(i, src); + } +}; + +template +struct ei_assign_impl +{ + EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) + { + ei_assign_LinearTraversal_CompleteUnrolling + ::run(dst, src); + } +}; + /************************** *** Inner vectorization *** **************************/ template -struct ei_assign_impl +struct ei_assign_impl { inline static void run(Derived1 &dst, const Derived2 &src) { @@ -295,7 +346,7 @@ struct ei_assign_impl }; template -struct ei_assign_impl +struct ei_assign_impl { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { @@ -305,7 +356,7 @@ struct ei_assign_impl }; template -struct ei_assign_impl +struct ei_assign_impl { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { @@ -323,7 +374,7 @@ struct ei_assign_impl ***************************/ template -struct ei_assign_impl +struct ei_assign_impl { inline static void run(Derived1 &dst, const Derived2 &src) { @@ -347,7 +398,7 @@ struct ei_assign_impl }; template -struct ei_assign_impl +struct ei_assign_impl { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { @@ -356,7 +407,7 @@ struct ei_assign_impl::run(dst, src); - ei_assign_novec_CompleteUnrolling::run(dst, src); + ei_assign_DefaultTraversal_CompleteUnrolling::run(dst, src); } }; @@ -365,7 +416,7 @@ struct ei_assign_impl -struct ei_assign_impl +struct ei_assign_impl { inline static void run(Derived1 &dst, const Derived2 &src) { diff --git a/Eigen/src/Core/Dot.h b/Eigen/src/Core/Dot.h index 631124f2b..a8983d4ce 100644 --- a/Eigen/src/Core/Dot.h +++ b/Eigen/src/Core/Dot.h @@ -34,10 +34,10 @@ struct ei_dot_traits { public: enum { - Vectorization = (int(Derived1::Flags)&int(Derived2::Flags)&ActualPacketAccessBit) + Traversal = (int(Derived1::Flags)&int(Derived2::Flags)&ActualPacketAccessBit) && (int(Derived1::Flags)&int(Derived2::Flags)&LinearAccessBit) - ? LinearVectorization - : NoVectorization + ? LinearVectorizedTraversal + : DefaultTraversal }; private: @@ -46,7 +46,7 @@ private: PacketSize = ei_packet_traits::size, Cost = Derived1::SizeAtCompileTime * (Derived1::CoeffReadCost + Derived2::CoeffReadCost + NumTraits::MulCost) + (Derived1::SizeAtCompileTime-1) * NumTraits::AddCost, - UnrollingLimit = EIGEN_UNROLLING_LIMIT * (int(Vectorization) == int(NoVectorization) ? 1 : int(PacketSize)) + UnrollingLimit = EIGEN_UNROLLING_LIMIT * (int(Traversal) == int(DefaultTraversal) ? 1 : int(PacketSize)) }; public: @@ -142,13 +142,13 @@ struct ei_dot_vec_unroller ***************************************************************************/ template::Vectorization, + int Traversal = ei_dot_traits::Traversal, int Unrolling = ei_dot_traits::Unrolling > struct ei_dot_impl; template -struct ei_dot_impl +struct ei_dot_impl { typedef typename Derived1::Scalar Scalar; static Scalar run(const Derived1& v1, const Derived2& v2) @@ -163,12 +163,12 @@ struct ei_dot_impl }; template -struct ei_dot_impl +struct ei_dot_impl : public ei_dot_novec_unroller {}; template -struct ei_dot_impl +struct ei_dot_impl { typedef typename Derived1::Scalar Scalar; typedef typename ei_packet_traits::type PacketScalar; @@ -221,20 +221,20 @@ struct ei_dot_impl }; template -struct ei_dot_impl +struct ei_dot_impl { typedef typename Derived1::Scalar Scalar; typedef typename ei_packet_traits::type PacketScalar; enum { PacketSize = ei_packet_traits::size, Size = Derived1::SizeAtCompileTime, - VectorizationSize = (Size / PacketSize) * PacketSize + VectorizedSize = (Size / PacketSize) * PacketSize }; static Scalar run(const Derived1& v1, const Derived2& v2) { - Scalar res = ei_predux(ei_dot_vec_unroller::run(v1, v2)); - if (VectorizationSize != Size) - res += ei_dot_novec_unroller::run(v1, v2); + Scalar res = ei_predux(ei_dot_vec_unroller::run(v1, v2)); + if (VectorizedSize != Size) + res += ei_dot_novec_unroller::run(v1, v2); return res; } }; diff --git a/Eigen/src/Core/Redux.h b/Eigen/src/Core/Redux.h index 9f796157a..171f6dcf5 100644 --- a/Eigen/src/Core/Redux.h +++ b/Eigen/src/Core/Redux.h @@ -54,16 +54,16 @@ private: public: enum { - Vectorization = int(MayLinearVectorize) ? int(LinearVectorization) - : int(MaySliceVectorize) ? int(SliceVectorization) - : int(NoVectorization) + Traversal = int(MayLinearVectorize) ? int(LinearVectorizedTraversal) + : int(MaySliceVectorize) ? int(SliceVectorizedTraversal) + : int(DefaultTraversal) }; private: enum { Cost = Derived::SizeAtCompileTime * Derived::CoeffReadCost + (Derived::SizeAtCompileTime-1) * NumTraits::AddCost, - UnrollingLimit = EIGEN_UNROLLING_LIMIT * (int(Vectorization) == int(NoVectorization) ? 1 : int(PacketSize)) + UnrollingLimit = EIGEN_UNROLLING_LIMIT * (int(Traversal) == int(DefaultTraversal) ? 1 : int(PacketSize)) }; public: @@ -171,13 +171,13 @@ struct ei_redux_vec_unroller ***************************************************************************/ template::Vectorization, + int Traversal = ei_redux_traits::Traversal, int Unrolling = ei_redux_traits::Unrolling > struct ei_redux_impl; template -struct ei_redux_impl +struct ei_redux_impl { typedef typename Derived::Scalar Scalar; static Scalar run(const Derived& mat, const Func& func) @@ -195,12 +195,12 @@ struct ei_redux_impl }; template -struct ei_redux_impl +struct ei_redux_impl : public ei_redux_novec_unroller {}; template -struct ei_redux_impl +struct ei_redux_impl { typedef typename Derived::Scalar Scalar; typedef typename ei_packet_traits::type PacketScalar; @@ -246,7 +246,7 @@ struct ei_redux_impl }; template -struct ei_redux_impl +struct ei_redux_impl { typedef typename Derived::Scalar Scalar; typedef typename ei_packet_traits::type PacketScalar; @@ -277,7 +277,7 @@ struct ei_redux_impl else // too small to vectorize anything. // since this is dynamic-size hence inefficient anyway for such small sizes, don't try to optimize. { - res = ei_redux_impl::run(mat, func); + res = ei_redux_impl::run(mat, func); } return res; @@ -285,20 +285,20 @@ struct ei_redux_impl }; template -struct ei_redux_impl +struct ei_redux_impl { typedef typename Derived::Scalar Scalar; typedef typename ei_packet_traits::type PacketScalar; enum { PacketSize = ei_packet_traits::size, Size = Derived::SizeAtCompileTime, - VectorizationSize = (Size / PacketSize) * PacketSize + VectorizedSize = (Size / PacketSize) * PacketSize }; EIGEN_STRONG_INLINE static Scalar run(const Derived& mat, const Func& func) { Scalar res = func.predux(ei_redux_vec_unroller::run(mat,func)); - if (VectorizationSize != Size) - res = func(res,ei_redux_novec_unroller::run(mat,func)); + if (VectorizedSize != Size) + res = func(res,ei_redux_novec_unroller::run(mat,func)); return res; } }; diff --git a/Eigen/src/Core/products/GeneralUnrolled.h b/Eigen/src/Core/products/GeneralUnrolled.h index 7241976a8..e8fb760ae 100644 --- a/Eigen/src/Core/products/GeneralUnrolled.h +++ b/Eigen/src/Core/products/GeneralUnrolled.h @@ -36,7 +36,7 @@ * Note that here the inner-loops should always be unrolled. */ -template +template struct ei_product_coeff_impl; template @@ -115,7 +115,7 @@ template class GeneralProduct::CanVectorizeInner }; - typedef ei_product_coeff_impl ScalarCoeffImpl; @@ -182,17 +182,17 @@ template class GeneralProduct -struct ei_product_coeff_impl +struct ei_product_coeff_impl { EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, RetScalar &res) { - ei_product_coeff_impl::run(row, col, lhs, rhs, res); + ei_product_coeff_impl::run(row, col, lhs, rhs, res); res += lhs.coeff(row, Index) * rhs.coeff(Index, col); } }; template -struct ei_product_coeff_impl +struct ei_product_coeff_impl { EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, RetScalar &res) { @@ -201,7 +201,7 @@ struct ei_product_coeff_impl }; template -struct ei_product_coeff_impl +struct ei_product_coeff_impl { EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, RetScalar& res) { @@ -214,7 +214,7 @@ struct ei_product_coeff_impl // prevent buggy user code from causing an infinite recursion template -struct ei_product_coeff_impl +struct ei_product_coeff_impl { EIGEN_STRONG_INLINE static void run(int, int, const Lhs&, const Rhs&, RetScalar&) {} }; @@ -244,7 +244,7 @@ struct ei_product_coeff_vectorized_unroller<0, Lhs, Rhs, PacketScalar> }; template -struct ei_product_coeff_impl +struct ei_product_coeff_impl { typedef typename Lhs::PacketScalar PacketScalar; enum { PacketSize = ei_packet_traits::size }; @@ -252,7 +252,7 @@ struct ei_product_coeff_impl { PacketScalar pres; ei_product_coeff_vectorized_unroller::run(row, col, lhs, rhs, pres); - ei_product_coeff_impl::run(row, col, lhs, rhs, res); + ei_product_coeff_impl::run(row, col, lhs, rhs, res); res = ei_predux(pres); } }; @@ -265,7 +265,7 @@ struct ei_product_coeff_vectorized_dyn_selector res = ei_dot_impl< Block::ColsAtCompileTime>, Block::RowsAtCompileTime, 1>, - LinearVectorization, NoUnrolling>::run(lhs.row(row), rhs.col(col)); + LinearVectorizedTraversal, NoUnrolling>::run(lhs.row(row), rhs.col(col)); } }; @@ -279,7 +279,7 @@ struct ei_product_coeff_vectorized_dyn_selector res = ei_dot_impl< Lhs, Block::RowsAtCompileTime, 1>, - LinearVectorization, NoUnrolling>::run(lhs, rhs.col(col)); + LinearVectorizedTraversal, NoUnrolling>::run(lhs, rhs.col(col)); } }; @@ -291,7 +291,7 @@ struct ei_product_coeff_vectorized_dyn_selector res = ei_dot_impl< Block::ColsAtCompileTime>, Rhs, - LinearVectorization, NoUnrolling>::run(lhs.row(row), rhs); + LinearVectorizedTraversal, NoUnrolling>::run(lhs.row(row), rhs); } }; @@ -303,12 +303,12 @@ struct ei_product_coeff_vectorized_dyn_selector res = ei_dot_impl< Lhs, Rhs, - LinearVectorization, NoUnrolling>::run(lhs, rhs); + LinearVectorizedTraversal, NoUnrolling>::run(lhs, rhs); } }; template -struct ei_product_coeff_impl +struct ei_product_coeff_impl { EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, typename Lhs::Scalar &res) { diff --git a/Eigen/src/Core/util/Constants.h b/Eigen/src/Core/util/Constants.h index 487425f88..5489d063a 100644 --- a/Eigen/src/Core/util/Constants.h +++ b/Eigen/src/Core/util/Constants.h @@ -202,16 +202,19 @@ enum DirectionType { Vertical, Horizontal, BothDirections }; enum ProductEvaluationMode { NormalProduct, CacheFriendlyProduct, SparseTimeSparseProduct, SparseTimeDenseProduct, DenseTimeSparseProduct }; enum { + /** \internal Default traversal, no vectorization, no index-based access */ + DefaultTraversal, + /** \internal No vectorization, use index-based access to have only one for loop instead of 2 nested loops */ + LinearTraversal, /** \internal Equivalent to a slice vectorization for fixed-size matrices having good alignment * and good size */ - InnerVectorization, + InnerVectorizedTraversal, /** \internal Vectorization path using a single loop plus scalar loops for the * unaligned boundaries */ - LinearVectorization, + LinearVectorizedTraversal, /** \internal Generic vectorization path using one vectorized loop per row/column with some * scalar loops to handle the unaligned boundaries */ - SliceVectorization, - NoVectorization + SliceVectorizedTraversal }; enum { diff --git a/test/vectorization_logic.cpp b/test/vectorization_logic.cpp index 680adeb45..3772bf13d 100644 --- a/test/vectorization_logic.cpp +++ b/test/vectorization_logic.cpp @@ -26,17 +26,18 @@ #include template -bool test_assign(const Dst&, const Src&, int vectorization, int unrolling) +bool test_assign(const Dst&, const Src&, int traversal, int unrolling) { - return ei_assign_traits::Vectorization==vectorization + ei_assign_traits::debug(); + return ei_assign_traits::Traversal==traversal && ei_assign_traits::Unrolling==unrolling; } template -bool test_redux(const Xpr&, int vectorization, int unrolling) +bool test_redux(const Xpr&, int traversal, int unrolling) { typedef ei_redux_traits,Xpr> traits; - return traits::Vectorization==vectorization && traits::Unrolling==unrolling; + return traits::Traversal==traversal && traits::Unrolling==unrolling; } void test_vectorization_logic() @@ -45,61 +46,67 @@ void test_vectorization_logic() #ifdef EIGEN_VECTORIZE VERIFY(test_assign(Vector4f(),Vector4f(), - InnerVectorization,CompleteUnrolling)); + InnerVectorizedTraversal,CompleteUnrolling)); VERIFY(test_assign(Vector4f(),Vector4f()+Vector4f(), - InnerVectorization,CompleteUnrolling)); + InnerVectorizedTraversal,CompleteUnrolling)); VERIFY(test_assign(Vector4f(),Vector4f().cwise() * Vector4f(), - InnerVectorization,CompleteUnrolling)); + InnerVectorizedTraversal,CompleteUnrolling)); VERIFY(test_assign(Vector4f(),Vector4f().cast(), - InnerVectorization,CompleteUnrolling)); + InnerVectorizedTraversal,CompleteUnrolling)); VERIFY(test_assign(Matrix4f(),Matrix4f(), - InnerVectorization,CompleteUnrolling)); + InnerVectorizedTraversal,CompleteUnrolling)); VERIFY(test_assign(Matrix4f(),Matrix4f()+Matrix4f(), - InnerVectorization,CompleteUnrolling)); + InnerVectorizedTraversal,CompleteUnrolling)); VERIFY(test_assign(Matrix4f(),Matrix4f().cwise() * Matrix4f(), - InnerVectorization,CompleteUnrolling)); + InnerVectorizedTraversal,CompleteUnrolling)); VERIFY(test_assign(Matrix(),Matrix()+Matrix(), - InnerVectorization,InnerUnrolling)); + InnerVectorizedTraversal,InnerUnrolling)); VERIFY(test_assign(Matrix(),Matrix()+Matrix(), - NoVectorization,InnerUnrolling)); + LinearTraversal,NoUnrolling)); + + VERIFY(test_assign(Matrix(),Matrix()+Matrix(), + LinearTraversal,CompleteUnrolling)); VERIFY(test_assign(Matrix(),Matrix().cwise() / Matrix(), - LinearVectorization,CompleteUnrolling)); + LinearVectorizedTraversal,CompleteUnrolling)); VERIFY(test_assign(Matrix(),Matrix()+Matrix(), - NoVectorization,InnerUnrolling)); + LinearTraversal,NoUnrolling)); + + VERIFY(test_assign(Matrix(),Matrix()+Matrix(), + LinearTraversal,CompleteUnrolling)); VERIFY(test_assign(Matrix(),Matrix().block<4,4>(2,3)+Matrix().block<4,4>(10,4), - NoVectorization,CompleteUnrolling)); + DefaultTraversal,CompleteUnrolling)); VERIFY(test_assign(MatrixXf(10,10),MatrixXf(20,20).block(10,10,2,3), - SliceVectorization,NoUnrolling)); + SliceVectorizedTraversal,NoUnrolling)); VERIFY(test_redux(VectorXf(10), - LinearVectorization,NoUnrolling)); + LinearVectorizedTraversal,NoUnrolling)); VERIFY(test_redux(Matrix(), - NoVectorization,CompleteUnrolling)); + DefaultTraversal,CompleteUnrolling)); VERIFY(test_redux(Matrix(), - LinearVectorization,CompleteUnrolling)); + LinearVectorizedTraversal,CompleteUnrolling)); VERIFY(test_redux(Matrix(), - LinearVectorization,NoUnrolling)); + LinearVectorizedTraversal,NoUnrolling)); VERIFY(test_redux(Matrix().block<4,4>(1,2), - NoVectorization,CompleteUnrolling)); + DefaultTraversal,CompleteUnrolling)); VERIFY(test_redux(Matrix().block<8,1>(1,2), - LinearVectorization,CompleteUnrolling)); + LinearVectorizedTraversal,CompleteUnrolling)); VERIFY(test_redux(Matrix(), - NoVectorization,CompleteUnrolling)); + DefaultTraversal,CompleteUnrolling)); #endif // EIGEN_VECTORIZE -- cgit v1.2.3 From 11fa2ae2c602a9771fadee6f5162e82d5d29cd85 Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Wed, 18 Nov 2009 16:31:14 -0500 Subject: temporarily disable linear traversal. Actually I don't think it's buggy. But it probably triggers existing bugs, I suspect that some xprs have LinearAccessBit and shouldn't have it. Also this fixes the "bugs" with JacobiSVD ---> now it works again --- Eigen/src/Core/Assign.h | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) (limited to 'Eigen/src/Core') diff --git a/Eigen/src/Core/Assign.h b/Eigen/src/Core/Assign.h index 86ba45481..32f9623e8 100644 --- a/Eigen/src/Core/Assign.h +++ b/Eigen/src/Core/Assign.h @@ -73,16 +73,18 @@ public: Traversal = int(MayInnerVectorize) ? int(InnerVectorizedTraversal) : int(MayLinearVectorize) ? int(LinearVectorizedTraversal) : int(MaySliceVectorize) ? int(SliceVectorizedTraversal) - : int(MayLinearize) ? int(LinearTraversal) +// : int(MayLinearize) ? int(LinearTraversal) : int(DefaultTraversal), - Vectorized = int(Traversal) != LinearTraversal && int(Traversal) == DefaultTraversal + Vectorized = int(Traversal) == InnerVectorizedTraversal + || int(Traversal) == LinearVectorizedTraversal + || int(Traversal) == SliceVectorizedTraversal }; private: enum { - UnrollingLimit = EIGEN_UNROLLING_LIMIT * (Vectorized ? 1 : int(PacketSize)), + UnrollingLimit = EIGEN_UNROLLING_LIMIT * (Vectorized ? int(PacketSize) : 1), MayUnrollCompletely = int(Derived::SizeAtCompileTime) * int(OtherDerived::CoeffReadCost) <= int(UnrollingLimit), - MayUnrollInner = int(InnerSize * OtherDerived::CoeffReadCost) <= int(UnrollingLimit) + MayUnrollInner = int(InnerSize) * int(OtherDerived::CoeffReadCost) <= int(UnrollingLimit) }; public: @@ -91,7 +93,7 @@ public: ? ( int(MayUnrollCompletely) ? int(CompleteUnrolling) : int(MayUnrollInner) ? int(InnerUnrolling) - : int(NoUnrolling) + : int(NoUnrolling) ) : int(Traversal) == int(LinearVectorizedTraversal) ? ( int(MayUnrollCompletely) && int(DstIsAligned) ? int(CompleteUnrolling) : int(NoUnrolling) ) -- cgit v1.2.3 From 40865fa28cab9473959458ec890d68b9df398dc9 Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Wed, 18 Nov 2009 17:20:39 -0500 Subject: fix bugs, old and new: * old bug: in CwiseBinaryOp: only set the LinearAccessBit if both sides have the same storage order. * new bug: in Assign.h, only consider linear traversal if both sides have the same storage order. --- Eigen/src/Core/Assign.h | 12 +++++++----- Eigen/src/Core/CwiseBinaryOp.h | 11 ++++++++--- 2 files changed, 15 insertions(+), 8 deletions(-) (limited to 'Eigen/src/Core') diff --git a/Eigen/src/Core/Assign.h b/Eigen/src/Core/Assign.h index 32f9623e8..00febdc5d 100644 --- a/Eigen/src/Core/Assign.h +++ b/Eigen/src/Core/Assign.h @@ -28,7 +28,7 @@ #define EIGEN_ASSIGN_H /*************************************************************************** -* Part 1 : the logic deciding a strategy for vectorization and unrolling +* Part 1 : the logic deciding a strategy for traversal and unrolling * ***************************************************************************/ template @@ -53,11 +53,12 @@ private: }; enum { - MightVectorize = (int(Derived::Flags) & int(OtherDerived::Flags) & ActualPacketAccessBit) - && ((int(Derived::Flags)&RowMajorBit)==(int(OtherDerived::Flags)&RowMajorBit)), + StorageOrdersAgree = (int(Derived::Flags)&RowMajorBit)==(int(OtherDerived::Flags)&RowMajorBit), + MightVectorize = StorageOrdersAgree + && (int(Derived::Flags) & int(OtherDerived::Flags) & ActualPacketAccessBit), MayInnerVectorize = MightVectorize && int(InnerSize)!=Dynamic && int(InnerSize)%int(PacketSize)==0 && int(DstIsAligned) && int(SrcIsAligned), - MayLinearize = (int(Derived::Flags) & int(OtherDerived::Flags) & LinearAccessBit), + MayLinearize = StorageOrdersAgree && (int(Derived::Flags) & int(OtherDerived::Flags) & LinearAccessBit), MayLinearVectorize = MightVectorize && MayLinearize && (DstIsAligned || InnerMaxSize == Dynamic), /* If the destination isn't aligned, we have to do runtime checks and we don't unroll, @@ -73,7 +74,7 @@ public: Traversal = int(MayInnerVectorize) ? int(InnerVectorizedTraversal) : int(MayLinearVectorize) ? int(LinearVectorizedTraversal) : int(MaySliceVectorize) ? int(SliceVectorizedTraversal) -// : int(MayLinearize) ? int(LinearTraversal) + : int(MayLinearize) ? int(LinearTraversal) : int(DefaultTraversal), Vectorized = int(Traversal) == InnerVectorizedTraversal || int(Traversal) == LinearVectorizedTraversal @@ -110,6 +111,7 @@ public: EIGEN_DEBUG_VAR(InnerSize) EIGEN_DEBUG_VAR(InnerMaxSize) EIGEN_DEBUG_VAR(PacketSize) + EIGEN_DEBUG_VAR(StorageOrdersAgree) EIGEN_DEBUG_VAR(MightVectorize) EIGEN_DEBUG_VAR(MayInnerVectorize) EIGEN_DEBUG_VAR(MayLinearVectorize) diff --git a/Eigen/src/Core/CwiseBinaryOp.h b/Eigen/src/Core/CwiseBinaryOp.h index 875bc9aa5..4bea0425f 100644 --- a/Eigen/src/Core/CwiseBinaryOp.h +++ b/Eigen/src/Core/CwiseBinaryOp.h @@ -67,11 +67,16 @@ struct ei_traits > ColsAtCompileTime = Lhs::ColsAtCompileTime, MaxRowsAtCompileTime = Lhs::MaxRowsAtCompileTime, MaxColsAtCompileTime = Lhs::MaxColsAtCompileTime, + StorageOrdersAgree = (int(Lhs::Flags)&RowMajorBit)==(int(Rhs::Flags)&RowMajorBit), Flags = (int(LhsFlags) | int(RhsFlags)) & ( HereditaryBits - | (int(LhsFlags) & int(RhsFlags) & (LinearAccessBit | AlignedBit)) - | (ei_functor_traits::PacketAccess && ((int(LhsFlags) & RowMajorBit)==(int(RhsFlags) & RowMajorBit)) - ? (int(LhsFlags) & int(RhsFlags) & PacketAccessBit) : 0)), + | (int(LhsFlags) & int(RhsFlags) & + ( AlignedBit + | (StorageOrdersAgree ? LinearAccessBit : 0) + | (ei_functor_traits::PacketAccess && StorageOrdersAgree ? PacketAccessBit : 0) + ) + ) + ), CoeffReadCost = LhsCoeffReadCost + RhsCoeffReadCost + ei_functor_traits::Cost }; }; -- cgit v1.2.3 From b5f4636d42eb8b8e2383c0fbe357dca8fa1d357e Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Thu, 19 Nov 2009 12:09:04 -0500 Subject: * eigen2->eigen3 * bump version to 2.91.0 * add FindEigen3.cmake --- CMakeLists.txt | 22 +++++------ Eigen/src/Core/util/Macros.h | 4 +- cmake/FindEigen3.cmake | 80 ++++++++++++++++++++++++++++++++++++++++ doc/C01_QuickStartGuide.dox | 2 +- doc/D11_UnalignedArrayAssert.dox | 2 +- doc/Doxyfile.in | 8 ---- doc/I00_CustomizingEigen.dox | 2 +- eigen2.pc.in | 7 ---- eigen3.pc.in | 6 +++ scripts/eigen_gen_credits | 4 +- test/testsuite.cmake | 8 ++-- unsupported/README.txt | 2 +- unsupported/doc/Doxyfile.in | 8 ---- 13 files changed, 109 insertions(+), 46 deletions(-) create mode 100644 cmake/FindEigen3.cmake delete mode 100644 eigen2.pc.in create mode 100644 eigen3.pc.in (limited to 'Eigen/src/Core') diff --git a/CMakeLists.txt b/CMakeLists.txt index 3a23479d7..62d292c02 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -7,14 +7,14 @@ if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR}) endif() # automatically parse the version number -file(READ "${CMAKE_SOURCE_DIR}/Eigen/src/Core/util/Macros.h" _eigen2_version_header) -string(REGEX MATCH "define[ \t]+EIGEN_WORLD_VERSION[ \t]+([0-9]+)" _eigen2_world_version_match "${_eigen2_version_header}") -set(EIGEN2_WORLD_VERSION "${CMAKE_MATCH_1}") -string(REGEX MATCH "define[ \t]+EIGEN_MAJOR_VERSION[ \t]+([0-9]+)" _eigen2_major_version_match "${_eigen2_version_header}") -set(EIGEN2_MAJOR_VERSION "${CMAKE_MATCH_1}") -string(REGEX MATCH "define[ \t]+EIGEN_MINOR_VERSION[ \t]+([0-9]+)" _eigen2_minor_version_match "${_eigen2_version_header}") -set(EIGEN2_MINOR_VERSION "${CMAKE_MATCH_1}") -set(EIGEN_VERSION_NUMBER ${EIGEN2_WORLD_VERSION}.${EIGEN2_MAJOR_VERSION}.${EIGEN2_MINOR_VERSION}) +file(READ "${CMAKE_SOURCE_DIR}/Eigen/src/Core/util/Macros.h" _eigen_version_header) +string(REGEX MATCH "define[ \t]+EIGEN_WORLD_VERSION[ \t]+([0-9]+)" _eigen_world_version_match "${_eigen_version_header}") +set(EIGEN_WORLD_VERSION "${CMAKE_MATCH_1}") +string(REGEX MATCH "define[ \t]+EIGEN_MAJOR_VERSION[ \t]+([0-9]+)" _eigen_major_version_match "${_eigen_version_header}") +set(EIGEN_MAJOR_VERSION "${CMAKE_MATCH_1}") +string(REGEX MATCH "define[ \t]+EIGEN_MINOR_VERSION[ \t]+([0-9]+)" _eigen_minor_version_match "${_eigen_version_header}") +set(EIGEN_MINOR_VERSION "${CMAKE_MATCH_1}") +set(EIGEN_VERSION_NUMBER ${EIGEN_WORLD_VERSION}.${EIGEN_MAJOR_VERSION}.${EIGEN_MINOR_VERSION}) # if the mercurial program is absent, this will leave the EIGEN_HG_CHANGESET string empty, # but won't stop CMake. @@ -117,14 +117,14 @@ option(EIGEN_TEST_RVALUE_REF_SUPPORT "Enable rvalue references for unit tests." include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}) set(INCLUDE_INSTALL_DIR - "${CMAKE_INSTALL_PREFIX}/include/eigen2" + "${CMAKE_INSTALL_PREFIX}/include/eigen3" CACHE PATH "The directory where we install the header files" ) if(EIGEN_BUILD_PKGCONFIG) - configure_file(eigen2.pc.in eigen2.pc) - install(FILES ${CMAKE_CURRENT_BINARY_DIR}/eigen2.pc + configure_file(eigen3.pc.in eigen3.pc) + install(FILES ${CMAKE_CURRENT_BINARY_DIR}/eigen3.pc DESTINATION share/pkgconfig ) endif(EIGEN_BUILD_PKGCONFIG) diff --git a/Eigen/src/Core/util/Macros.h b/Eigen/src/Core/util/Macros.h index a94300de3..a51b46f02 100644 --- a/Eigen/src/Core/util/Macros.h +++ b/Eigen/src/Core/util/Macros.h @@ -29,8 +29,8 @@ #undef minor #define EIGEN_WORLD_VERSION 2 -#define EIGEN_MAJOR_VERSION 90 -#define EIGEN_MINOR_VERSION 1 +#define EIGEN_MAJOR_VERSION 91 +#define EIGEN_MINOR_VERSION 0 #define EIGEN_VERSION_AT_LEAST(x,y,z) (EIGEN_WORLD_VERSION>x || (EIGEN_WORLD_VERSION>=x && \ (EIGEN_MAJOR_VERSION>y || (EIGEN_MAJOR_VERSION>=y && \ diff --git a/cmake/FindEigen3.cmake b/cmake/FindEigen3.cmake new file mode 100644 index 000000000..610df8023 --- /dev/null +++ b/cmake/FindEigen3.cmake @@ -0,0 +1,80 @@ +# - Try to find Eigen3 lib +# +# This module supports requiring a minimum version, e.g. you can do +# find_package(Eigen3 3.1.2) +# to require version 3.1.2 or newer of Eigen3. +# +# Once done this will define +# +# EIGEN3_FOUND - system has eigen lib with correct version +# EIGEN3_INCLUDE_DIR - the eigen include directory +# EIGEN3_VERSION - eigen version + +# Copyright (c) 2006, 2007 Montel Laurent, +# Copyright (c) 2008, 2009 Gael Guennebaud, +# Redistribution and use is allowed according to the terms of the BSD license. + +if(NOT Eigen3_FIND_VERSION) + if(NOT Eigen3_FIND_VERSION_MAJOR) + set(Eigen3_FIND_VERSION_MAJOR 2) + endif(NOT Eigen3_FIND_VERSION_MAJOR) + if(NOT Eigen3_FIND_VERSION_MINOR) + set(Eigen3_FIND_VERSION_MINOR 91) + endif(NOT Eigen3_FIND_VERSION_MINOR) + if(NOT Eigen3_FIND_VERSION_PATCH) + set(Eigen3_FIND_VERSION_PATCH 0) + endif(NOT Eigen3_FIND_VERSION_PATCH) + + set(Eigen3_FIND_VERSION "${Eigen3_FIND_VERSION_MAJOR}.${Eigen3_FIND_VERSION_MINOR}.${Eigen3_FIND_VERSION_PATCH}") +endif(NOT Eigen3_FIND_VERSION) + +macro(_eigen3_check_version) + file(READ "${EIGEN3_INCLUDE_DIR}/Eigen/src/Core/util/Macros.h" _eigen3_version_header LIMIT 5000 OFFSET 1000) + + string(REGEX MATCH "define *EIGEN_WORLD_VERSION ([0-9]*)" _eigen3_world_version_match "${_eigen3_version_header}") + set(EIGEN3_WORLD_VERSION "${CMAKE_MATCH_1}") + string(REGEX MATCH "define *EIGEN_MAJOR_VERSION ([0-9]*)" _eigen3_major_version_match "${_eigen3_version_header}") + set(EIGEN3_MAJOR_VERSION "${CMAKE_MATCH_1}") + string(REGEX MATCH "define *EIGEN_MINOR_VERSION ([0-9]*)" _eigen3_minor_version_match "${_eigen3_version_header}") + set(EIGEN3_MINOR_VERSION "${CMAKE_MATCH_1}") + + set(EIGEN3_VERSION ${EIGEN3_WORLD_VERSION}.${EIGEN3_MAJOR_VERSION}.${EIGEN3_MINOR_VERSION}) + if(${EIGEN3_VERSION} VERSION_LESS ${Eigen3_FIND_VERSION}) + set(EIGEN3_VERSION_OK FALSE) + else(${EIGEN3_VERSION} VERSION_LESS ${Eigen3_FIND_VERSION}) + set(EIGEN3_VERSION_OK TRUE) + endif(${EIGEN3_VERSION} VERSION_LESS ${Eigen3_FIND_VERSION}) + + if(NOT EIGEN3_VERSION_OK) + + message(STATUS "Eigen3 version ${EIGEN3_VERSION} found in ${EIGEN3_INCLUDE_DIR}, " + "but at least version ${Eigen3_FIND_VERSION} is required") + endif(NOT EIGEN3_VERSION_OK) +endmacro(_eigen3_check_version) + +if (EIGEN3_INCLUDE_DIR) + + # in cache already + _eigen3_check_version() + set(EIGEN3_FOUND ${EIGEN3_VERSION_OK}) + +else (EIGEN3_INCLUDE_DIR) + + find_path(EIGEN3_INCLUDE_DIR NAMES Eigen/Core + PATHS + ${INCLUDE_INSTALL_DIR} + ${KDE4_INCLUDE_DIR} + PATH_SUFFIXES eigen3 + ) + + if(EIGEN3_INCLUDE_DIR) + _eigen3_check_version() + endif(EIGEN3_INCLUDE_DIR) + + include(FindPackageHandleStandardArgs) + find_package_handle_standard_args(Eigen3 DEFAULT_MSG EIGEN3_INCLUDE_DIR EIGEN3_VERSION_OK) + + mark_as_advanced(EIGEN3_INCLUDE_DIR) + +endif(EIGEN3_INCLUDE_DIR) + diff --git a/doc/C01_QuickStartGuide.dox b/doc/C01_QuickStartGuide.dox index 06b2595e7..0c545f735 100644 --- a/doc/C01_QuickStartGuide.dox +++ b/doc/C01_QuickStartGuide.dox @@ -36,7 +36,7 @@ In order to use Eigen, you just need to download and extract Eigen's source code Here are some quick compilation instructions with GCC. To quickly test an example program, just do -\code g++ -I /path/to/eigen2/ my_program.cpp -o my_program \endcode +\code g++ -I /path/to/eigen/ my_program.cpp -o my_program \endcode There is no library to link to. For good performance, add the \c -O2 compile-flag. Note however that this makes it impossible to debug inside Eigen code, as many functions get inlined. In some cases, performance can be further improved by disabling Eigen assertions: use \c -DEIGEN_NO_DEBUG or \c -DNDEBUG to disable them. diff --git a/doc/D11_UnalignedArrayAssert.dox b/doc/D11_UnalignedArrayAssert.dox index 226b20452..f4da15236 100644 --- a/doc/D11_UnalignedArrayAssert.dox +++ b/doc/D11_UnalignedArrayAssert.dox @@ -4,7 +4,7 @@ namespace Eigen { Hello! You are seeing this webpage because your program terminated on an assertion failure like this one: 
-my_program: path/to/eigen2/Eigen/src/Core/MatrixStorage.h:44:
+my_program: path/to/eigen/Eigen/src/Core/MatrixStorage.h:44:
 Eigen::ei_matrix_array::ei_matrix_array()
 [with T = double, int Size = 2, int MatrixOptions = 2, bool Align = true]:
 Assertion `(reinterpret_cast(array) & 0xf) == 0 && "this assertion
diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in
index 82ebf6aa0..7f5b26a61 100644
--- a/doc/Doxyfile.in
+++ b/doc/Doxyfile.in
@@ -1,11 +1,3 @@
-################################################################################
-##                                                                            ##
-##                                  WARNING                                   ##
-##                                                                            ##
-##  all modifications in this file must be reported in eigen2/Mainpage.dox    ##
-##                                                                            ##
-################################################################################
-
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project
 #
diff --git a/doc/I00_CustomizingEigen.dox b/doc/I00_CustomizingEigen.dox
index 7c8ba9b75..ede6f23b7 100644
--- a/doc/I00_CustomizingEigen.dox
+++ b/doc/I00_CustomizingEigen.dox
@@ -2,7 +2,7 @@ namespace Eigen {
 
 /** \page CustomizingEigen Advanced - Customizing/Extending Eigen
 
-Eigen2 can be extended in several ways, for instance, by defining global methods, \ref ExtendingMatrixBase "by adding custom methods to MatrixBase", adding support to \ref CustomScalarType "custom types" etc.
+Eigen can be extended in several ways, for instance, by defining global methods, \ref ExtendingMatrixBase "by adding custom methods to MatrixBase", adding support to \ref CustomScalarType "custom types" etc.
 
 \b Table \b of \b contents
   - \ref ExtendingMatrixBase
diff --git a/eigen2.pc.in b/eigen2.pc.in
deleted file mode 100644
index b508a58d3..000000000
--- a/eigen2.pc.in
+++ /dev/null
@@ -1,7 +0,0 @@
-
-Name: Eigen2
-Description: A C++ template library for linear algebra: vectors, matrices, and related algorithms
-Requires:
-Version: ${EIGEN_VERSION_NUMBER}
-Libs:
-Cflags: -I${INCLUDE_INSTALL_DIR}
diff --git a/eigen3.pc.in b/eigen3.pc.in
new file mode 100644
index 000000000..c5855de33
--- /dev/null
+++ b/eigen3.pc.in
@@ -0,0 +1,6 @@
+Name: Eigen3
+Description: A C++ template library for linear algebra: vectors, matrices, and related algorithms
+Requires:
+Version: ${EIGEN_VERSION_NUMBER}
+Libs:
+Cflags: -I${INCLUDE_INSTALL_DIR}
diff --git a/scripts/eigen_gen_credits b/scripts/eigen_gen_credits
index c67416784..83ca8da12 100755
--- a/scripts/eigen_gen_credits
+++ b/scripts/eigen_gen_credits
@@ -1,10 +1,10 @@
 #!/bin/sh
 
-# this script must be run from the eigen2/ directory.
+# this script must be run from the eigen/ directory.
 # when running hg churn from the scripts/ subdir, i hit a divide-by-zero error.
 #
 # like this:
-#   cd eigen2
+#   cd eigen
 #   USER=yourtuxfamilyuser scripts/eigen_gen_credits
 
 rm -f eigen_gen_credits.log
diff --git a/test/testsuite.cmake b/test/testsuite.cmake
index 9c38e48b1..90edf2853 100644
--- a/test/testsuite.cmake
+++ b/test/testsuite.cmake
@@ -4,7 +4,7 @@
 # Usage:
 #  - create a new folder, let's call it cdash
 #  - in that folder, do:
-#    ctest -S path/to/eigen2/test/testsuite.cmake[,option1=value1[,option2=value2]]
+#    ctest -S path/to/eigen/test/testsuite.cmake[,option1=value1[,option2=value2]]
 #
 # Options:
 #  - EIGEN_CXX: compiler, eg.: g++-4.2
@@ -44,9 +44,9 @@
 # ARCH=`uname -m`
 # SITE=`hostname`
 # VERSION=opensuse-11.1
-# WORK_DIR=/home/gael/Coding/eigen2/cdash
+# WORK_DIR=/home/gael/Coding/eigen/cdash
 # # get the last version of the script
-# wget http://bitbucket.org/eigen/eigen2/raw/tip/test/testsuite.cmake -o $WORK_DIR/testsuite.cmake
+# wget http://bitbucket.org/eigen/eigen/raw/tip/test/testsuite.cmake -o $WORK_DIR/testsuite.cmake
 # COMMON="ctest -S $WORK_DIR/testsuite.cmake,EIGEN_WORK_DIR=$WORK_DIR,EIGEN_SITE=$SITE,EIGEN_MODE=$1,EIGEN_BUILD_STRING=$OS_VERSION-$ARCH"
 # $COMMON-gcc-3.4.6,EIGEN_CXX=g++-3.4
 # $COMMON-gcc-4.0.1,EIGEN_CXX=g++-4.0.1
@@ -141,7 +141,7 @@ endif(NOT EIGEN_MODE)
 
 if(NOT EIGEN_NO_UPDATE)
   SET (CTEST_CVS_COMMAND "hg")
-  SET (CTEST_CVS_CHECKOUT "${CTEST_CVS_COMMAND} clone http://bitbucket.org/eigen/eigen2 \"${CTEST_SOURCE_DIRECTORY}\"")
+  SET (CTEST_CVS_CHECKOUT "${CTEST_CVS_COMMAND} clone http://bitbucket.org/eigen/eigen \"${CTEST_SOURCE_DIRECTORY}\"")
   SET(CTEST_BACKUP_AND_RESTORE TRUE) # the backup is CVS related ...
 endif(NOT EIGEN_NO_UPDATE)
 
diff --git a/unsupported/README.txt b/unsupported/README.txt
index ed1341426..83479ff0b 100644
--- a/unsupported/README.txt
+++ b/unsupported/README.txt
@@ -4,7 +4,7 @@ most of them are subject to be included in Eigen in the future.
 
 In order to use an unsupported module you have to do either:
 
- - add the path_to_eigen2/unsupported directory to your include path and do:
+ - add the path_to_eigen/unsupported directory to your include path and do:
    #include 
 
  - or directly do:
diff --git a/unsupported/doc/Doxyfile.in b/unsupported/doc/Doxyfile.in
index 269595820..a9c7d6004 100644
--- a/unsupported/doc/Doxyfile.in
+++ b/unsupported/doc/Doxyfile.in
@@ -1,11 +1,3 @@
-################################################################################
-##                                                                            ##
-##                                  WARNING                                   ##
-##                                                                            ##
-##  all modifications in this file must be reported in eigen2/Mainpage.dox    ##
-##                                                                            ##
-################################################################################
-
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project
 #
-- 
cgit v1.2.3


From a20a744adc5414f9a79ae0637de9c3227c3dd420 Mon Sep 17 00:00:00 2001
From: Benoit Jacob 
Date: Thu, 19 Nov 2009 17:07:55 -0500
Subject: TriangularMatrix: extend to rectangular matrices

---
 Eigen/src/Core/TriangularMatrix.h |  93 ++++++++++---------
 test/triangular.cpp               | 183 +++++++++++++++++++++++++++++---------
 2 files changed, 193 insertions(+), 83 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/TriangularMatrix.h b/Eigen/src/Core/TriangularMatrix.h
index e60d57e70..ed26683ea 100644
--- a/Eigen/src/Core/TriangularMatrix.h
+++ b/Eigen/src/Core/TriangularMatrix.h
@@ -26,22 +26,11 @@
 #ifndef EIGEN_TRIANGULARMATRIX_H
 #define EIGEN_TRIANGULARMATRIX_H
 
-/** \nonstableyet
-  * \class TriangularBase
-  *
-  * \brief Expression of a triangular matrix extracted from a given matrix
-  *
-  * \param MatrixType the type of the object in which we are taking the triangular part
-  * \param Mode the kind of triangular matrix expression to construct. Can be UpperTriangular,
-  *             LowerTriangular, UpperSelfadjoint, or LowerSelfadjoint. This is in fact a bit field;
-  *             it must have either UpperBit or LowerBit, and additionnaly it may have either
-  *             TraingularBit or SelfadjointBit.
+/** \internal
   *
-  * This class represents an expression of the upper or lower triangular part of
-  * a square matrix, possibly with a further assumption on the diagonal. It is the return type
-  * of MatrixBase::part() and most of the time this is the only way it is used.
+  * \class TriangularBase
   *
-  * \sa MatrixBase::part()
+  * \brief Base class for triangular part in a matrix
   */
 template class TriangularBase : public AnyMatrixBase
 {
@@ -115,19 +104,21 @@ template class TriangularBase : public AnyMatrixBase
 
 };
 
-
 /** \class TriangularView
-  * \nonstableyet
   *
-  * \brief Expression of a triangular part of a dense matrix
+  * \brief Base class for triangular part in a matrix
   *
-  * \param MatrixType the type of the dense matrix storing the coefficients
+  * \param MatrixType the type of the object in which we are taking the triangular part
+  * \param Mode the kind of triangular matrix expression to construct. Can be UpperTriangular,
+  *             LowerTriangular, UpperSelfadjoint, or LowerSelfadjoint. This is in fact a bit field;
+  *             it must have either UpperBit or LowerBit, and additionnaly it may have either
+  *             TraingularBit or SelfadjointBit.
   *
-  * This class is an expression of a triangular part of a matrix with given dense
-  * storage of the coefficients. It is the return type of MatrixBase::triangularPart()
-  * and most of the time this is the only way that it is used.
+  * This class represents a triangular part of a matrix, not necessarily square. Strictly speaking, for rectangular
+  * matrices one should speak ok "trapezoid" parts. This class is the return type
+  * of MatrixBase::triangularView() and most of the time this is the only way it is used.
   *
-  * \sa class TriangularBase, MatrixBase::triangularPart(), class DiagonalWrapper
+  * \sa MatrixBase::triangularView()
   */
 template
 struct ei_traits > : ei_traits
@@ -155,7 +146,7 @@ template class TriangularView
     typedef TriangularBase Base;
     typedef typename ei_traits::Scalar Scalar;
     typedef _MatrixType MatrixType;
-    typedef typename MatrixType::PlainMatrixType PlainMatrixType;
+    typedef typename MatrixType::PlainMatrixType DenseMatrixType;
     typedef typename MatrixType::Nested MatrixTypeNested;
     typedef typename ei_cleantype::type _MatrixTypeNested;
 
@@ -244,9 +235,9 @@ template class TriangularView
     inline const TriangularView >,TransposeMode> transpose() const
     { return m_matrix.transpose().nestByValue(); }
 
-    PlainMatrixType toDense() const
+    DenseMatrixType toDenseMatrix() const
     {
-      PlainMatrixType res(rows(), cols());
+      DenseMatrixType res(rows(), cols());
       res = *this;
       return res;
     }
@@ -351,6 +342,7 @@ struct ei_triangular_assignment_selector
     }
   }
 };
+
 template
 struct ei_triangular_assignment_selector
 {
@@ -365,6 +357,7 @@ struct ei_triangular_assignment_selector
 struct ei_triangular_assignment_selector
@@ -379,14 +372,16 @@ struct ei_triangular_assignment_selector
 struct ei_triangular_assignment_selector
 {
@@ -396,8 +391,9 @@ struct ei_triangular_assignment_selector
 struct ei_triangular_assignment_selector
 {
@@ -427,8 +425,9 @@ struct ei_triangular_assignment_selector::operator=(const TriangularBase&
   ei_assert(Mode == OtherDerived::Mode);
   if(ei_traits::Flags & EvalBeforeAssigningBit)
   {
-    typename OtherDerived::PlainMatrixType other_evaluated(other.rows(), other.cols());
+    typename OtherDerived::DenseMatrixType other_evaluated(other.rows(), other.cols());
     other_evaluated.template triangularView().lazyAssign(other.derived());
     lazyAssign(other_evaluated);
   }
@@ -633,17 +634,20 @@ const TriangularView MatrixBase::triangularView() const
 template
 bool MatrixBase::isUpperTriangular(RealScalar prec) const
 {
-  if(cols() != rows()) return false;
   RealScalar maxAbsOnUpperTriangularPart = static_cast(-1);
   for(int j = 0; j < cols(); ++j)
-    for(int i = 0; i <= j; ++i)
+  {
+    int maxi = std::min(j, rows()-1);
+    for(int i = 0; i <= maxi; ++i)
     {
       RealScalar absValue = ei_abs(coeff(i,j));
       if(absValue > maxAbsOnUpperTriangularPart) maxAbsOnUpperTriangularPart = absValue;
     }
-  for(int j = 0; j < cols()-1; ++j)
+  }
+  RealScalar threshold = maxAbsOnUpperTriangularPart * prec;
+  for(int j = 0; j < cols(); ++j)
     for(int i = j+1; i < rows(); ++i)
-      if(!ei_isMuchSmallerThan(coeff(i, j), maxAbsOnUpperTriangularPart, prec)) return false;
+      if(ei_abs(coeff(i, j)) > threshold) return false;
   return true;
 }
 
@@ -655,7 +659,6 @@ bool MatrixBase::isUpperTriangular(RealScalar prec) const
 template
 bool MatrixBase::isLowerTriangular(RealScalar prec) const
 {
-  if(cols() != rows()) return false;
   RealScalar maxAbsOnLowerTriangularPart = static_cast(-1);
   for(int j = 0; j < cols(); ++j)
     for(int i = j; i < rows(); ++i)
@@ -663,9 +666,13 @@ bool MatrixBase::isLowerTriangular(RealScalar prec) const
       RealScalar absValue = ei_abs(coeff(i,j));
       if(absValue > maxAbsOnLowerTriangularPart) maxAbsOnLowerTriangularPart = absValue;
     }
+  RealScalar threshold = maxAbsOnLowerTriangularPart * prec;
   for(int j = 1; j < cols(); ++j)
-    for(int i = 0; i < j; ++i)
-      if(!ei_isMuchSmallerThan(coeff(i, j), maxAbsOnLowerTriangularPart, prec)) return false;
+  {
+    int maxi = std::min(j, rows()-1);
+    for(int i = 0; i < maxi; ++i)
+      if(ei_abs(coeff(i, j)) > threshold) return false;
+  }
   return true;
 }
 
diff --git a/test/triangular.cpp b/test/triangular.cpp
index ee02c0022..3c89a8abb 100644
--- a/test/triangular.cpp
+++ b/test/triangular.cpp
@@ -24,7 +24,9 @@
 
 #include "main.h"
 
-template void triangular(const MatrixType& m)
+
+
+template void triangular_square(const MatrixType& m)
 {
   typedef typename MatrixType::Scalar Scalar;
   typedef typename NumTraits::Real RealScalar;
@@ -51,8 +53,8 @@ template void triangular(const MatrixType& m)
              v2 = VectorType::Random(rows),
              vzero = VectorType::Zero(rows);
 
-  MatrixType m1up = m1.template triangularView();
-  MatrixType m2up = m2.template triangularView();
+  MatrixType m1up = m1.template triangularView();
+  MatrixType m2up = m2.template triangularView();
 
   if (rows*cols>1)
   {
@@ -66,20 +68,20 @@ template void triangular(const MatrixType& m)
   // test overloaded operator+=
   r1.setZero();
   r2.setZero();
-  r1.template triangularView() +=  m1;
+  r1.template triangularView() +=  m1;
   r2 += m1up;
   VERIFY_IS_APPROX(r1,r2);
 
   // test overloaded operator=
   m1.setZero();
-  m1.template triangularView() = m2.transpose() + m2;
+  m1.template triangularView() = m2.transpose() + m2;
   m3 = m2.transpose() + m2;
-  VERIFY_IS_APPROX(m3.template triangularView().transpose().toDense(), m1);
+  VERIFY_IS_APPROX(m3.template triangularView().transpose().toDenseMatrix(), m1);
 
   // test overloaded operator=
   m1.setZero();
-  m1.template triangularView() = m2.transpose() + m2;
-  VERIFY_IS_APPROX(m3.template triangularView().toDense(), m1);
+  m1.template triangularView() = m2.transpose() + m2;
+  VERIFY_IS_APPROX(m3.template triangularView().toDenseMatrix(), m1);
 
   m1 = MatrixType::Random(rows, cols);
   for (int i=0; i void triangular(const MatrixType& m)
 
   Transpose trm4(m4);
   // test back and forward subsitution with a vector as the rhs
-  m3 = m1.template triangularView();
-  VERIFY(v2.isApprox(m3.adjoint() * (m1.adjoint().template triangularView().solve(v2)), largerEps));
-  m3 = m1.template triangularView();
-  VERIFY(v2.isApprox(m3.transpose() * (m1.transpose().template triangularView().solve(v2)), largerEps));
-  m3 = m1.template triangularView();
-  VERIFY(v2.isApprox(m3 * (m1.template triangularView().solve(v2)), largerEps));
-  m3 = m1.template triangularView();
-  VERIFY(v2.isApprox(m3.conjugate() * (m1.conjugate().template triangularView().solve(v2)), largerEps));
+  m3 = m1.template triangularView();
+  VERIFY(v2.isApprox(m3.adjoint() * (m1.adjoint().template triangularView().solve(v2)), largerEps));
+  m3 = m1.template triangularView();
+  VERIFY(v2.isApprox(m3.transpose() * (m1.transpose().template triangularView().solve(v2)), largerEps));
+  m3 = m1.template triangularView();
+  VERIFY(v2.isApprox(m3 * (m1.template triangularView().solve(v2)), largerEps));
+  m3 = m1.template triangularView();
+  VERIFY(v2.isApprox(m3.conjugate() * (m1.conjugate().template triangularView().solve(v2)), largerEps));
 
   // test back and forward subsitution with a matrix as the rhs
-  m3 = m1.template triangularView();
-  VERIFY(m2.isApprox(m3.adjoint() * (m1.adjoint().template triangularView().solve(m2)), largerEps));
-  m3 = m1.template triangularView();
-  VERIFY(m2.isApprox(m3.transpose() * (m1.transpose().template triangularView().solve(m2)), largerEps));
-  m3 = m1.template triangularView();
-  VERIFY(m2.isApprox(m3 * (m1.template triangularView().solve(m2)), largerEps));
-  m3 = m1.template triangularView();
-  VERIFY(m2.isApprox(m3.conjugate() * (m1.conjugate().template triangularView().solve(m2)), largerEps));
+  m3 = m1.template triangularView();
+  VERIFY(m2.isApprox(m3.adjoint() * (m1.adjoint().template triangularView().solve(m2)), largerEps));
+  m3 = m1.template triangularView();
+  VERIFY(m2.isApprox(m3.transpose() * (m1.transpose().template triangularView().solve(m2)), largerEps));
+  m3 = m1.template triangularView();
+  VERIFY(m2.isApprox(m3 * (m1.template triangularView().solve(m2)), largerEps));
+  m3 = m1.template triangularView();
+  VERIFY(m2.isApprox(m3.conjugate() * (m1.conjugate().template triangularView().solve(m2)), largerEps));
 
   // check M * inv(L) using in place API
   m4 = m3;
-  m3.transpose().template triangularView().solveInPlace(trm4);
+  m3.transpose().template triangularView().solveInPlace(trm4);
   VERIFY(m4.cwise().abs().isIdentity(test_precision()));
 
   // check M * inv(U) using in place API
-  m3 = m1.template triangularView();
+  m3 = m1.template triangularView();
   m4 = m3;
-  m3.transpose().template triangularView().solveInPlace(trm4);
+  m3.transpose().template triangularView().solveInPlace(trm4);
   VERIFY(m4.cwise().abs().isIdentity(test_precision()));
 
   // check solve with unit diagonal
-  m3 = m1.template triangularView();
-  VERIFY(m2.isApprox(m3 * (m1.template triangularView().solve(m2)), largerEps));
+  m3 = m1.template triangularView();
+  VERIFY(m2.isApprox(m3 * (m1.template triangularView().solve(m2)), largerEps));
+
+//   VERIFY((  m1.template triangularView()
+//           * m2.template triangularView()).isUpperTriangular());
+
+  // test swap
+  m1.setOnes();
+  m2.setZero();
+  m2.template triangularView().swap(m1);
+  m3.setZero();
+  m3.template triangularView().setOnes();
+  VERIFY_IS_APPROX(m2,m3);
+
+}
+
+
+template void triangular_rect(const MatrixType& m)
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits::Real RealScalar;
+  typedef Matrix VectorType;
+
+  int rows = m.rows();
+  int cols = m.cols();
+
+  MatrixType m1 = MatrixType::Random(rows, cols),
+             m2 = MatrixType::Random(rows, cols),
+             m3(rows, cols),
+             m4(rows, cols),
+             r1(rows, cols),
+             r2(rows, cols),
+             mzero = MatrixType::Zero(rows, cols),
+             mones = MatrixType::Ones(rows, cols),
+             identity = Matrix
+                              ::Identity(rows, rows),
+             square = Matrix
+                              ::Random(rows, rows);
+  VectorType v1 = VectorType::Random(rows),
+             v2 = VectorType::Random(rows),
+             vzero = VectorType::Zero(rows);
+
+  MatrixType m1up = m1.template triangularView();
+  MatrixType m2up = m2.template triangularView();
+
+  if (rows*cols>1)
+  {
+    VERIFY(m1up.isUpperTriangular());
+    VERIFY(m2up.transpose().isLowerTriangular());
+    VERIFY(!m2.isLowerTriangular());
+  }
+
+//   VERIFY_IS_APPROX(m1up.transpose() * m2, m1.upper().transpose().lower() * m2);
 
-//   VERIFY((  m1.template triangularView()
-//           * m2.template triangularView()).isUpperTriangular());
+  // test overloaded operator+=
+  r1.setZero();
+  r2.setZero();
+  r1.template triangularView() +=  m1;
+  r2 += m1up;
+  VERIFY_IS_APPROX(r1,r2);
 
+  // test overloaded operator=
+  m1.setZero();
+  m1.template triangularView() = 3 * m2;
+  m3 = 3 * m2;
+  VERIFY_IS_APPROX(m3.template triangularView().toDenseMatrix(), m1);
+
+  m1.setZero();
+  m1.template triangularView() = 3 * m2;
+  VERIFY_IS_APPROX(m3.template triangularView().toDenseMatrix(), m1);
+
+  m1.setZero();
+  m1.template triangularView() = 3 * m2;
+  VERIFY_IS_APPROX(m3.template triangularView().toDenseMatrix(), m1);
+
+  m1.setZero();
+  m1.template triangularView() = 3 * m2;
+  VERIFY_IS_APPROX(m3.template triangularView().toDenseMatrix(), m1);
+
+  m1.setRandom();
+  m2 = m1.template triangularView();
+  VERIFY(m2.isUpperTriangular());
+  VERIFY(!m2.isLowerTriangular());
+  m2 = m1.template triangularView();
+  VERIFY(m2.isUpperTriangular());
+  VERIFY(m2.diagonal().isMuchSmallerThan(RealScalar(1)));
+  m2 = m1.template triangularView();
+  VERIFY(m2.isUpperTriangular());
+  m2.diagonal().cwise() -= Scalar(1);
+  VERIFY(m2.diagonal().isMuchSmallerThan(RealScalar(1)));
+  m2 = m1.template triangularView();
+  VERIFY(m2.isLowerTriangular());
+  VERIFY(!m2.isUpperTriangular());
+  m2 = m1.template triangularView();
+  VERIFY(m2.isLowerTriangular());
+  VERIFY(m2.diagonal().isMuchSmallerThan(RealScalar(1)));
+  m2 = m1.template triangularView();
+  VERIFY(m2.isLowerTriangular());
+  m2.diagonal().cwise() -= Scalar(1);
+  VERIFY(m2.diagonal().isMuchSmallerThan(RealScalar(1)));
   // test swap
   m1.setOnes();
   m2.setZero();
-  m2.template triangularView().swap(m1);
+  m2.template triangularView().swap(m1);
   m3.setZero();
-  m3.template triangularView().setOnes();
+  m3.template triangularView().setOnes();
   VERIFY_IS_APPROX(m2,m3);
 
 }
@@ -137,12 +233,19 @@ template void triangular(const MatrixType& m)
 void test_triangular()
 {
   for(int i = 0; i < g_repeat ; i++) {
-    CALL_SUBTEST_1( triangular(Matrix()) );
-    CALL_SUBTEST_2( triangular(Matrix()) );
-    CALL_SUBTEST_3( triangular(Matrix3d()) );
-    CALL_SUBTEST_4( triangular(MatrixXcf(4, 4)) );
-    CALL_SUBTEST_5( triangular(Matrix,8, 8>()) );
-    CALL_SUBTEST_6( triangular(MatrixXcd(17,17)) );
-    CALL_SUBTEST_7( triangular(Matrix(5, 5)) );
+    CALL_SUBTEST_1( triangular_square(Matrix()) );
+    CALL_SUBTEST_2( triangular_square(Matrix()) );
+    CALL_SUBTEST_3( triangular_square(Matrix3d()) );
+    CALL_SUBTEST_4( triangular_square(MatrixXcf(4, 4)) );
+    CALL_SUBTEST_5( triangular_square(Matrix,8, 8>()) );
+    CALL_SUBTEST_6( triangular_square(MatrixXcd(17,17)) );
+    CALL_SUBTEST_7( triangular_square(Matrix(5, 5)) );
+
+    CALL_SUBTEST_8( triangular_rect(Matrix()) );
+    CALL_SUBTEST_9( triangular_rect(Matrix()) );
+    CALL_SUBTEST_4( triangular_rect(MatrixXcf(4, 10)) );
+    CALL_SUBTEST_6( triangular_rect(MatrixXcd(11, 3)) );
+    CALL_SUBTEST_7( triangular_rect(Matrix(7, 6)) );
+
   }
 }
-- 
cgit v1.2.3


From 88b551e89bd34367c12f0ba540ee1134c6897ba1 Mon Sep 17 00:00:00 2001
From: Benoit Jacob 
Date: Thu, 19 Nov 2009 19:20:19 -0500
Subject: * fix compilation of unit-tests (sorry, had tested only 1 channel) *
 remove buggy (superfluous?) specialization in the meta-unroller

---
 Eigen/src/Core/TriangularMatrix.h | 15 ---------------
 test/triangular.cpp               | 28 +++++++++++++++++-----------
 2 files changed, 17 insertions(+), 26 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/TriangularMatrix.h b/Eigen/src/Core/TriangularMatrix.h
index ed26683ea..34b029421 100644
--- a/Eigen/src/Core/TriangularMatrix.h
+++ b/Eigen/src/Core/TriangularMatrix.h
@@ -343,21 +343,6 @@ struct ei_triangular_assignment_selector
   }
 };
 
-template
-struct ei_triangular_assignment_selector
-{
-  inline static void run(Derived1 &dst, const Derived2 &src)
-  {
-    if(Mode&UnitDiagBit)
-    {
-      if(ClearOpposite)
-        dst.coeffRef(0, 0) = 1;
-    }
-    else if(!(Mode & ZeroDiagBit))
-      dst.copyCoeff(0, 0, src);
-  }
-};
-
 // prevent buggy user code from causing an infinite recursion
 template
 struct ei_triangular_assignment_selector
diff --git a/test/triangular.cpp b/test/triangular.cpp
index 3c89a8abb..a10b457a7 100644
--- a/test/triangular.cpp
+++ b/test/triangular.cpp
@@ -141,7 +141,10 @@ template void triangular_rect(const MatrixType& m)
 {
   typedef typename MatrixType::Scalar Scalar;
   typedef typename NumTraits::Real RealScalar;
-  typedef Matrix VectorType;
+  enum { Rows =  MatrixType::RowsAtCompileTime, Cols =  MatrixType::ColsAtCompileTime };
+  typedef Matrix VectorType;
+  typedef Matrix RMatrixType;
+  
 
   int rows = m.rows();
   int cols = m.cols();
@@ -153,10 +156,10 @@ template void triangular_rect(const MatrixType& m)
              r1(rows, cols),
              r2(rows, cols),
              mzero = MatrixType::Zero(rows, cols),
-             mones = MatrixType::Ones(rows, cols),
-             identity = Matrix
+             mones = MatrixType::Ones(rows, cols);
+  RMatrixType identity = Matrix
                               ::Identity(rows, rows),
-             square = Matrix
+              square = Matrix
                               ::Random(rows, rows);
   VectorType v1 = VectorType::Random(rows),
              v2 = VectorType::Random(rows),
@@ -172,8 +175,6 @@ template void triangular_rect(const MatrixType& m)
     VERIFY(!m2.isLowerTriangular());
   }
 
-//   VERIFY_IS_APPROX(m1up.transpose() * m2, m1.upper().transpose().lower() * m2);
-
   // test overloaded operator+=
   r1.setZero();
   r2.setZero();
@@ -227,25 +228,30 @@ template void triangular_rect(const MatrixType& m)
   m3.setZero();
   m3.template triangularView().setOnes();
   VERIFY_IS_APPROX(m2,m3);
-
 }
 
 void test_triangular()
 {
-  for(int i = 0; i < g_repeat ; i++) {
+  for(int i = 0; i < g_repeat ; i++)
+  {
+
+#ifdef EIGEN_TEST_PART_7
+    int r = ei_random(2,20);
+    int c = ei_random(2,20);
+#endif
+
     CALL_SUBTEST_1( triangular_square(Matrix()) );
     CALL_SUBTEST_2( triangular_square(Matrix()) );
     CALL_SUBTEST_3( triangular_square(Matrix3d()) );
     CALL_SUBTEST_4( triangular_square(MatrixXcf(4, 4)) );
     CALL_SUBTEST_5( triangular_square(Matrix,8, 8>()) );
     CALL_SUBTEST_6( triangular_square(MatrixXcd(17,17)) );
-    CALL_SUBTEST_7( triangular_square(Matrix(5, 5)) );
+    CALL_SUBTEST_7( triangular_square(Matrix(r, r)) );
 
     CALL_SUBTEST_8( triangular_rect(Matrix()) );
     CALL_SUBTEST_9( triangular_rect(Matrix()) );
     CALL_SUBTEST_4( triangular_rect(MatrixXcf(4, 10)) );
     CALL_SUBTEST_6( triangular_rect(MatrixXcd(11, 3)) );
-    CALL_SUBTEST_7( triangular_rect(Matrix(7, 6)) );
-
+    CALL_SUBTEST_7( triangular_rect(Matrix(r, c)) );
   }
 }
-- 
cgit v1.2.3


From eac3232095baf7c69e8ff7a6b636ffcf03db156b Mon Sep 17 00:00:00 2001
From: Benoit Jacob 
Date: Thu, 19 Nov 2009 20:50:50 -0500
Subject: minor improvements in triangular stuff

---
 Eigen/src/Core/TriangularMatrix.h | 2 +-
 test/triangular.cpp               | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/TriangularMatrix.h b/Eigen/src/Core/TriangularMatrix.h
index 34b029421..1286bf6a6 100644
--- a/Eigen/src/Core/TriangularMatrix.h
+++ b/Eigen/src/Core/TriangularMatrix.h
@@ -238,7 +238,7 @@ template class TriangularView
     DenseMatrixType toDenseMatrix() const
     {
       DenseMatrixType res(rows(), cols());
-      res = *this;
+      evalToLazy(res);
       return res;
     }
 
diff --git a/test/triangular.cpp b/test/triangular.cpp
index a10b457a7..379f586c4 100644
--- a/test/triangular.cpp
+++ b/test/triangular.cpp
@@ -85,7 +85,7 @@ template void triangular_square(const MatrixType& m)
 
   m1 = MatrixType::Random(rows, cols);
   for (int i=0; i();
+    while (ei_abs2(m1(i,i))<1e-1) m1(i,i) = ei_random();
 
   Transpose trm4(m4);
   // test back and forward subsitution with a vector as the rhs
-- 
cgit v1.2.3


From 6cbf662f14d8fd0606d9e9c6f7052e5dcc52b2ae Mon Sep 17 00:00:00 2001
From: Benoit Jacob 
Date: Thu, 19 Nov 2009 22:01:13 -0500
Subject: * don't laugh, but these bugs took me forever to fix. * expand unit
 tests to make sure to catch them: they nearly escaped the existing tests as
 these memory violations were highly dependent on the numbers of rows and
 cols.

---
 Eigen/src/Core/TriangularMatrix.h |  6 +++---
 test/triangular.cpp               | 29 +++++++++++++----------------
 2 files changed, 16 insertions(+), 19 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/TriangularMatrix.h b/Eigen/src/Core/TriangularMatrix.h
index 1286bf6a6..1a8f6493d 100644
--- a/Eigen/src/Core/TriangularMatrix.h
+++ b/Eigen/src/Core/TriangularMatrix.h
@@ -410,7 +410,7 @@ struct ei_triangular_assignment_selector
@@ -451,9 +451,9 @@ struct ei_triangular_assignment_selector void triangular_rect(const MatrixType& m)
   m3 = 3 * m2;
   VERIFY_IS_APPROX(m3.template triangularView().toDenseMatrix(), m1);
 
+
   m1.setZero();
   m1.template triangularView() = 3 * m2;
   VERIFY_IS_APPROX(m3.template triangularView().toDenseMatrix(), m1);
@@ -196,10 +197,10 @@ template void triangular_rect(const MatrixType& m)
   m1.template triangularView() = 3 * m2;
   VERIFY_IS_APPROX(m3.template triangularView().toDenseMatrix(), m1);
 
+
   m1.setZero();
   m1.template triangularView() = 3 * m2;
   VERIFY_IS_APPROX(m3.template triangularView().toDenseMatrix(), m1);
-
   m1.setRandom();
   m2 = m1.template triangularView();
   VERIFY(m2.isUpperTriangular());
@@ -234,24 +235,20 @@ void test_triangular()
 {
   for(int i = 0; i < g_repeat ; i++)
   {
-
-#ifdef EIGEN_TEST_PART_7
-    int r = ei_random(2,20);
-    int c = ei_random(2,20);
-#endif
+    EIGEN_UNUSED int r = ei_random(2,20);
+    EIGEN_UNUSED int c = ei_random(2,20);
 
     CALL_SUBTEST_1( triangular_square(Matrix()) );
     CALL_SUBTEST_2( triangular_square(Matrix()) );
     CALL_SUBTEST_3( triangular_square(Matrix3d()) );
-    CALL_SUBTEST_4( triangular_square(MatrixXcf(4, 4)) );
-    CALL_SUBTEST_5( triangular_square(Matrix,8, 8>()) );
-    CALL_SUBTEST_6( triangular_square(MatrixXcd(17,17)) );
-    CALL_SUBTEST_7( triangular_square(Matrix(r, r)) );
-
-    CALL_SUBTEST_8( triangular_rect(Matrix()) );
-    CALL_SUBTEST_9( triangular_rect(Matrix()) );
-    CALL_SUBTEST_4( triangular_rect(MatrixXcf(4, 10)) );
-    CALL_SUBTEST_6( triangular_rect(MatrixXcd(11, 3)) );
-    CALL_SUBTEST_7( triangular_rect(Matrix(r, c)) );
+    CALL_SUBTEST_4( triangular_square(Matrix,8, 8>()) );
+    CALL_SUBTEST_5( triangular_square(MatrixXcd(r,r)) );
+    CALL_SUBTEST_6( triangular_square(Matrix(r, r)) );
+
+    CALL_SUBTEST_7( triangular_rect(Matrix()) );
+    CALL_SUBTEST_8( triangular_rect(Matrix()) );
+    CALL_SUBTEST_9( triangular_rect(MatrixXcf(r, c)) );
+    CALL_SUBTEST_5( triangular_rect(MatrixXcd(r, c)) );
+    CALL_SUBTEST_6( triangular_rect(Matrix(r, c)) );
   }
 }
-- 
cgit v1.2.3


From abdb2a2bd55661d09db7a6b5ae7f603fc61db815 Mon Sep 17 00:00:00 2001
From: Benoit Jacob 
Date: Tue, 24 Nov 2009 12:14:40 -0500
Subject: fix assert and handle Unit shapes

---
 Eigen/src/Core/TriangularMatrix.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/TriangularMatrix.h b/Eigen/src/Core/TriangularMatrix.h
index 1a8f6493d..e5d7367d8 100644
--- a/Eigen/src/Core/TriangularMatrix.h
+++ b/Eigen/src/Core/TriangularMatrix.h
@@ -88,11 +88,11 @@ template class TriangularBase : public AnyMatrixBase
 
     void check_coordinates(int row, int col)
     {
-      ei_assert(col>0 && col0 && row=0 && col=0 && row=row)
                 || (Mode==LowerTriangular && col<=row)
-                || (Mode==StrictlyUpperTriangular && col>row)
-                || (Mode==StrictlyLowerTriangular && colrow)
+                || ((Mode==StrictlyLowerTriangular || Mode==UnitLowerTriangular) && col
Date: Tue, 24 Nov 2009 15:12:43 -0500
Subject: add SSE4 support, start with integer multiplication

---
 CMakeLists.txt                       | 22 +++++++++++++++++-----
 Eigen/Core                           |  6 ++++++
 Eigen/src/Core/arch/SSE/PacketMath.h |  4 ++++
 cmake/EigenTesting.cmake             | 32 ++++++++++++++++++++++----------
 4 files changed, 49 insertions(+), 15 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8932fff2a..33e7584c4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -63,31 +63,43 @@ if(CMAKE_COMPILER_IS_GNUCXX)
 
     if(NOT EIGEN_TEST_LIB)
       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
-    endif(NOT EIGEN_TEST_LIB)
+    endif()
 
     option(EIGEN_TEST_SSE2 "Enable/Disable SSE2 in tests/examples" OFF)
     if(EIGEN_TEST_SSE2)
       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse2")
       message("Enabling SSE2 in tests/examples")
-    endif(EIGEN_TEST_SSE2)
+    endif()
 
     option(EIGEN_TEST_SSE3 "Enable/Disable SSE3 in tests/examples" OFF)
     if(EIGEN_TEST_SSE3)
       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse3")
       message("Enabling SSE3 in tests/examples")
-    endif(EIGEN_TEST_SSE3)
+    endif()
 
     option(EIGEN_TEST_SSSE3 "Enable/Disable SSSE3 in tests/examples" OFF)
     if(EIGEN_TEST_SSSE3)
       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mssse3")
       message("Enabling SSSE3 in tests/examples")
-    endif(EIGEN_TEST_SSSE3)
+    endif()
+
+    option(EIGEN_TEST_SSE4_1 "Enable/Disable SSE4.1 in tests/examples" OFF)
+    if(EIGEN_TEST_SSE4_1)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.1")
+      message("Enabling SSE4.1 in tests/examples")
+    endif()
+
+    option(EIGEN_TEST_SSE4_2 "Enable/Disable SSE4.2 in tests/examples" OFF)
+    if(EIGEN_TEST_SSE4_2)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.2")
+      message("Enabling SSE4.2 in tests/examples")
+    endif()
 
     option(EIGEN_TEST_ALTIVEC "Enable/Disable altivec in tests/examples" OFF)
     if(EIGEN_TEST_ALTIVEC)
       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maltivec -mabi=altivec")
       message("Enabling AltiVec in tests/examples")
-    endif(EIGEN_TEST_ALTIVEC)
+    endif()
 
   endif(CMAKE_SYSTEM_NAME MATCHES Linux)
 endif(CMAKE_COMPILER_IS_GNUCXX)
diff --git a/Eigen/Core b/Eigen/Core
index 2968e36c6..e095aee11 100644
--- a/Eigen/Core
+++ b/Eigen/Core
@@ -67,6 +67,12 @@
     #ifdef __SSSE3__
       #include 
     #endif
+    #ifdef __SSE4_1__
+      #include 
+    #endif
+    #ifdef __SSE4_2__
+      #include 
+    #endif
   #elif defined __ALTIVEC__
     #define EIGEN_VECTORIZE
     #define EIGEN_VECTORIZE_ALTIVEC
diff --git a/Eigen/src/Core/arch/SSE/PacketMath.h b/Eigen/src/Core/arch/SSE/PacketMath.h
index 60ccadc21..69f6979bd 100644
--- a/Eigen/src/Core/arch/SSE/PacketMath.h
+++ b/Eigen/src/Core/arch/SSE/PacketMath.h
@@ -118,6 +118,9 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_pmul(const Packet4f& a, con
 template<> EIGEN_STRONG_INLINE Packet2d ei_pmul(const Packet2d& a, const Packet2d& b) { return _mm_mul_pd(a,b); }
 template<> EIGEN_STRONG_INLINE Packet4i ei_pmul(const Packet4i& a, const Packet4i& b)
 {
+#ifdef __SSE4_1__
+  return _mm_mullo_epi32(a,b);
+#else
   // this version is slightly faster than 4 scalar products
   return ei_vec4i_swizzle1(
             ei_vec4i_swizzle2(
@@ -126,6 +129,7 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_pmul(const Packet4i& a, con
                             ei_vec4i_swizzle1(b,1,0,3,2)),
               0,2,0,2),
             0,2,1,3);
+#endif
 }
 
 template<> EIGEN_STRONG_INLINE Packet4f ei_pdiv(const Packet4f& a, const Packet4f& b) { return _mm_div_ps(a,b); }
diff --git a/cmake/EigenTesting.cmake b/cmake/EigenTesting.cmake
index 42f7454f4..43ae53cc1 100644
--- a/cmake/EigenTesting.cmake
+++ b/cmake/EigenTesting.cmake
@@ -147,33 +147,45 @@ macro(ei_testing_print_summary)
 
   if(EIGEN_TEST_SSE2)
     message("SSE2:              ON")
-  else(EIGEN_TEST_SSE2)
+  else()
     message("SSE2:              Using architecture defaults")
-  endif(EIGEN_TEST_SSE2)
+  endif()
 
   if(EIGEN_TEST_SSE3)
     message("SSE3:              ON")
-  else(EIGEN_TEST_SSE3)
+  else()
     message("SSE3:              Using architecture defaults")
-  endif(EIGEN_TEST_SSE3)
+  endif()
 
   if(EIGEN_TEST_SSSE3)
     message("SSSE3:             ON")
-  else(EIGEN_TEST_SSSE3)
+  else()
     message("SSSE3:             Using architecture defaults")
-  endif(EIGEN_TEST_SSSE3)
+  endif()
+
+  if(EIGEN_TEST_SSE4_1)
+    message("SSE4.1:            ON")
+  else()
+    message("SSE4.1:            Using architecture defaults")
+  endif()
+
+  if(EIGEN_TEST_SSE4_2)
+    message("SSE4.2:            ON")
+  else()
+    message("SSE4.2:            Using architecture defaults")
+  endif()
 
   if(EIGEN_TEST_ALTIVEC)
     message("Altivec:           Using architecture defaults")
-  else(EIGEN_TEST_ALTIVEC)
+  else()
     message("Altivec:           Using architecture defaults")
-  endif(EIGEN_TEST_ALTIVEC)
+  endif()
 
   if(EIGEN_TEST_NO_EXPLICIT_VECTORIZATION)
     message("Explicit vec:      OFF")
-  else(EIGEN_TEST_NO_EXPLICIT_VECTORIZATION)
+  else()
     message("Explicit vec:      Using architecture defaults")
-  endif(EIGEN_TEST_NO_EXPLICIT_VECTORIZATION)
+  endif()
 
   message("\n${EIGEN_TESTING_SUMMARY}")
   #   message("CXX:               ${CMAKE_CXX_COMPILER}")
-- 
cgit v1.2.3


From 4b1aca2288ebf549791def6287b2886759dec2f4 Mon Sep 17 00:00:00 2001
From: Benoit Jacob 
Date: Thu, 26 Nov 2009 22:05:02 -0500
Subject: precision  --->  dummy_precision

---
 Eigen/src/Core/MathFunctions.h                   | 58 ++++++++++++------------
 Eigen/src/Core/MatrixBase.h                      | 30 ++++++------
 Eigen/src/Geometry/AlignedBox.h                  |  2 +-
 Eigen/src/Geometry/AngleAxis.h                   |  4 +-
 Eigen/src/Geometry/EulerAngles.h                 |  2 +-
 Eigen/src/Geometry/Hyperplane.h                  |  2 +-
 Eigen/src/Geometry/ParametrizedLine.h            |  2 +-
 Eigen/src/Geometry/Quaternion.h                  |  6 +--
 Eigen/src/Geometry/Rotation2D.h                  |  2 +-
 Eigen/src/Geometry/Scaling.h                     |  2 +-
 Eigen/src/Geometry/Transform.h                   |  2 +-
 Eigen/src/Geometry/Translation.h                 |  2 +-
 Eigen/src/SVD/SVD.h                              |  2 +-
 Eigen/src/Sparse/AmbiVector.h                    |  2 +-
 Eigen/src/Sparse/CompressedStorage.h             |  2 +-
 Eigen/src/Sparse/DynamicSparseMatrix.h           |  2 +-
 Eigen/src/Sparse/SparseLDLT.h                    |  4 +-
 Eigen/src/Sparse/SparseLLT.h                     |  4 +-
 Eigen/src/Sparse/SparseLU.h                      |  4 +-
 Eigen/src/Sparse/SparseMatrix.h                  |  2 +-
 Eigen/src/Sparse/SparseMatrixBase.h              | 26 +++++------
 Eigen/src/Sparse/SparseVector.h                  |  2 +-
 test/product.h                                   |  2 +-
 unsupported/Eigen/AlignedVector3                 |  2 +-
 unsupported/Eigen/src/Skyline/SkylineInplaceLU.h |  2 +-
 unsupported/Eigen/src/Skyline/SkylineMatrix.h    |  2 +-
 unsupported/Eigen/src/Skyline/SkylineStorage.h   |  2 +-
 27 files changed, 87 insertions(+), 87 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/MathFunctions.h b/Eigen/src/Core/MathFunctions.h
index 05469b340..7ffddcbf8 100644
--- a/Eigen/src/Core/MathFunctions.h
+++ b/Eigen/src/Core/MathFunctions.h
@@ -30,7 +30,7 @@ template inline typename NumTraits::Real epsilon()
  return std::numeric_limits::Real>::epsilon();
 }
 
-template inline typename NumTraits::Real precision();
+template inline typename NumTraits::Real dummy_precision();
 
 template inline T ei_random(T a, T b);
 template inline T ei_random();
@@ -55,7 +55,7 @@ template inline typename NumTraits::Real ei_hypot(T x, T y)
 ***   int   ***
 **************/
 
-template<> inline int precision() { return 0; }
+template<> inline int dummy_precision() { return 0; }
 inline int ei_real(int x)  { return x; }
 inline int& ei_real_ref(int& x)  { return x; }
 inline int ei_imag(int)    { return 0; }
@@ -92,15 +92,15 @@ template<> inline int ei_random()
 {
   return ei_random(-ei_random_amplitude(), ei_random_amplitude());
 }
-inline bool ei_isMuchSmallerThan(int a, int, int = precision())
+inline bool ei_isMuchSmallerThan(int a, int, int = dummy_precision())
 {
   return a == 0;
 }
-inline bool ei_isApprox(int a, int b, int = precision())
+inline bool ei_isApprox(int a, int b, int = dummy_precision())
 {
   return a == b;
 }
-inline bool ei_isApproxOrLessThan(int a, int b, int = precision())
+inline bool ei_isApproxOrLessThan(int a, int b, int = dummy_precision())
 {
   return a <= b;
 }
@@ -109,7 +109,7 @@ inline bool ei_isApproxOrLessThan(int a, int b, int = precision())
 *** float   ***
 **************/
 
-template<> inline float precision() { return 1e-5f; }
+template<> inline float dummy_precision() { return 1e-5f; }
 inline float ei_real(float x)  { return x; }
 inline float& ei_real_ref(float& x)  { return x; }
 inline float ei_imag(float)    { return 0.f; }
@@ -140,15 +140,15 @@ template<> inline float ei_random()
 {
   return ei_random(-ei_random_amplitude(), ei_random_amplitude());
 }
-inline bool ei_isMuchSmallerThan(float a, float b, float prec = precision())
+inline bool ei_isMuchSmallerThan(float a, float b, float prec = dummy_precision())
 {
   return ei_abs(a) <= ei_abs(b) * prec;
 }
-inline bool ei_isApprox(float a, float b, float prec = precision())
+inline bool ei_isApprox(float a, float b, float prec = dummy_precision())
 {
   return ei_abs(a - b) <= std::min(ei_abs(a), ei_abs(b)) * prec;
 }
-inline bool ei_isApproxOrLessThan(float a, float b, float prec = precision())
+inline bool ei_isApproxOrLessThan(float a, float b, float prec = dummy_precision())
 {
   return a <= b || ei_isApprox(a, b, prec);
 }
@@ -157,7 +157,7 @@ inline bool ei_isApproxOrLessThan(float a, float b, float prec = precision inline double precision() { return 1e-12; }
+template<> inline double dummy_precision() { return 1e-12; }
 
 inline double ei_real(double x)  { return x; }
 inline double& ei_real_ref(double& x)  { return x; }
@@ -189,15 +189,15 @@ template<> inline double ei_random()
 {
   return ei_random(-ei_random_amplitude(), ei_random_amplitude());
 }
-inline bool ei_isMuchSmallerThan(double a, double b, double prec = precision())
+inline bool ei_isMuchSmallerThan(double a, double b, double prec = dummy_precision())
 {
   return ei_abs(a) <= ei_abs(b) * prec;
 }
-inline bool ei_isApprox(double a, double b, double prec = precision())
+inline bool ei_isApprox(double a, double b, double prec = dummy_precision())
 {
   return ei_abs(a - b) <= std::min(ei_abs(a), ei_abs(b)) * prec;
 }
-inline bool ei_isApproxOrLessThan(double a, double b, double prec = precision())
+inline bool ei_isApproxOrLessThan(double a, double b, double prec = dummy_precision())
 {
   return a <= b || ei_isApprox(a, b, prec);
 }
@@ -206,7 +206,7 @@ inline bool ei_isApproxOrLessThan(double a, double b, double prec = precision ***
 *********************/
 
-template<> inline float precision >() { return precision(); }
+template<> inline float dummy_precision >() { return dummy_precision(); }
 inline float ei_real(const std::complex& x) { return std::real(x); }
 inline float ei_imag(const std::complex& x) { return std::imag(x); }
 inline float& ei_real_ref(std::complex& x) { return reinterpret_cast(&x)[0]; }
@@ -224,15 +224,15 @@ template<> inline std::complex ei_random()
 {
   return std::complex(ei_random(), ei_random());
 }
-inline bool ei_isMuchSmallerThan(const std::complex& a, const std::complex& b, float prec = precision())
+inline bool ei_isMuchSmallerThan(const std::complex& a, const std::complex& b, float prec = dummy_precision())
 {
   return ei_abs2(a) <= ei_abs2(b) * prec * prec;
 }
-inline bool ei_isMuchSmallerThan(const std::complex& a, float b, float prec = precision())
+inline bool ei_isMuchSmallerThan(const std::complex& a, float b, float prec = dummy_precision())
 {
   return ei_abs2(a) <= ei_abs2(b) * prec * prec;
 }
-inline bool ei_isApprox(const std::complex& a, const std::complex& b, float prec = precision())
+inline bool ei_isApprox(const std::complex& a, const std::complex& b, float prec = dummy_precision())
 {
   return ei_isApprox(ei_real(a), ei_real(b), prec)
       && ei_isApprox(ei_imag(a), ei_imag(b), prec);
@@ -243,7 +243,7 @@ inline bool ei_isApprox(const std::complex& a, const std::complex&
 *** complex ***
 **********************/
 
-template<> inline double precision >() { return precision(); }
+template<> inline double dummy_precision >() { return dummy_precision(); }
 inline double ei_real(const std::complex& x) { return std::real(x); }
 inline double ei_imag(const std::complex& x) { return std::imag(x); }
 inline double& ei_real_ref(std::complex& x) { return reinterpret_cast(&x)[0]; }
@@ -261,15 +261,15 @@ template<> inline std::complex ei_random()
 {
   return std::complex(ei_random(), ei_random());
 }
-inline bool ei_isMuchSmallerThan(const std::complex& a, const std::complex& b, double prec = precision())
+inline bool ei_isMuchSmallerThan(const std::complex& a, const std::complex& b, double prec = dummy_precision())
 {
   return ei_abs2(a) <= ei_abs2(b) * prec * prec;
 }
-inline bool ei_isMuchSmallerThan(const std::complex& a, double b, double prec = precision())
+inline bool ei_isMuchSmallerThan(const std::complex& a, double b, double prec = dummy_precision())
 {
   return ei_abs2(a) <= ei_abs2(b) * prec * prec;
 }
-inline bool ei_isApprox(const std::complex& a, const std::complex& b, double prec = precision())
+inline bool ei_isApprox(const std::complex& a, const std::complex& b, double prec = dummy_precision())
 {
   return ei_isApprox(ei_real(a), ei_real(b), prec)
       && ei_isApprox(ei_imag(a), ei_imag(b), prec);
@@ -281,7 +281,7 @@ inline bool ei_isApprox(const std::complex& a, const std::complex inline long double precision() { return precision(); }
+template<> inline long double dummy_precision() { return dummy_precision(); }
 inline long double ei_real(long double x)  { return x; }
 inline long double& ei_real_ref(long double& x)  { return x; }
 inline long double ei_imag(long double)    { return 0.; }
@@ -304,15 +304,15 @@ template<> inline long double ei_random()
 {
   return ei_random(-ei_random_amplitude(), ei_random_amplitude());
 }
-inline bool ei_isMuchSmallerThan(long double a, long double b, long double prec = precision())
+inline bool ei_isMuchSmallerThan(long double a, long double b, long double prec = dummy_precision())
 {
   return ei_abs(a) <= ei_abs(b) * prec;
 }
-inline bool ei_isApprox(long double a, long double b, long double prec = precision())
+inline bool ei_isApprox(long double a, long double b, long double prec = dummy_precision())
 {
   return ei_abs(a - b) <= std::min(ei_abs(a), ei_abs(b)) * prec;
 }
-inline bool ei_isApproxOrLessThan(long double a, long double b, long double prec = precision())
+inline bool ei_isApproxOrLessThan(long double a, long double b, long double prec = dummy_precision())
 {
   return a <= b || ei_isApprox(a, b, prec);
 }
@@ -321,7 +321,7 @@ inline bool ei_isApproxOrLessThan(long double a, long double b, long double prec
 ***  bool  ***
 **************/
 
-template<> inline bool precision() { return 0; }
+template<> inline bool dummy_precision() { return 0; }
 inline bool ei_real(bool x)  { return x; }
 inline bool& ei_real_ref(bool& x)  { return x; }
 inline bool ei_imag(bool)    { return 0; }
@@ -334,15 +334,15 @@ template<> inline bool ei_random()
 {
   return (ei_random(0,1) == 1);
 }
-inline bool ei_isMuchSmallerThan(bool a, bool, bool = precision())
+inline bool ei_isMuchSmallerThan(bool a, bool, bool = dummy_precision())
 {
   return !a;
 }
-inline bool ei_isApprox(bool a, bool b, bool = precision())
+inline bool ei_isApprox(bool a, bool b, bool = dummy_precision())
 {
   return a == b;
 }
-inline bool ei_isApproxOrLessThan(bool a, bool b, bool = precision())
+inline bool ei_isApproxOrLessThan(bool a, bool b, bool = dummy_precision())
 {
   return int(a) <= int(b);
 }
diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h
index 8078b75b0..9f62ceb8f 100644
--- a/Eigen/src/Core/MatrixBase.h
+++ b/Eigen/src/Core/MatrixBase.h
@@ -558,27 +558,27 @@ template class MatrixBase
 
     template
     bool isApprox(const MatrixBase& other,
-                  RealScalar prec = precision()) const;
+                  RealScalar prec = dummy_precision()) const;
     bool isMuchSmallerThan(const RealScalar& other,
-                           RealScalar prec = precision()) const;
+                           RealScalar prec = dummy_precision()) const;
     template
     bool isMuchSmallerThan(const MatrixBase& other,
-                           RealScalar prec = precision()) const;
+                           RealScalar prec = dummy_precision()) const;
 
-    bool isApproxToConstant(const Scalar& value, RealScalar prec = precision()) const;
-    bool isConstant(const Scalar& value, RealScalar prec = precision()) const;
-    bool isZero(RealScalar prec = precision()) const;
-    bool isOnes(RealScalar prec = precision()) const;
-    bool isIdentity(RealScalar prec = precision()) const;
-    bool isDiagonal(RealScalar prec = precision()) const;
+    bool isApproxToConstant(const Scalar& value, RealScalar prec = dummy_precision()) const;
+    bool isConstant(const Scalar& value, RealScalar prec = dummy_precision()) const;
+    bool isZero(RealScalar prec = dummy_precision()) const;
+    bool isOnes(RealScalar prec = dummy_precision()) const;
+    bool isIdentity(RealScalar prec = dummy_precision()) const;
+    bool isDiagonal(RealScalar prec = dummy_precision()) const;
 
-    bool isUpperTriangular(RealScalar prec = precision()) const;
-    bool isLowerTriangular(RealScalar prec = precision()) const;
+    bool isUpperTriangular(RealScalar prec = dummy_precision()) const;
+    bool isLowerTriangular(RealScalar prec = dummy_precision()) const;
 
     template
     bool isOrthogonal(const MatrixBase& other,
-                      RealScalar prec = precision()) const;
-    bool isUnitary(RealScalar prec = precision()) const;
+                      RealScalar prec = dummy_precision()) const;
+    bool isUnitary(RealScalar prec = dummy_precision()) const;
 
     template
     inline bool operator==(const MatrixBase& other) const
@@ -722,13 +722,13 @@ template class MatrixBase
       ResultType& inverse,
       typename ResultType::Scalar& determinant,
       bool& invertible,
-      const RealScalar& absDeterminantThreshold = precision()
+      const RealScalar& absDeterminantThreshold = dummy_precision()
     ) const;
     template
     void computeInverseWithCheck(
       ResultType& inverse,
       bool& invertible,
-      const RealScalar& absDeterminantThreshold = precision()
+      const RealScalar& absDeterminantThreshold = dummy_precision()
     ) const;
     Scalar determinant() const;
 
diff --git a/Eigen/src/Geometry/AlignedBox.h b/Eigen/src/Geometry/AlignedBox.h
index 94edc5561..0a716cf31 100644
--- a/Eigen/src/Geometry/AlignedBox.h
+++ b/Eigen/src/Geometry/AlignedBox.h
@@ -171,7 +171,7 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim)
     * determined by \a prec.
     *
     * \sa MatrixBase::isApprox() */
-  bool isApprox(const AlignedBox& other, typename NumTraits::Real prec = precision()) const
+  bool isApprox(const AlignedBox& other, typename NumTraits::Real prec = dummy_precision()) const
   { return m_min.isApprox(other.m_min, prec) && m_max.isApprox(other.m_max, prec); }
 
 protected:
diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h
index ef86eb20d..2486df0e6 100644
--- a/Eigen/src/Geometry/AngleAxis.h
+++ b/Eigen/src/Geometry/AngleAxis.h
@@ -146,7 +146,7 @@ public:
     * determined by \a prec.
     *
     * \sa MatrixBase::isApprox() */
-  bool isApprox(const AngleAxis& other, typename NumTraits::Real prec = precision()) const
+  bool isApprox(const AngleAxis& other, typename NumTraits::Real prec = dummy_precision()) const
   { return m_axis.isApprox(other.m_axis, prec) && ei_isApprox(m_angle,other.m_angle, prec); }
 };
 
@@ -165,7 +165,7 @@ template
 AngleAxis& AngleAxis::operator=(const QuaternionBase& q)
 {
   Scalar n2 = q.vec().squaredNorm();
-  if (n2 < precision()*precision())
+  if (n2 < dummy_precision()*dummy_precision())
   {
     m_angle = 0;
     m_axis << 1, 0, 0;
diff --git a/Eigen/src/Geometry/EulerAngles.h b/Eigen/src/Geometry/EulerAngles.h
index dbcc7ae89..b6dbf8ae9 100644
--- a/Eigen/src/Geometry/EulerAngles.h
+++ b/Eigen/src/Geometry/EulerAngles.h
@@ -50,7 +50,7 @@ MatrixBase::eulerAngles(int a0, int a1, int a2) const
 
   Matrix res;
   typedef Matrix Vector2;
-  const Scalar epsilon = precision();
+  const Scalar epsilon = dummy_precision();
 
   const int odd = ((a0+1)%3 == a1) ? 0 : 1;
   const int i = a0;
diff --git a/Eigen/src/Geometry/Hyperplane.h b/Eigen/src/Geometry/Hyperplane.h
index ab65ca2ae..49a9ac7bb 100644
--- a/Eigen/src/Geometry/Hyperplane.h
+++ b/Eigen/src/Geometry/Hyperplane.h
@@ -257,7 +257,7 @@ public:
     * determined by \a prec.
     *
     * \sa MatrixBase::isApprox() */
-  bool isApprox(const Hyperplane& other, typename NumTraits::Real prec = precision()) const
+  bool isApprox(const Hyperplane& other, typename NumTraits::Real prec = dummy_precision()) const
   { return m_coeffs.isApprox(other.m_coeffs, prec); }
 
 protected:
diff --git a/Eigen/src/Geometry/ParametrizedLine.h b/Eigen/src/Geometry/ParametrizedLine.h
index 6a4fcb1c5..21a5595b9 100644
--- a/Eigen/src/Geometry/ParametrizedLine.h
+++ b/Eigen/src/Geometry/ParametrizedLine.h
@@ -123,7 +123,7 @@ public:
     * determined by \a prec.
     *
     * \sa MatrixBase::isApprox() */
-  bool isApprox(const ParametrizedLine& other, typename NumTraits::Real prec = precision()) const
+  bool isApprox(const ParametrizedLine& other, typename NumTraits::Real prec = dummy_precision()) const
   { return m_origin.isApprox(other.m_origin, prec) && m_direction.isApprox(other.m_direction, prec); }
 
 protected:
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index 660e10d1e..a6bdb2408 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -163,7 +163,7 @@ public:
     *
     * \sa MatrixBase::isApprox() */
   template
-  bool isApprox(const QuaternionBase& other, RealScalar prec = precision()) const
+  bool isApprox(const QuaternionBase& other, RealScalar prec = dummy_precision()) const
   { return coeffs().isApprox(other.coeffs(), prec); }
 
 	/** return the result vector of \a v through the rotation*/
@@ -514,7 +514,7 @@ inline Derived& QuaternionBase::setFromTwoVectors(const MatrixBase())
+  if (c < Scalar(-1)+dummy_precision())
   {
     c = std::max(c,-1);
     Matrix m; m << v0.transpose(), v1.transpose();
@@ -590,7 +590,7 @@ template 
 Quaternion::Scalar>
 QuaternionBase::slerp(Scalar t, const QuaternionBase& other) const
 {
-  static const Scalar one = Scalar(1) - precision();
+  static const Scalar one = Scalar(1) - dummy_precision();
   Scalar d = this->dot(other);
   Scalar absD = ei_abs(d);
   if (absD>=one)
diff --git a/Eigen/src/Geometry/Rotation2D.h b/Eigen/src/Geometry/Rotation2D.h
index b80fcace0..7f24a3eae 100644
--- a/Eigen/src/Geometry/Rotation2D.h
+++ b/Eigen/src/Geometry/Rotation2D.h
@@ -121,7 +121,7 @@ public:
     * determined by \a prec.
     *
     * \sa MatrixBase::isApprox() */
-  bool isApprox(const Rotation2D& other, typename NumTraits::Real prec = precision()) const
+  bool isApprox(const Rotation2D& other, typename NumTraits::Real prec = dummy_precision()) const
   { return ei_isApprox(m_angle,other.m_angle, prec); }
 };
 
diff --git a/Eigen/src/Geometry/Scaling.h b/Eigen/src/Geometry/Scaling.h
index ce191b5da..4695914fd 100644
--- a/Eigen/src/Geometry/Scaling.h
+++ b/Eigen/src/Geometry/Scaling.h
@@ -107,7 +107,7 @@ public:
     * determined by \a prec.
     *
     * \sa MatrixBase::isApprox() */
-  bool isApprox(const UniformScaling& other, typename NumTraits::Real prec = precision()) const
+  bool isApprox(const UniformScaling& other, typename NumTraits::Real prec = dummy_precision()) const
   { return ei_isApprox(m_factor, other.factor(), prec); }
 
 };
diff --git a/Eigen/src/Geometry/Transform.h b/Eigen/src/Geometry/Transform.h
index 4ee036140..d478675bd 100644
--- a/Eigen/src/Geometry/Transform.h
+++ b/Eigen/src/Geometry/Transform.h
@@ -424,7 +424,7 @@ public:
     * determined by \a prec.
     *
     * \sa MatrixBase::isApprox() */
-  bool isApprox(const Transform& other, typename NumTraits::Real prec = precision()) const
+  bool isApprox(const Transform& other, typename NumTraits::Real prec = dummy_precision()) const
   { return m_matrix.isApprox(other.m_matrix, prec); }
 
   /** Sets the last row to [0 ... 0 1]
diff --git a/Eigen/src/Geometry/Translation.h b/Eigen/src/Geometry/Translation.h
index 1fff03810..b7477df9f 100644
--- a/Eigen/src/Geometry/Translation.h
+++ b/Eigen/src/Geometry/Translation.h
@@ -154,7 +154,7 @@ public:
     * determined by \a prec.
     *
     * \sa MatrixBase::isApprox() */
-  bool isApprox(const Translation& other, typename NumTraits::Real prec = precision()) const
+  bool isApprox(const Translation& other, typename NumTraits::Real prec = dummy_precision()) const
   { return m_coeffs.isApprox(other.m_coeffs, prec); }
 
 };
diff --git a/Eigen/src/SVD/SVD.h b/Eigen/src/SVD/SVD.h
index 254885873..3c7aaf322 100644
--- a/Eigen/src/SVD/SVD.h
+++ b/Eigen/src/SVD/SVD.h
@@ -193,7 +193,7 @@ SVD& SVD::compute(const MatrixType& matrix)
   int i,its,j,k,l,nm;
   Scalar anorm, c, f, g, h, s, scale, x, y, z;
   bool convergence = true;
-  Scalar eps = precision();
+  Scalar eps = dummy_precision();
 
   Matrix rv1(n);
   g = scale = anorm = 0;
diff --git a/Eigen/src/Sparse/AmbiVector.h b/Eigen/src/Sparse/AmbiVector.h
index 474626848..5e75bd6e7 100644
--- a/Eigen/src/Sparse/AmbiVector.h
+++ b/Eigen/src/Sparse/AmbiVector.h
@@ -300,7 +300,7 @@ class AmbiVector<_Scalar>::Iterator
       * In practice, all coefficients having a magnitude smaller than \a epsilon
       * are skipped.
       */
-    Iterator(const AmbiVector& vec, RealScalar epsilon = RealScalar(0.1)*precision())
+    Iterator(const AmbiVector& vec, RealScalar epsilon = RealScalar(0.1)*dummy_precision())
       : m_vector(vec)
     {
       m_epsilon = epsilon;
diff --git a/Eigen/src/Sparse/CompressedStorage.h b/Eigen/src/Sparse/CompressedStorage.h
index abf42914f..fcf5c7bfe 100644
--- a/Eigen/src/Sparse/CompressedStorage.h
+++ b/Eigen/src/Sparse/CompressedStorage.h
@@ -185,7 +185,7 @@ class CompressedStorage
       return m_values[id];
     }
     
-    void prune(Scalar reference, RealScalar epsilon = precision())
+    void prune(Scalar reference, RealScalar epsilon = dummy_precision())
     {
       size_t k = 0;
       size_t n = size();
diff --git a/Eigen/src/Sparse/DynamicSparseMatrix.h b/Eigen/src/Sparse/DynamicSparseMatrix.h
index 6a5cd070e..15135f9db 100644
--- a/Eigen/src/Sparse/DynamicSparseMatrix.h
+++ b/Eigen/src/Sparse/DynamicSparseMatrix.h
@@ -208,7 +208,7 @@ class DynamicSparseMatrix
 
     inline void finalize() {}
 
-    void prune(Scalar reference, RealScalar epsilon = precision())
+    void prune(Scalar reference, RealScalar epsilon = dummy_precision())
     {
       for (int j=0; j();
+      m_precision = RealScalar(0.1) * Eigen::dummy_precision();
     }
 
     /** Creates a LDLT object and compute the respective factorization of \a matrix using
@@ -103,7 +103,7 @@ class SparseLDLT
       : m_matrix(matrix.rows(), matrix.cols()), m_flags(flags), m_status(0)
     {
       ei_assert((MatrixType::Flags&RowMajorBit)==0);
-      m_precision = RealScalar(0.1) * Eigen::precision();
+      m_precision = RealScalar(0.1) * Eigen::dummy_precision();
       compute(matrix);
     }
 
diff --git a/Eigen/src/Sparse/SparseLLT.h b/Eigen/src/Sparse/SparseLLT.h
index b2f65b944..4b73dd205 100644
--- a/Eigen/src/Sparse/SparseLLT.h
+++ b/Eigen/src/Sparse/SparseLLT.h
@@ -54,7 +54,7 @@ class SparseLLT
     SparseLLT(int flags = 0)
       : m_flags(flags), m_status(0)
     {
-      m_precision = RealScalar(0.1) * Eigen::precision();
+      m_precision = RealScalar(0.1) * Eigen::dummy_precision();
     }
 
     /** Creates a LLT object and compute the respective factorization of \a matrix using
@@ -62,7 +62,7 @@ class SparseLLT
     SparseLLT(const MatrixType& matrix, int flags = 0)
       : m_matrix(matrix.rows(), matrix.cols()), m_flags(flags), m_status(0)
     {
-      m_precision = RealScalar(0.1) * Eigen::precision();
+      m_precision = RealScalar(0.1) * Eigen::dummy_precision();
       compute(matrix);
     }
 
diff --git a/Eigen/src/Sparse/SparseLU.h b/Eigen/src/Sparse/SparseLU.h
index 3f8d0f8db..2ec6d0e74 100644
--- a/Eigen/src/Sparse/SparseLU.h
+++ b/Eigen/src/Sparse/SparseLU.h
@@ -59,7 +59,7 @@ class SparseLU
     SparseLU(int flags = 0)
       : m_flags(flags), m_status(0)
     {
-      m_precision = RealScalar(0.1) * Eigen::precision();
+      m_precision = RealScalar(0.1) * Eigen::dummy_precision();
     }
 
     /** Creates a LU object and compute the respective factorization of \a matrix using
@@ -67,7 +67,7 @@ class SparseLU
     SparseLU(const MatrixType& matrix, int flags = 0)
       : /*m_matrix(matrix.rows(), matrix.cols()),*/ m_flags(flags), m_status(0)
     {
-      m_precision = RealScalar(0.1) * Eigen::precision();
+      m_precision = RealScalar(0.1) * Eigen::dummy_precision();
       compute(matrix);
     }
 
diff --git a/Eigen/src/Sparse/SparseMatrix.h b/Eigen/src/Sparse/SparseMatrix.h
index af3b5e5eb..7010602b7 100644
--- a/Eigen/src/Sparse/SparseMatrix.h
+++ b/Eigen/src/Sparse/SparseMatrix.h
@@ -341,7 +341,7 @@ class SparseMatrix
       }
     }
 
-    void prune(Scalar reference, RealScalar epsilon = precision())
+    void prune(Scalar reference, RealScalar epsilon = dummy_precision())
     {
       int k = 0;
       for (int j=0; j class SparseMatrixBase : public AnyMatrixBase
     bool isApprox(const SparseMatrixBase& other,
-                  RealScalar prec = precision()) const
+                  RealScalar prec = dummy_precision()) const
     { return toDense().isApprox(other.toDense(),prec); }
 
     template
     bool isApprox(const MatrixBase& other,
-                  RealScalar prec = precision()) const
+                  RealScalar prec = dummy_precision()) const
     { return toDense().isApprox(other,prec); }
 //     bool isMuchSmallerThan(const RealScalar& other,
-//                            RealScalar prec = precision()) const;
+//                            RealScalar prec = dummy_precision()) const;
 //     template
 //     bool isMuchSmallerThan(const MatrixBase& other,
-//                            RealScalar prec = precision()) const;
+//                            RealScalar prec = dummy_precision()) const;
 
-//     bool isApproxToConstant(const Scalar& value, RealScalar prec = precision()) const;
-//     bool isZero(RealScalar prec = precision()) const;
-//     bool isOnes(RealScalar prec = precision()) const;
-//     bool isIdentity(RealScalar prec = precision()) const;
-//     bool isDiagonal(RealScalar prec = precision()) const;
+//     bool isApproxToConstant(const Scalar& value, RealScalar prec = dummy_precision()) const;
+//     bool isZero(RealScalar prec = dummy_precision()) const;
+//     bool isOnes(RealScalar prec = dummy_precision()) const;
+//     bool isIdentity(RealScalar prec = dummy_precision()) const;
+//     bool isDiagonal(RealScalar prec = dummy_precision()) const;
 
-//     bool isUpperTriangular(RealScalar prec = precision()) const;
-//     bool isLowerTriangular(RealScalar prec = precision()) const;
+//     bool isUpperTriangular(RealScalar prec = dummy_precision()) const;
+//     bool isLowerTriangular(RealScalar prec = dummy_precision()) const;
 
 //     template
 //     bool isOrthogonal(const MatrixBase& other,
-//                       RealScalar prec = precision()) const;
-//     bool isUnitary(RealScalar prec = precision()) const;
+//                       RealScalar prec = dummy_precision()) const;
+//     bool isUnitary(RealScalar prec = dummy_precision()) const;
 
 //     template
 //     inline bool operator==(const MatrixBase& other) const
diff --git a/Eigen/src/Sparse/SparseVector.h b/Eigen/src/Sparse/SparseVector.h
index 122b1888e..8c8728b87 100644
--- a/Eigen/src/Sparse/SparseVector.h
+++ b/Eigen/src/Sparse/SparseVector.h
@@ -201,7 +201,7 @@ class SparseVector
     EIGEN_DEPRECATED void endFill() {}
     inline void finalize() {}
 
-    void prune(Scalar reference, RealScalar epsilon = precision())
+    void prune(Scalar reference, RealScalar epsilon = dummy_precision())
     {
       m_data.prune(reference,epsilon);
     }
diff --git a/test/product.h b/test/product.h
index 40773ad90..c1413cc2c 100644
--- a/test/product.h
+++ b/test/product.h
@@ -27,7 +27,7 @@
 #include 
 
 template
-bool areNotApprox(const MatrixBase& m1, const MatrixBase& m2, typename Derived1::RealScalar epsilon = precision())
+bool areNotApprox(const MatrixBase& m1, const MatrixBase& m2, typename Derived1::RealScalar epsilon = dummy_precision())
 {
   return !((m1-m2).cwise().abs2().maxCoeff() < epsilon * epsilon
                           * std::max(m1.cwise().abs2().maxCoeff(), m2.cwise().abs2().maxCoeff()));
diff --git a/unsupported/Eigen/AlignedVector3 b/unsupported/Eigen/AlignedVector3
index f20fad6d1..a1510f19d 100644
--- a/unsupported/Eigen/AlignedVector3
+++ b/unsupported/Eigen/AlignedVector3
@@ -188,7 +188,7 @@ template class AlignedVector3
     }
 
     template
-    inline bool isApprox(const MatrixBase& other, RealScalar eps=precision()) const
+    inline bool isApprox(const MatrixBase& other, RealScalar eps=dummy_precision()) const
     {
       return m_coeffs.template start<3>().isApprox(other,eps);
     }
diff --git a/unsupported/Eigen/src/Skyline/SkylineInplaceLU.h b/unsupported/Eigen/src/Skyline/SkylineInplaceLU.h
index feed564c5..c8c5f7575 100644
--- a/unsupported/Eigen/src/Skyline/SkylineInplaceLU.h
+++ b/unsupported/Eigen/src/Skyline/SkylineInplaceLU.h
@@ -46,7 +46,7 @@ public:
      * flags \a flags. */
     SkylineInplaceLU(MatrixType& matrix, int flags = 0)
     : /*m_matrix(matrix.rows(), matrix.cols()),*/ m_flags(flags), m_status(0), m_lu(matrix) {
-        m_precision = RealScalar(0.1) * Eigen::precision ();
+        m_precision = RealScalar(0.1) * Eigen::dummy_precision ();
         m_lu.IsRowMajor ? computeRowMajor() : compute();
     }
 
diff --git a/unsupported/Eigen/src/Skyline/SkylineMatrix.h b/unsupported/Eigen/src/Skyline/SkylineMatrix.h
index 5d47d970f..6dd4f1736 100644
--- a/unsupported/Eigen/src/Skyline/SkylineMatrix.h
+++ b/unsupported/Eigen/src/Skyline/SkylineMatrix.h
@@ -589,7 +589,7 @@ public:
         m_data.squeeze();
     }
 
-    void prune(Scalar reference, RealScalar epsilon = precision ()) {
+    void prune(Scalar reference, RealScalar epsilon = dummy_precision ()) {
         //TODO
     }
 
diff --git a/unsupported/Eigen/src/Skyline/SkylineStorage.h b/unsupported/Eigen/src/Skyline/SkylineStorage.h
index f725da0bf..641508f75 100644
--- a/unsupported/Eigen/src/Skyline/SkylineStorage.h
+++ b/unsupported/Eigen/src/Skyline/SkylineStorage.h
@@ -206,7 +206,7 @@ public:
         memset(m_lowerProfile, 0, m_diagSize * sizeof (int));
     }
 
-    void prune(Scalar reference, RealScalar epsilon = precision()) {
+    void prune(Scalar reference, RealScalar epsilon = dummy_precision()) {
         //TODO
     }
 
-- 
cgit v1.2.3


From 1c2e476fa745d7323d77959d5fb88fd3587be187 Mon Sep 17 00:00:00 2001
From: Hauke Heibel 
Date: Mon, 30 Nov 2009 18:56:56 +0100
Subject: Initial commit for a modified ei_nested logic.

---
 Eigen/src/Core/util/XprHelper.h | 61 ++++++++++++++++++++++++++++++++++++-----
 1 file changed, 54 insertions(+), 7 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/util/XprHelper.h b/Eigen/src/Core/util/XprHelper.h
index be4266f85..7f58797d7 100644
--- a/Eigen/src/Core/util/XprHelper.h
+++ b/Eigen/src/Core/util/XprHelper.h
@@ -171,6 +171,46 @@ template struct ei_plain_matrix_type_row_major
 template struct ei_must_nest_by_value { enum { ret = false }; };
 template struct ei_must_nest_by_value > { enum { ret = true }; };
 
+/**
+* Just a sanity check in order to verify that NestByValue is never
+* used in combination with Matrix. Currently, I don't see a use case
+* for nesting matrices by value. When an expression requires a temporary
+* this should be handled through PlainMatrixType (i.e. arithmetic cost 
+* check + eval before nesting check).
+* Note: If this were happening there were no harm but - if we are sure
+*       this does not happen, we can actually get rid of NestByValue!
+**/
+template  struct ei_is_nested_matrix { typedef int ok; };
+template
+struct ei_is_nested_matrix< NestByValue< Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > > {};
+
+/**
+* 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 
+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
+struct ei_ref_selector< Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > 
+{
+  typedef typename 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
   * nested into the bigger product expression. The choice is between nesting the expression b+c as-is, or
@@ -195,15 +235,22 @@ template::ty
     CostEval   = (n+1) * int(NumTraits::Scalar>::ReadCost),
     CostNoEval = (n-1) * int(ei_traits::CoeffReadCost)
   };
+
+  typedef typename ei_is_nested_matrix::ok is_ok;
+
   typedef typename ei_meta_if<
     ei_must_nest_by_value::ret,
-    T,
-    typename ei_meta_if<
-      (int(ei_traits::Flags) & EvalBeforeNestingBit)
-      || ( int(CostEval) <= int(CostNoEval) ),
-      PlainMatrixType,
-      const T&
-    >::ret
+      T,
+      typename ei_meta_if<
+      ( int(ei_traits::Flags) & EvalBeforeNestingBit ) || 
+      ( int(CostEval) <= int(CostNoEval) ),
+        PlainMatrixType,
+#ifdef EIGEN_OLD_NESTED
+        const T&
+#else
+        typename ei_ref_selector::type
+#endif
+      >::ret
   >::ret type;
 };
 
-- 
cgit v1.2.3


From e6c560aedfff176cbc6df40eedd4c5cf343b0fa6 Mon Sep 17 00:00:00 2001
From: Hauke Heibel 
Date: Mon, 30 Nov 2009 19:06:07 +0100
Subject: Removed wrong typename.

---
 Eigen/src/Core/util/XprHelper.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/util/XprHelper.h b/Eigen/src/Core/util/XprHelper.h
index 7f58797d7..d1250c009 100644
--- a/Eigen/src/Core/util/XprHelper.h
+++ b/Eigen/src/Core/util/XprHelper.h
@@ -207,7 +207,7 @@ struct ei_ref_selector
 template
 struct ei_ref_selector< Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > 
 {
-  typedef typename Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> MatrixType;
+  typedef Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> MatrixType;
   typedef MatrixType const& type;
 };
 
-- 
cgit v1.2.3


From 88be82679171c3ef13c432949f4b635482b422e3 Mon Sep 17 00:00:00 2001
From: Hauke Heibel 
Date: Tue, 1 Dec 2009 09:49:15 +0100
Subject: Removed NestByValue dependency from MatrixBase::select().

---
 Eigen/src/Array/Select.h    | 8 ++++----
 Eigen/src/Core/MatrixBase.h | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Array/Select.h b/Eigen/src/Array/Select.h
index 46c4a22ec..bc55147fd 100644
--- a/Eigen/src/Array/Select.h
+++ b/Eigen/src/Array/Select.h
@@ -131,11 +131,11 @@ MatrixBase::select(const MatrixBase& thenMatrix,
   */
 template
 template
-inline const Select >
+inline const Select
 MatrixBase::select(const MatrixBase& thenMatrix,
                             typename ThenDerived::Scalar elseScalar) const
 {
-  return Select >(
+  return Select(
     derived(), thenMatrix.derived(), ThenDerived::Constant(rows(),cols(),elseScalar));
 }
 
@@ -148,11 +148,11 @@ MatrixBase::select(const MatrixBase& thenMatrix,
   */
 template
 template
-inline const Select, ElseDerived >
+inline const Select
 MatrixBase::select(typename ElseDerived::Scalar thenScalar,
                             const MatrixBase& elseMatrix) const
 {
-  return Select,ElseDerived>(
+  return Select(
     derived(), ElseDerived::Constant(rows(),cols(),thenScalar), elseMatrix.derived());
 }
 
diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h
index 9f62ceb8f..1cee31936 100644
--- a/Eigen/src/Core/MatrixBase.h
+++ b/Eigen/src/Core/MatrixBase.h
@@ -694,11 +694,11 @@ template class MatrixBase
            const MatrixBase& elseMatrix) const;
 
     template
-    inline const Select >
+    inline const Select
     select(const MatrixBase& thenMatrix, typename ThenDerived::Scalar elseScalar) const;
 
     template
-    inline const Select, ElseDerived >
+    inline const Select
     select(typename ElseDerived::Scalar thenScalar, const MatrixBase& elseMatrix) const;
 
     template RealScalar lpNorm() const;
-- 
cgit v1.2.3


From 2bf354da80d15a7a1e7ad9f58f375a21c6e721aa Mon Sep 17 00:00:00 2001
From: Hauke Heibel 
Date: Tue, 1 Dec 2009 11:51:22 +0100
Subject: Much more NestByValue cleanup.

---
 Eigen/src/Array/VectorwiseOp.h              |  4 ++--
 Eigen/src/Core/BandMatrix.h                 |  2 +-
 Eigen/src/Core/Cwise.h                      |  2 +-
 Eigen/src/Core/MatrixBase.h                 | 10 +++++-----
 Eigen/src/Core/Transpose.h                  | 14 +++++++-------
 Eigen/src/Core/TriangularMatrix.h           | 16 ++++++++--------
 Eigen/src/Geometry/Homogeneous.h            | 11 +++++------
 Eigen/src/Geometry/Transform.h              |  2 +-
 Eigen/src/Householder/HouseholderSequence.h |  2 +-
 Eigen/src/Sparse/SparseCwise.h              |  2 +-
 blas/common.h                               |  8 ++++----
 test/geo_quaternion.cpp                     |  2 +-
 12 files changed, 37 insertions(+), 38 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Array/VectorwiseOp.h b/Eigen/src/Array/VectorwiseOp.h
index 0a46f49fc..71b83eaad 100644
--- a/Eigen/src/Array/VectorwiseOp.h
+++ b/Eigen/src/Array/VectorwiseOp.h
@@ -440,7 +440,7 @@ template class VectorwiseOp
     operator+(const MatrixBase& 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 */
@@ -451,7 +451,7 @@ template class VectorwiseOp
     operator-(const MatrixBase& other) const
     {
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived);
-      return m_matrix - extendedTo(other).nestByValue();
+      return m_matrix - extendedTo(other);
     }
 
 /////////// Geometry module ///////////
diff --git a/Eigen/src/Core/BandMatrix.h b/Eigen/src/Core/BandMatrix.h
index 85bd8dba7..7943e6280 100644
--- a/Eigen/src/Core/BandMatrix.h
+++ b/Eigen/src/Core/BandMatrix.h
@@ -141,7 +141,7 @@ class BandMatrix : public AnyMatrixBase BuildType;
       typedef typename ei_meta_if,NestByValue >,
+                 CwiseUnaryOp,BuildType >,
                  BuildType>::ret Type;
     };
 
diff --git a/Eigen/src/Core/Cwise.h b/Eigen/src/Core/Cwise.h
index 4b143325e..80414782e 100644
--- a/Eigen/src/Core/Cwise.h
+++ b/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::Scalar>, ExpressionType, \
-        NestByValue >
+        typename ExpressionType::ConstantReturnType >
 
 /** \class Cwise
   *
diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h
index 1cee31936..f1cf4ef90 100644
--- a/Eigen/src/Core/MatrixBase.h
+++ b/Eigen/src/Core/MatrixBase.h
@@ -248,7 +248,7 @@ template class MatrixBase
     typedef CwiseUnaryView, Derived> NonConstImagReturnType;
     /** \internal the return type of MatrixBase::adjoint() */
     typedef typename ei_meta_if::IsComplex,
-                        CwiseUnaryOp, NestByValue > >,
+                        CwiseUnaryOp, Eigen::Transpose >,
                         Transpose
                      >::ret AdjointReturnType;
     /** \internal the return type of MatrixBase::eigenvalues() */
@@ -445,11 +445,11 @@ template class MatrixBase
     Derived& lazyAssign(const CwiseBinaryOp,DerivedA,Transpose >& other);
 
     template
-    Derived& lazyAssign(const CwiseUnaryOp, NestByValue > >& other);
+    Derived& lazyAssign(const CwiseUnaryOp, Eigen::Transpose >& other);
     template
-    Derived& lazyAssign(const CwiseBinaryOp,CwiseUnaryOp, NestByValue > >,DerivedB>& other);
+    Derived& lazyAssign(const CwiseBinaryOp,CwiseUnaryOp, Eigen::Transpose >,DerivedB>& other);
     template
-    Derived& lazyAssign(const CwiseBinaryOp,DerivedA,CwiseUnaryOp, NestByValue > > >& other);
+    Derived& lazyAssign(const CwiseBinaryOp,DerivedA,CwiseUnaryOp, Eigen::Transpose > >& other);
     #endif
 
     RowXpr row(int i);
@@ -766,7 +766,7 @@ template class MatrixBase
                   ei_traits::ColsAtCompileTime==1 ? SizeMinusOne : 1,
                   ei_traits::ColsAtCompileTime==1 ? 1 : SizeMinusOne> StartMinusOne;
     typedef CwiseUnaryOp::Scalar>,
-                NestByValue > HNormalizedReturnType;
+                StartMinusOne > HNormalizedReturnType;
 
     const HNormalizedReturnType hnormalized() const;
     typedef Homogeneous::ColsAtCompileTime==1?Vertical:Horizontal> HomogeneousReturnType;
diff --git a/Eigen/src/Core/Transpose.h b/Eigen/src/Core/Transpose.h
index 990aa3807..79aef9fa7 100644
--- a/Eigen/src/Core/Transpose.h
+++ b/Eigen/src/Core/Transpose.h
@@ -186,7 +186,7 @@ template
 inline const typename MatrixBase::AdjointReturnType
 MatrixBase::adjoint() const
 {
-  return transpose().nestByValue();
+  return transpose();
 }
 
 /***************************************************************************
@@ -326,31 +326,31 @@ lazyAssign(const CwiseBinaryOp,DerivedA,Transpose
 template Derived&
 MatrixBase::
-lazyAssign(const CwiseUnaryOp, NestByValue > >& other)
+lazyAssign(const CwiseUnaryOp, Eigen::Transpose >& other)
 {
   ei_assert(ei_extract_data(other) != ei_extract_data(derived())
             && "aliasing detected during tranposition, please use adjointInPlace()");
-  return lazyAssign(static_cast, NestByValue > > >& >(other));
+  return lazyAssign(static_cast, Eigen::Transpose > >& >(other));
 }
 
 template
 template
 Derived& MatrixBase::
-lazyAssign(const CwiseBinaryOp,CwiseUnaryOp, NestByValue > >,DerivedB>& other)
+lazyAssign(const CwiseBinaryOp,CwiseUnaryOp, Eigen::Transpose >,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,CwiseUnaryOp, NestByValue > >,DerivedB> >& >(other));
+  return lazyAssign(static_cast,CwiseUnaryOp, Eigen::Transpose >,DerivedB> >& >(other));
 }
 
 template
 template
 Derived& MatrixBase::
-lazyAssign(const CwiseBinaryOp,DerivedA,CwiseUnaryOp, NestByValue > > >& other)
+lazyAssign(const CwiseBinaryOp,DerivedA,CwiseUnaryOp, Eigen::Transpose > >& other)
 {
   ei_assert(ei_extract_data(derived()) != ei_extract_data(other.rhs())
             && "aliasing detected during tranposition, please evaluate your expression");
-  return lazyAssign(static_cast,DerivedA,CwiseUnaryOp, NestByValue > > > >& >(other));
+  return lazyAssign(static_cast,DerivedA,CwiseUnaryOp, Eigen::Transpose > > >& >(other));
 }
 #endif
 
diff --git a/Eigen/src/Core/TriangularMatrix.h b/Eigen/src/Core/TriangularMatrix.h
index e5d7367d8..aaf781d1f 100644
--- a/Eigen/src/Core/TriangularMatrix.h
+++ b/Eigen/src/Core/TriangularMatrix.h
@@ -222,18 +222,18 @@ template class TriangularView
 
 
     /** \sa MatrixBase::adjoint() */
-    inline TriangularView,TransposeMode> adjoint()
-    { return m_matrix.adjoint().nestByValue(); }
+    inline TriangularView adjoint()
+    { return m_matrix.adjoint(); }
     /** \sa MatrixBase::adjoint() const */
-    inline const TriangularView,TransposeMode> adjoint() const
-    { return m_matrix.adjoint().nestByValue(); }
+    inline const TriangularView adjoint() const
+    { return m_matrix.adjoint(); }
 
     /** \sa MatrixBase::transpose() */
-    inline TriangularView >,TransposeMode> transpose()
-    { return m_matrix.transpose().nestByValue(); }
+    inline TriangularView,TransposeMode> transpose()
+    { return m_matrix.transpose(); }
     /** \sa MatrixBase::transpose() const */
-    inline const TriangularView >,TransposeMode> transpose() const
-    { return m_matrix.transpose().nestByValue(); }
+    inline const TriangularView,TransposeMode> transpose() const
+    { return m_matrix.transpose(); }
 
     DenseMatrixType toDenseMatrix() const
     {
diff --git a/Eigen/src/Geometry/Homogeneous.h b/Eigen/src/Geometry/Homogeneous.h
index 035d213b7..ffa828f71 100644
--- a/Eigen/src/Geometry/Homogeneous.h
+++ b/Eigen/src/Geometry/Homogeneous.h
@@ -175,7 +175,7 @@ MatrixBase::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::hnormalized() const
 {
   return HNormalized_Block(_expression(),0,0,
       Direction==Vertical   ? _expression().rows()-1 : _expression().rows(),
-      Direction==Horizontal ? _expression().cols()-1 : _expression().cols()).nestByValue()
-    .cwise()/
-      Replicate,
+      Direction==Horizontal ? _expression().cols()-1 : _expression().cols()).cwise()/
+      Replicate
         (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
diff --git a/Eigen/src/Geometry/Transform.h b/Eigen/src/Geometry/Transform.h
index d478675bd..363fa9dc4 100644
--- a/Eigen/src/Geometry/Transform.h
+++ b/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 > >::ret AffinePartNested;
+                              Block >::ret AffinePartNested;
   /** type of a vector */
   typedef Matrix VectorType;
   /** type of a read/write reference to the translation part of the rotation */
diff --git a/Eigen/src/Householder/HouseholderSequence.h b/Eigen/src/Householder/HouseholderSequence.h
index 85aa90362..afeb758b3 100644
--- a/Eigen/src/Householder/HouseholderSequence.h
+++ b/Eigen/src/Householder/HouseholderSequence.h
@@ -69,7 +69,7 @@ template class HouseholderSequence
 
     typedef HouseholderSequence::IsComplex,
-        NestByValue::type >,
+        typename ei_cleantype::type,
         CoeffsType>::ret> ConjugateReturnType;
 
     HouseholderSequence(const VectorsType& v, const CoeffsType& h, bool trans = false)
diff --git a/Eigen/src/Sparse/SparseCwise.h b/Eigen/src/Sparse/SparseCwise.h
index dd745fe7c..bf8f2355c 100644
--- a/Eigen/src/Sparse/SparseCwise.h
+++ b/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::Scalar>, ExpressionType, \
-        NestByValue >*/
+        typename ExpressionType::ConstantReturnType >*/
 
 template class SparseCwise
 {
diff --git a/blas/common.h b/blas/common.h
index 74c3c9f11..4be530da2 100644
--- a/blas/common.h
+++ b/blas/common.h
@@ -76,14 +76,14 @@ extern "C"
 using namespace Eigen;
 
 template
-Block > >, Dynamic, Dynamic>
+Block >, Dynamic, Dynamic>
 matrix(T* data, int rows, int cols, int stride)
 {
   return Map >(data, stride, cols).nestByValue().block(0,0,rows,cols);
 }
 
 template
-Block > >, Dynamic, 1>
+Block >, Dynamic, 1>
 vector(T* data, int size, int incr)
 {
   return Map >(data, size, incr).nestByValue().col(0);
@@ -106,8 +106,8 @@ enum
   Conj = IsComplex
 };
 
-typedef Block > >, Dynamic, Dynamic> MatrixType;
-typedef Block > >, Dynamic, 1> StridedVectorType;
+typedef Block >, Dynamic, Dynamic> MatrixType;
+typedef Block >, Dynamic, 1> StridedVectorType;
 typedef Map > CompactVectorType;
 
 #define EIGEN_BLAS_FUNC(X) EIGEN_CAT(SCALAR_SUFFIX,X##_)
diff --git a/test/geo_quaternion.cpp b/test/geo_quaternion.cpp
index 2e97fe295..5a55138f9 100644
--- a/test/geo_quaternion.cpp
+++ b/test/geo_quaternion.cpp
@@ -43,7 +43,7 @@ template void quaternion(void)
   if (ei_is_same_type::ret)
     largeEps = 1e-3f;
 
-  Scalar eps = ei_random() * 1e-2;
+  Scalar eps = ei_random() * Scalar(1e-2);
 
   Vector3 v0 = Vector3::Random(),
           v1 = Vector3::Random(),
-- 
cgit v1.2.3


From b08d5b2d2c73c095706cd2442878b960ef46df1f Mon Sep 17 00:00:00 2001
From: Hauke Heibel 
Date: Tue, 1 Dec 2009 13:16:51 +0100
Subject: Even more NestByValue cleanup...

---
 Eigen/Sparse                                    |  1 -
 Eigen/src/Core/ExpressionMaker.h                |  6 --
 Eigen/src/Core/util/BlasUtil.h                  | 14 -----
 Eigen/src/LU/FullPivLU.h                        |  2 +-
 Eigen/src/LU/PartialPivLU.h                     |  2 +-
 Eigen/src/QR/ColPivHouseholderQR.h              |  2 +-
 Eigen/src/QR/FullPivHouseholderQR.h             |  2 +-
 Eigen/src/Sparse/SparseDiagonalProduct.h        |  6 +-
 Eigen/src/Sparse/SparseExpressionMaker.h        |  6 --
 Eigen/src/Sparse/SparseMatrixBase.h             | 11 ++--
 Eigen/src/Sparse/SparseNestByValue.h            | 84 -------------------------
 Eigen/src/Sparse/SparseUtil.h                   |  3 -
 blas/common.h                                   |  4 +-
 unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h | 24 +++----
 unsupported/Eigen/src/AutoDiff/AutoDiffVector.h | 10 +--
 15 files changed, 30 insertions(+), 147 deletions(-)
 delete mode 100644 Eigen/src/Sparse/SparseNestByValue.h

(limited to 'Eigen/src/Core')

diff --git a/Eigen/Sparse b/Eigen/Sparse
index 96bd61419..a319405e6 100644
--- a/Eigen/Sparse
+++ b/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"
diff --git a/Eigen/src/Core/ExpressionMaker.h b/Eigen/src/Core/ExpressionMaker.h
index 1d265b63c..7e2b81d4a 100644
--- a/Eigen/src/Core/ExpressionMaker.h
+++ b/Eigen/src/Core/ExpressionMaker.h
@@ -37,12 +37,6 @@ template 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::ret>
-struct MakeNestByValue
-{
-  typedef NestByValue Type;
-};
-
 template::ret>
 struct MakeCwiseUnaryOp
 {
diff --git a/Eigen/src/Core/util/BlasUtil.h b/Eigen/src/Core/util/BlasUtil.h
index 94154108c..a012a6e12 100644
--- a/Eigen/src/Core/util/BlasUtil.h
+++ b/Eigen/src/Core/util/BlasUtil.h
@@ -214,20 +214,6 @@ struct ei_blas_traits, NestedXpr> >
   { return - Base::extractScalarFactor(x._expression()); }
 };
 
-// pop NestByValue
-template
-struct ei_blas_traits >
- : ei_blas_traits
-{
-  typedef typename NestedXpr::Scalar Scalar;
-  typedef ei_blas_traits Base;
-  typedef NestByValue XprType;
-  typedef typename Base::ExtractType ExtractType;
-  static inline ExtractType extract(const XprType& x) { return Base::extract(static_cast(x)); }
-  static inline Scalar extractScalarFactor(const XprType& x)
-  { return Base::extractScalarFactor(static_cast(x)); }
-};
-
 // pop/push transpose
 template
 struct ei_blas_traits >
diff --git a/Eigen/src/LU/FullPivLU.h b/Eigen/src/LU/FullPivLU.h
index 8d18e65f7..974106509 100644
--- a/Eigen/src/LU/FullPivLU.h
+++ b/Eigen/src/LU/FullPivLU.h
@@ -356,7 +356,7 @@ template class FullPivLU
       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
-               (*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(); }
diff --git a/Eigen/src/LU/PartialPivLU.h b/Eigen/src/LU/PartialPivLU.h
index 84bc165df..577daa345 100644
--- a/Eigen/src/LU/PartialPivLU.h
+++ b/Eigen/src/LU/PartialPivLU.h
@@ -147,7 +147,7 @@ template class PartialPivLU
     {
       ei_assert(m_isInitialized && "PartialPivLU is not initialized.");
       return ei_solve_retval
-               (*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
diff --git a/Eigen/src/QR/ColPivHouseholderQR.h b/Eigen/src/QR/ColPivHouseholderQR.h
index 614aa0295..c4fc34f93 100644
--- a/Eigen/src/QR/ColPivHouseholderQR.h
+++ b/Eigen/src/QR/ColPivHouseholderQR.h
@@ -219,7 +219,7 @@ template class ColPivHouseholderQR
     {
       ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
       return ei_solve_retval
-               (*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(); }
diff --git a/Eigen/src/QR/FullPivHouseholderQR.h b/Eigen/src/QR/FullPivHouseholderQR.h
index db57ba088..ae4e4aa4d 100644
--- a/Eigen/src/QR/FullPivHouseholderQR.h
+++ b/Eigen/src/QR/FullPivHouseholderQR.h
@@ -221,7 +221,7 @@ template class FullPivHouseholderQR
     {
       ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
       return ei_solve_retval
-               (*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(); }
diff --git a/Eigen/src/Sparse/SparseDiagonalProduct.h b/Eigen/src/Sparse/SparseDiagonalProduct.h
index f12ccb929..e9ba47f70 100644
--- a/Eigen/src/Sparse/SparseDiagonalProduct.h
+++ b/Eigen/src/Sparse/SparseDiagonalProduct.h
@@ -154,16 +154,16 @@ class ei_sparse_diagonal_product_inner_iterator_selector
   : public SparseCwiseBinaryOp<
       ei_scalar_product_op,
       SparseInnerVectorSet,
-      NestByValue > >::InnerIterator
+      Transpose >::InnerIterator
 {
     typedef typename SparseCwiseBinaryOp<
       ei_scalar_product_op,
       SparseInnerVectorSet,
-      NestByValue > >::InnerIterator Base;
+      Transpose >::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)
     {}
 };
 
diff --git a/Eigen/src/Sparse/SparseExpressionMaker.h b/Eigen/src/Sparse/SparseExpressionMaker.h
index 1fdcbb1f2..8e31d55ef 100644
--- a/Eigen/src/Sparse/SparseExpressionMaker.h
+++ b/Eigen/src/Sparse/SparseExpressionMaker.h
@@ -25,12 +25,6 @@
 #ifndef EIGEN_SPARSE_EXPRESSIONMAKER_H
 #define EIGEN_SPARSE_EXPRESSIONMAKER_H
 
-template
-struct MakeNestByValue
-{
-  typedef SparseNestByValue Type;
-};
-
 template
 struct MakeCwiseUnaryOp
 {
diff --git a/Eigen/src/Sparse/SparseMatrixBase.h b/Eigen/src/Sparse/SparseMatrixBase.h
index 2fd314708..cbbaf6b8b 100644
--- a/Eigen/src/Sparse/SparseMatrixBase.h
+++ b/Eigen/src/Sparse/SparseMatrixBase.h
@@ -100,7 +100,7 @@ template class SparseMatrixBase : public AnyMatrixBase, Derived> ImagReturnType;
     /** \internal the return type of MatrixBase::adjoint() */
     typedef typename ei_meta_if::IsComplex,
-                        SparseCwiseUnaryOp, SparseNestByValue > >,
+                        SparseCwiseUnaryOp, Eigen::SparseTranspose >,
                         SparseTranspose
                      >::ret AdjointReturnType;
 
@@ -356,7 +356,7 @@ template class SparseMatrixBase : public AnyMatrixBase transpose() { return derived(); }
     const SparseTranspose transpose() const { return derived(); }
     // void transposeInPlace();
-    const AdjointReturnType adjoint() const { return transpose().nestByValue(); }
+    const AdjointReturnType adjoint() const { return transpose(); }
 
     // sub-vector
     SparseInnerVectorSet row(int i);
@@ -528,9 +528,6 @@ template class SparseMatrixBase : public AnyMatrixBase nestByValue() const;
-
-
     ConjugateReturnType conjugate() const;
     const RealReturnType real() const;
     const ImagReturnType imag() const;
@@ -583,11 +580,11 @@ template class SparseMatrixBase : public AnyMatrixBase& elseMatrix) const;
 
     template
-    inline const Select >
+    inline const Select
     select(const MatrixBase& thenMatrix, typename ThenDerived::Scalar elseScalar) const;
 
     template
-    inline const Select, ElseDerived >
+    inline const Select
     select(typename ElseDerived::Scalar thenScalar, const MatrixBase& elseMatrix) const;
 
     template RealScalar lpNorm() const;
diff --git a/Eigen/src/Sparse/SparseNestByValue.h b/Eigen/src/Sparse/SparseNestByValue.h
deleted file mode 100644
index b48277232..000000000
--- a/Eigen/src/Sparse/SparseNestByValue.h
+++ /dev/null
@@ -1,84 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008-2009 Gael Guennebaud 
-// Copyright (C) 2006-2008 Benoit Jacob 
-//
-// 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 .
-
-#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
-struct ei_traits > : public ei_traits
-{};
-
-template class SparseNestByValue
-  : public SparseMatrixBase >
-{
-  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
-inline const SparseNestByValue
-SparseMatrixBase::nestByValue() const
-{
-  return SparseNestByValue(derived());
-}
-
-// template
-// class SparseNestByValue::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
diff --git a/Eigen/src/Sparse/SparseUtil.h b/Eigen/src/Sparse/SparseUtil.h
index b5fc7c7b7..52781aa46 100644
--- a/Eigen/src/Sparse/SparseUtil.h
+++ b/Eigen/src/Sparse/SparseUtil.h
@@ -106,7 +106,6 @@ template class DynamicSparseMatrix;
 template class SparseVector;
 template class MappedSparseMatrix;
 
-template                            class SparseNestByValue;
 template                            class SparseTranspose;
 template                  class SparseInnerVectorSet;
 template                               class SparseCwise;
@@ -147,6 +146,4 @@ template class ei_eval
     typedef SparseMatrix<_Scalar, _Flags> type;
 };
 
-template struct ei_must_nest_by_value > { enum { ret = true }; };
-
 #endif // EIGEN_SPARSEUTIL_H
diff --git a/blas/common.h b/blas/common.h
index 4be530da2..e7bfda570 100644
--- a/blas/common.h
+++ b/blas/common.h
@@ -79,14 +79,14 @@ template
 Block >, Dynamic, Dynamic>
 matrix(T* data, int rows, int cols, int stride)
 {
-  return Map >(data, stride, cols).nestByValue().block(0,0,rows,cols);
+  return Map >(data, stride, cols).block(0,0,rows,cols);
 }
 
 template
 Block >, Dynamic, 1>
 vector(T* data, int size, int incr)
 {
-  return Map >(data, size, incr).nestByValue().col(0);
+  return Map >(data, size, incr).col(0);
 }
 
 template
diff --git a/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h b/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h
index c4607c2b8..795dd6b4d 100644
--- a/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h
+++ b/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h
@@ -212,33 +212,33 @@ class AutoDiffScalar
 
     template
     inline const AutoDiffScalar,
-        typename MakeNestByValue,
-          typename MakeNestByValue, DerType>::Type>::Type,
-          typename MakeNestByValue, typename ei_cleantype::type>::Type>::Type >::Type >::Type >::Type >
+        typename MakeCwiseBinaryOp,
+          typename MakeCwiseUnaryOp, DerType>::Type,
+          typename MakeCwiseUnaryOp, typename ei_cleantype::type>::Type>::Type >::Type >
     operator/(const AutoDiffScalar& other) const
     {
       ei_make_coherent(m_derivatives, other.derivatives());
       return AutoDiffScalar,
-        typename MakeNestByValue,
-          typename MakeNestByValue, DerType>::Type>::Type,
-          typename MakeNestByValue, typename ei_cleantype::type>::Type>::Type >::Type >::Type >::Type >(
+        typename MakeCwiseBinaryOp,
+          typename MakeCwiseUnaryOp, DerType>::Type,
+          typename MakeCwiseUnaryOp, typename ei_cleantype::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
     inline const AutoDiffScalar,
-        typename MakeNestByValue, DerType>::Type>::Type,
-        typename MakeNestByValue, typename ei_cleantype::type>::Type>::Type >::Type >
+        typename MakeCwiseUnaryOp, DerType>::Type,
+        typename MakeCwiseUnaryOp, typename ei_cleantype::type>::Type>::Type >
     operator*(const AutoDiffScalar& other) const
     {
       ei_make_coherent(m_derivatives, other.derivatives());
       return AutoDiffScalar,
-        typename MakeNestByValue, DerType>::Type>::Type,
-        typename MakeNestByValue, typename ei_cleantype::type>::Type>::Type >::Type >(
+        typename MakeCwiseUnaryOp, DerType>::Type,
+        typename MakeCwiseUnaryOp, typename ei_cleantype::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)
diff --git a/unsupported/Eigen/src/AutoDiff/AutoDiffVector.h b/unsupported/Eigen/src/AutoDiff/AutoDiffVector.h
index 03c82b7e8..c0765d494 100644
--- a/unsupported/Eigen/src/AutoDiff/AutoDiffVector.h
+++ b/unsupported/Eigen/src/AutoDiff/AutoDiffVector.h
@@ -196,17 +196,17 @@ class AutoDiffVector
 //     inline const AutoDiffVector<
 //       CwiseBinaryOp, ValueType, OtherValueType>
 //       CwiseBinaryOp,
-//         NestByValue, JacobianType> >,
-//         NestByValue, OtherJacobianType> > > >
+//         CwiseUnaryOp, JacobianType>,
+//         CwiseUnaryOp, OtherJacobianType> > >
 //     operator*(const AutoDiffVector& other) const
 //     {
 //       return AutoDiffVector<
 //         CwiseBinaryOp, ValueType, OtherValueType>
 //         CwiseBinaryOp,
-//           NestByValue, JacobianType> >,
-//           NestByValue, OtherJacobianType> > > >(
+//           CwiseUnaryOp, JacobianType>,
+//           CwiseUnaryOp, 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)
-- 
cgit v1.2.3


From d3250cb38feaae3637ae2a9ab6266424a321674d Mon Sep 17 00:00:00 2001
From: Hauke Heibel 
Date: Tue, 1 Dec 2009 13:29:08 +0100
Subject: That's it NestByValue and .nestByValue() are both gone!

---
 Eigen/Core                                |   1 -
 Eigen/src/Core/MatrixBase.h               |   3 -
 Eigen/src/Core/NestByValue.h              | 119 ------------------------------
 Eigen/src/Core/util/ForwardDeclarations.h |   1 -
 Eigen/src/Core/util/XprHelper.h           |  35 ++-------
 5 files changed, 6 insertions(+), 153 deletions(-)
 delete mode 100644 Eigen/src/Core/NestByValue.h

(limited to 'Eigen/src/Core')

diff --git a/Eigen/Core b/Eigen/Core
index e095aee11..1accbfd09 100644
--- a/Eigen/Core
+++ b/Eigen/Core
@@ -162,7 +162,6 @@ namespace Eigen {
 
 #include "src/Core/util/BlasUtil.h"
 #include "src/Core/MatrixStorage.h"
-#include "src/Core/NestByValue.h"
 #include "src/Core/ReturnByValue.h"
 #include "src/Core/Flagged.h"
 #include "src/Core/NoAlias.h"
diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h
index f1cf4ef90..338395250 100644
--- a/Eigen/src/Core/MatrixBase.h
+++ b/Eigen/src/Core/MatrixBase.h
@@ -620,9 +620,6 @@ template class MatrixBase
       */
     inline int stride(void) const { return derived().stride(); }
 
-    inline const NestByValue nestByValue() const;
-
-
     ConjugateReturnType conjugate() const;
     RealReturnType real() const;
     NonConstRealReturnType real();
diff --git a/Eigen/src/Core/NestByValue.h b/Eigen/src/Core/NestByValue.h
deleted file mode 100644
index 94a8f8078..000000000
--- a/Eigen/src/Core/NestByValue.h
+++ /dev/null
@@ -1,119 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008 Gael Guennebaud 
-// Copyright (C) 2006-2008 Benoit Jacob 
-//
-// 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 .
-
-#ifndef EIGEN_NESTBYVALUE_H
-#define EIGEN_NESTBYVALUE_H
-
-/** \class NestByValue
-  *
-  * \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 MatrixBase::nestByValue()
-  */
-template
-struct ei_traits > : public ei_traits
-{};
-
-template class NestByValue
-  : public MatrixBase >
-{
-  public:
-
-    EIGEN_GENERIC_PUBLIC_INTERFACE(NestByValue)
-
-    inline NestByValue(const ExpressionType& matrix) : m_expression(matrix) {}
-
-    inline int rows() const { return m_expression.rows(); }
-    inline int cols() const { return m_expression.cols(); }
-    inline int stride() const { return m_expression.stride(); }
-
-    inline const CoeffReturnType coeff(int row, int col) const
-    {
-      return m_expression.coeff(row, col);
-    }
-
-    inline Scalar& coeffRef(int row, int col)
-    {
-      return m_expression.const_cast_derived().coeffRef(row, col);
-    }
-
-    inline const CoeffReturnType coeff(int index) const
-    {
-      return m_expression.coeff(index);
-    }
-
-    inline Scalar& coeffRef(int index)
-    {
-      return m_expression.const_cast_derived().coeffRef(index);
-    }
-
-    template
-    inline const PacketScalar packet(int row, int col) const
-    {
-      return m_expression.template packet(row, col);
-    }
-
-    template
-    inline void writePacket(int row, int col, const PacketScalar& x)
-    {
-      m_expression.const_cast_derived().template writePacket(row, col, x);
-    }
-
-    template
-    inline const PacketScalar packet(int index) const
-    {
-      return m_expression.template packet(index);
-    }
-
-    template
-    inline void writePacket(int index, const PacketScalar& x)
-    {
-      m_expression.const_cast_derived().template writePacket(index, x);
-    }
-    
-    operator const ExpressionType&() const { return m_expression; }
-
-  protected:
-    const ExpressionType m_expression;
-
-  private:
-    NestByValue& operator=(const NestByValue&);
-};
-
-/** \returns an expression of the temporary version of *this.
-  */
-template
-inline const NestByValue
-MatrixBase::nestByValue() const
-{
-  return NestByValue(derived());
-}
-
-#endif // EIGEN_NESTBYVALUE_H
diff --git a/Eigen/src/Core/util/ForwardDeclarations.h b/Eigen/src/Core/util/ForwardDeclarations.h
index 62e4bb31b..8670dccdb 100644
--- a/Eigen/src/Core/util/ForwardDeclarations.h
+++ b/Eigen/src/Core/util/ForwardDeclarations.h
@@ -36,7 +36,6 @@ template class Flagged;
 template class NoAlias;
-template class NestByValue;
 template class SwapWrapper;
 template class Minor;
 template struct ei_plain_matrix_type_row_major
           > type;
 };
 
+// we should be able to get rid of this one too
 template struct ei_must_nest_by_value { enum { ret = false }; };
-template struct ei_must_nest_by_value > { enum { ret = true }; };
-
-/**
-* Just a sanity check in order to verify that NestByValue is never
-* used in combination with Matrix. Currently, I don't see a use case
-* for nesting matrices by value. When an expression requires a temporary
-* this should be handled through PlainMatrixType (i.e. arithmetic cost 
-* check + eval before nesting check).
-* Note: If this were happening there were no harm but - if we are sure
-*       this does not happen, we can actually get rid of NestByValue!
-**/
-template  struct ei_is_nested_matrix { typedef int ok; };
-template
-struct ei_is_nested_matrix< NestByValue< Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > > {};
 
 /**
 * The reference selector for template expressions. The idea is that we don't
@@ -236,21 +223,11 @@ template::ty
     CostNoEval = (n-1) * int(ei_traits::CoeffReadCost)
   };
 
-  typedef typename ei_is_nested_matrix::ok is_ok;
-
   typedef typename ei_meta_if<
-    ei_must_nest_by_value::ret,
-      T,
-      typename ei_meta_if<
-      ( int(ei_traits::Flags) & EvalBeforeNestingBit ) || 
-      ( int(CostEval) <= int(CostNoEval) ),
-        PlainMatrixType,
-#ifdef EIGEN_OLD_NESTED
-        const T&
-#else
-        typename ei_ref_selector::type
-#endif
-      >::ret
+    ( int(ei_traits::Flags) & EvalBeforeNestingBit ) || 
+    ( int(CostEval) <= int(CostNoEval) ),
+      PlainMatrixType,
+      typename ei_ref_selector::type
   >::ret type;
 };
 
@@ -303,7 +280,7 @@ template struct HNormalizedReturnType {
                 ei_traits::ColsAtCompileTime==1 ? SizeMinusOne : 1,
                 ei_traits::ColsAtCompileTime==1 ? 1 : SizeMinusOne> StartMinusOne;
   typedef CwiseUnaryOp::Scalar>,
-              NestByValue > Type;
+              StartMinusOne > Type;
 };
 
 template struct ei_cast_return_type
-- 
cgit v1.2.3


From e3612bc0b843302259d79e4ecb73dff25e891122 Mon Sep 17 00:00:00 2001
From: Hauke Heibel 
Date: Wed, 2 Dec 2009 09:11:24 +0100
Subject: Removed unnecessary code.

---
 Eigen/src/Core/ProductBase.h | 8 --------
 1 file changed, 8 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/ProductBase.h b/Eigen/src/Core/ProductBase.h
index 57183ac52..955e87feb 100644
--- a/Eigen/src/Core/ProductBase.h
+++ b/Eigen/src/Core/ProductBase.h
@@ -111,14 +111,6 @@ class ProductBase : public MatrixBase
     template
     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 lazy() const
     { return *this; }
 
-- 
cgit v1.2.3


From 95861fbd6cbf9ec6634f2903d06f7ff5320a4f2a Mon Sep 17 00:00:00 2001
From: Hauke Heibel 
Date: Wed, 2 Dec 2009 10:53:30 +0100
Subject: Added NestByValue and .nestByValue() again for the sake of backwards
 compatibility.

---
 Eigen/Core                                |   1 +
 Eigen/src/Core/MatrixBase.h               |   2 +
 Eigen/src/Core/NestByValue.h              | 119 ++++++++++++++++++++++++++++++
 Eigen/src/Core/util/ForwardDeclarations.h |   1 +
 4 files changed, 123 insertions(+)
 create mode 100644 Eigen/src/Core/NestByValue.h

(limited to 'Eigen/src/Core')

diff --git a/Eigen/Core b/Eigen/Core
index 1accbfd09..e095aee11 100644
--- a/Eigen/Core
+++ b/Eigen/Core
@@ -162,6 +162,7 @@ namespace Eigen {
 
 #include "src/Core/util/BlasUtil.h"
 #include "src/Core/MatrixStorage.h"
+#include "src/Core/NestByValue.h"
 #include "src/Core/ReturnByValue.h"
 #include "src/Core/Flagged.h"
 #include "src/Core/NoAlias.h"
diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h
index 338395250..03d8d5f55 100644
--- a/Eigen/src/Core/MatrixBase.h
+++ b/Eigen/src/Core/MatrixBase.h
@@ -620,6 +620,8 @@ template class MatrixBase
       */
     inline int stride(void) const { return derived().stride(); }
 
+    inline const NestByValue nestByValue() const;
+
     ConjugateReturnType conjugate() const;
     RealReturnType real() const;
     NonConstRealReturnType real();
diff --git a/Eigen/src/Core/NestByValue.h b/Eigen/src/Core/NestByValue.h
new file mode 100644
index 000000000..94a8f8078
--- /dev/null
+++ b/Eigen/src/Core/NestByValue.h
@@ -0,0 +1,119 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud 
+// Copyright (C) 2006-2008 Benoit Jacob 
+//
+// 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 .
+
+#ifndef EIGEN_NESTBYVALUE_H
+#define EIGEN_NESTBYVALUE_H
+
+/** \class NestByValue
+  *
+  * \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 MatrixBase::nestByValue()
+  */
+template
+struct ei_traits > : public ei_traits
+{};
+
+template class NestByValue
+  : public MatrixBase >
+{
+  public:
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(NestByValue)
+
+    inline NestByValue(const ExpressionType& matrix) : m_expression(matrix) {}
+
+    inline int rows() const { return m_expression.rows(); }
+    inline int cols() const { return m_expression.cols(); }
+    inline int stride() const { return m_expression.stride(); }
+
+    inline const CoeffReturnType coeff(int row, int col) const
+    {
+      return m_expression.coeff(row, col);
+    }
+
+    inline Scalar& coeffRef(int row, int col)
+    {
+      return m_expression.const_cast_derived().coeffRef(row, col);
+    }
+
+    inline const CoeffReturnType coeff(int index) const
+    {
+      return m_expression.coeff(index);
+    }
+
+    inline Scalar& coeffRef(int index)
+    {
+      return m_expression.const_cast_derived().coeffRef(index);
+    }
+
+    template
+    inline const PacketScalar packet(int row, int col) const
+    {
+      return m_expression.template packet(row, col);
+    }
+
+    template
+    inline void writePacket(int row, int col, const PacketScalar& x)
+    {
+      m_expression.const_cast_derived().template writePacket(row, col, x);
+    }
+
+    template
+    inline const PacketScalar packet(int index) const
+    {
+      return m_expression.template packet(index);
+    }
+
+    template
+    inline void writePacket(int index, const PacketScalar& x)
+    {
+      m_expression.const_cast_derived().template writePacket(index, x);
+    }
+    
+    operator const ExpressionType&() const { return m_expression; }
+
+  protected:
+    const ExpressionType m_expression;
+
+  private:
+    NestByValue& operator=(const NestByValue&);
+};
+
+/** \returns an expression of the temporary version of *this.
+  */
+template
+inline const NestByValue
+MatrixBase::nestByValue() const
+{
+  return NestByValue(derived());
+}
+
+#endif // EIGEN_NESTBYVALUE_H
diff --git a/Eigen/src/Core/util/ForwardDeclarations.h b/Eigen/src/Core/util/ForwardDeclarations.h
index 8670dccdb..62e4bb31b 100644
--- a/Eigen/src/Core/util/ForwardDeclarations.h
+++ b/Eigen/src/Core/util/ForwardDeclarations.h
@@ -36,6 +36,7 @@ template class Flagged;
 template class NoAlias;
+template class NestByValue;
 template class SwapWrapper;
 template class Minor;
 template
Date: Wed, 2 Dec 2009 11:09:56 +0100
Subject: * remove empty destructors in Matrix.h and MatrixStorage.h

---
 Eigen/src/Core/Matrix.h        | 3 ---
 Eigen/src/Core/MatrixStorage.h | 3 ---
 2 files changed, 6 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/Matrix.h b/Eigen/src/Core/Matrix.h
index 290247978..c2680b71c 100644
--- a/Eigen/src/Core/Matrix.h
+++ b/Eigen/src/Core/Matrix.h
@@ -536,9 +536,6 @@ class Matrix
       other.evalTo(*this);
     }
 
-    /** Destructor */
-    inline ~Matrix() {}
-
     /** \sa MatrixBase::operator=(const AnyMatrixBase&) */
     template
     EIGEN_STRONG_INLINE Matrix& operator=(const AnyMatrixBase &other)
diff --git a/Eigen/src/Core/MatrixStorage.h b/Eigen/src/Core/MatrixStorage.h
index 73b17e63e..8bfa728b6 100644
--- a/Eigen/src/Core/MatrixStorage.h
+++ b/Eigen/src/Core/MatrixStorage.h
@@ -117,7 +117,6 @@ template class ei_matrix_storage class ei_matrix_storage<
     inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert)
       : m_data(ei_constructor_without_unaligned_array_assert()), m_rows(0) {}
     inline ei_matrix_storage(int, int rows, int) : m_rows(rows) {}
-    inline ~ei_matrix_storage() {}
     inline void swap(ei_matrix_storage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); }
     inline int rows(void) const {return m_rows;}
     inline int cols(void) const {return _Cols;}
@@ -163,7 +161,6 @@ template class ei_matrix_storage<
     inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert)
       : m_data(ei_constructor_without_unaligned_array_assert()), m_cols(0) {}
     inline ei_matrix_storage(int, int, int cols) : m_cols(cols) {}
-    inline ~ei_matrix_storage() {}
     inline void swap(ei_matrix_storage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); }
     inline int rows(void) const {return _Rows;}
     inline int cols(void) const {return m_cols;}
-- 
cgit v1.2.3


From e12f5adbdeee6281af8a534652c3d82638630419 Mon Sep 17 00:00:00 2001
From: Gael Guennebaud 
Date: Wed, 2 Dec 2009 19:32:54 +0100
Subject: fix MSVC10 compilation

---
 Eigen/src/Core/Block.h          | 2 +-
 Eigen/src/Core/util/XprHelper.h | 4 ++--
 Eigen/src/Geometry/Hyperplane.h | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/Block.h b/Eigen/src/Core/Block.h
index 5fffdcb01..f9bbf473d 100644
--- a/Eigen/src/Core/Block.h
+++ b/Eigen/src/Core/Block.h
@@ -228,7 +228,7 @@ class Block
 
     class InnerIterator;
     typedef typename ei_traits::AlignedDerivedType AlignedDerivedType;
-    friend class Block;
+    friend class Block;
 
     EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
 
diff --git a/Eigen/src/Core/util/XprHelper.h b/Eigen/src/Core/util/XprHelper.h
index 659b3d7d1..5f3b6286c 100644
--- a/Eigen/src/Core/util/XprHelper.h
+++ b/Eigen/src/Core/util/XprHelper.h
@@ -192,7 +192,7 @@ struct ei_ref_selector
 *       to the user.
 **/
 template
-struct ei_ref_selector< Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _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;
@@ -224,7 +224,7 @@ template::ty
   };
 
   typedef typename ei_meta_if<
-    ( int(ei_traits::Flags) & EvalBeforeNestingBit ) || 
+    ( int(ei_traits::Flags) & EvalBeforeNestingBit ) ||
     ( int(CostEval) <= int(CostNoEval) ),
       PlainMatrixType,
       typename ei_ref_selector::type
diff --git a/Eigen/src/Geometry/Hyperplane.h b/Eigen/src/Geometry/Hyperplane.h
index 49a9ac7bb..aab3d5b35 100644
--- a/Eigen/src/Geometry/Hyperplane.h
+++ b/Eigen/src/Geometry/Hyperplane.h
@@ -52,9 +52,9 @@ public:
   typedef _Scalar Scalar;
   typedef typename NumTraits::Real RealScalar;
   typedef Matrix VectorType;
-  typedef Matrix Coefficients;
+                        : int(AmbientDimAtCompileTime)+1,1> Coefficients;
   typedef Block NormalReturnType;
 
   /** Default constructor without initialization */
-- 
cgit v1.2.3


From 8bfa354ee3267691a7aec6fe576847296e074c90 Mon Sep 17 00:00:00 2001
From: Jitse Niesen 
Date: Tue, 8 Dec 2009 15:12:27 +0000
Subject: Documentation clean up. * remove non-existant reference to CwiseAll *
 define \householder_module (used in HouseholderSequence.h) * update
 I01_TopicLazyEvaluation.dox - Product is now called GeneralProduct * remove
 reference to list of examples which was deleted ages ago * rename
 PartialLU_solve.cpp snippet to PartialPivLU_solve.cpp

---
 Eigen/Householder                   |  2 +-
 Eigen/src/Core/PermutationMatrix.h  |  2 +-
 doc/C01_QuickStartGuide.dox         |  2 +-
 doc/Doxyfile.in                     | 11 ++++++-----
 doc/I01_TopicLazyEvaluation.dox     |  6 +++---
 doc/Overview.dox                    |  2 +-
 doc/snippets/PartialLU_solve.cpp    |  7 -------
 doc/snippets/PartialPivLU_solve.cpp |  7 +++++++
 8 files changed, 20 insertions(+), 19 deletions(-)
 delete mode 100644 doc/snippets/PartialLU_solve.cpp
 create mode 100644 doc/snippets/PartialPivLU_solve.cpp

(limited to 'Eigen/src/Core')

diff --git a/Eigen/Householder b/Eigen/Householder
index 98970ef0c..dcaeeeae8 100644
--- a/Eigen/Householder
+++ b/Eigen/Householder
@@ -8,7 +8,7 @@
 namespace Eigen {
 
 /** \defgroup Householder_Module Householder module
-  * This module provides householder transformations.
+  * This module provides Householder transformations.
   *
   * \code
   * #include 
diff --git a/Eigen/src/Core/PermutationMatrix.h b/Eigen/src/Core/PermutationMatrix.h
index 147c48734..284baf678 100644
--- a/Eigen/src/Core/PermutationMatrix.h
+++ b/Eigen/src/Core/PermutationMatrix.h
@@ -95,7 +95,7 @@ class PermutationMatrix : public AnyMatrixBase
diff --git a/doc/C01_QuickStartGuide.dox b/doc/C01_QuickStartGuide.dox
index 0c545f735..7c4aa8f76 100644
--- a/doc/C01_QuickStartGuide.dox
+++ b/doc/C01_QuickStartGuide.dox
@@ -470,7 +470,7 @@ mat = 2 7 8
 
 Also note that maxCoeff and minCoeff can takes optional arguments returning the coordinates of the respective min/max coeff: \link MatrixBase::maxCoeff(int*,int*) const maxCoeff(int* i, int* j) \endlink, \link MatrixBase::minCoeff(int*,int*) const minCoeff(int* i, int* j) \endlink.
 
-\b Side \b note: The all() and any() functions are especially useful in combination with coeff-wise comparison operators (\ref CwiseAll "example").
+\b Side \b note: The all() and any() functions are especially useful in combination with coeff-wise comparison operators.
 
 
 
diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in
index 497f7ab6c..3d79a300d 100644
--- a/doc/Doxyfile.in
+++ b/doc/Doxyfile.in
@@ -197,14 +197,15 @@ TAB_SIZE               = 8
 
 ALIASES                = "only_for_vectors=This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column." \
                          "array_module=This is defined in the %Array module. \code #include  \endcode" \
-                         "lu_module=This is defined in the %LU module. \code #include  \endcode" \
                          "cholesky_module=This is defined in the %Cholesky module. \code #include  \endcode" \
-                         "qr_module=This is defined in the %QR module. \code #include  \endcode" \
-                         "jacobi_module=This is defined in the %Jacobi module. \code #include  \endcode" \
-                         "svd_module=This is defined in the %SVD module. \code #include  \endcode" \
+                         "eigenvalues_module=This is defined in the %Eigenvalues module. \code #include  \endcode" \
                          "geometry_module=This is defined in the %Geometry module. \code #include  \endcode" \
+                         "householder_module=This is defined in the %Householder module. \code #include  \endcode" \
+                         "jacobi_module=This is defined in the %Jacobi module. \code #include  \endcode" \
                          "leastsquares_module=This is defined in the %LeastSquares module. \code #include  \endcode" \
-                         "eigenvalues_module=This is defined in the %Eigenvalues module. \code #include  \endcode" \
+                         "lu_module=This is defined in the %LU module. \code #include  \endcode" \
+                         "qr_module=This is defined in the %QR module. \code #include  \endcode" \
+                         "svd_module=This is defined in the %SVD module. \code #include  \endcode" \
                          "label=\bug" \
                          "redstar=*" \
                          "nonstableyet=\warning This is not considered to be part of the stable public API yet. Changes may happen in future releases. See \ref Experimental \"Experimental parts of Eigen\"" \
diff --git a/doc/I01_TopicLazyEvaluation.dox b/doc/I01_TopicLazyEvaluation.dox
index f40afa06d..68fa1e2df 100644
--- a/doc/I01_TopicLazyEvaluation.dox
+++ b/doc/I01_TopicLazyEvaluation.dox
@@ -36,7 +36,7 @@ Here is now a more involved example:
 
 Eigen chooses lazy evaluation at every stage in that example, which is clearly the correct choice. In fact, lazy evaluation is the "default choice" and Eigen will choose it except in a few circumstances.
 
-The first circumstance in which Eigen chooses immediate evaluation, is when it sees an assignment a = b; and the expression \c b has the evaluate-before-assigning \link flags flag\endlink. The most important example of such an expression is the \link Product matrix product expression\endlink. For example, when you do
+The first circumstance in which Eigen chooses immediate evaluation, is when it sees an assignment a = b; and the expression \c b has the evaluate-before-assigning \link flags flag\endlink. The most important example of such an expression is the \link GeneralProduct matrix product expression\endlink. For example, when you do
 
 \code matrix = matrix * matrix; \endcode
 
@@ -48,7 +48,7 @@ What if you know that the result does no alias the operand of the product and wa
 
 Here, since we know that matrix2 is not the same matrix as matrix1, we know that lazy evaluation is not dangerous, so we may force lazy evaluation. Concretely, the effect of noalias() here is to bypass the evaluate-before-assigning \link flags flag\endlink.
 
-The second circumstance in which Eigen chooses immediate evaluation, is when it sees a nested expression such as a + b where \c b is already an expression having the evaluate-before-nesting \link flags flag\endlink. Again, the most important example of such an expression is the \link Product matrix product expression\endlink. For example, when you do
+The second circumstance in which Eigen chooses immediate evaluation, is when it sees a nested expression such as a + b where \c b is already an expression having the evaluate-before-nesting \link flags flag\endlink. Again, the most important example of such an expression is the \link GeneralProduct matrix product expression\endlink. For example, when you do
 
 \code matrix1 = matrix2 + matrix3 * matrix4; \endcode
 
@@ -62,4 +62,4 @@ Here, provided the matrices have at least 2 rows and 2 columns, each coefficienc
 
 */
 
-}
\ No newline at end of file
+}
diff --git a/doc/Overview.dox b/doc/Overview.dox
index db0d9587a..78bf5f9dd 100644
--- a/doc/Overview.dox
+++ b/doc/Overview.dox
@@ -15,7 +15,7 @@ For a first contact with Eigen, the best place is to have a look at the \ref Tut
 
 Most of the API is available as methods in MatrixBase, so this is a good starting point for browsing. Also have a look at Matrix, as a few methods and the matrix constructors are there. Other notable classes for the Eigen API are Cwise, which contains the methods for doing certain coefficient-wise operations, and Part.
 
-In fact, except for advanced use, the only class that you'll have to explicitly name in your program, i.e. of which you'll explicitly contruct objects, is Matrix. For instance, vectors are handled as a special case of Matrix with one column. Typedefs are provided, e.g. Vector2f is a typedef for Matrix. Finally, you might also have look at the \ref ExampleList "the list of selected examples".
+In fact, except for advanced use, the only class that you'll have to explicitly name in your program, i.e. of which you'll explicitly contruct objects, is Matrix. For instance, vectors are handled as a special case of Matrix with one column. Typedefs are provided, e.g. Vector2f is a typedef for Matrix.
 
 Most of the other classes are just return types for MatrixBase methods.
 
diff --git a/doc/snippets/PartialLU_solve.cpp b/doc/snippets/PartialLU_solve.cpp
deleted file mode 100644
index fa3570ab8..000000000
--- a/doc/snippets/PartialLU_solve.cpp
+++ /dev/null
@@ -1,7 +0,0 @@
-MatrixXd A = MatrixXd::Random(3,3);
-MatrixXd B = MatrixXd::Random(3,2);
-cout << "Here is the invertible matrix A:" << endl << A << endl;
-cout << "Here is the matrix B:" << endl << B << endl;
-MatrixXd X = A.lu().solve(B);
-cout << "Here is the (unique) solution X to the equation AX=B:" << endl << X << endl;
-cout << "Relative error: " << (A*X-B).norm() / B.norm() << endl;
diff --git a/doc/snippets/PartialPivLU_solve.cpp b/doc/snippets/PartialPivLU_solve.cpp
new file mode 100644
index 000000000..fa3570ab8
--- /dev/null
+++ b/doc/snippets/PartialPivLU_solve.cpp
@@ -0,0 +1,7 @@
+MatrixXd A = MatrixXd::Random(3,3);
+MatrixXd B = MatrixXd::Random(3,2);
+cout << "Here is the invertible matrix A:" << endl << A << endl;
+cout << "Here is the matrix B:" << endl << B << endl;
+MatrixXd X = A.lu().solve(B);
+cout << "Here is the (unique) solution X to the equation AX=B:" << endl << X << endl;
+cout << "Relative error: " << (A*X-B).norm() / B.norm() << endl;
-- 
cgit v1.2.3


From d2e44f263631981d9e547caafe36b1de5ba785f9 Mon Sep 17 00:00:00 2001
From: Benoit Jacob 
Date: Wed, 9 Dec 2009 12:43:25 -0500
Subject: * 4x4 inverse: revert to cofactors method * inverse tests: use
 createRandomMatrixOfRank, use more strict precision * tests:
 createRandomMatrixOfRank: support 1x1 matrices * determinant: nest the xpr *
 Minor: add comment

---
 Eigen/src/Core/Minor.h     |   5 ++-
 Eigen/src/LU/Determinant.h |   4 +-
 Eigen/src/LU/Inverse.h     | 101 ++++++++-------------------------------------
 test/inverse.cpp           |  11 +----
 test/main.h                |  15 ++++++-
 test/prec_inverse_4x4.cpp  |  28 ++-----------
 6 files changed, 43 insertions(+), 121 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/Minor.h b/Eigen/src/Core/Minor.h
index ab058b187..eb44f3760 100644
--- a/Eigen/src/Core/Minor.h
+++ b/Eigen/src/Core/Minor.h
@@ -1,7 +1,7 @@
 // This file is part of Eigen, a lightweight C++ template library
 // for linear algebra.
 //
-// Copyright (C) 2006-2008 Benoit Jacob 
+// Copyright (C) 2006-2009 Benoit Jacob 
 //
 // Eigen is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
@@ -54,7 +54,8 @@ struct ei_traits >
     MaxColsAtCompileTime = (MatrixType::MaxColsAtCompileTime != Dynamic) ?
                              int(MatrixType::MaxColsAtCompileTime) - 1 : Dynamic,
     Flags = _MatrixTypeNested::Flags & HereditaryBits,
-    CoeffReadCost = _MatrixTypeNested::CoeffReadCost
+    CoeffReadCost = _MatrixTypeNested::CoeffReadCost // minor is used typically on tiny matrices,
+      // where loops are unrolled and the 'if' evaluates at compile time
   };
 };
 
diff --git a/Eigen/src/LU/Determinant.h b/Eigen/src/LU/Determinant.h
index 8870d9f20..27ad6abe9 100644
--- a/Eigen/src/LU/Determinant.h
+++ b/Eigen/src/LU/Determinant.h
@@ -118,7 +118,9 @@ template
 inline typename ei_traits::Scalar MatrixBase::determinant() const
 {
   assert(rows() == cols());
-  return ei_determinant_impl::run(derived());
+  typedef typename ei_nested::type Nested;
+  Nested nested(derived());
+  return ei_determinant_impl::type>::run(nested);
 }
 
 #endif // EIGEN_DETERMINANT_H
diff --git a/Eigen/src/LU/Inverse.h b/Eigen/src/LU/Inverse.h
index 9d5e86845..8afbfda96 100644
--- a/Eigen/src/LU/Inverse.h
+++ b/Eigen/src/LU/Inverse.h
@@ -182,93 +182,28 @@ struct ei_compute_inverse_and_det_with_check
 *** Size 4 implementation ***
 ****************************/
 
-template
-void ei_compute_inverse_size4_helper(const MatrixType& matrix, ResultType& result)
-{
-  /* Let's split M into four 2x2 blocks:
-    * (P Q)
-    * (R S)
-    * If P is invertible, with inverse denoted by P_inverse, and if
-    * (S - R*P_inverse*Q) is also invertible, then the inverse of M is
-    * (P' Q')
-    * (R' S')
-    * where
-    * S' = (S - R*P_inverse*Q)^(-1)
-    * P' = P1 + (P1*Q) * S' *(R*P_inverse)
-    * Q' = -(P_inverse*Q) * S'
-    * R' = -S' * (R*P_inverse)
-    */
-  typedef Block XprBlock22;
-  typedef typename MatrixBase::PlainMatrixType Block22;
-  Block22 P_inverse;
-  ei_compute_inverse::run(matrix.template block<2,2>(0,0), P_inverse);
-  const Block22 Q = matrix.template block<2,2>(0,2);
-  const Block22 P_inverse_times_Q = P_inverse * Q;
-  const XprBlock22 R = matrix.template block<2,2>(2,0);
-  const Block22 R_times_P_inverse = R * P_inverse;
-  const Block22 R_times_P_inverse_times_Q = R_times_P_inverse * Q;
-  const XprBlock22 S = matrix.template block<2,2>(2,2);
-  const Block22 X = S - R_times_P_inverse_times_Q;
-  Block22 Y;
-  ei_compute_inverse::run(X, Y);
-  result.template block<2,2>(2,2) = Y;
-  result.template block<2,2>(2,0) = - Y * R_times_P_inverse;
-  const Block22 Z = P_inverse_times_Q * Y;
-  result.template block<2,2>(0,2) = - Z;
-  result.template block<2,2>(0,0) = P_inverse + Z * R_times_P_inverse;
-}
-
 template
 struct ei_compute_inverse
 {
-  static inline void run(const MatrixType& _matrix, ResultType& result)
+  static inline void run(const MatrixType& matrix, ResultType& result)
   {
-    typedef typename ResultType::Scalar Scalar;
-    typedef typename MatrixType::RealScalar RealScalar;
-
-    // we will do row permutations on the matrix. This copy should have negligible cost.
-    // if not, consider working in-place on the matrix (const-cast it, but then undo the permutations
-    // to nevertheless honor constness)
-    typename MatrixType::PlainMatrixType matrix(_matrix);
-
-    // let's extract from the 2 first colums a 2x2 block whose determinant is as big as possible.
-    int good_row0, good_row1, good_i;
-    Matrix absdet;
-
-    // any 2x2 block with determinant above this threshold will be considered good enough.
-    // The magic value 1e-1 here comes from experimentation. The bigger it is, the higher the precision,
-    // the slower the computation. This value 1e-1 gives precision almost as good as the brutal cofactors
-    // algorithm, both in average and in worst-case precision.
-    RealScalar d = (matrix.col(0).squaredNorm()+matrix.col(1).squaredNorm()) * RealScalar(1e-1);
-    #define ei_inv_size4_helper_macro(i,row0,row1) \
-    absdet[i] = ei_abs(matrix.coeff(row0,0)*matrix.coeff(row1,1) \
-                                 - matrix.coeff(row0,1)*matrix.coeff(row1,0)); \
-    if(absdet[i] > d) { good_row0=row0; good_row1=row1; goto good; }
-    ei_inv_size4_helper_macro(0,0,1)
-    ei_inv_size4_helper_macro(1,0,2)
-    ei_inv_size4_helper_macro(2,0,3)
-    ei_inv_size4_helper_macro(3,1,2)
-    ei_inv_size4_helper_macro(4,1,3)
-    ei_inv_size4_helper_macro(5,2,3)
-
-    // no 2x2 block has determinant bigger than the threshold. So just take the one that
-    // has the biggest determinant
-    absdet.maxCoeff(&good_i);
-    good_row0 = good_i <= 2 ? 0 : good_i <= 4 ? 1 : 2;
-    good_row1 = good_i <= 2 ? good_i+1 : good_i <= 4 ? good_i-1 : 3;
-
-    // now good_row0 and good_row1 are correctly set
-    good:
-    
-    // do row permutations to move this 2x2 block to the top
-    matrix.row(0).swap(matrix.row(good_row0));
-    matrix.row(1).swap(matrix.row(good_row1));
-    // now applying our helper function is numerically stable
-    ei_compute_inverse_size4_helper(matrix, result);
-    // Since we did row permutations on the original matrix, we need to do column permutations
-    // in the reverse order on the inverse
-    result.col(1).swap(result.col(good_row1));
-    result.col(0).swap(result.col(good_row0));
+    result.coeffRef(0,0) = matrix.minor(0,0).determinant();
+    result.coeffRef(1,0) = -matrix.minor(0,1).determinant();
+    result.coeffRef(2,0) = matrix.minor(0,2).determinant();
+    result.coeffRef(3,0) = -matrix.minor(0,3).determinant();
+    result.coeffRef(0,2) = matrix.minor(2,0).determinant();
+    result.coeffRef(1,2) = -matrix.minor(2,1).determinant();
+    result.coeffRef(2,2) = matrix.minor(2,2).determinant();
+    result.coeffRef(3,2) = -matrix.minor(2,3).determinant();
+    result.coeffRef(0,1) = -matrix.minor(1,0).determinant();
+    result.coeffRef(1,1) = matrix.minor(1,1).determinant();
+    result.coeffRef(2,1) = -matrix.minor(1,2).determinant();
+    result.coeffRef(3,1) = matrix.minor(1,3).determinant();
+    result.coeffRef(0,3) = -matrix.minor(3,0).determinant();
+    result.coeffRef(1,3) = matrix.minor(3,1).determinant();
+    result.coeffRef(2,3) = -matrix.minor(3,2).determinant();
+    result.coeffRef(3,3) = matrix.minor(3,3).determinant();
+    result /= (matrix.col(0).cwise()*result.row(0).transpose()).sum();
   }
 };
 
diff --git a/test/inverse.cpp b/test/inverse.cpp
index 59b791507..b80e139e0 100644
--- a/test/inverse.cpp
+++ b/test/inverse.cpp
@@ -38,18 +38,11 @@ template void inverse(const MatrixType& m)
   typedef typename NumTraits::Real RealScalar;
   typedef Matrix VectorType;
 
-  MatrixType m1 = MatrixType::Random(rows, cols),
+  MatrixType m1(rows, cols),
              m2(rows, cols),
              mzero = MatrixType::Zero(rows, cols),
              identity = MatrixType::Identity(rows, rows);
-
-  if (ei_is_same_type::ret)
-  {
-    // let's build a more stable to inverse matrix
-    MatrixType a = MatrixType::Random(rows,cols);
-    m1 += m1 * m1.adjoint() + a * a.adjoint();
-  }
-
+  createRandomMatrixOfRank(rows,rows,rows,m1);
   m2 = m1.inverse();
   VERIFY_IS_APPROX(m1, m2.inverse() );
 
diff --git a/test/main.h b/test/main.h
index 8bc71b3ae..06c17a9ae 100644
--- a/test/main.h
+++ b/test/main.h
@@ -353,13 +353,26 @@ void createRandomMatrixOfRank(int desired_rank, int rows, int cols, MatrixType&
   typedef Matrix MatrixAType;
   typedef Matrix MatrixBType;
 
+  if(desired_rank == 0)
+  {
+    m.setZero(rows,cols);
+    return;
+  }
+
+  if(desired_rank == 1)
+  {
+    m = VectorType::Random(rows) * VectorType::Random(cols).transpose();
+    return;
+  }
+
   MatrixAType a = MatrixAType::Random(rows,rows);
   MatrixType d = MatrixType::Identity(rows,cols);
   MatrixBType  b = MatrixBType::Random(cols,cols);
 
   // set the diagonal such that only desired_rank non-zero entries reamain
   const int diag_size = std::min(d.rows(),d.cols());
-  d.diagonal().segment(desired_rank, diag_size-desired_rank) = VectorType::Zero(diag_size-desired_rank);
+  if(diag_size != desired_rank)
+    d.diagonal().segment(desired_rank, diag_size-desired_rank) = VectorType::Zero(diag_size-desired_rank);
 
   HouseholderQR qra(a);
   HouseholderQR qrb(b);
diff --git a/test/prec_inverse_4x4.cpp b/test/prec_inverse_4x4.cpp
index 613535346..83b1a8a71 100644
--- a/test/prec_inverse_4x4.cpp
+++ b/test/prec_inverse_4x4.cpp
@@ -26,28 +26,6 @@
 #include 
 #include 
 
-Matrix4f inverse(const Matrix4f& m)
-{
-  Matrix4f r;
-  r(0,0) = m.minor(0,0).determinant();
-  r(1,0) = -m.minor(0,1).determinant();
-  r(2,0) = m.minor(0,2).determinant();
-  r(3,0) = -m.minor(0,3).determinant();
-  r(0,2) = m.minor(2,0).determinant();
-  r(1,2) = -m.minor(2,1).determinant();
-  r(2,2) = m.minor(2,2).determinant();
-  r(3,2) = -m.minor(2,3).determinant();
-  r(0,1) = -m.minor(1,0).determinant();
-  r(1,1) = m.minor(1,1).determinant();
-  r(2,1) = -m.minor(1,2).determinant();
-  r(3,1) = m.minor(1,3).determinant();
-  r(0,3) = -m.minor(3,0).determinant();
-  r(1,3) = m.minor(3,1).determinant();
-  r(2,3) = -m.minor(3,2).determinant();
-  r(3,3) = m.minor(3,3).determinant();
-  return r / (m(0,0)*r(0,0) + m(1,0)*r(0,1) + m(2,0)*r(0,2) + m(3,0)*r(0,3));
-}
-
 template void inverse_permutation_4x4()
 {
   typedef typename MatrixType::Scalar Scalar;
@@ -79,7 +57,7 @@ template void inverse_general_4x4(int repeat)
     do {
       m = MatrixType::Random();
       absdet = ei_abs(m.determinant());
-    } while(absdet < 10 * epsilon());
+    } while(absdet < epsilon());
     MatrixType inv = m.inverse();
     double error = double( (m*inv-MatrixType::Identity()).norm() * absdet / epsilon() );
     error_sum += error;
@@ -89,8 +67,8 @@ template void inverse_general_4x4(int repeat)
   double error_avg = error_sum / repeat;
   EIGEN_DEBUG_VAR(error_avg);
   EIGEN_DEBUG_VAR(error_max);
-  VERIFY(error_avg < (NumTraits::IsComplex ? 8.4 : 1.4) );
-  VERIFY(error_max < (NumTraits::IsComplex ? 160.0 : 75.) );
+  VERIFY(error_avg < (NumTraits::IsComplex ? 8.0 : 1.0));
+  VERIFY(error_max < (NumTraits::IsComplex ? 64.0 : 16.0));
 }
 
 void test_prec_inverse_4x4()
-- 
cgit v1.2.3


From d088ee35f644f9178270f0c3dc8c76011d208099 Mon Sep 17 00:00:00 2001
From: Hauke Heibel 
Date: Sat, 12 Dec 2009 11:39:07 +0100
Subject: Added to possibility to compile unit tests at maximum warning level.
 Silenced (amongst others) many conversion related warnings.

---
 CMakeLists.txt                                            |  3 ++-
 Eigen/src/Array/Functors.h                                |  4 ++++
 Eigen/src/Array/VectorwiseOp.h                            |  2 ++
 Eigen/src/Cholesky/LDLT.h                                 |  2 ++
 Eigen/src/Cholesky/LLT.h                                  |  2 ++
 Eigen/src/Core/Flagged.h                                  |  3 +++
 Eigen/src/Core/SelfAdjointView.h                          |  4 +++-
 Eigen/src/Core/util/Memory.h                              | 10 +++++-----
 Eigen/src/Geometry/Homogeneous.h                          |  4 ++++
 Eigen/src/LU/FullPivLU.h                                  |  9 +++++++++
 Eigen/src/LU/Inverse.h                                    |  2 ++
 Eigen/src/QR/HouseholderQR.h                              |  2 ++
 Eigen/src/SVD/SVD.h                                       |  4 +++-
 Eigen/src/Sparse/CompressedStorage.h                      |  4 ++--
 Eigen/src/Sparse/DynamicSparseMatrix.h                    |  6 +++---
 Eigen/src/Sparse/RandomSetter.h                           |  2 +-
 Eigen/src/Sparse/SparseBlock.h                            |  2 ++
 Eigen/src/Sparse/SparseCwise.h                            |  3 +++
 Eigen/src/Sparse/SparseCwiseBinaryOp.h                    |  7 +++++++
 Eigen/src/Sparse/SparseCwiseUnaryOp.h                     |  3 +++
 Eigen/src/Sparse/SparseDiagonalProduct.h                  |  4 ++++
 Eigen/src/Sparse/SparseFlagged.h                          |  6 ++++++
 Eigen/src/Sparse/SparseMatrix.h                           |  9 ++++++---
 Eigen/src/Sparse/SparseTranspose.h                        |  6 ++++++
 Eigen/src/Sparse/SparseTriangular.h                       |  3 +++
 Eigen/src/Sparse/SparseVector.h                           |  6 +++---
 Eigen/src/misc/Image.h                                    |  9 ++++++---
 Eigen/src/misc/Kernel.h                                   |  7 +++++--
 Eigen/src/misc/Solve.h                                    |  7 +++++--
 cmake/EigenTesting.cmake                                  | 12 +++++++++---
 test/sparse_basic.cpp                                     |  4 ++--
 unsupported/Eigen/FFT                                     |  4 ++--
 unsupported/Eigen/src/BVH/BVAlgorithms.h                  |  4 ++++
 unsupported/Eigen/src/BVH/KdBVH.h                         |  4 ++--
 unsupported/Eigen/src/FFT/ei_kissfft_impl.h               |  4 ++--
 unsupported/Eigen/src/MatrixFunctions/MatrixExponential.h |  2 +-
 unsupported/test/Complex.cpp                              |  2 +-
 unsupported/test/FFT.cpp                                  |  8 ++++----
 38 files changed, 135 insertions(+), 44 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d1d9b12de..a7d4089c0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -124,7 +124,8 @@ endif(EIGEN_TEST_NO_EXPLICIT_VECTORIZATION)
 
 option(EIGEN_TEST_C++0x "Enables all C++0x features." OFF)
 
-option(EIGEN_TEST_RVALUE_REF_SUPPORT "Enable rvalue references for unit tests." OFF)
+option(EIGEN_TEST_MAX_WARNING_LEVEL "Sets the warning level to /Wall while building the unit tests." OFF)
+mark_as_advanced(EIGEN_TEST_MAX_WARNING_LEVEL)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 
diff --git a/Eigen/src/Array/Functors.h b/Eigen/src/Array/Functors.h
index fd259f7bc..3a7753d04 100644
--- a/Eigen/src/Array/Functors.h
+++ b/Eigen/src/Array/Functors.h
@@ -43,6 +43,8 @@ struct ei_scalar_add_op {
   inline const PacketScalar packetOp(const PacketScalar& a) const
   { return ei_padd(a, ei_pset1(m_other)); }
   const Scalar m_other;
+private:
+  ei_scalar_add_op& operator=(const ei_scalar_add_op&);
 };
 template
 struct ei_functor_traits >
@@ -128,6 +130,8 @@ struct ei_scalar_pow_op {
   inline ei_scalar_pow_op(const Scalar& exponent) : m_exponent(exponent) {}
   inline Scalar operator() (const Scalar& a) const { return ei_pow(a, m_exponent); }
   const Scalar m_exponent;
+private:
+  ei_scalar_pow_op& operator=(const ei_scalar_pow_op&);
 };
 template
 struct ei_functor_traits >
diff --git a/Eigen/src/Array/VectorwiseOp.h b/Eigen/src/Array/VectorwiseOp.h
index 71b83eaad..92e5cc000 100644
--- a/Eigen/src/Array/VectorwiseOp.h
+++ b/Eigen/src/Array/VectorwiseOp.h
@@ -147,6 +147,8 @@ struct ei_member_redux {
   inline result_type operator()(const MatrixBase& mat) const
   { return mat.redux(m_functor); }
   const BinaryOp m_functor;
+private:
+  ei_member_redux& operator=(const ei_member_redux&);
 };
 
 /** \array_module \ingroup Array_Module
diff --git a/Eigen/src/Cholesky/LDLT.h b/Eigen/src/Cholesky/LDLT.h
index d0f292634..2898d8747 100644
--- a/Eigen/src/Cholesky/LDLT.h
+++ b/Eigen/src/Cholesky/LDLT.h
@@ -275,6 +275,8 @@ struct ei_solve_retval, Rhs>
     dst = rhs();
     dec().solveInPlace(dst);
   }
+private:
+  ei_solve_retval& operator=(const ei_solve_retval&);
 };
 
 /** This is the \em in-place version of solve().
diff --git a/Eigen/src/Cholesky/LLT.h b/Eigen/src/Cholesky/LLT.h
index ad737aaeb..871530aef 100644
--- a/Eigen/src/Cholesky/LLT.h
+++ b/Eigen/src/Cholesky/LLT.h
@@ -270,6 +270,8 @@ struct ei_solve_retval, Rhs>
     dst = rhs();
     dec().solveInPlace(dst);
   }
+private:
+  ei_solve_retval_base& operator=(const ei_solve_retval_base&);
 };
 
 /** This is the \em in-place version of solve().
diff --git a/Eigen/src/Core/Flagged.h b/Eigen/src/Core/Flagged.h
index 754eaf6c5..b98861f42 100644
--- a/Eigen/src/Core/Flagged.h
+++ b/Eigen/src/Core/Flagged.h
@@ -111,6 +111,9 @@ template clas
 
   protected:
     ExpressionTypeNested m_matrix;
+
+  private:
+    Flagged& operator=(const Flagged&);
 };
 
 /** \deprecated it is only used by lazy() which is deprecated
diff --git a/Eigen/src/Core/SelfAdjointView.h b/Eigen/src/Core/SelfAdjointView.h
index 95ce666c9..9518a6498 100644
--- a/Eigen/src/Core/SelfAdjointView.h
+++ b/Eigen/src/Core/SelfAdjointView.h
@@ -150,8 +150,10 @@ template class SelfAdjointView
     const LDLT ldlt() const;
 
   protected:
-
     const typename MatrixType::Nested m_matrix;
+
+  private:
+    SelfAdjointView& operator=(const SelfAdjointView&);
 };
 
 
diff --git a/Eigen/src/Core/util/Memory.h b/Eigen/src/Core/util/Memory.h
index bc5235582..1bff682ff 100644
--- a/Eigen/src/Core/util/Memory.h
+++ b/Eigen/src/Core/util/Memory.h
@@ -210,15 +210,15 @@ template inline void ei_conditional_aligned_delete(T *pt
 }
 
 /** \internal \returns the number of elements which have to be skipped such that data are 16 bytes aligned */
-template
-inline static int ei_alignmentOffset(const Scalar* ptr, int maxOffset)
+template
+inline static Integer ei_alignmentOffset(const Scalar* ptr, Integer maxOffset)
 {
   typedef typename ei_packet_traits::type Packet;
-  const int PacketSize = ei_packet_traits::size;
-  const int PacketAlignedMask = PacketSize-1;
+  const Integer PacketSize = ei_packet_traits::size;
+  const Integer PacketAlignedMask = PacketSize-1;
   const bool Vectorized = PacketSize>1;
   return Vectorized
-          ? std::min( (PacketSize - (int((size_t(ptr)/sizeof(Scalar))) & PacketAlignedMask))
+          ? std::min( (PacketSize - (Integer((Integer(ptr)/sizeof(Scalar))) & PacketAlignedMask))
                            & PacketAlignedMask, maxOffset)
           : 0;
 }
diff --git a/Eigen/src/Geometry/Homogeneous.h b/Eigen/src/Geometry/Homogeneous.h
index ffa828f71..f2a2fe73e 100644
--- a/Eigen/src/Geometry/Homogeneous.h
+++ b/Eigen/src/Geometry/Homogeneous.h
@@ -241,6 +241,8 @@ struct ei_homogeneous_left_product_impl,Lhs>
 
   const typename Lhs::Nested m_lhs;
   const typename MatrixType::Nested m_rhs;
+private:
+  ei_homogeneous_left_product_impl& operator=(const ei_homogeneous_left_product_impl&);
 };
 
 template
@@ -280,6 +282,8 @@ struct ei_homogeneous_right_product_impl,Rhs>
   const typename MatrixType::Nested m_lhs;
   const typename Rhs::Nested m_rhs;
 
+private:
+  ei_homogeneous_right_product_impl& operator=(const ei_homogeneous_right_product_impl&);
 };
 
 #endif // EIGEN_HOMOGENEOUS_H
diff --git a/Eigen/src/LU/FullPivLU.h b/Eigen/src/LU/FullPivLU.h
index 1358c9490..5505d3bee 100644
--- a/Eigen/src/LU/FullPivLU.h
+++ b/Eigen/src/LU/FullPivLU.h
@@ -562,6 +562,9 @@ struct ei_kernel_retval >
     for(int i = rank(); i < cols; ++i) dst.row(dec().permutationQ().indices().coeff(i)).setZero();
     for(int k = 0; k < dimker; ++k) dst.coeffRef(dec().permutationQ().indices().coeff(rank()+k), k) = Scalar(1);
   }
+
+private:
+  ei_kernel_retval& operator=(const ei_kernel_retval&);
 };
 
 /***** Implementation of image() *****************************************************/
@@ -599,6 +602,9 @@ struct ei_image_retval >
     for(int i = 0; i < rank(); ++i)
       dst.col(i) = originalMatrix().col(dec().permutationQ().indices().coeff(pivots.coeff(i)));
   }
+
+private:
+  ei_image_retval& operator=(const ei_image_retval&);
 };
 
 /***** Implementation of solve() *****************************************************/
@@ -659,6 +665,9 @@ struct ei_solve_retval, Rhs>
     for(int i = nonzero_pivots; i < dec().matrixLU().cols(); ++i)
       dst.row(dec().permutationQ().indices().coeff(i)).setZero();
   }
+
+private:
+  ei_solve_retval& operator=(const ei_solve_retval&);
 };
 
 /******* MatrixBase methods *****************************************************************/
diff --git a/Eigen/src/LU/Inverse.h b/Eigen/src/LU/Inverse.h
index 8afbfda96..c31b3502e 100644
--- a/Eigen/src/LU/Inverse.h
+++ b/Eigen/src/LU/Inverse.h
@@ -258,6 +258,8 @@ struct ei_inverse_impl : public ReturnByValue >
   {
     ei_compute_inverse::run(m_matrix, dst);
   }
+private:
+  ei_inverse_impl& operator=(const ei_inverse_impl&);
 };
 
 /** \lu_module
diff --git a/Eigen/src/QR/HouseholderQR.h b/Eigen/src/QR/HouseholderQR.h
index 95496b943..3b174a873 100644
--- a/Eigen/src/QR/HouseholderQR.h
+++ b/Eigen/src/QR/HouseholderQR.h
@@ -237,6 +237,8 @@ struct ei_solve_retval, Rhs>
     dst.corner(TopLeft, rank, c.cols()) = c.corner(TopLeft, rank, c.cols());
     dst.corner(BottomLeft, cols-rank, c.cols()).setZero();
   }
+private:
+  ei_solve_retval& operator=(const ei_solve_retval&);
 };
 
 #endif // EIGEN_HIDE_HEAVY_CODE
diff --git a/Eigen/src/SVD/SVD.h b/Eigen/src/SVD/SVD.h
index 3c7aaf322..a90704cb9 100644
--- a/Eigen/src/SVD/SVD.h
+++ b/Eigen/src/SVD/SVD.h
@@ -190,7 +190,7 @@ SVD& SVD::compute(const MatrixType& matrix)
   SingularValuesType& W = m_sigma;
 
   bool flag;
-  int i,its,j,k,l,nm;
+  int i=0,its=0,j=0,k=0,l=0,nm=0;
   Scalar anorm, c, f, g, h, s, scale, x, y, z;
   bool convergence = true;
   Scalar eps = dummy_precision();
@@ -456,6 +456,8 @@ struct ei_solve_retval, Rhs>
       dst.col(j) = dec().matrixV() * dst.col(j);
     }
   }
+private:
+  ei_solve_retval& operator=(const ei_solve_retval&);
 };
 
 /** Computes the polar decomposition of the matrix, as a product unitary x positive.
diff --git a/Eigen/src/Sparse/CompressedStorage.h b/Eigen/src/Sparse/CompressedStorage.h
index fcf5c7bfe..b25b05e91 100644
--- a/Eigen/src/Sparse/CompressedStorage.h
+++ b/Eigen/src/Sparse/CompressedStorage.h
@@ -93,7 +93,7 @@ class CompressedStorage
 
     void append(const Scalar& v, int i)
     {
-      int id = m_size;
+      int id = static_cast(m_size);
       resize(m_size+1, 1);
       m_values[id] = v;
       m_indices[id] = i;
@@ -135,7 +135,7 @@ class CompressedStorage
         else
           end = mid;
       }
-      return start;
+      return static_cast(start);
     }
     
     /** \returns the stored value at index \a key
diff --git a/Eigen/src/Sparse/DynamicSparseMatrix.h b/Eigen/src/Sparse/DynamicSparseMatrix.h
index 189a56bd0..f4f83533a 100644
--- a/Eigen/src/Sparse/DynamicSparseMatrix.h
+++ b/Eigen/src/Sparse/DynamicSparseMatrix.h
@@ -88,7 +88,7 @@ class DynamicSparseMatrix
     inline int rows() const { return IsRowMajor ? outerSize() : m_innerSize; }
     inline int cols() const { return IsRowMajor ? m_innerSize : outerSize(); }
     inline int innerSize() const { return m_innerSize; }
-    inline int outerSize() const { return m_data.size(); }
+    inline int outerSize() const { return static_cast(m_data.size()); }
     inline int innerNonZeros(int j) const { return m_data[j].size(); }
 
     std::vector >& _data() { return m_data; }
@@ -128,7 +128,7 @@ class DynamicSparseMatrix
     {
       int res = 0;
       for (int j=0; j(m_data[j].size());
       return res;
     }
 
@@ -195,7 +195,7 @@ class DynamicSparseMatrix
       const int inner = IsRowMajor ? col : row;
 
       int startId = 0;
-      int id = m_data[outer].size() - 1;
+      int id = static_cast(m_data[outer].size()) - 1;
       m_data[outer].resize(id+2,1);
 
       while ( (id >= startId) && (m_data[outer].index(id) > inner) )
diff --git a/Eigen/src/Sparse/RandomSetter.h b/Eigen/src/Sparse/RandomSetter.h
index 50824eba1..b34ca19a8 100644
--- a/Eigen/src/Sparse/RandomSetter.h
+++ b/Eigen/src/Sparse/RandomSetter.h
@@ -322,7 +322,7 @@ class RandomSetter
     {
       int nz = 0;
       for (int k=0; k(m_hashmaps[k].size());
       return nz;
     }
 
diff --git a/Eigen/src/Sparse/SparseBlock.h b/Eigen/src/Sparse/SparseBlock.h
index 6659a88e2..1fe919736 100644
--- a/Eigen/src/Sparse/SparseBlock.h
+++ b/Eigen/src/Sparse/SparseBlock.h
@@ -220,6 +220,8 @@ class SparseInnerVectorSet, Size>
         inline int col() const { return IsRowMajor ? this->index() : m_outer; }
       protected:
         int m_outer;
+      private:
+        InnerIterator& operator=(const InnerIterator&);
     };
 
     inline SparseInnerVectorSet(const MatrixType& matrix, int outerStart, int outerSize)
diff --git a/Eigen/src/Sparse/SparseCwise.h b/Eigen/src/Sparse/SparseCwise.h
index bf8f2355c..c2e302956 100644
--- a/Eigen/src/Sparse/SparseCwise.h
+++ b/Eigen/src/Sparse/SparseCwise.h
@@ -156,6 +156,9 @@ template class SparseCwise
 
   protected:
     ExpressionTypeNested m_matrix;
+
+  private:
+    SparseCwise& operator=(const SparseCwise&);
 };
 
 template
diff --git a/Eigen/src/Sparse/SparseCwiseBinaryOp.h b/Eigen/src/Sparse/SparseCwiseBinaryOp.h
index 2dcd6b944..bb93b60ef 100644
--- a/Eigen/src/Sparse/SparseCwiseBinaryOp.h
+++ b/Eigen/src/Sparse/SparseCwiseBinaryOp.h
@@ -126,6 +126,9 @@ class SparseCwiseBinaryOp::InnerIterator
     EIGEN_STRONG_INLINE InnerIterator(const SparseCwiseBinaryOp& binOp, int outer)
       : Base(binOp,outer)
     {}
+
+  private:
+    InnerIterator& operator=(const InnerIterator&);
 };
 
 /***************************************************************************
@@ -197,6 +200,8 @@ class ei_sparse_cwise_binary_op_inner_iterator_selector,
     LhsIterator m_lhsIter;
     RhsIterator m_rhsIter;
     const BinaryFunc& m_functor;
+  private:
+    ei_sparse_cwise_binary_op_inner_iterator_selector& operator=(const ei_sparse_cwise_binary_op_inner_iterator_selector&);
 };
 
 // sparse - dense  (product)
diff --git a/Eigen/src/Sparse/SparseCwiseUnaryOp.h b/Eigen/src/Sparse/SparseCwiseUnaryOp.h
index 9a73374bd..9c102ed64 100644
--- a/Eigen/src/Sparse/SparseCwiseUnaryOp.h
+++ b/Eigen/src/Sparse/SparseCwiseUnaryOp.h
@@ -90,6 +90,9 @@ class SparseCwiseUnaryOp::InnerIterator
   protected:
     MatrixTypeIterator m_iter;
     const UnaryOp m_functor;
+
+  private:
+    InnerIterator& operator=(const InnerIterator&);
 };
 
 template
diff --git a/Eigen/src/Sparse/SparseDiagonalProduct.h b/Eigen/src/Sparse/SparseDiagonalProduct.h
index e9ba47f70..24f724ad1 100644
--- a/Eigen/src/Sparse/SparseDiagonalProduct.h
+++ b/Eigen/src/Sparse/SparseDiagonalProduct.h
@@ -133,6 +133,8 @@ class ei_sparse_diagonal_product_inner_iterator_selector
               const SparseDiagonalProductType& expr, int outer)
       : Base(expr.rhs().innerVector(outer) .cwise()* expr.lhs().diagonal(), 0)
     {}
+  private:
+    ei_sparse_diagonal_product_inner_iterator_selector& operator=(const ei_sparse_diagonal_product_inner_iterator_selector&);
 };
 
 template
@@ -165,6 +167,8 @@ class ei_sparse_diagonal_product_inner_iterator_selector
               const SparseDiagonalProductType& expr, int outer)
       : Base(expr.lhs().innerVector(outer) .cwise()* expr.rhs().diagonal().transpose(), 0)
     {}
+  private:
+    ei_sparse_diagonal_product_inner_iterator_selector& operator=(const ei_sparse_diagonal_product_inner_iterator_selector&);
 };
 
 // SparseMatrixBase functions
diff --git a/Eigen/src/Sparse/SparseFlagged.h b/Eigen/src/Sparse/SparseFlagged.h
index 386a80abc..34233e5a1 100644
--- a/Eigen/src/Sparse/SparseFlagged.h
+++ b/Eigen/src/Sparse/SparseFlagged.h
@@ -64,6 +64,9 @@ template clas
 
   protected:
     ExpressionTypeNested m_matrix;
+
+  private:
+    SparseFlagged& operator=(const SparseFlagged&);
 };
 
 template
@@ -74,6 +77,9 @@ template
     EIGEN_STRONG_INLINE InnerIterator(const SparseFlagged& xpr, int outer)
       : ExpressionType::InnerIterator(xpr.m_matrix, outer)
     {}
+
+  private:
+    InnerIterator& operator=(const InnerIterator&);
 };
 
 template
diff --git a/Eigen/src/Sparse/SparseMatrix.h b/Eigen/src/Sparse/SparseMatrix.h
index 36fa123fb..e1c740cdb 100644
--- a/Eigen/src/Sparse/SparseMatrix.h
+++ b/Eigen/src/Sparse/SparseMatrix.h
@@ -138,7 +138,7 @@ class SparseMatrix
     }
 
     /** \returns the number of non zero coefficients */
-    inline int nonZeros() const  { return m_data.size(); }
+    inline int nonZeros() const  { return static_cast(m_data.size()); }
 
     /** \deprecated use setZero() and reserve()
       * Initializes the filling process of \c *this.
@@ -236,7 +236,7 @@ class SparseMatrix
         // we start a new inner vector
         while (previousOuter>=0 && m_outerIndex[previousOuter]==0)
         {
-          m_outerIndex[previousOuter] = m_data.size();
+          m_outerIndex[previousOuter] = static_cast(m_data.size());
           --previousOuter;
         }
         m_outerIndex[outer+1] = m_outerIndex[outer];
@@ -335,7 +335,7 @@ class SparseMatrix
       */
     inline void finalize()
     {
-      int size = m_data.size();
+      int size = static_cast(m_data.size());
       int i = m_outerSize;
       // find the last filled column
       while (i>=0 && m_outerIndex[i]==0)
@@ -557,6 +557,9 @@ class SparseMatrix::InnerIterator
     int m_id;
     const int m_start;
     const int m_end;
+
+  private:
+    InnerIterator& operator=(const InnerIterator&);
 };
 
 #endif // EIGEN_SPARSEMATRIX_H
diff --git a/Eigen/src/Sparse/SparseTranspose.h b/Eigen/src/Sparse/SparseTranspose.h
index 9a702739d..2689caf79 100644
--- a/Eigen/src/Sparse/SparseTranspose.h
+++ b/Eigen/src/Sparse/SparseTranspose.h
@@ -62,6 +62,9 @@ template class SparseTranspose
 
   protected:
     const typename MatrixType::Nested m_matrix;
+
+  private:
+    SparseTranspose& operator=(const SparseTranspose&);
 };
 
 template class SparseTranspose::InnerIterator : public MatrixType::InnerIterator
@@ -74,6 +77,9 @@ template class SparseTranspose::InnerIterator :
     {}
     inline int row() const { return Base::col(); }
     inline int col() const { return Base::row(); }
+
+  private:
+    InnerIterator& operator=(const InnerIterator&);
 };
 
 template class SparseTranspose::ReverseInnerIterator : public MatrixType::ReverseInnerIterator
diff --git a/Eigen/src/Sparse/SparseTriangular.h b/Eigen/src/Sparse/SparseTriangular.h
index 42e7ff02a..c3d3ea48f 100644
--- a/Eigen/src/Sparse/SparseTriangular.h
+++ b/Eigen/src/Sparse/SparseTriangular.h
@@ -47,6 +47,9 @@ template class SparseTriangular
     
   protected:
     ExpressionTypeNested m_matrix;
+
+  private:
+    SparseTriangular& operator=(const SparseTriangular&);
 };
 
 template
diff --git a/Eigen/src/Sparse/SparseVector.h b/Eigen/src/Sparse/SparseVector.h
index 1fa1980b2..b87cae856 100644
--- a/Eigen/src/Sparse/SparseVector.h
+++ b/Eigen/src/Sparse/SparseVector.h
@@ -125,7 +125,7 @@ class SparseVector
     inline void setZero() { m_data.clear(); }
 
     /** \returns the number of non zero coefficients */
-    inline int nonZeros() const  { return m_data.size(); }
+    inline int nonZeros() const  { return static_cast(m_data.size()); }
 
     inline void startVec(int outer)
     {
@@ -374,13 +374,13 @@ class SparseVector::InnerIterator
 {
   public:
     InnerIterator(const SparseVector& vec, int outer=0)
-      : m_data(vec.m_data), m_id(0), m_end(m_data.size())
+      : m_data(vec.m_data), m_id(0), m_end(static_cast(m_data.size()))
     {
       ei_assert(outer==0);
     }
 
     InnerIterator(const CompressedStorage& data)
-      : m_data(data), m_id(0), m_end(m_data.size())
+      : m_data(data), m_id(0), m_end(static_cast(m_data.size()))
     {}
 
     template
diff --git a/Eigen/src/misc/Image.h b/Eigen/src/misc/Image.h
index 9ed5d5f70..05ffa667c 100644
--- a/Eigen/src/misc/Image.h
+++ b/Eigen/src/misc/Image.h
@@ -67,9 +67,12 @@ template struct ei_image_retval_base
   }
 
   protected:
-  const DecompositionType& m_dec;
-  int m_rank, m_cols;
-  const MatrixType& m_originalMatrix;
+    const DecompositionType& m_dec;
+    int m_rank, m_cols;
+    const MatrixType& m_originalMatrix;
+
+  private:
+    ei_image_retval_base& operator=(const ei_image_retval_base&);
 };
 
 #define EIGEN_MAKE_IMAGE_HELPERS(DecompositionType) \
diff --git a/Eigen/src/misc/Kernel.h b/Eigen/src/misc/Kernel.h
index 717eef450..bb8458e11 100644
--- a/Eigen/src/misc/Kernel.h
+++ b/Eigen/src/misc/Kernel.h
@@ -67,8 +67,11 @@ template struct ei_kernel_retval_base
   }
 
   protected:
-  const DecompositionType& m_dec;
-  int m_rank, m_cols;
+    const DecompositionType& m_dec;
+    int m_rank, m_cols;
+
+  private:
+    ei_kernel_retval_base& operator=(const ei_kernel_retval_base&);
 };
 
 #define EIGEN_MAKE_KERNEL_HELPERS(DecompositionType) \
diff --git a/Eigen/src/misc/Solve.h b/Eigen/src/misc/Solve.h
index d93869121..75597564b 100644
--- a/Eigen/src/misc/Solve.h
+++ b/Eigen/src/misc/Solve.h
@@ -61,8 +61,11 @@ template struct ei_solve_retval_base
   }
 
   protected:
-  const DecompositionType& m_dec;
-  const typename Rhs::Nested m_rhs;
+    const DecompositionType& m_dec;
+    const typename Rhs::Nested m_rhs;
+
+  private:
+    ei_solve_retval_base& operator=(const ei_solve_retval_base&);
 };
 
 #define EIGEN_MAKE_SOLVE_HELPERS(DecompositionType,Rhs) \
diff --git a/cmake/EigenTesting.cmake b/cmake/EigenTesting.cmake
index 8e52152e4..bb1da41de 100644
--- a/cmake/EigenTesting.cmake
+++ b/cmake/EigenTesting.cmake
@@ -222,9 +222,12 @@ if(CMAKE_COMPILER_IS_GNUCXX)
   else(EIGEN_COVERAGE_TESTING)
     set(COVERAGE_FLAGS "")
   endif(EIGEN_COVERAGE_TESTING)
-  if(EIGEN_TEST_RVALUE_REF_SUPPORT OR EIGEN_TEST_C++0x)
+  if(EIGEN_TEST_C++0x)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++0x")
-  endif(EIGEN_TEST_RVALUE_REF_SUPPORT OR EIGEN_TEST_C++0x)
+  endif(EIGEN_TEST_C++0x)
+  if(EIGEN_TEST_MAX_WARNING_LEVEL)
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wconversion")
+  endif(EIGEN_TEST_MAX_WARNING_LEVEL)  
   if(CMAKE_SYSTEM_NAME MATCHES Linux)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_FLAGS} -g2")
     set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${COVERAGE_FLAGS} -O2 -g2")
@@ -232,5 +235,8 @@ if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${COVERAGE_FLAGS} -O0 -g3")
   endif(CMAKE_SYSTEM_NAME MATCHES Linux)
 elseif(MSVC)
-  set(CMAKE_CXX_FLAGS_DEBUG "/D_DEBUG /MDd /Zi /Ob0 /Od" CACHE STRING "Flags used by the compiler during debug builds." FORCE)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D_CRT_SECURE_NO_WARNINGS /D_SCL_SECURE_NO_WARNINGS")
+  if(EIGEN_TEST_MAX_WARNING_LEVEL)
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
+  endif(EIGEN_TEST_MAX_WARNING_LEVEL)
 endif(CMAKE_COMPILER_IS_GNUCXX)
diff --git a/test/sparse_basic.cpp b/test/sparse_basic.cpp
index 050b14995..009cc5ae2 100644
--- a/test/sparse_basic.cpp
+++ b/test/sparse_basic.cpp
@@ -34,7 +34,7 @@ bool test_random_setter(SparseMatrix& sm, const DenseType& ref,
     std::vector remaining = nonzeroCoords;
     while(!remaining.empty())
     {
-      int i = ei_random(0,remaining.size()-1);
+      int i = ei_random(0,static_cast(remaining.size())-1);
       w(remaining[i].x(),remaining[i].y()) = ref.coeff(remaining[i].x(),remaining[i].y());
       remaining[i] = remaining.back();
       remaining.pop_back();
@@ -50,7 +50,7 @@ bool test_random_setter(DynamicSparseMatrix& sm, const DenseType& ref, const
   std::vector remaining = nonzeroCoords;
   while(!remaining.empty())
   {
-    int i = ei_random(0,remaining.size()-1);
+    int i = ei_random(0,static_cast(remaining.size())-1);
     sm.coeffRef(remaining[i].x(),remaining[i].y()) = ref.coeff(remaining[i].x(),remaining[i].y());
     remaining[i] = remaining.back();
     remaining.pop_back();
diff --git a/unsupported/Eigen/FFT b/unsupported/Eigen/FFT
index fc2efc1d6..a43cd8d97 100644
--- a/unsupported/Eigen/FFT
+++ b/unsupported/Eigen/FFT
@@ -160,7 +160,7 @@ class FFT
         dst.resize( (src.size()>>1)+1);
       else
         dst.resize(src.size());
-      fwd(&dst[0],&src[0],src.size());
+      fwd(&dst[0],&src[0],static_cast(src.size()));
     }
 
     template
@@ -224,7 +224,7 @@ class FFT
         dst.resize( 2*(src.size()-1) );
       else
         dst.resize( src.size() );
-      inv( &dst[0],&src[0],dst.size() );
+      inv( &dst[0],&src[0],static_cast(dst.size()) );
     }
 
     // TODO: multi-dimensional FFTs
diff --git a/unsupported/Eigen/src/BVH/BVAlgorithms.h b/unsupported/Eigen/src/BVH/BVAlgorithms.h
index 47c49be7f..63725763a 100644
--- a/unsupported/Eigen/src/BVH/BVAlgorithms.h
+++ b/unsupported/Eigen/src/BVH/BVAlgorithms.h
@@ -74,6 +74,8 @@ struct ei_intersector_helper1
   bool intersectObject(const Object1 &obj) { return intersector.intersectObjectObject(obj, stored); }
   Object2 stored;
   Intersector &intersector;
+private:
+  ei_intersector_helper1& operator=(const ei_intersector_helper1&);
 };
 
 template
@@ -216,6 +218,8 @@ struct ei_minimizer_helper2
   Scalar minimumOnObject(const Object2 &obj) { return minimizer.minimumOnObjectObject(stored, obj); }
   Object1 stored;
   Minimizer &minimizer;
+private:
+  ei_minimizer_helper2& operator=(const ei_minimizer_helper2&);
 };
 
 /**  Given two BVH's, runs the query on their cartesian product encapsulated by \a minimizer.
diff --git a/unsupported/Eigen/src/BVH/KdBVH.h b/unsupported/Eigen/src/BVH/KdBVH.h
index ec47254af..c4719607f 100644
--- a/unsupported/Eigen/src/BVH/KdBVH.h
+++ b/unsupported/Eigen/src/BVH/KdBVH.h
@@ -107,7 +107,7 @@ public:
     children.clear();
 
     objects.insert(objects.end(), begin, end);
-    int n = objects.size();
+    int n = static_cast(objects.size());
 
     if(n < 2)
       return; //if we have at most one object, we don't need any internal nodes
@@ -149,7 +149,7 @@ public:
       return;
     }
 
-    int numBoxes = boxes.size();
+    int numBoxes = static_cast(boxes.size());
 
     int idx = index * 2;
     if(children[idx + 1] < numBoxes) { //second index is always bigger
diff --git a/unsupported/Eigen/src/FFT/ei_kissfft_impl.h b/unsupported/Eigen/src/FFT/ei_kissfft_impl.h
index 2dff2bd00..dbd92132e 100644
--- a/unsupported/Eigen/src/FFT/ei_kissfft_impl.h
+++ b/unsupported/Eigen/src/FFT/ei_kissfft_impl.h
@@ -247,7 +247,7 @@ struct ei_kiss_cpx_fft
       int u,k,q1,q;
       Complex * twiddles = &m_twiddles[0];
       Complex t;
-      int Norig = m_twiddles.size();
+      int Norig = static_cast(m_twiddles.size());
       Complex * scratchbuf = &m_scratchBuf[0];
 
       for ( u=0; u(fstride) * k;
             if (twidx>=Norig) twidx-=Norig;
             t=scratchbuf[q] * twiddles[twidx];
             Fout[ k ] += t;
diff --git a/unsupported/Eigen/src/MatrixFunctions/MatrixExponential.h b/unsupported/Eigen/src/MatrixFunctions/MatrixExponential.h
index add000c44..9c0d2e53f 100644
--- a/unsupported/Eigen/src/MatrixFunctions/MatrixExponential.h
+++ b/unsupported/Eigen/src/MatrixFunctions/MatrixExponential.h
@@ -292,7 +292,7 @@ void MatrixExponential::computeUV(float)
   } else {
     const float maxnorm = 3.925724783138660f;
     m_squarings = std::max(0, (int)ceil(log2(m_l1norm / maxnorm)));
-    MatrixType A = *m_M / std::pow(Scalar(2), Scalar(m_squarings));
+    MatrixType A = *m_M / std::pow(Scalar(2), Scalar(static_cast(m_squarings)));
     pade7(A);
   }
 }
diff --git a/unsupported/test/Complex.cpp b/unsupported/test/Complex.cpp
index 969e3f4f9..9ea91cf42 100644
--- a/unsupported/test/Complex.cpp
+++ b/unsupported/test/Complex.cpp
@@ -40,7 +40,7 @@ template 
 void take_std( std::complex * dst, int n )
 {
     for (int i=0;i(i,i);
+        dst[i] = std::complex(static_cast(i),static_cast(i));
     cout << dst[n-1] << endl;
 }
 
diff --git a/unsupported/test/FFT.cpp b/unsupported/test/FFT.cpp
index b029ba655..056be2ef3 100644
--- a/unsupported/test/FFT.cpp
+++ b/unsupported/test/FFT.cpp
@@ -46,10 +46,10 @@ complex  promote(long double x) { return complex( x);
         long double difpower=0;
         cerr <<"idx\ttruth\t\tvalue\t|dif|=\n";
         long double pi = acos((long double)-1);
-        for (size_t k0=0;k0 acc = 0;
             long double phinc = -2.*k0* pi / timebuf.size();
-            for (size_t k1=0;k1(0,k1*phinc) );
             }
             totalpower += norm(acc);
@@ -67,8 +67,8 @@ complex  promote(long double x) { return complex( x);
     {
         long double totalpower=0;
         long double difpower=0;
-        size_t n = min( buf1.size(),buf2.size() );
-        for (size_t k=0;k
Date: Sat, 12 Dec 2009 14:49:43 +0100
Subject: Removed more warnings.

---
 Eigen/src/Core/Functors.h                 | 4 ++++
 Eigen/src/Core/PermutationMatrix.h        | 3 +++
 Eigen/src/Core/util/DisableMSVCWarnings.h | 6 ++++--
 Eigen/src/Sparse/DynamicSparseMatrix.h    | 3 +++
 Eigen/src/Sparse/SparseCwiseBinaryOp.h    | 3 +++
 cmake/EigenTesting.cmake                  | 4 +++-
 test/unalignedassert.cpp                  | 1 +
 7 files changed, 21 insertions(+), 3 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/Functors.h b/Eigen/src/Core/Functors.h
index 259f40244..e2a212c89 100644
--- a/Eigen/src/Core/Functors.h
+++ b/Eigen/src/Core/Functors.h
@@ -365,6 +365,8 @@ struct ei_scalar_multiple2_op {
   EIGEN_STRONG_INLINE ei_scalar_multiple2_op(const Scalar2& other) : m_other(other) { }
   EIGEN_STRONG_INLINE result_type operator() (const Scalar1& a) const { return a * m_other; }
   typename ei_makeconst::Nested>::type m_other;
+private:
+  ei_scalar_multiple2_op& operator=(ei_scalar_multiple2_op&);
 };
 template
 struct ei_functor_traits >
@@ -394,6 +396,8 @@ struct ei_scalar_quotient1_impl {
   EIGEN_STRONG_INLINE ei_scalar_quotient1_impl(const Scalar& other) : m_other(other) {}
   EIGEN_STRONG_INLINE Scalar operator() (const Scalar& a) const { return a / m_other; }
   typename ei_makeconst::Nested>::type m_other;
+private:
+  ei_scalar_quotient1_impl& operator=(const ei_scalar_quotient1_impl&);
 };
 template
 struct ei_functor_traits >
diff --git a/Eigen/src/Core/PermutationMatrix.h b/Eigen/src/Core/PermutationMatrix.h
index 284baf678..4d30b2dac 100644
--- a/Eigen/src/Core/PermutationMatrix.h
+++ b/Eigen/src/Core/PermutationMatrix.h
@@ -320,6 +320,9 @@ struct ei_permut_matrix_product_retval
   protected:
     const PermutationType& m_permutation;
     const typename MatrixType::Nested m_matrix;
+
+  private:
+    ei_permut_matrix_product_retval& operator=(ei_permut_matrix_product_retval&);
 };
 
 #endif // EIGEN_PERMUTATIONMATRIX_H
diff --git a/Eigen/src/Core/util/DisableMSVCWarnings.h b/Eigen/src/Core/util/DisableMSVCWarnings.h
index c08d0389f..18484e490 100644
--- a/Eigen/src/Core/util/DisableMSVCWarnings.h
+++ b/Eigen/src/Core/util/DisableMSVCWarnings.h
@@ -1,6 +1,8 @@
 
 #ifdef _MSC_VER
-  // 4273 - QtAlignedMalloc, inconsistent dll linkage
+  // 4273 - QtAlignedMalloc, inconsistent DLL linkage
+  // 4100 - unreferenced formal parameter (occurred e.g. in aligned_allocator::destroy(pointer p))
+  // 4101 - we need this one for the inlining fix
   #pragma warning( push )
-  #pragma warning( disable : 4181 4244 4127 4211 4273 4522 4717 )
+  #pragma warning( disable : 4100 4101 4181 4244 4127 4211 4273 4522 4717 )
 #endif
diff --git a/Eigen/src/Sparse/DynamicSparseMatrix.h b/Eigen/src/Sparse/DynamicSparseMatrix.h
index f4f83533a..00386442c 100644
--- a/Eigen/src/Sparse/DynamicSparseMatrix.h
+++ b/Eigen/src/Sparse/DynamicSparseMatrix.h
@@ -323,6 +323,9 @@ class DynamicSparseMatrix::InnerIterator : public SparseVector,
     LhsIterator m_lhsIter;
     const BinaryFunc m_functor;
     const int m_outer;
+
+private:
+  ei_sparse_cwise_binary_op_inner_iterator_selector& operator=(ei_sparse_cwise_binary_op_inner_iterator_selector&);
 };
 
 // sparse - dense  (product)
diff --git a/cmake/EigenTesting.cmake b/cmake/EigenTesting.cmake
index bb1da41de..b8cd63ac1 100644
--- a/cmake/EigenTesting.cmake
+++ b/cmake/EigenTesting.cmake
@@ -237,6 +237,8 @@ if(CMAKE_COMPILER_IS_GNUCXX)
 elseif(MSVC)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D_CRT_SECURE_NO_WARNINGS /D_SCL_SECURE_NO_WARNINGS")
   if(EIGEN_TEST_MAX_WARNING_LEVEL)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
+	# C4127 - conditional expression is constant
+	# C4505 - unreferenced local function has been removed
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /wd4127 /wd4505")
   endif(EIGEN_TEST_MAX_WARNING_LEVEL)
 endif(CMAKE_COMPILER_IS_GNUCXX)
diff --git a/test/unalignedassert.cpp b/test/unalignedassert.cpp
index 2b819417e..c3a07d195 100644
--- a/test/unalignedassert.cpp
+++ b/test/unalignedassert.cpp
@@ -87,6 +87,7 @@ void construct_at_boundary(int boundary)
   _buf += (16 - (_buf % 16)); // make 16-byte aligned
   _buf += boundary; // make exact boundary-aligned
   T *x = ::new(reinterpret_cast(_buf)) T;
+  x[0]; // just in order to silence warnings
   x->~T();
 }
 #endif
-- 
cgit v1.2.3


From 4498864fc83340f3f52a55c12027faac19d1ede1 Mon Sep 17 00:00:00 2001
From: Hauke Heibel 
Date: Sun, 13 Dec 2009 09:26:57 +0100
Subject: Fixed a bad type conversion.

---
 Eigen/src/Core/util/Memory.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/util/Memory.h b/Eigen/src/Core/util/Memory.h
index 1bff682ff..ebeb55ddd 100644
--- a/Eigen/src/Core/util/Memory.h
+++ b/Eigen/src/Core/util/Memory.h
@@ -218,7 +218,7 @@ inline static Integer ei_alignmentOffset(const Scalar* ptr, Integer maxOffset)
   const Integer PacketAlignedMask = PacketSize-1;
   const bool Vectorized = PacketSize>1;
   return Vectorized
-          ? std::min( (PacketSize - (Integer((Integer(ptr)/sizeof(Scalar))) & PacketAlignedMask))
+          ? std::min( (PacketSize - (Integer((size_t(ptr)/sizeof(Scalar))) & PacketAlignedMask))
                            & PacketAlignedMask, maxOffset)
           : 0;
 }
-- 
cgit v1.2.3


From 832045d363a6edf59d4dc4ad0cfbe02272dcce3c Mon Sep 17 00:00:00 2001
From: Hauke Heibel 
Date: Mon, 14 Dec 2009 10:32:43 +0100
Subject: Warning 4512 (assignment operators could not be generated) is now
 simply disabled. All unimplemented assignment operators have been removed.

---
 Eigen/src/Array/Functors.h                  |  4 ----
 Eigen/src/Array/Replicate.h                 |  3 ---
 Eigen/src/Array/VectorwiseOp.h              |  5 -----
 Eigen/src/Cholesky/LDLT.h                   |  2 --
 Eigen/src/Cholesky/LLT.h                    |  2 --
 Eigen/src/Core/CommaInitializer.h           |  3 ---
 Eigen/src/Core/Cwise.h                      |  3 ---
 Eigen/src/Core/Flagged.h                    |  3 ---
 Eigen/src/Core/Functors.h                   | 10 ----------
 Eigen/src/Core/NestByValue.h                |  3 ---
 Eigen/src/Core/NoAlias.h                    |  3 ---
 Eigen/src/Core/PermutationMatrix.h          |  3 ---
 Eigen/src/Core/Product.h                    |  6 ------
 Eigen/src/Core/ProductBase.h                |  2 --
 Eigen/src/Core/SelfAdjointView.h            |  3 ---
 Eigen/src/Core/Swap.h                       |  3 ---
 Eigen/src/Core/util/DisableMSVCWarnings.h   |  3 ++-
 Eigen/src/Geometry/Homogeneous.h            |  5 -----
 Eigen/src/Householder/HouseholderSequence.h |  3 ---
 Eigen/src/LU/FullPivLU.h                    |  9 ---------
 Eigen/src/LU/Inverse.h                      |  2 --
 Eigen/src/QR/HouseholderQR.h                |  2 --
 Eigen/src/SVD/SVD.h                         |  2 --
 Eigen/src/Sparse/AmbiVector.h               |  4 ----
 Eigen/src/Sparse/DynamicSparseMatrix.h      |  4 ----
 Eigen/src/Sparse/SparseBlock.h              |  2 --
 Eigen/src/Sparse/SparseCwise.h              |  3 ---
 Eigen/src/Sparse/SparseCwiseBinaryOp.h      | 10 ----------
 Eigen/src/Sparse/SparseCwiseUnaryOp.h       |  3 ---
 Eigen/src/Sparse/SparseDiagonalProduct.h    |  4 ----
 Eigen/src/Sparse/SparseFlagged.h            |  6 ------
 Eigen/src/Sparse/SparseMatrix.h             |  3 ---
 Eigen/src/Sparse/SparseTranspose.h          |  6 ------
 Eigen/src/Sparse/SparseTriangular.h         |  3 ---
 Eigen/src/misc/Image.h                      |  3 ---
 Eigen/src/misc/Kernel.h                     |  3 ---
 Eigen/src/misc/Solve.h                      |  3 ---
 37 files changed, 2 insertions(+), 139 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Array/Functors.h b/Eigen/src/Array/Functors.h
index 3a7753d04..fd259f7bc 100644
--- a/Eigen/src/Array/Functors.h
+++ b/Eigen/src/Array/Functors.h
@@ -43,8 +43,6 @@ struct ei_scalar_add_op {
   inline const PacketScalar packetOp(const PacketScalar& a) const
   { return ei_padd(a, ei_pset1(m_other)); }
   const Scalar m_other;
-private:
-  ei_scalar_add_op& operator=(const ei_scalar_add_op&);
 };
 template
 struct ei_functor_traits >
@@ -130,8 +128,6 @@ struct ei_scalar_pow_op {
   inline ei_scalar_pow_op(const Scalar& exponent) : m_exponent(exponent) {}
   inline Scalar operator() (const Scalar& a) const { return ei_pow(a, m_exponent); }
   const Scalar m_exponent;
-private:
-  ei_scalar_pow_op& operator=(const ei_scalar_pow_op&);
 };
 template
 struct ei_functor_traits >
diff --git a/Eigen/src/Array/Replicate.h b/Eigen/src/Array/Replicate.h
index 478c0bf68..653bda666 100644
--- a/Eigen/src/Array/Replicate.h
+++ b/Eigen/src/Array/Replicate.h
@@ -94,9 +94,6 @@ template class Replicate
     const typename MatrixType::Nested m_matrix;
     const ei_int_if_dynamic m_rowFactor;
     const ei_int_if_dynamic m_colFactor;
-
-  private:
-    Replicate& operator=(const Replicate&);
 };
 
 /** \nonstableyet
diff --git a/Eigen/src/Array/VectorwiseOp.h b/Eigen/src/Array/VectorwiseOp.h
index 92e5cc000..37ed8ac17 100644
--- a/Eigen/src/Array/VectorwiseOp.h
+++ b/Eigen/src/Array/VectorwiseOp.h
@@ -147,8 +147,6 @@ struct ei_member_redux {
   inline result_type operator()(const MatrixBase& mat) const
   { return mat.redux(m_functor); }
   const BinaryOp m_functor;
-private:
-  ei_member_redux& operator=(const ei_member_redux&);
 };
 
 /** \array_module \ingroup Array_Module
@@ -490,9 +488,6 @@ template class VectorwiseOp
 
   protected:
     ExpressionTypeNested m_matrix;
-
-  private:
-    VectorwiseOp& operator=(const VectorwiseOp&);
 };
 
 /** \array_module
diff --git a/Eigen/src/Cholesky/LDLT.h b/Eigen/src/Cholesky/LDLT.h
index 2898d8747..d0f292634 100644
--- a/Eigen/src/Cholesky/LDLT.h
+++ b/Eigen/src/Cholesky/LDLT.h
@@ -275,8 +275,6 @@ struct ei_solve_retval, Rhs>
     dst = rhs();
     dec().solveInPlace(dst);
   }
-private:
-  ei_solve_retval& operator=(const ei_solve_retval&);
 };
 
 /** This is the \em in-place version of solve().
diff --git a/Eigen/src/Cholesky/LLT.h b/Eigen/src/Cholesky/LLT.h
index 6612984ab..ad737aaeb 100644
--- a/Eigen/src/Cholesky/LLT.h
+++ b/Eigen/src/Cholesky/LLT.h
@@ -270,8 +270,6 @@ struct ei_solve_retval, Rhs>
     dst = rhs();
     dec().solveInPlace(dst);
   }
-private:
-  ei_solve_retval& operator=(const ei_solve_retval&);
 };
 
 /** This is the \em in-place version of solve().
diff --git a/Eigen/src/Core/CommaInitializer.h b/Eigen/src/Core/CommaInitializer.h
index 328c5580c..e86f47ad0 100644
--- a/Eigen/src/Core/CommaInitializer.h
+++ b/Eigen/src/Core/CommaInitializer.h
@@ -116,9 +116,6 @@ struct CommaInitializer
   int m_row;              // current row id
   int m_col;              // current col id
   int m_currentBlockRows; // current block height
-
-private:
-  CommaInitializer& operator=(const CommaInitializer&);
 };
 
 /** \anchor MatrixBaseCommaInitRef
diff --git a/Eigen/src/Core/Cwise.h b/Eigen/src/Core/Cwise.h
index 80414782e..4f3d641cb 100644
--- a/Eigen/src/Core/Cwise.h
+++ b/Eigen/src/Core/Cwise.h
@@ -178,9 +178,6 @@ template class Cwise
 
   protected:
     ExpressionTypeNested m_matrix;
-
-  private:
-    Cwise& operator=(const Cwise&);
 };
 
 /** \returns a Cwise wrapper of *this providing additional coefficient-wise operations
diff --git a/Eigen/src/Core/Flagged.h b/Eigen/src/Core/Flagged.h
index b98861f42..754eaf6c5 100644
--- a/Eigen/src/Core/Flagged.h
+++ b/Eigen/src/Core/Flagged.h
@@ -111,9 +111,6 @@ template clas
 
   protected:
     ExpressionTypeNested m_matrix;
-
-  private:
-    Flagged& operator=(const Flagged&);
 };
 
 /** \deprecated it is only used by lazy() which is deprecated
diff --git a/Eigen/src/Core/Functors.h b/Eigen/src/Core/Functors.h
index e2a212c89..6b62fb4ea 100644
--- a/Eigen/src/Core/Functors.h
+++ b/Eigen/src/Core/Functors.h
@@ -351,8 +351,6 @@ struct ei_scalar_multiple_op {
   EIGEN_STRONG_INLINE const PacketScalar packetOp(const PacketScalar& a) const
   { return ei_pmul(a, ei_pset1(m_other)); }
   typename ei_makeconst::Nested>::type m_other;
-private:
-  ei_scalar_multiple_op& operator=(const ei_scalar_multiple_op&);
 };
 template
 struct ei_functor_traits >
@@ -365,8 +363,6 @@ struct ei_scalar_multiple2_op {
   EIGEN_STRONG_INLINE ei_scalar_multiple2_op(const Scalar2& other) : m_other(other) { }
   EIGEN_STRONG_INLINE result_type operator() (const Scalar1& a) const { return a * m_other; }
   typename ei_makeconst::Nested>::type m_other;
-private:
-  ei_scalar_multiple2_op& operator=(ei_scalar_multiple2_op&);
 };
 template
 struct ei_functor_traits >
@@ -382,8 +378,6 @@ struct ei_scalar_quotient1_impl {
   EIGEN_STRONG_INLINE const PacketScalar packetOp(const PacketScalar& a) const
   { return ei_pmul(a, ei_pset1(m_other)); }
   const Scalar m_other;
-private:
-  ei_scalar_quotient1_impl& operator=(const ei_scalar_quotient1_impl&);
 };
 template
 struct ei_functor_traits >
@@ -396,8 +390,6 @@ struct ei_scalar_quotient1_impl {
   EIGEN_STRONG_INLINE ei_scalar_quotient1_impl(const Scalar& other) : m_other(other) {}
   EIGEN_STRONG_INLINE Scalar operator() (const Scalar& a) const { return a / m_other; }
   typename ei_makeconst::Nested>::type m_other;
-private:
-  ei_scalar_quotient1_impl& operator=(const ei_scalar_quotient1_impl&);
 };
 template
 struct ei_functor_traits >
@@ -431,8 +423,6 @@ struct ei_scalar_constant_op {
   EIGEN_STRONG_INLINE const Scalar operator() (int, int = 0) const { return m_other; }
   EIGEN_STRONG_INLINE const PacketScalar packetOp() const { return ei_pset1(m_other); }
   const Scalar m_other;
-private:
-  ei_scalar_constant_op& operator=(const ei_scalar_constant_op&);
 };
 template
 struct ei_functor_traits >
diff --git a/Eigen/src/Core/NestByValue.h b/Eigen/src/Core/NestByValue.h
index 94a8f8078..85a672779 100644
--- a/Eigen/src/Core/NestByValue.h
+++ b/Eigen/src/Core/NestByValue.h
@@ -102,9 +102,6 @@ template class NestByValue
 
   protected:
     const ExpressionType m_expression;
-
-  private:
-    NestByValue& operator=(const NestByValue&);
 };
 
 /** \returns an expression of the temporary version of *this.
diff --git a/Eigen/src/Core/NoAlias.h b/Eigen/src/Core/NoAlias.h
index dc32c2f7b..66d8d834d 100644
--- a/Eigen/src/Core/NoAlias.h
+++ b/Eigen/src/Core/NoAlias.h
@@ -73,9 +73,6 @@ class NoAlias
 
   protected:
     ExpressionType& m_expression;
-
-  private:
-    NoAlias& operator=(const NoAlias&);
 };
 
 /** \returns a pseudo expression of \c *this with an operator= assuming
diff --git a/Eigen/src/Core/PermutationMatrix.h b/Eigen/src/Core/PermutationMatrix.h
index 4d30b2dac..284baf678 100644
--- a/Eigen/src/Core/PermutationMatrix.h
+++ b/Eigen/src/Core/PermutationMatrix.h
@@ -320,9 +320,6 @@ struct ei_permut_matrix_product_retval
   protected:
     const PermutationType& m_permutation;
     const typename MatrixType::Nested m_matrix;
-
-  private:
-    ei_permut_matrix_product_retval& operator=(ei_permut_matrix_product_retval&);
 };
 
 #endif // EIGEN_PERMUTATIONMATRIX_H
diff --git a/Eigen/src/Core/Product.h b/Eigen/src/Core/Product.h
index cc751650d..d24ef6159 100644
--- a/Eigen/src/Core/Product.h
+++ b/Eigen/src/Core/Product.h
@@ -211,9 +211,6 @@ class GeneralProduct
     {
       ei_outer_product_selector<(int(Dest::Flags)&RowMajorBit) ? RowMajor : ColMajor>::run(*this, dest, alpha);
     }
-
-  private:
-    GeneralProduct& operator=(const GeneralProduct&);
 };
 
 template<> struct ei_outer_product_selector {
@@ -279,9 +276,6 @@ class GeneralProduct
       ei_gemv_selector::ActualAccess)>::run(*this, dst, alpha);
     }
-
-private:
-  GeneralProduct& operator=(const GeneralProduct&);
 };
 
 // The vector is on the left => transposition
diff --git a/Eigen/src/Core/ProductBase.h b/Eigen/src/Core/ProductBase.h
index 955e87feb..33ada4bee 100644
--- a/Eigen/src/Core/ProductBase.h
+++ b/Eigen/src/Core/ProductBase.h
@@ -129,8 +129,6 @@ class ProductBase : public MatrixBase
     void coeffRef(int,int);
     void coeff(int) const;
     void coeffRef(int);
-
-    ProductBase& operator=(const ProductBase&);
 };
 
 template
diff --git a/Eigen/src/Core/SelfAdjointView.h b/Eigen/src/Core/SelfAdjointView.h
index 9518a6498..9b6b3261f 100644
--- a/Eigen/src/Core/SelfAdjointView.h
+++ b/Eigen/src/Core/SelfAdjointView.h
@@ -151,9 +151,6 @@ template class SelfAdjointView
 
   protected:
     const typename MatrixType::Nested m_matrix;
-
-  private:
-    SelfAdjointView& operator=(const SelfAdjointView&);
 };
 
 
diff --git a/Eigen/src/Core/Swap.h b/Eigen/src/Core/Swap.h
index 45c180983..a7cf219f7 100644
--- a/Eigen/src/Core/Swap.h
+++ b/Eigen/src/Core/Swap.h
@@ -117,9 +117,6 @@ template class SwapWrapper
 
   protected:
     ExpressionType& m_expression;
-
-  private:
-    SwapWrapper& operator=(const SwapWrapper&);
 };
 
 /** swaps *this with the expression \a other.
diff --git a/Eigen/src/Core/util/DisableMSVCWarnings.h b/Eigen/src/Core/util/DisableMSVCWarnings.h
index 18484e490..c11d582fd 100644
--- a/Eigen/src/Core/util/DisableMSVCWarnings.h
+++ b/Eigen/src/Core/util/DisableMSVCWarnings.h
@@ -2,7 +2,8 @@
 #ifdef _MSC_VER
   // 4273 - QtAlignedMalloc, inconsistent DLL linkage
   // 4100 - unreferenced formal parameter (occurred e.g. in aligned_allocator::destroy(pointer p))
-  // 4101 - we need this one for the inlining fix
+  // 4101 - unreferenced local variable
+  // 4512 - assignment operator could not be generated
   #pragma warning( push )
   #pragma warning( disable : 4100 4101 4181 4244 4127 4211 4273 4522 4717 )
 #endif
diff --git a/Eigen/src/Geometry/Homogeneous.h b/Eigen/src/Geometry/Homogeneous.h
index f2a2fe73e..229fd80b3 100644
--- a/Eigen/src/Geometry/Homogeneous.h
+++ b/Eigen/src/Geometry/Homogeneous.h
@@ -241,8 +241,6 @@ struct ei_homogeneous_left_product_impl,Lhs>
 
   const typename Lhs::Nested m_lhs;
   const typename MatrixType::Nested m_rhs;
-private:
-  ei_homogeneous_left_product_impl& operator=(const ei_homogeneous_left_product_impl&);
 };
 
 template
@@ -281,9 +279,6 @@ struct ei_homogeneous_right_product_impl,Rhs>
 
   const typename MatrixType::Nested m_lhs;
   const typename Rhs::Nested m_rhs;
-
-private:
-  ei_homogeneous_right_product_impl& operator=(const ei_homogeneous_right_product_impl&);
 };
 
 #endif // EIGEN_HOMOGENEOUS_H
diff --git a/Eigen/src/Householder/HouseholderSequence.h b/Eigen/src/Householder/HouseholderSequence.h
index 1159f03ed..25e962001 100644
--- a/Eigen/src/Householder/HouseholderSequence.h
+++ b/Eigen/src/Householder/HouseholderSequence.h
@@ -161,9 +161,6 @@ template class HouseholderSequence
     typename CoeffsType::Nested m_coeffs;
     bool m_trans;
     int m_actualVectors;
-
-private:
-  HouseholderSequence& operator=(const HouseholderSequence&);
 };
 
 template
diff --git a/Eigen/src/LU/FullPivLU.h b/Eigen/src/LU/FullPivLU.h
index 5505d3bee..1358c9490 100644
--- a/Eigen/src/LU/FullPivLU.h
+++ b/Eigen/src/LU/FullPivLU.h
@@ -562,9 +562,6 @@ struct ei_kernel_retval >
     for(int i = rank(); i < cols; ++i) dst.row(dec().permutationQ().indices().coeff(i)).setZero();
     for(int k = 0; k < dimker; ++k) dst.coeffRef(dec().permutationQ().indices().coeff(rank()+k), k) = Scalar(1);
   }
-
-private:
-  ei_kernel_retval& operator=(const ei_kernel_retval&);
 };
 
 /***** Implementation of image() *****************************************************/
@@ -602,9 +599,6 @@ struct ei_image_retval >
     for(int i = 0; i < rank(); ++i)
       dst.col(i) = originalMatrix().col(dec().permutationQ().indices().coeff(pivots.coeff(i)));
   }
-
-private:
-  ei_image_retval& operator=(const ei_image_retval&);
 };
 
 /***** Implementation of solve() *****************************************************/
@@ -665,9 +659,6 @@ struct ei_solve_retval, Rhs>
     for(int i = nonzero_pivots; i < dec().matrixLU().cols(); ++i)
       dst.row(dec().permutationQ().indices().coeff(i)).setZero();
   }
-
-private:
-  ei_solve_retval& operator=(const ei_solve_retval&);
 };
 
 /******* MatrixBase methods *****************************************************************/
diff --git a/Eigen/src/LU/Inverse.h b/Eigen/src/LU/Inverse.h
index c31b3502e..8afbfda96 100644
--- a/Eigen/src/LU/Inverse.h
+++ b/Eigen/src/LU/Inverse.h
@@ -258,8 +258,6 @@ struct ei_inverse_impl : public ReturnByValue >
   {
     ei_compute_inverse::run(m_matrix, dst);
   }
-private:
-  ei_inverse_impl& operator=(const ei_inverse_impl&);
 };
 
 /** \lu_module
diff --git a/Eigen/src/QR/HouseholderQR.h b/Eigen/src/QR/HouseholderQR.h
index 3b174a873..95496b943 100644
--- a/Eigen/src/QR/HouseholderQR.h
+++ b/Eigen/src/QR/HouseholderQR.h
@@ -237,8 +237,6 @@ struct ei_solve_retval, Rhs>
     dst.corner(TopLeft, rank, c.cols()) = c.corner(TopLeft, rank, c.cols());
     dst.corner(BottomLeft, cols-rank, c.cols()).setZero();
   }
-private:
-  ei_solve_retval& operator=(const ei_solve_retval&);
 };
 
 #endif // EIGEN_HIDE_HEAVY_CODE
diff --git a/Eigen/src/SVD/SVD.h b/Eigen/src/SVD/SVD.h
index a90704cb9..0ec41e36d 100644
--- a/Eigen/src/SVD/SVD.h
+++ b/Eigen/src/SVD/SVD.h
@@ -456,8 +456,6 @@ struct ei_solve_retval, Rhs>
       dst.col(j) = dec().matrixV() * dst.col(j);
     }
   }
-private:
-  ei_solve_retval& operator=(const ei_solve_retval&);
 };
 
 /** Computes the polar decomposition of the matrix, as a product unitary x positive.
diff --git a/Eigen/src/Sparse/AmbiVector.h b/Eigen/src/Sparse/AmbiVector.h
index 5e75bd6e7..2988999d6 100644
--- a/Eigen/src/Sparse/AmbiVector.h
+++ b/Eigen/src/Sparse/AmbiVector.h
@@ -126,10 +126,6 @@ template class AmbiVector
     int m_llStart;
     int m_llCurrent;
     int m_llSize;
-
-  private:
-    AmbiVector(const AmbiVector&);
-
 };
 
 /** \returns the number of non zeros in the current sub vector */
diff --git a/Eigen/src/Sparse/DynamicSparseMatrix.h b/Eigen/src/Sparse/DynamicSparseMatrix.h
index 00386442c..3ce5e84da 100644
--- a/Eigen/src/Sparse/DynamicSparseMatrix.h
+++ b/Eigen/src/Sparse/DynamicSparseMatrix.h
@@ -320,12 +320,8 @@ class DynamicSparseMatrix::InnerIterator : public SparseVector, Size>
         inline int col() const { return IsRowMajor ? this->index() : m_outer; }
       protected:
         int m_outer;
-      private:
-        InnerIterator& operator=(const InnerIterator&);
     };
 
     inline SparseInnerVectorSet(const MatrixType& matrix, int outerStart, int outerSize)
diff --git a/Eigen/src/Sparse/SparseCwise.h b/Eigen/src/Sparse/SparseCwise.h
index c2e302956..bf8f2355c 100644
--- a/Eigen/src/Sparse/SparseCwise.h
+++ b/Eigen/src/Sparse/SparseCwise.h
@@ -156,9 +156,6 @@ template class SparseCwise
 
   protected:
     ExpressionTypeNested m_matrix;
-
-  private:
-    SparseCwise& operator=(const SparseCwise&);
 };
 
 template
diff --git a/Eigen/src/Sparse/SparseCwiseBinaryOp.h b/Eigen/src/Sparse/SparseCwiseBinaryOp.h
index 01f4da197..2dcd6b944 100644
--- a/Eigen/src/Sparse/SparseCwiseBinaryOp.h
+++ b/Eigen/src/Sparse/SparseCwiseBinaryOp.h
@@ -126,9 +126,6 @@ class SparseCwiseBinaryOp::InnerIterator
     EIGEN_STRONG_INLINE InnerIterator(const SparseCwiseBinaryOp& binOp, int outer)
       : Base(binOp,outer)
     {}
-
-  private:
-    InnerIterator& operator=(const InnerIterator&);
 };
 
 /***************************************************************************
@@ -200,8 +197,6 @@ class ei_sparse_cwise_binary_op_inner_iterator_selector,
     LhsIterator m_lhsIter;
     RhsIterator m_rhsIter;
     const BinaryFunc& m_functor;
-  private:
-    ei_sparse_cwise_binary_op_inner_iterator_selector& operator=(const ei_sparse_cwise_binary_op_inner_iterator_selector&);
 };
 
 // sparse - dense  (product)
@@ -297,9 +290,6 @@ class ei_sparse_cwise_binary_op_inner_iterator_selector,
     LhsIterator m_lhsIter;
     const BinaryFunc m_functor;
     const int m_outer;
-
-private:
-  ei_sparse_cwise_binary_op_inner_iterator_selector& operator=(ei_sparse_cwise_binary_op_inner_iterator_selector&);
 };
 
 // sparse - dense  (product)
diff --git a/Eigen/src/Sparse/SparseCwiseUnaryOp.h b/Eigen/src/Sparse/SparseCwiseUnaryOp.h
index 9c102ed64..9a73374bd 100644
--- a/Eigen/src/Sparse/SparseCwiseUnaryOp.h
+++ b/Eigen/src/Sparse/SparseCwiseUnaryOp.h
@@ -90,9 +90,6 @@ class SparseCwiseUnaryOp::InnerIterator
   protected:
     MatrixTypeIterator m_iter;
     const UnaryOp m_functor;
-
-  private:
-    InnerIterator& operator=(const InnerIterator&);
 };
 
 template
diff --git a/Eigen/src/Sparse/SparseDiagonalProduct.h b/Eigen/src/Sparse/SparseDiagonalProduct.h
index 24f724ad1..e9ba47f70 100644
--- a/Eigen/src/Sparse/SparseDiagonalProduct.h
+++ b/Eigen/src/Sparse/SparseDiagonalProduct.h
@@ -133,8 +133,6 @@ class ei_sparse_diagonal_product_inner_iterator_selector
               const SparseDiagonalProductType& expr, int outer)
       : Base(expr.rhs().innerVector(outer) .cwise()* expr.lhs().diagonal(), 0)
     {}
-  private:
-    ei_sparse_diagonal_product_inner_iterator_selector& operator=(const ei_sparse_diagonal_product_inner_iterator_selector&);
 };
 
 template
@@ -167,8 +165,6 @@ class ei_sparse_diagonal_product_inner_iterator_selector
               const SparseDiagonalProductType& expr, int outer)
       : Base(expr.lhs().innerVector(outer) .cwise()* expr.rhs().diagonal().transpose(), 0)
     {}
-  private:
-    ei_sparse_diagonal_product_inner_iterator_selector& operator=(const ei_sparse_diagonal_product_inner_iterator_selector&);
 };
 
 // SparseMatrixBase functions
diff --git a/Eigen/src/Sparse/SparseFlagged.h b/Eigen/src/Sparse/SparseFlagged.h
index 34233e5a1..386a80abc 100644
--- a/Eigen/src/Sparse/SparseFlagged.h
+++ b/Eigen/src/Sparse/SparseFlagged.h
@@ -64,9 +64,6 @@ template clas
 
   protected:
     ExpressionTypeNested m_matrix;
-
-  private:
-    SparseFlagged& operator=(const SparseFlagged&);
 };
 
 template
@@ -77,9 +74,6 @@ template
     EIGEN_STRONG_INLINE InnerIterator(const SparseFlagged& xpr, int outer)
       : ExpressionType::InnerIterator(xpr.m_matrix, outer)
     {}
-
-  private:
-    InnerIterator& operator=(const InnerIterator&);
 };
 
 template
diff --git a/Eigen/src/Sparse/SparseMatrix.h b/Eigen/src/Sparse/SparseMatrix.h
index e1c740cdb..8369bba54 100644
--- a/Eigen/src/Sparse/SparseMatrix.h
+++ b/Eigen/src/Sparse/SparseMatrix.h
@@ -557,9 +557,6 @@ class SparseMatrix::InnerIterator
     int m_id;
     const int m_start;
     const int m_end;
-
-  private:
-    InnerIterator& operator=(const InnerIterator&);
 };
 
 #endif // EIGEN_SPARSEMATRIX_H
diff --git a/Eigen/src/Sparse/SparseTranspose.h b/Eigen/src/Sparse/SparseTranspose.h
index 2689caf79..9a702739d 100644
--- a/Eigen/src/Sparse/SparseTranspose.h
+++ b/Eigen/src/Sparse/SparseTranspose.h
@@ -62,9 +62,6 @@ template class SparseTranspose
 
   protected:
     const typename MatrixType::Nested m_matrix;
-
-  private:
-    SparseTranspose& operator=(const SparseTranspose&);
 };
 
 template class SparseTranspose::InnerIterator : public MatrixType::InnerIterator
@@ -77,9 +74,6 @@ template class SparseTranspose::InnerIterator :
     {}
     inline int row() const { return Base::col(); }
     inline int col() const { return Base::row(); }
-
-  private:
-    InnerIterator& operator=(const InnerIterator&);
 };
 
 template class SparseTranspose::ReverseInnerIterator : public MatrixType::ReverseInnerIterator
diff --git a/Eigen/src/Sparse/SparseTriangular.h b/Eigen/src/Sparse/SparseTriangular.h
index c3d3ea48f..42e7ff02a 100644
--- a/Eigen/src/Sparse/SparseTriangular.h
+++ b/Eigen/src/Sparse/SparseTriangular.h
@@ -47,9 +47,6 @@ template class SparseTriangular
     
   protected:
     ExpressionTypeNested m_matrix;
-
-  private:
-    SparseTriangular& operator=(const SparseTriangular&);
 };
 
 template
diff --git a/Eigen/src/misc/Image.h b/Eigen/src/misc/Image.h
index 05ffa667c..2f39d6b9d 100644
--- a/Eigen/src/misc/Image.h
+++ b/Eigen/src/misc/Image.h
@@ -70,9 +70,6 @@ template struct ei_image_retval_base
     const DecompositionType& m_dec;
     int m_rank, m_cols;
     const MatrixType& m_originalMatrix;
-
-  private:
-    ei_image_retval_base& operator=(const ei_image_retval_base&);
 };
 
 #define EIGEN_MAKE_IMAGE_HELPERS(DecompositionType) \
diff --git a/Eigen/src/misc/Kernel.h b/Eigen/src/misc/Kernel.h
index bb8458e11..908c408e9 100644
--- a/Eigen/src/misc/Kernel.h
+++ b/Eigen/src/misc/Kernel.h
@@ -69,9 +69,6 @@ template struct ei_kernel_retval_base
   protected:
     const DecompositionType& m_dec;
     int m_rank, m_cols;
-
-  private:
-    ei_kernel_retval_base& operator=(const ei_kernel_retval_base&);
 };
 
 #define EIGEN_MAKE_KERNEL_HELPERS(DecompositionType) \
diff --git a/Eigen/src/misc/Solve.h b/Eigen/src/misc/Solve.h
index 75597564b..4ab0775fc 100644
--- a/Eigen/src/misc/Solve.h
+++ b/Eigen/src/misc/Solve.h
@@ -63,9 +63,6 @@ template struct ei_solve_retval_base
   protected:
     const DecompositionType& m_dec;
     const typename Rhs::Nested m_rhs;
-
-  private:
-    ei_solve_retval_base& operator=(const ei_solve_retval_base&);
 };
 
 #define EIGEN_MAKE_SOLVE_HELPERS(DecompositionType,Rhs) \
-- 
cgit v1.2.3


From d5f3b2dc943a712a92834cebaea8bb9caae2f6e9 Mon Sep 17 00:00:00 2001
From: Benoit Jacob 
Date: Mon, 14 Dec 2009 17:26:24 -0500
Subject: change the Arch constants: const int ---> enum, more explicit names,
 and use of a namespace instead of Prefix_Name.

---
 Eigen/src/Core/util/Constants.h        | 21 ++++++++++++---------
 Eigen/src/Geometry/OrthoMethods.h      |  5 +++--
 Eigen/src/Geometry/Quaternion.h        |  2 +-
 Eigen/src/Geometry/arch/Geometry_SSE.h |  6 ++++--
 4 files changed, 20 insertions(+), 14 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/util/Constants.h b/Eigen/src/Core/util/Constants.h
index 5489d063a..1128876f8 100644
--- a/Eigen/src/Core/util/Constants.h
+++ b/Eigen/src/Core/util/Constants.h
@@ -228,8 +228,7 @@ enum {
   RowMajor = 0x1,  // it is only a coincidence that this is equal to RowMajorBit -- don't rely on that
   /** \internal Align the matrix itself if it is vectorizable fixed-size */
   AutoAlign = 0,
-  /** \internal Don't require alignment for the matrix itself (the array of coefficients, if dynamically allocated, may still be
-                requested to be aligned) */
+  /** \internal Don't require alignment for the matrix itself (the array of coefficients, if dynamically allocated, may still be requested to be aligned) */ // FIXME --- clarify the situation
   DontAlign = 0x2
 };
 
@@ -277,16 +276,20 @@ enum TransformTraits {
   Projective    = 0x20
 };
 
-const int EiArch_Generic = 0x0;
-const int EiArch_SSE     = 0x1;
-const int EiArch_AltiVec = 0x2;
-
+namespace Architecture
+{
+  enum Type {
+    Generic = 0x0,
+    SSE = 0x1,
+    AltiVec = 0x2,
 #if defined EIGEN_VECTORIZE_SSE
-  const int EiArch = EiArch_SSE;
+    Target = SSE
 #elif defined EIGEN_VECTORIZE_ALTIVEC
-  const int EiArch = EiArch_AltiVec;
+    Target = AltiVec
 #else
-  const int EiArch = EiArch_Generic;
+    Target = Generic
 #endif
+  };
+}
 
 #endif // EIGEN_CONSTANTS_H
diff --git a/Eigen/src/Geometry/OrthoMethods.h b/Eigen/src/Geometry/OrthoMethods.h
index 6d4a8f673..d16b72c43 100644
--- a/Eigen/src/Geometry/OrthoMethods.h
+++ b/Eigen/src/Geometry/OrthoMethods.h
@@ -90,8 +90,9 @@ MatrixBase::cross3(const MatrixBase& other) const
   const DerivedNested lhs(derived());
   const OtherDerivedNested rhs(other.derived());
 
-  return ei_cross3_impl::type,
-                               typename ei_cleantype::type>::run(lhs,rhs);
+  return ei_cross3_impl::type,
+                        typename ei_cleantype::type>::run(lhs,rhs);
 }
 
 /** \returns a matrix expression of the cross product of each column or row
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index b6eb74d66..861eff19c 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -367,7 +367,7 @@ QuaternionBase::operator* (const QuaternionBase& other) c
 {
   EIGEN_STATIC_ASSERT((ei_is_same_type::ret),
    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
-  return ei_quat_product::Scalar,
                          ei_traits::PacketAccess && ei_traits::PacketAccess>::run(*this, other);
 }
diff --git a/Eigen/src/Geometry/arch/Geometry_SSE.h b/Eigen/src/Geometry/arch/Geometry_SSE.h
index a6ed10d82..297932f92 100644
--- a/Eigen/src/Geometry/arch/Geometry_SSE.h
+++ b/Eigen/src/Geometry/arch/Geometry_SSE.h
@@ -26,7 +26,8 @@
 #ifndef EIGEN_GEOMETRY_SSE_H
 #define EIGEN_GEOMETRY_SSE_H
 
-template struct ei_quat_product
+template
+struct ei_quat_product
 {
   inline static Quaternion run(const QuaternionBase& _a, const QuaternionBase& _b)
   {
@@ -48,7 +49,8 @@ template struct ei_quat_product
-struct ei_cross3_impl {
+struct ei_cross3_impl
+{
   inline static typename ei_plain_matrix_type::type
   run(const VectorLhs& lhs, const VectorRhs& rhs)
   {
-- 
cgit v1.2.3


From 3ea1f97f6911a29b98a77b5ba793e8c0a9fc75e0 Mon Sep 17 00:00:00 2001
From: Hauke Heibel 
Date: Tue, 15 Dec 2009 08:09:14 +0100
Subject: Suppressed the warning for missing assignment generators (forgot that
 in the last submission). Commented Quake3's fast inverser sqrt in SSE's
 MathFunction header.

---
 Eigen/src/Core/arch/SSE/MathFunctions.h   | 2 ++
 Eigen/src/Core/util/DisableMSVCWarnings.h | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/arch/SSE/MathFunctions.h b/Eigen/src/Core/arch/SSE/MathFunctions.h
index 8399aac30..3c0020248 100644
--- a/Eigen/src/Core/arch/SSE/MathFunctions.h
+++ b/Eigen/src/Core/arch/SSE/MathFunctions.h
@@ -365,6 +365,8 @@ static EIGEN_DONT_INLINE EIGEN_UNUSED Packet4f ei_pcos(Packet4f x)
   return _mm_xor_ps(y, sign_bit);
 }
 
+// This is Quake3's fast inverse square root.
+// For detail see here: http://www.beyond3d.com/content/articles/8/
 static EIGEN_UNUSED Packet4f ei_psqrt(Packet4f _x)
 {
   Packet4f half = ei_pmul(_x, ei_pset1(.5f));
diff --git a/Eigen/src/Core/util/DisableMSVCWarnings.h b/Eigen/src/Core/util/DisableMSVCWarnings.h
index c11d582fd..dcc71143d 100644
--- a/Eigen/src/Core/util/DisableMSVCWarnings.h
+++ b/Eigen/src/Core/util/DisableMSVCWarnings.h
@@ -5,5 +5,5 @@
   // 4101 - unreferenced local variable
   // 4512 - assignment operator could not be generated
   #pragma warning( push )
-  #pragma warning( disable : 4100 4101 4181 4244 4127 4211 4273 4522 4717 )
+  #pragma warning( disable : 4100 4101 4181 4244 4127 4211 4273 4512 4522 4717 )
 #endif
-- 
cgit v1.2.3


From 6db6774c4685b997ab4343e5c5b4d48af84e45e7 Mon Sep 17 00:00:00 2001
From: Gael Guennebaud 
Date: Wed, 16 Dec 2009 11:41:16 +0100
Subject: * fix aliasing checks when the lhs is also transposed. At the same
 time,   significantly simplify the code of these checks while extending them 
  to catch much more expressions! * move the enabling/disabling of vectorized
 sin/cos to the architecture traits

---
 Eigen/src/Array/Functors.h           |  4 +-
 Eigen/src/Core/Assign.h              |  3 ++
 Eigen/src/Core/MatrixBase.h          | 23 ++++-------
 Eigen/src/Core/Transpose.h           | 78 +++++++++---------------------------
 Eigen/src/Core/arch/SSE/PacketMath.h |  4 +-
 Eigen/src/Core/util/BlasUtil.h       |  4 ++
 test/adjoint.cpp                     |  8 ++++
 7 files changed, 46 insertions(+), 78 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Array/Functors.h b/Eigen/src/Array/Functors.h
index fd259f7bc..120c56cc1 100644
--- a/Eigen/src/Array/Functors.h
+++ b/Eigen/src/Array/Functors.h
@@ -87,7 +87,7 @@ struct ei_functor_traits >
 {
   enum {
     Cost = 5 * NumTraits::MulCost,
-    PacketAccess = ei_packet_traits::HasCos && EIGEN_FAST_MATH
+    PacketAccess = ei_packet_traits::HasCos
   };
 };
 
@@ -109,7 +109,7 @@ struct ei_functor_traits >
 {
   enum {
     Cost = 5 * NumTraits::MulCost,
-    PacketAccess = ei_packet_traits::HasSin && EIGEN_FAST_MATH
+    PacketAccess = ei_packet_traits::HasSin
   };
 };
 
diff --git a/Eigen/src/Core/Assign.h b/Eigen/src/Core/Assign.h
index 00febdc5d..d544a6198 100644
--- a/Eigen/src/Core/Assign.h
+++ b/Eigen/src/Core/Assign.h
@@ -484,6 +484,9 @@ EIGEN_STRONG_INLINE Derived& MatrixBase
   ei_assign_impl::run(derived(),other.derived());
 #ifdef EIGEN_DEBUG_ASSIGN
   ei_assign_traits::debug();
+#endif
+#ifndef EIGEN_NO_DEBUG
+  checkTransposeAliasing(other.derived());
 #endif
   return derived();
 }
diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h
index 03d8d5f55..593108522 100644
--- a/Eigen/src/Core/MatrixBase.h
+++ b/Eigen/src/Core/MatrixBase.h
@@ -436,21 +436,12 @@ template class MatrixBase
     void transposeInPlace();
     const AdjointReturnType adjoint() const;
     void adjointInPlace();
-    #ifndef EIGEN_NO_DEBUG
-    template
-    Derived& lazyAssign(const Transpose& other);
-    template
-    Derived& lazyAssign(const CwiseBinaryOp,Transpose,DerivedB>& other);
-    template
-    Derived& lazyAssign(const CwiseBinaryOp,DerivedA,Transpose >& other);
-
+#ifndef EIGEN_NO_DEBUG
+  protected:
     template
-    Derived& lazyAssign(const CwiseUnaryOp, Eigen::Transpose >& other);
-    template
-    Derived& lazyAssign(const CwiseBinaryOp,CwiseUnaryOp, Eigen::Transpose >,DerivedB>& other);
-    template
-    Derived& lazyAssign(const CwiseBinaryOp,DerivedA,CwiseUnaryOp, Eigen::Transpose > >& other);
-    #endif
+    void checkTransposeAliasing(const OtherDerived& other) const;
+  public:
+#endif
 
     RowXpr row(int i);
     const RowXpr row(int i) const;
@@ -638,7 +629,7 @@ template class MatrixBase
     const CwiseBinaryOp
     binaryExpr(const MatrixBase &other, const CustomBinaryOp& func = CustomBinaryOp()) const;
 
-    
+
     Scalar sum() const;
     Scalar mean() const;
     Scalar trace() const;
@@ -818,7 +809,7 @@ template class MatrixBase
                           INVALID_MATRIXBASE_TEMPLATE_PARAMETERS)
 #endif
     }
-    
+
   private:
     explicit MatrixBase(int);
     MatrixBase(int,int);
diff --git a/Eigen/src/Core/Transpose.h b/Eigen/src/Core/Transpose.h
index 79aef9fa7..796ec8573 100644
--- a/Eigen/src/Core/Transpose.h
+++ b/Eigen/src/Core/Transpose.h
@@ -268,13 +268,7 @@ inline void MatrixBase::adjointInPlace()
 
 #ifndef EIGEN_NO_DEBUG
 
-// The following is to detect aliasing problems in the following common cases:
-// a = a.transpose()
-// a = a.transpose() + X
-// a = X + a.transpose()
-// a = a.adjoint()
-// a = a.adjoint() + X
-// a = X + a.adjoint()
+// The following is to detect aliasing problems in most common cases.
 
 template::ActualAccess>
 struct ei_extract_data_selector {
@@ -294,63 +288,31 @@ template typename T::Scalar* ei_extract_data(const T& m)
   return ei_extract_data_selector::run(m);
 }
 
-template
-template
-Derived& MatrixBase::lazyAssign(const Transpose& other)
-{
-  ei_assert(ei_extract_data(other) != ei_extract_data(derived())
-            && "aliasing detected during tranposition, please use transposeInPlace()");
-  return lazyAssign(static_cast >& >(other));
-}
-
-template
-template
-Derived& MatrixBase::
-lazyAssign(const CwiseBinaryOp,Transpose,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,Transpose,DerivedB> >& >(other));
-}
-
-template
-template
-Derived& MatrixBase::
-lazyAssign(const CwiseBinaryOp,DerivedA,Transpose >& other)
-{
-  ei_assert(ei_extract_data(derived()) != ei_extract_data(other.rhs())
-            && "aliasing detected during tranposition, please evaluate your expression");
-  return lazyAssign(static_cast,DerivedA,Transpose > >& >(other));
-}
-
-template
-template Derived&
-MatrixBase::
-lazyAssign(const CwiseUnaryOp, Eigen::Transpose >& other)
+template
+struct ei_check_transpose_aliasing_selector
 {
-  ei_assert(ei_extract_data(other) != ei_extract_data(derived())
-            && "aliasing detected during tranposition, please use adjointInPlace()");
-  return lazyAssign(static_cast, Eigen::Transpose > >& >(other));
-}
+  static bool run(const Scalar* dest, const OtherDerived& src)
+  {
+    return (ei_blas_traits::IsTransposed != DestIsTranposed) && (dest==ei_extract_data(src));
+  }
+};
 
-template
-template
-Derived& MatrixBase::
-lazyAssign(const CwiseBinaryOp,CwiseUnaryOp, Eigen::Transpose >,DerivedB>& other)
+template
+struct ei_check_transpose_aliasing_selector >
 {
-  ei_assert(ei_extract_data(derived()) != ei_extract_data(other.lhs())
-            && "aliasing detected during tranposition, please evaluate your expression");
-  return lazyAssign(static_cast,CwiseUnaryOp, Eigen::Transpose >,DerivedB> >& >(other));
-}
+  static bool run(const Scalar* dest, const CwiseBinaryOp& src)
+  {
+    return ((ei_blas_traits::IsTransposed != DestIsTranposed) && dest==ei_extract_data(src.lhs()))
+        || ((ei_blas_traits::IsTransposed != DestIsTranposed) && dest==ei_extract_data(src.rhs()));
+  }
+};
 
 template
-template
-Derived& MatrixBase::
-lazyAssign(const CwiseBinaryOp,DerivedA,CwiseUnaryOp, Eigen::Transpose > >& other)
+template
+void MatrixBase::checkTransposeAliasing(const OtherDerived& other) const
 {
-  ei_assert(ei_extract_data(derived()) != ei_extract_data(other.rhs())
-            && "aliasing detected during tranposition, please evaluate your expression");
-  return lazyAssign(static_cast,DerivedA,CwiseUnaryOp, Eigen::Transpose > > >& >(other));
+  ei_assert((!ei_check_transpose_aliasing_selector::IsTransposed,OtherDerived>::run(ei_extract_data(derived()), other))
+         && "aliasing detected during tranposition, use transposeInPlace() or evaluate the rhs into a temporary using .eval()");
 }
 #endif
 
diff --git a/Eigen/src/Core/arch/SSE/PacketMath.h b/Eigen/src/Core/arch/SSE/PacketMath.h
index 69f6979bd..dbdddb38d 100644
--- a/Eigen/src/Core/arch/SSE/PacketMath.h
+++ b/Eigen/src/Core/arch/SSE/PacketMath.h
@@ -58,8 +58,8 @@ template<> struct ei_packet_traits  : ei_default_packet_traits
 {
   typedef Packet4f type; enum {size=4};
   enum {
-    HasSin  = 1,
-    HasCos  = 1,
+    HasSin  = EIGEN_FAST_MATH,
+    HasCos  = EIGEN_FAST_MATH,
     HasLog  = 1,
     HasExp  = 1,
     HasSqrt = 1
diff --git a/Eigen/src/Core/util/BlasUtil.h b/Eigen/src/Core/util/BlasUtil.h
index a012a6e12..fa21ceebb 100644
--- a/Eigen/src/Core/util/BlasUtil.h
+++ b/Eigen/src/Core/util/BlasUtil.h
@@ -160,6 +160,7 @@ template struct ei_blas_traits
   typedef XprType _ExtractType;
   enum {
     IsComplex = NumTraits::IsComplex,
+    IsTransposed = false,
     NeedToConjugate = false,
     ActualAccess = int(ei_traits::Flags)&DirectAccessBit ? HasDirectAccess : NoDirectAccess
   };
@@ -227,6 +228,9 @@ struct ei_blas_traits >
     ExtractType,
     typename ExtractType::PlainMatrixType
     >::ret DirectLinearAccessType;
+  enum {
+    IsTransposed = Base::IsTransposed ? 0 : 1
+  };
   static inline const ExtractType extract(const XprType& x) { return Base::extract(x._expression()); }
   static inline Scalar extractScalarFactor(const XprType& x) { return Base::extractScalarFactor(x._expression()); }
 };
diff --git a/test/adjoint.cpp b/test/adjoint.cpp
index 344399257..b34112249 100644
--- a/test/adjoint.cpp
+++ b/test/adjoint.cpp
@@ -128,6 +128,14 @@ void test_adjoint()
     VERIFY_RAISES_ASSERT(a = a.adjoint());
     VERIFY_RAISES_ASSERT(a = a.adjoint() + b);
     VERIFY_RAISES_ASSERT(a = b + a.adjoint());
+
+    // no assertion should be triggered for these cases:
+    a.transpose() = a.transpose();
+    a.transpose() += a.transpose();
+    a.transpose() += a.transpose() + b;
+    a.transpose() = a.adjoint();
+    a.transpose() += a.adjoint();
+    a.transpose() += a.adjoint() + b;
   }
 #endif
 }
-- 
cgit v1.2.3


From bb59c22dc99517080276b61e09c53c00bbdb844d Mon Sep 17 00:00:00 2001
From: Gael Guennebaud 
Date: Wed, 16 Dec 2009 12:48:15 +0100
Subject: fix compilation when mixing types

---
 Eigen/src/Core/Transpose.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/Transpose.h b/Eigen/src/Core/Transpose.h
index 796ec8573..1e037e618 100644
--- a/Eigen/src/Core/Transpose.h
+++ b/Eigen/src/Core/Transpose.h
@@ -293,7 +293,7 @@ struct ei_check_transpose_aliasing_selector
 {
   static bool run(const Scalar* dest, const OtherDerived& src)
   {
-    return (ei_blas_traits::IsTransposed != DestIsTranposed) && (dest==ei_extract_data(src));
+    return (ei_blas_traits::IsTransposed != DestIsTranposed) && (dest==(Scalar*)ei_extract_data(src));
   }
 };
 
@@ -302,8 +302,8 @@ struct ei_check_transpose_aliasing_selector& src)
   {
-    return ((ei_blas_traits::IsTransposed != DestIsTranposed) && dest==ei_extract_data(src.lhs()))
-        || ((ei_blas_traits::IsTransposed != DestIsTranposed) && dest==ei_extract_data(src.rhs()));
+    return ((ei_blas_traits::IsTransposed != DestIsTranposed) && dest==(Scalar*)ei_extract_data(src.lhs()))
+        || ((ei_blas_traits::IsTransposed != DestIsTranposed) && dest==(Scalar*)ei_extract_data(src.rhs()));
   }
 };
 
-- 
cgit v1.2.3


From c35fcf3bbdbc746e0739c7ae3a6865ccf606d5ed Mon Sep 17 00:00:00 2001
From: Gael Guennebaud 
Date: Wed, 16 Dec 2009 12:53:55 +0100
Subject: fix warning by making ei_empty_struct::_ei_dummy_ private

---
 Eigen/src/Core/util/XprHelper.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/util/XprHelper.h b/Eigen/src/Core/util/XprHelper.h
index 5f3b6286c..eb7f30ced 100644
--- a/Eigen/src/Core/util/XprHelper.h
+++ b/Eigen/src/Core/util/XprHelper.h
@@ -28,7 +28,7 @@
 
 // just a workaround because GCC seems to not really like empty structs
 #ifdef __GNUG__
-  struct ei_empty_struct{char _ei_dummy_;};
+  class ei_empty_struct{char _ei_dummy_;};
   #define EIGEN_EMPTY_STRUCT : Eigen::ei_empty_struct
 #else
   #define EIGEN_EMPTY_STRUCT
-- 
cgit v1.2.3


From e0aa29121fe72ea5f8e420d363b18ac9d7a96949 Mon Sep 17 00:00:00 2001
From: Gael Guennebaud 
Date: Wed, 16 Dec 2009 13:06:47 +0100
Subject: this really fix the previous warning

---
 Eigen/src/Core/util/XprHelper.h | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/util/XprHelper.h b/Eigen/src/Core/util/XprHelper.h
index eb7f30ced..622c84a8e 100644
--- a/Eigen/src/Core/util/XprHelper.h
+++ b/Eigen/src/Core/util/XprHelper.h
@@ -28,7 +28,13 @@
 
 // just a workaround because GCC seems to not really like empty structs
 #ifdef __GNUG__
-  class ei_empty_struct{char _ei_dummy_;};
+  struct ei_empty_struct
+  {
+    EIGEN_ALWAYS_INLINE_ATTRIB ei_empty_struct() {}
+    EIGEN_ALWAYS_INLINE_ATTRIB ei_empty_struct(const ei_empty_struct&) {}
+    EIGEN_ALWAYS_INLINE_ATTRIB ei_empty_struct& operator=(const ei_empty_struct&) { return *this; }
+    char _ei_dummy_;
+  };
   #define EIGEN_EMPTY_STRUCT : Eigen::ei_empty_struct
 #else
   #define EIGEN_EMPTY_STRUCT
-- 
cgit v1.2.3


From 5cb779e5e15ff0e10976f59672bd9067ea0e972e Mon Sep 17 00:00:00 2001
From: Benoit Jacob 
Date: Wed, 16 Dec 2009 08:53:14 -0500
Subject: * introduce ei_alignmentOffset(MatrixBase&,Integer)   couldnt put it
 in Memory.h as it needs the definition of MatrixBase * make Redux use it

---
 Eigen/src/Core/Coeffs.h      | 32 ++++++++++++++++++++++++++++++++
 Eigen/src/Core/Redux.h       |  5 +----
 Eigen/src/Core/util/Memory.h |  6 +++++-
 3 files changed, 38 insertions(+), 5 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/Coeffs.h b/Eigen/src/Core/Coeffs.h
index 2618f0dce..eda36b7bb 100644
--- a/Eigen/src/Core/Coeffs.h
+++ b/Eigen/src/Core/Coeffs.h
@@ -379,6 +379,38 @@ EIGEN_STRONG_INLINE void MatrixBase::copyPacket(int index, const Matrix
     other.derived().template packet(index));
 }
 
+
+template
+struct ei_alignmentOffset_impl
+{
+  inline static Integer run(const MatrixBase&, Integer)
+  { return 0; }
+};
+
+template
+struct ei_alignmentOffset_impl
+{
+  inline static Integer run(const MatrixBase& m, Integer maxOffset)
+  {
+    return ei_alignmentOffset(&m.const_cast_derived().coeffRef(0,0), maxOffset);
+  }
+};
+
+/** \internal \returns the number of elements which have to be skipped, starting
+  * from the address of coeffRef(0,0), to find the first 16-byte aligned element.
+  *
+  * \note If the expression doesn't have the DirectAccessBit, this function returns 0.
+  *
+  * There is also the variant ei_alignmentOffset(const Scalar*, Integer) defined in Memory.h.
+  */
+template
+inline static Integer ei_alignmentOffset(const MatrixBase& m, Integer maxOffset)
+{
+  return ei_alignmentOffset_impl
+                                 ::run(m, maxOffset);
+}
+
 #endif
 
 #endif // EIGEN_COEFFS_H
diff --git a/Eigen/src/Core/Redux.h b/Eigen/src/Core/Redux.h
index 171f6dcf5..ae6b01f57 100644
--- a/Eigen/src/Core/Redux.h
+++ b/Eigen/src/Core/Redux.h
@@ -209,10 +209,7 @@ struct ei_redux_impl
   {
     const int size = mat.size();
     const int packetSize = ei_packet_traits::size;
-    const int alignedStart =  (Derived::Flags & AlignedBit)
-                           || !(Derived::Flags & DirectAccessBit)
-                           ? 0
-                           : ei_alignmentOffset(&mat.const_cast_derived().coeffRef(0), size);
+    const int alignedStart = ei_alignmentOffset(mat,size);
     enum {
       alignment = (Derived::Flags & DirectAccessBit) || (Derived::Flags & AlignedBit)
                 ? Aligned : Unaligned
diff --git a/Eigen/src/Core/util/Memory.h b/Eigen/src/Core/util/Memory.h
index ebeb55ddd..524bec2fc 100644
--- a/Eigen/src/Core/util/Memory.h
+++ b/Eigen/src/Core/util/Memory.h
@@ -209,7 +209,11 @@ template inline void ei_conditional_aligned_delete(T *pt
   ei_conditional_aligned_free(ptr);
 }
 
-/** \internal \returns the number of elements which have to be skipped such that data are 16 bytes aligned */
+/** \internal \returns the number of elements which have to be skipped to
+  * find the first 16-byte aligned element
+  *
+  * There is also the variant ei_alignmentOffset(const MatrixBase&, Integer) defined in Coeffs.h.
+  */
 template
 inline static Integer ei_alignmentOffset(const Scalar* ptr, Integer maxOffset)
 {
-- 
cgit v1.2.3


From 9d5478303667bd97f3e20696f8a8c82cb5b2d65f Mon Sep 17 00:00:00 2001
From: Gael Guennebaud 
Date: Fri, 18 Dec 2009 17:08:59 +0100
Subject: much better workaround for empty struct (the previous one caused GCC
 4.3 to generate wrong code leading to segfaults)

---
 Eigen/src/Array/Functors.h      | 12 +++++++---
 Eigen/src/Array/Random.h        |  4 ++--
 Eigen/src/Array/VectorwiseOp.h  |  3 ++-
 Eigen/src/Core/Functors.h       | 51 +++++++++++++++++++++++++++--------------
 Eigen/src/Core/util/XprHelper.h | 17 +++++---------
 5 files changed, 53 insertions(+), 34 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Array/Functors.h b/Eigen/src/Array/Functors.h
index 120c56cc1..975fd9c7f 100644
--- a/Eigen/src/Array/Functors.h
+++ b/Eigen/src/Array/Functors.h
@@ -56,7 +56,8 @@ struct ei_functor_traits >
   *
   * \sa class CwiseUnaryOp, Cwise::sqrt()
   */
-template struct ei_scalar_sqrt_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_sqrt_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_sqrt_op)
   inline const Scalar operator() (const Scalar& a) const { return ei_sqrt(a); }
   typedef typename ei_packet_traits::type Packet;
   inline Packet packetOp(const Packet& a) const { return ei_psqrt(a); }
@@ -77,7 +78,8 @@ struct ei_functor_traits >
   *
   * \sa class CwiseUnaryOp, Cwise::cos()
   */
-template struct ei_scalar_cos_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_cos_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_cos_op)
   inline Scalar operator() (const Scalar& a) const { return ei_cos(a); }
   typedef typename ei_packet_traits::type Packet;
   inline Packet packetOp(const Packet& a) const { return ei_pcos(a); }
@@ -99,7 +101,8 @@ struct ei_functor_traits >
   *
   * \sa class CwiseUnaryOp, Cwise::sin()
   */
-template struct ei_scalar_sin_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_sin_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_sin_op)
   inline const Scalar operator() (const Scalar& a) const { return ei_sin(a); }
   typedef typename ei_packet_traits::type Packet;
   inline Packet packetOp(const Packet& a) const { return ei_psin(a); }
@@ -143,6 +146,7 @@ struct ei_functor_traits >
   */
 template
 struct ei_scalar_inverse_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_inverse_op)
   inline Scalar operator() (const Scalar& a) const { return Scalar(1)/a; }
   template
   inline const PacketScalar packetOp(const PacketScalar& a) const
@@ -162,6 +166,7 @@ struct ei_functor_traits >
   */
 template
 struct ei_scalar_square_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_square_op)
   inline Scalar operator() (const Scalar& a) const { return a*a; }
   template
   inline const PacketScalar packetOp(const PacketScalar& a) const
@@ -181,6 +186,7 @@ struct ei_functor_traits >
   */
 template
 struct ei_scalar_cube_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_cube_op)
   inline Scalar operator() (const Scalar& a) const { return a*a*a; }
   template
   inline const PacketScalar packetOp(const PacketScalar& a) const
diff --git a/Eigen/src/Array/Random.h b/Eigen/src/Array/Random.h
index adadf99e3..b94ccda68 100644
--- a/Eigen/src/Array/Random.h
+++ b/Eigen/src/Array/Random.h
@@ -25,8 +25,8 @@
 #ifndef EIGEN_RANDOM_H
 #define EIGEN_RANDOM_H
 
-template struct ei_scalar_random_op EIGEN_EMPTY_STRUCT {
-  inline ei_scalar_random_op(void) {}
+template struct ei_scalar_random_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_random_op)
   inline const Scalar operator() (int, int) const { return ei_random(); }
 };
 template
diff --git a/Eigen/src/Array/VectorwiseOp.h b/Eigen/src/Array/VectorwiseOp.h
index 37ed8ac17..bb695c795 100644
--- a/Eigen/src/Array/VectorwiseOp.h
+++ b/Eigen/src/Array/VectorwiseOp.h
@@ -110,7 +110,8 @@ class PartialReduxExpr : ei_no_assignment_operator,
 
 #define EIGEN_MEMBER_FUNCTOR(MEMBER,COST)                           \
   template                                     \
-  struct ei_member_##MEMBER EIGEN_EMPTY_STRUCT {                    \
+  struct ei_member_##MEMBER {                                       \
+    EIGEN_EMPTY_STRUCT_CTOR(ei_member_##MEMBER)                     \
     typedef ResultType result_type;                                 \
     template struct Cost                 \
     { enum { value = COST }; };                                     \
diff --git a/Eigen/src/Core/Functors.h b/Eigen/src/Core/Functors.h
index 6b62fb4ea..1a4edfc4a 100644
--- a/Eigen/src/Core/Functors.h
+++ b/Eigen/src/Core/Functors.h
@@ -32,7 +32,8 @@
   *
   * \sa class CwiseBinaryOp, MatrixBase::operator+, class VectorwiseOp, MatrixBase::sum()
   */
-template struct ei_scalar_sum_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_sum_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_sum_op)
   EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a + b; }
   template
   EIGEN_STRONG_INLINE const PacketScalar packetOp(const PacketScalar& a, const PacketScalar& b) const
@@ -54,7 +55,8 @@ struct ei_functor_traits > {
   *
   * \sa class CwiseBinaryOp, Cwise::operator*(), class VectorwiseOp, MatrixBase::redux()
   */
-template struct ei_scalar_product_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_product_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_product_op)
   EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a * b; }
   template
   EIGEN_STRONG_INLINE const PacketScalar packetOp(const PacketScalar& a, const PacketScalar& b) const
@@ -76,7 +78,8 @@ struct ei_functor_traits > {
   *
   * \sa class CwiseBinaryOp, MatrixBase::cwiseMin, class VectorwiseOp, MatrixBase::minCoeff()
   */
-template struct ei_scalar_min_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_min_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_min_op)
   EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return std::min(a, b); }
   template
   EIGEN_STRONG_INLINE const PacketScalar packetOp(const PacketScalar& a, const PacketScalar& b) const
@@ -98,7 +101,8 @@ struct ei_functor_traits > {
   *
   * \sa class CwiseBinaryOp, MatrixBase::cwiseMax, class VectorwiseOp, MatrixBase::maxCoeff()
   */
-template struct ei_scalar_max_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_max_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_max_op)
   EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return std::max(a, b); }
   template
   EIGEN_STRONG_INLINE const PacketScalar packetOp(const PacketScalar& a, const PacketScalar& b) const
@@ -120,7 +124,8 @@ struct ei_functor_traits > {
   *
   * \sa MatrixBase::stableNorm(), class Redux
   */
-template struct ei_scalar_hypot_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_hypot_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_hypot_op)
 //   typedef typename NumTraits::Real result_type;
   EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& _x, const Scalar& _y) const
   {
@@ -142,7 +147,8 @@ struct ei_functor_traits > {
   *
   * \sa class CwiseBinaryOp, MatrixBase::operator-
   */
-template struct ei_scalar_difference_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_difference_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_difference_op)
   EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a - b; }
   template
   EIGEN_STRONG_INLINE const PacketScalar packetOp(const PacketScalar& a, const PacketScalar& b) const
@@ -161,7 +167,8 @@ struct ei_functor_traits > {
   *
   * \sa class CwiseBinaryOp, Cwise::operator/()
   */
-template struct ei_scalar_quotient_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_quotient_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_quotient_op)
   EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a / b; }
   template
   EIGEN_STRONG_INLINE const PacketScalar packetOp(const PacketScalar& a, const PacketScalar& b) const
@@ -185,7 +192,8 @@ struct ei_functor_traits > {
   *
   * \sa class CwiseUnaryOp, MatrixBase::operator-
   */
-template struct ei_scalar_opposite_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_opposite_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_opposite_op)
   EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return -a; }
   template
   EIGEN_STRONG_INLINE const PacketScalar packetOp(const PacketScalar& a) const
@@ -203,7 +211,8 @@ struct ei_functor_traits >
   *
   * \sa class CwiseUnaryOp, Cwise::abs
   */
-template struct ei_scalar_abs_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_abs_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_abs_op)
   typedef typename NumTraits::Real result_type;
   EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return ei_abs(a); }
   template
@@ -224,7 +233,8 @@ struct ei_functor_traits >
   *
   * \sa class CwiseUnaryOp, Cwise::abs2
   */
-template struct ei_scalar_abs2_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_abs2_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_abs2_op)
   typedef typename NumTraits::Real result_type;
   EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return ei_abs2(a); }
   template
@@ -240,7 +250,8 @@ struct ei_functor_traits >
   *
   * \sa class CwiseUnaryOp, MatrixBase::conjugate()
   */
-template struct ei_scalar_conjugate_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_conjugate_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_conjugate_op)
   EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return ei_conj(a); }
   template
   EIGEN_STRONG_INLINE const PacketScalar packetOp(const PacketScalar& a) const { return a; }
@@ -260,7 +271,8 @@ struct ei_functor_traits >
   * \sa class CwiseUnaryOp, MatrixBase::cast()
   */
 template
-struct ei_scalar_cast_op EIGEN_EMPTY_STRUCT {
+struct ei_scalar_cast_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_cast_op)
   typedef NewType result_type;
   EIGEN_STRONG_INLINE const NewType operator() (const Scalar& a) const { return static_cast(a); }
 };
@@ -274,7 +286,8 @@ struct ei_functor_traits >
   * \sa class CwiseUnaryOp, MatrixBase::real()
   */
 template
-struct ei_scalar_real_op EIGEN_EMPTY_STRUCT {
+struct ei_scalar_real_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_real_op)
   typedef typename NumTraits::Real result_type;
   EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return ei_real(a); }
   EIGEN_STRONG_INLINE result_type& operator() (Scalar& a) const { return ei_real_ref(a); }
@@ -289,7 +302,8 @@ struct ei_functor_traits >
   * \sa class CwiseUnaryOp, MatrixBase::imag()
   */
 template
-struct ei_scalar_imag_op EIGEN_EMPTY_STRUCT {
+struct ei_scalar_imag_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_imag_op)
   typedef typename NumTraits::Real result_type;
   EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return ei_imag(a); }
   EIGEN_STRONG_INLINE result_type& operator() (Scalar& a) const { return ei_imag_ref(a); }
@@ -304,7 +318,8 @@ struct ei_functor_traits >
   *
   * \sa class CwiseUnaryOp, Cwise::exp()
   */
-template struct ei_scalar_exp_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_exp_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_exp_op)
   inline const Scalar operator() (const Scalar& a) const { return ei_exp(a); }
   typedef typename ei_packet_traits::type Packet;
   inline Packet packetOp(const Packet& a) const { return ei_pexp(a); }
@@ -319,7 +334,8 @@ struct ei_functor_traits >
   *
   * \sa class CwiseUnaryOp, Cwise::log()
   */
-template struct ei_scalar_log_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_log_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_log_op)
   inline const Scalar operator() (const Scalar& a) const { return ei_log(a); }
   typedef typename ei_packet_traits::type Packet;
   inline Packet packetOp(const Packet& a) const { return ei_plog(a); }
@@ -428,7 +444,8 @@ template
 struct ei_functor_traits >
 { enum { Cost = 1, PacketAccess = ei_packet_traits::size>1, IsRepeatable = true }; };
 
-template struct ei_scalar_identity_op EIGEN_EMPTY_STRUCT {
+template struct ei_scalar_identity_op {
+  EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_identity_op)
   EIGEN_STRONG_INLINE ei_scalar_identity_op(void) {}
   EIGEN_STRONG_INLINE const Scalar operator() (int row, int col) const { return row==col ? Scalar(1) : Scalar(0); }
 };
diff --git a/Eigen/src/Core/util/XprHelper.h b/Eigen/src/Core/util/XprHelper.h
index 622c84a8e..2a9feaeeb 100644
--- a/Eigen/src/Core/util/XprHelper.h
+++ b/Eigen/src/Core/util/XprHelper.h
@@ -28,16 +28,11 @@
 
 // just a workaround because GCC seems to not really like empty structs
 #ifdef __GNUG__
-  struct ei_empty_struct
-  {
-    EIGEN_ALWAYS_INLINE_ATTRIB ei_empty_struct() {}
-    EIGEN_ALWAYS_INLINE_ATTRIB ei_empty_struct(const ei_empty_struct&) {}
-    EIGEN_ALWAYS_INLINE_ATTRIB ei_empty_struct& operator=(const ei_empty_struct&) { return *this; }
-    char _ei_dummy_;
-  };
-  #define EIGEN_EMPTY_STRUCT : Eigen::ei_empty_struct
+  #define EIGEN_EMPTY_STRUCT_CTOR(X) \
+    EIGEN_STRONG_INLINE X() {} \
+    EIGEN_STRONG_INLINE X(const X&) {}
 #else
-  #define EIGEN_EMPTY_STRUCT
+  #define EIGEN_EMPTY_STRUCT_CTOR(X)
 #endif
 
 //classes inheriting ei_no_assignment_operator don't generate a default operator=.
@@ -51,10 +46,10 @@ class ei_no_assignment_operator
   * can be accessed using value() and setValue().
   * Otherwise, this class is an empty structure and value() just returns the template parameter Value.
   */
-template class ei_int_if_dynamic EIGEN_EMPTY_STRUCT
+template class ei_int_if_dynamic
 {
   public:
-    ei_int_if_dynamic() {}
+    EIGEN_EMPTY_STRUCT_CTOR(ei_int_if_dynamic)
     explicit ei_int_if_dynamic(int) {}
     static int value() { return Value; }
     void setValue(int) {}
-- 
cgit v1.2.3


From f8cb9a6230d21d9b9fa618f3d5ebc4ecb6ab6de1 Mon Sep 17 00:00:00 2001
From: Gael Guennebaud 
Date: Sat, 19 Dec 2009 13:45:14 +0100
Subject: oops, remove duplicated ctor

---
 Eigen/src/Core/Functors.h | 1 -
 1 file changed, 1 deletion(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/Functors.h b/Eigen/src/Core/Functors.h
index 1a4edfc4a..aa3eba5cc 100644
--- a/Eigen/src/Core/Functors.h
+++ b/Eigen/src/Core/Functors.h
@@ -446,7 +446,6 @@ struct ei_functor_traits >
 
 template struct ei_scalar_identity_op {
   EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_identity_op)
-  EIGEN_STRONG_INLINE ei_scalar_identity_op(void) {}
   EIGEN_STRONG_INLINE const Scalar operator() (int row, int col) const { return row==col ? Scalar(1) : Scalar(0); }
 };
 template
-- 
cgit v1.2.3


From 4ec99bbc0c3756520fb6e53ffdc0f63a739dd87a Mon Sep 17 00:00:00 2001
From: Benoit Jacob 
Date: Mon, 21 Dec 2009 13:49:43 -0500
Subject: support gcc 4.5

---
 Eigen/src/Core/Product.h | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'Eigen/src/Core')

diff --git a/Eigen/src/Core/Product.h b/Eigen/src/Core/Product.h
index d24ef6159..7066e5743 100644
--- a/Eigen/src/Core/Product.h
+++ b/Eigen/src/Core/Product.h
@@ -58,10 +58,12 @@ enum { OuterProduct, InnerProduct, UnrolledProduct, GemvProduct, GemmProduct };
 
 template struct ei_product_type
 {
+  typedef typename ei_cleantype::type _Lhs;
+  typedef typename ei_cleantype::type _Rhs;
   enum {
-    Rows  = Lhs::RowsAtCompileTime,
-    Cols  = Rhs::ColsAtCompileTime,
-    Depth = EIGEN_ENUM_MIN(Lhs::ColsAtCompileTime,Rhs::RowsAtCompileTime)
+    Rows  = _Lhs::RowsAtCompileTime,
+    Cols  = _Rhs::ColsAtCompileTime,
+    Depth = EIGEN_ENUM_MIN(_Lhs::ColsAtCompileTime,_Rhs::RowsAtCompileTime)
   };
 
   // the splitting into different lines of code here, introducing the _select enums and the typedef below,
-- 
cgit v1.2.3