* add PermutationMatrix

* DiagonalMatrix:
   - add MaxSizeAtCompileTime parameter
   - DiagonalOnTheLeft ---> OnTheLeft
   - fix bug in DiagonalMatrix::setIdentity()

Eigen/src/Core/DiagonalMatrix.h

@@ -66,7 +66,7 @@ class DiagonalBase : public AnyMatrixBase<Derived>
     inline int cols() const { return diagonal().size(); }
 
     template<typename MatrixDerived>
-    const DiagonalProduct<MatrixDerived, Derived, DiagonalOnTheLeft>
+    const DiagonalProduct<MatrixDerived, Derived, OnTheLeft>
     operator*(const MatrixBase<MatrixDerived> &matrix) const;
 };
 
@@ -88,16 +88,16 @@ void DiagonalBase<Derived>::evalTo(MatrixBase<DenseDerived> &other) const
   *
   * \sa class Matrix
   */
-template<typename _Scalar, int _Size>
-struct ei_traits<DiagonalMatrix<_Scalar,_Size> >
- : ei_traits<Matrix<_Scalar,_Size,_Size> >
+template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime>
+struct ei_traits<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> >
+ : ei_traits<Matrix<_Scalar,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> >
 {
-  typedef Matrix<_Scalar,_Size,1> DiagonalVectorType;
+  typedef Matrix<_Scalar,SizeAtCompileTime,1,0,MaxSizeAtCompileTime,1> DiagonalVectorType;
 };
 
-template<typename _Scalar, int _Size>
+template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime>
 class DiagonalMatrix
-  : public DiagonalBase<DiagonalMatrix<_Scalar,_Size> >
+  : public DiagonalBase<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> >
 {
   public:
 
@@ -156,8 +156,8 @@ class DiagonalMatrix
     inline void resize(int size) { m_diagonal.resize(size); }
     inline void setZero() { m_diagonal.setZero(); }
     inline void setZero(int size) { m_diagonal.setZero(size); }
-    inline void setIdentity() { m_diagonal.setIdentity(); }
-    inline void setIdentity(int size) { m_diagonal.setIdentity(size); }
+    inline void setIdentity() { m_diagonal.setOnes(); }
+    inline void setIdentity(int size) { m_diagonal.setOnes(size); }
 };
 
 /** \class DiagonalWrapper

Eigen/src/Core/DiagonalProduct.h

@@ -52,7 +52,7 @@ class DiagonalProduct : ei_no_assignment_operator,
     inline DiagonalProduct(const MatrixType& matrix, const DiagonalType& diagonal)
       : m_matrix(matrix), m_diagonal(diagonal)
     {
-      ei_assert(diagonal.diagonal().size() == (ProductOrder == DiagonalOnTheLeft ? matrix.rows() : matrix.cols()));
+      ei_assert(diagonal.diagonal().size() == (ProductOrder == OnTheLeft ? matrix.rows() : matrix.cols()));
     }
 
     inline int rows() const { return m_matrix.rows(); }
@@ -60,7 +60,7 @@ class DiagonalProduct : ei_no_assignment_operator,
 
     const Scalar coeff(int row, int col) const
     {
-      return m_diagonal.diagonal().coeff(ProductOrder == DiagonalOnTheLeft ? row : col) * m_matrix.coeff(row, col);
+      return m_diagonal.diagonal().coeff(ProductOrder == OnTheLeft ? row : col) * m_matrix.coeff(row, col);
     }
 
     template<int LoadMode>
@@ -71,10 +71,10 @@ class DiagonalProduct : ei_no_assignment_operator,
         InnerSize = (MatrixType::Flags & RowMajorBit) ? MatrixType::ColsAtCompileTime : MatrixType::RowsAtCompileTime,
         DiagonalVectorPacketLoadMode = (LoadMode == Aligned && ((InnerSize%16) == 0)) ? Aligned : Unaligned
       };
-      const int indexInDiagonalVector = ProductOrder == DiagonalOnTheLeft ? row : col;
+      const int indexInDiagonalVector = ProductOrder == OnTheLeft ? row : col;
 
-      if((int(StorageOrder) == RowMajor && int(ProductOrder) == DiagonalOnTheLeft)
-       ||(int(StorageOrder) == ColMajor && int(ProductOrder) == DiagonalOnTheRight))
+      if((int(StorageOrder) == RowMajor && int(ProductOrder) == OnTheLeft)
+       ||(int(StorageOrder) == ColMajor && int(ProductOrder) == OnTheRight))
       {
         return ei_pmul(m_matrix.template packet<LoadMode>(row, col),
                        ei_pset1(m_diagonal.diagonal().coeff(indexInDiagonalVector)));
@@ -95,20 +95,20 @@ class DiagonalProduct : ei_no_assignment_operator,
   */
 template<typename Derived>
 template<typename DiagonalDerived>
-inline const DiagonalProduct<Derived, DiagonalDerived, DiagonalOnTheRight>
+inline const DiagonalProduct<Derived, DiagonalDerived, OnTheRight>
 MatrixBase<Derived>::operator*(const DiagonalBase<DiagonalDerived> &diagonal) const
 {
-  return DiagonalProduct<Derived, DiagonalDerived, DiagonalOnTheRight>(derived(), diagonal.derived());
+  return DiagonalProduct<Derived, DiagonalDerived, OnTheRight>(derived(), diagonal.derived());
 }
 
 /** \returns the diagonal matrix product of \c *this by the matrix \a matrix.
   */
 template<typename DiagonalDerived>
 template<typename MatrixDerived>
-inline const DiagonalProduct<MatrixDerived, DiagonalDerived, DiagonalOnTheLeft>
+inline const DiagonalProduct<MatrixDerived, DiagonalDerived, OnTheLeft>
 DiagonalBase<DiagonalDerived>::operator*(const MatrixBase<MatrixDerived> &matrix) const
 {
-  return DiagonalProduct<MatrixDerived, DiagonalDerived, DiagonalOnTheLeft>(matrix.derived(), derived());
+  return DiagonalProduct<MatrixDerived, DiagonalDerived, OnTheLeft>(matrix.derived(), derived());
 }
 
 

Eigen/src/Core/MatrixBase.h

@@ -410,7 +410,7 @@ template<typename Derived> class MatrixBase
     void applyOnTheRight(const AnyMatrixBase<OtherDerived>& other);
 
     template<typename DiagonalDerived>
-    const DiagonalProduct<Derived, DiagonalDerived, DiagonalOnTheRight>
+    const DiagonalProduct<Derived, DiagonalDerived, OnTheRight>
     operator*(const DiagonalBase<DiagonalDerived> &diagonal) const;
 
     template<typename OtherDerived>

Eigen/src/Core/PermutationMatrix.h

@@ -0,0 +1,205 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// Eigen is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 3 of the License, or (at your option) any later version.
+//
+// Alternatively, you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of
+// the License, or (at your option) any later version.
+//
+// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License and a copy of the GNU General Public License along with
+// Eigen. If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef EIGEN_PERMUTATIONMATRIX_H
+#define EIGEN_PERMUTATIONMATRIX_H
+
+/** \nonstableyet
+  * \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.
+  *
+  * This class represents a permutation matrix, internally stored as a vector of integers.
+  * The convention followed here is the same as on <a href="http://en.wikipedia.org/wiki/Permutation_matrix">Wikipedia</a>,
+  * 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).
+  *
+  * \sa class DiagonalMatrix
+  */
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime = SizeAtCompileTime> class PermutationMatrix;
+template<typename PermutationType, typename MatrixType, int Side> struct ei_permut_matrix_product_retval;
+
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime>
+struct ei_traits<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> >
+ : ei_traits<Matrix<int,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> >
+{};
+
+template<int SizeAtCompileTime, int MaxSizeAtCompileTime>
+class PermutationMatrix : public AnyMatrixBase<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> >
+{
+  public:
+
+    typedef ei_traits<PermutationMatrix> Traits;
+    typedef Matrix<int,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime>
+            DenseMatrixType;
+    enum {
+      Flags = Traits::Flags,
+      CoeffReadCost = Traits::CoeffReadCost,
+      RowsAtCompileTime = Traits::RowsAtCompileTime,
+      ColsAtCompileTime = Traits::ColsAtCompileTime,
+      MaxRowsAtCompileTime = Traits::MaxRowsAtCompileTime,
+      MaxColsAtCompileTime = Traits::MaxColsAtCompileTime
+    };
+    typedef typename Traits::Scalar Scalar;
+
+    typedef Matrix<int, RowsAtCompileTime, 1, 0, MaxRowsAtCompileTime, 1> IndicesType;
+
+    inline PermutationMatrix()
+    {
+    }
+
+    template<int OtherSize, int OtherMaxSize>
+    inline PermutationMatrix(const PermutationMatrix<OtherSize, OtherMaxSize>& other)
+      : m_indices(other.indices()) {}
+
+    /** copy constructor. 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 */
+    template<typename Other>
+    explicit inline PermutationMatrix(const MatrixBase<Other>& other) : m_indices(other)
+    {}
+
+    template<int OtherSize, int OtherMaxSize>
+    PermutationMatrix& operator=(const PermutationMatrix<OtherSize, OtherMaxSize>& other)
+    {
+      m_indices = other.indices();
+      return *this;
+    }
+
+    /** This is a special case of the templated operator=. Its purpose is to
+      * prevent a default operator= from hiding the templated operator=.
+      */
+    PermutationMatrix& operator=(const PermutationMatrix& other)
+    {
+      m_indices = other.m_indices();
+      return *this;
+    }
+
+    inline PermutationMatrix(int rows, int cols) : m_indices(rows)
+    {
+      ei_assert(rows == cols);
+    }
+
+    /** \returns the number of columns */
+    inline int rows() const { return m_indices.size(); }
+
+    /** \returns the number of rows */
+    inline int cols() const { return m_indices.size(); }
+
+    template<typename DenseDerived>
+    void evalTo(MatrixBase<DenseDerived>& other) const
+    {
+      other.setZero();
+      for (int i=0; i<rows();++i)
+        other.coeffRef(i,m_indices.coeff(i)) = typename DenseDerived::Scalar(1);
+    }
+
+    DenseMatrixType toDenseMatrix() const
+    {
+      return *this;
+    }
+
+    const IndicesType& indices() const { return m_indices; }
+    IndicesType& indices() { return m_indices; }
+    
+  protected:
+
+    IndicesType m_indices;
+};
+
+/** \returns the matrix with the permutation applied to the columns.
+  */
+template<typename Derived, int SizeAtCompileTime, int MaxSizeAtCompileTime>
+inline const ei_permut_matrix_product_retval<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime>, Derived, OnTheRight>
+operator*(const MatrixBase<Derived>& matrix,
+          const PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> &permutation)
+{
+  return ei_permut_matrix_product_retval
+           <PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime>, Derived, OnTheRight>
+           (permutation, matrix.derived());
+}
+
+/** \returns the matrix with the permutation applied to the rows.
+  */
+template<typename Derived, int SizeAtCompileTime, int MaxSizeAtCompileTime>
+inline const ei_permut_matrix_product_retval
+               <PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime>, Derived, OnTheLeft>
+operator*(const PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> &permutation,
+          const MatrixBase<Derived>& matrix)
+{
+  return ei_permut_matrix_product_retval
+           <PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime>, Derived, OnTheLeft>
+           (permutation, matrix.derived());
+}
+
+template<typename PermutationType, typename MatrixType, int Side>
+struct ei_traits<ei_permut_matrix_product_retval<PermutationType, MatrixType, Side> >
+{
+  typedef typename MatrixType::PlainMatrixType ReturnMatrixType;
+};
+
+template<typename PermutationType, typename MatrixType, int Side>
+struct ei_permut_matrix_product_retval
+ : public ReturnByValue<ei_permut_matrix_product_retval<PermutationType, MatrixType, Side> >
+{
+    typedef typename ei_cleantype<typename MatrixType::Nested>::type MatrixTypeNestedCleaned;
+
+    ei_permut_matrix_product_retval(const PermutationType& perm, const MatrixType& matrix)
+      : m_permutation(perm), m_matrix(matrix)
+    {}
+
+    inline int rows() const { return m_matrix.rows(); }
+    inline int cols() const { return m_matrix.cols(); }
+
+    template<typename Dest> inline void evalTo(Dest& dst) const
+    {
+      const int n = Side==OnTheLeft ? rows() : cols();
+      for(int i = 0; i < n; ++i)
+      {
+        Block<
+          Dest,
+          Side==OnTheLeft ? 1 : Dest::RowsAtCompileTime,
+          Side==OnTheRight ? 1 : Dest::ColsAtCompileTime
+        >(dst, Side==OnTheRight ? m_permutation.indices().coeff(i) : i)
+
+        =
+
+        Block<
+          MatrixTypeNestedCleaned,
+          Side==OnTheLeft ? 1 : MatrixType::RowsAtCompileTime,
+          Side==OnTheRight ? 1 : MatrixType::ColsAtCompileTime
+        >(m_matrix, Side==OnTheLeft ? m_permutation.indices().coeff(i) : i);
+      }
+    }
+
+  protected:
+    const PermutationType& m_permutation;
+    const typename MatrixType::Nested m_matrix;
+};
+
+#endif // EIGEN_PERMUTATIONMATRIX_H

Eigen/src/Core/util/Constants.h

@@ -194,8 +194,6 @@ const unsigned int SelfAdjoint = SelfAdjointBit;
 const unsigned int UnitUpperTriangular = UpperTriangularBit | UnitDiagBit;
 const unsigned int UnitLowerTriangular = LowerTriangularBit | UnitDiagBit;
 
-enum { DiagonalOnTheLeft, DiagonalOnTheRight };
-
 enum { Unaligned=0, Aligned=1 };
 enum { AsRequested=0, EnforceAlignedAccess=2 };
 enum { ConditionalJumpCost = 5 };
@@ -232,7 +230,6 @@ enum {
   DontAlign = 0x2
 };
 
-// used for the solvers
 enum {
   OnTheLeft = 1,
   OnTheRight = 2

Eigen/src/Core/util/ForwardDeclarations.h

@@ -53,7 +53,7 @@ template<typename Derived,   typename Lhs, typename Rhs>  class ProductBase;
 
 template<typename Derived> class DiagonalBase;
 template<typename _DiagonalVectorType> class DiagonalWrapper;
-template<typename _Scalar, int _Size> class DiagonalMatrix;
+template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime=SizeAtCompileTime> class DiagonalMatrix;
 template<typename MatrixType, typename DiagonalType, int ProductOrder> class DiagonalProduct;
 template<typename MatrixType, int Index> class Diagonal;