constant Diagonal ---> DiagonalBits

introduce ei_is_diagonal to check for it
DiagonalCoeffs ---> Diagonal and allow Index to by Dynamic
-> add MatrixBase::diagonal(int) with unittest and doc

Eigen/Core

@@ -166,7 +166,7 @@ namespace Eigen {
 #include "src/Core/Minor.h"
 #include "src/Core/Transpose.h"
 #include "src/Core/DiagonalMatrix.h"
-#include "src/Core/DiagonalCoeffs.h"
+#include "src/Core/Diagonal.h"
 #include "src/Core/Redux.h"
 #include "src/Core/Visitor.h"
 #include "src/Core/Fuzzy.h"

Eigen/src/Cholesky/LDLT.h

@@ -83,7 +83,7 @@ template<typename MatrixType> class LDLT
     }
 
     /** \returns the coefficients of the diagonal matrix D */
-    inline DiagonalCoeffs<MatrixType> vectorD(void) const { return m_matrix.diagonal(); }
+    inline Diagonal<MatrixType,0> vectorD(void) const { return m_matrix.diagonal(); }
 
     /** \returns true if the matrix is positive (semidefinite) */
     inline bool isPositive(void) const { return m_sign == 1; }

Eigen/src/Core/Diagonal.h

@@ -0,0 +1,187 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra. Eigen itself is part of the KDE project.
+//
+// Copyright (C) 2007-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_DIAGONAL_H
+#define EIGEN_DIAGONAL_H
+
+/** \class Diagonal
+  *
+  * \brief Expression of a diagonal/subdiagonal/superdiagonal in a matrix
+  *
+  * \param MatrixType the type of the object in which we are taking a sub/main/super diagonal
+  * \param Index the index of the sub/super diagonal. The default is 0 and it means the main diagonal.
+  *              A positive value means a superdiagonal, a negative value means a subdiagonal.
+  *              You can also use Dynamic so the index can be set at runtime.
+  *
+  * The matrix is not required to be square.
+  *
+  * This class represents an expression of the main diagonal, or any sub/super diagonal
+  * of a square matrix. It is the return type of MatrixBase::diagonal() and MatrixBase::diagonal(int) and most of the
+  * time this is the only way it is used.
+  *
+  * \sa MatrixBase::diagonal(), MatrixBase::diagonal(int)
+  */
+template<typename MatrixType, int Index>
+struct ei_traits<Diagonal<MatrixType,Index> >
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename ei_nested<MatrixType>::type MatrixTypeNested;
+  typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested;
+  enum {
+    AbsIndex = Index<0 ? -Index : Index, // only used if Index != Dynamic
+    RowsAtCompileTime = (int(Index) == Dynamic || int(MatrixType::SizeAtCompileTime) == Dynamic) ? Dynamic
+                      : (EIGEN_ENUM_MIN(MatrixType::RowsAtCompileTime,
+                                        MatrixType::ColsAtCompileTime) - AbsIndex),
+    ColsAtCompileTime = 1,
+    MaxRowsAtCompileTime = int(MatrixType::MaxSizeAtCompileTime) == Dynamic ? Dynamic
+                         : (EIGEN_ENUM_MIN(MatrixType::MaxRowsAtCompileTime,
+                                          MatrixType::MaxColsAtCompileTime) - AbsIndex),
+    MaxColsAtCompileTime = 1,
+    Flags = (unsigned int)_MatrixTypeNested::Flags & (HereditaryBits | LinearAccessBit),
+    CoeffReadCost = _MatrixTypeNested::CoeffReadCost
+  };
+};
+
+template<typename MatrixType, int Index> class Diagonal
+   : public MatrixBase<Diagonal<MatrixType, Index> >
+{
+    // some compilers may fail to optimize std::max etc in case of compile-time constants...
+    EIGEN_STRONG_INLINE int absIndex() const { return m_index.value()>0 ? m_index.value() : -m_index.value(); }
+    EIGEN_STRONG_INLINE int rowOffset() const { return m_index.value()>0 ? 0 : -m_index.value(); }
+    EIGEN_STRONG_INLINE int colOffset() const { return m_index.value()>0 ? m_index.value() : 0; }
+    
+  public:
+
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Diagonal)
+
+    inline Diagonal(const MatrixType& matrix, int index = Index) : m_matrix(matrix), m_index(index) {}
+
+    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Diagonal)
+
+    inline int rows() const{ return m_matrix.diagonalSize() - absIndex(); }
+    inline int cols() const { return 1; }
+
+    inline Scalar& coeffRef(int row, int)
+    {
+      return m_matrix.const_cast_derived().coeffRef(row+rowOffset(), row+colOffset());
+    }
+
+    inline const Scalar coeff(int row, int) const
+    {
+      return m_matrix.coeff(row+rowOffset(), row+colOffset());
+    }
+
+    inline Scalar& coeffRef(int index)
+    {
+      return m_matrix.const_cast_derived().coeffRef(index+rowOffset(), index+colOffset());
+    }
+
+    inline const Scalar coeff(int index) const
+    {
+      return m_matrix.coeff(index+rowOffset(), index+colOffset());
+    }
+
+  protected:
+    const typename MatrixType::Nested m_matrix;
+    const ei_int_if_dynamic<Index> m_index;
+};
+
+/** \returns an expression of the main diagonal of the matrix \c *this
+  *
+  * \c *this is not required to be square.
+  *
+  * Example: \include MatrixBase_diagonal.cpp
+  * Output: \verbinclude MatrixBase_diagonal.out
+  *
+  * \sa class Diagonal */
+template<typename Derived>
+inline Diagonal<Derived, 0>
+MatrixBase<Derived>::diagonal()
+{
+  return Diagonal<Derived, 0>(derived());
+}
+
+/** This is the const version of diagonal(). */
+template<typename Derived>
+inline const Diagonal<Derived, 0>
+MatrixBase<Derived>::diagonal() const
+{
+  return Diagonal<Derived, 0>(derived());
+}
+
+/** \returns an expression of the \a Index-th sub or super diagonal of the matrix \c *this
+  *
+  * \c *this is not required to be square.
+  *
+  * The template parameter \a Index represent a super diagonal if \a Index > 0
+  * and a sub diagonal otherwise. \a Index == 0 is equivalent to the main diagonal.
+  *
+  * Example: \include MatrixBase_diagonal_int.cpp
+  * Output: \verbinclude MatrixBase_diagonal_int.out
+  *
+  * \sa MatrixBase::diagonal(), class Diagonal */
+template<typename Derived>
+inline Diagonal<Derived, Dynamic>
+MatrixBase<Derived>::diagonal(int index)
+{
+  return Diagonal<Derived, Dynamic>(derived(), index);
+}
+
+/** This is the const version of diagonal(int). */
+template<typename Derived>
+inline const Diagonal<Derived, Dynamic>
+MatrixBase<Derived>::diagonal(int index) const
+{
+  return Diagonal<Derived, Dynamic>(derived(), index);
+}
+
+/** \returns an expression of the \a Index-th sub or super diagonal of the matrix \c *this
+  *
+  * \c *this is not required to be square.
+  *
+  * The template parameter \a Index represent a super diagonal if \a Index > 0
+  * and a sub diagonal otherwise. \a Index == 0 is equivalent to the main diagonal.
+  *
+  * Example: \include MatrixBase_diagonal_template_int.cpp
+  * Output: \verbinclude MatrixBase_diagonal_template_int.out
+  *
+  * \sa MatrixBase::diagonal(), class Diagonal */
+template<typename Derived>
+template<int Index>
+inline Diagonal<Derived,Index>
+MatrixBase<Derived>::diagonal()
+{
+  return Diagonal<Derived,Index>(derived());
+}
+
+/** This is the const version of diagonal<int>(). */
+template<typename Derived>
+template<int Index>
+inline const Diagonal<Derived,Index>
+MatrixBase<Derived>::diagonal() const
+{
+  return Diagonal<Derived,Index>(derived());
+}
+
+#endif // EIGEN_DIAGONAL_H

Eigen/src/Core/DiagonalCoeffs.h

@@ -1,159 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
-//
-// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
-//
-// 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_DIAGONALCOEFFS_H
-#define EIGEN_DIAGONALCOEFFS_H
-
-/** \class DiagonalCoeffs
-  *
-  * \brief Expression of a sub/main/super diagonal of a matrix
-  *
-  * \param MatrixType the type of the object in which we are taking s sub/main/super diagonal
-  * \param DiagId the index of the sub/super diagonal. The default is 0 and it means the main diagonal.
-  *
-  * The matrix is not required to be square.
-  *
-  * This class represents an expression of the main diagonal, or any sub/super diagonal
-  * of a square matrix. It is the return type of MatrixBase::diagonal() and most of the
-  * time this is the only way it is used.
-  *
-  * \sa MatrixBase::diagonal()
-  */
-template<typename MatrixType, int DiagId>
-struct ei_traits<DiagonalCoeffs<MatrixType,DiagId> >
-{
-  typedef typename MatrixType::Scalar Scalar;
-  typedef typename ei_nested<MatrixType>::type MatrixTypeNested;
-  typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested;
-  enum {
-    AbsDiagId = DiagId<0 ? -DiagId : DiagId,
-    RowsAtCompileTime = int(MatrixType::SizeAtCompileTime) == Dynamic ? Dynamic
-                      : (EIGEN_ENUM_MIN(MatrixType::RowsAtCompileTime,
-                                        MatrixType::ColsAtCompileTime) - AbsDiagId),
-    ColsAtCompileTime = 1,
-    MaxRowsAtCompileTime = int(MatrixType::MaxSizeAtCompileTime) == Dynamic ? Dynamic
-                         : (EIGEN_ENUM_MIN(MatrixType::MaxRowsAtCompileTime,
-                                          MatrixType::MaxColsAtCompileTime) - AbsDiagId),
-    MaxColsAtCompileTime = 1,
-    Flags = (unsigned int)_MatrixTypeNested::Flags & (HereditaryBits | LinearAccessBit),
-    CoeffReadCost = _MatrixTypeNested::CoeffReadCost
-  };
-};
-
-template<typename MatrixType, int DiagId> class DiagonalCoeffs
-   : public MatrixBase<DiagonalCoeffs<MatrixType, DiagId> >
-{
-    enum {
-      AbsDiagId = DiagId<0 ? -DiagId : DiagId,
-      OffsetRow = DiagId<0 ? -DiagId : 0,
-      OffsetCol = DiagId<0 ? 0 : DiagId
-    };
-  public:
-
-    EIGEN_GENERIC_PUBLIC_INTERFACE(DiagonalCoeffs)
-
-    inline DiagonalCoeffs(const MatrixType& matrix) : m_matrix(matrix) {}
-
-    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(DiagonalCoeffs)
-
-    inline int rows() const { return std::min(m_matrix.rows(), m_matrix.cols()) - AbsDiagId; }
-    inline int cols() const { return 1; }
-
-    inline Scalar& coeffRef(int row, int)
-    {
-      return m_matrix.const_cast_derived().coeffRef(row+OffsetRow, row+OffsetCol);
-    }
-
-    inline const Scalar coeff(int row, int) const
-    {
-      return m_matrix.coeff(row+OffsetRow, row+OffsetCol);
-    }
-
-    inline Scalar& coeffRef(int index)
-    {
-      return m_matrix.const_cast_derived().coeffRef(index+OffsetRow, index+OffsetCol);
-    }
-
-    inline const Scalar coeff(int index) const
-    {
-      return m_matrix.coeff(index+OffsetRow, index+OffsetCol);
-    }
-
-  protected:
-
-    const typename MatrixType::Nested m_matrix;
-};
-
-/** \returns an expression of the main diagonal of the matrix \c *this
-  *
-  * \c *this is not required to be square.
-  *
-  * Example: \include MatrixBase_diagonal.cpp
-  * Output: \verbinclude MatrixBase_diagonal.out
-  *
-  * \sa class DiagonalCoeffs */
-template<typename Derived>
-inline DiagonalCoeffs<Derived>
-MatrixBase<Derived>::diagonal()
-{
-  return DiagonalCoeffs<Derived>(derived());
-}
-
-/** This is the const version of diagonal(). */
-template<typename Derived>
-inline const DiagonalCoeffs<Derived>
-MatrixBase<Derived>::diagonal() const
-{
-  return DiagonalCoeffs<Derived>(derived());
-}
-
-/** \returns an expression of the \a Id-th sub or super diagonal of the matrix \c *this
-  *
-  * \c *this is not required to be square.
-  *
-  * The template parameter \a Id represent a super diagonal if \a Id > 0
-  * and a sub diagonal otherwise. \a Id == 0 is equivalent to the main diagonal.
-  *
-  * Example: \include MatrixBase_diagonal_int.cpp
-  * Output: \verbinclude MatrixBase_diagonal_int.out
-  *
-  * \sa MatrixBase::diagonal(), class DiagonalCoeffs */
-template<typename Derived>
-template<int Id>
-inline DiagonalCoeffs<Derived,Id>
-MatrixBase<Derived>::diagonal()
-{
-  return DiagonalCoeffs<Derived,Id>(derived());
-}
-
-/** This is the const version of diagonal<int>(). */
-template<typename Derived>
-template<int Id>
-inline const DiagonalCoeffs<Derived,Id>
-MatrixBase<Derived>::diagonal() const
-{
-  return DiagonalCoeffs<Derived,Id>(derived());
-}
-
-#endif // EIGEN_DIAGONALCOEFFS_H

Eigen/src/Core/DiagonalMatrix.h

@@ -67,7 +67,7 @@ class DiagonalMatrixBase : ei_no_assignment_operator,
     template<typename OtherDerived>
     inline DiagonalMatrixBase(const MatrixBase<OtherDerived>& other)
     {
-      construct_from_expression<OtherDerived,OtherDerived::IsVectorAtCompileTime,(OtherDerived::Flags&Diagonal)==Diagonal>
+      construct_from_expression<OtherDerived,OtherDerived::IsVectorAtCompileTime,ei_is_diagonal<OtherDerived>::ret>
         ::run(derived(),other.derived());
     }
     
@@ -109,7 +109,7 @@ class DiagonalMatrixBase : ei_no_assignment_operator,
     template<typename OtherDerived>
     inline Derived& operator=(const MatrixBase<OtherDerived>& other)
     {
-      construct_from_expression<OtherDerived,OtherDerived::IsVectorAtCompileTime,(OtherDerived::Flags&Diagonal)==Diagonal>
+      construct_from_expression<OtherDerived,OtherDerived::IsVectorAtCompileTime,ei_is_diagonal<OtherDerived>::ret>
         ::run(derived(),other);
       return derived();
     }
@@ -149,7 +149,7 @@ template<typename _Scalar,int _Size>
 struct ei_traits<DiagonalMatrix<_Scalar,_Size> > : ei_traits<Matrix<_Scalar,_Size,_Size> >
 {
   enum {
-    Flags = (ei_traits<Matrix<_Scalar,_Size,_Size> >::Flags & HereditaryBits) | Diagonal
+    Flags = (ei_traits<Matrix<_Scalar,_Size,_Size> >::Flags & HereditaryBits) | DiagonalBits
   };
 };
 
@@ -209,7 +209,7 @@ class DiagonalMatrix
     template<typename OtherDerived>
     DiagonalMatrix& operator=(const MatrixBase<OtherDerived>& other)
     {
-      EIGEN_STATIC_ASSERT((OtherDerived::Flags&Diagonal)==Diagonal, THIS_METHOD_IS_ONLY_FOR_DIAGONAL_MATRIX);
+      EIGEN_STATIC_ASSERT(ei_is_diagonal<OtherDerived>::ret, THIS_METHOD_IS_ONLY_FOR_DIAGONAL_MATRIX);
       m_coeffs = other.diagonal();
       return *this;
     }
@@ -252,7 +252,7 @@ struct ei_traits<DiagonalMatrixWrapper<CoeffsVectorType> >
     ColsAtCompileTime = CoeffsVectorType::SizeAtCompileTime,
     MaxRowsAtCompileTime = CoeffsVectorType::MaxSizeAtCompileTime,
     MaxColsAtCompileTime = CoeffsVectorType::MaxSizeAtCompileTime,
-    Flags = (_CoeffsVectorTypeNested::Flags & HereditaryBits) | Diagonal,
+    Flags = (_CoeffsVectorTypeNested::Flags & HereditaryBits) | DiagonalBits,
     CoeffReadCost = _CoeffsVectorTypeNested::CoeffReadCost
   };
 };

Eigen/src/Core/DiagonalProduct.h

@@ -30,7 +30,7 @@
  *  Unlike ei_nested, if the argument is a DiagonalMatrix and if it must be evaluated,
  *  then it evaluated to a DiagonalMatrix having its own argument evaluated.
  */
-template<typename T, int N, bool IsDiagonal = (T::Flags&Diagonal)==Diagonal> struct ei_nested_diagonal : ei_nested<T,N> {};
+template<typename T, int N, bool IsDiagonal = ei_is_diagonal<T>::ret> struct ei_nested_diagonal : ei_nested<T,N> {};
 template<typename T, int N> struct ei_nested_diagonal<T,N,true>
  : ei_nested<T, N, DiagonalMatrix<typename T::Scalar, EIGEN_ENUM_MIN(T::RowsAtCompileTime,T::ColsAtCompileTime)> >
 {};
@@ -61,8 +61,8 @@ struct ei_traits<Product<LhsNested, RhsNested, DiagonalProduct> >
     MaxRowsAtCompileTime = _LhsNested::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = _RhsNested::MaxColsAtCompileTime,
 
-    LhsIsDiagonal = (_LhsNested::Flags&Diagonal)==Diagonal,
-    RhsIsDiagonal = (_RhsNested::Flags&Diagonal)==Diagonal,
+    LhsIsDiagonal = ei_is_diagonal<_LhsNested>::ret,
+    RhsIsDiagonal = ei_is_diagonal<_RhsNested>::ret,
 
     CanVectorizeRhs =  (!RhsIsDiagonal) && (RhsFlags & RowMajorBit) && (RhsFlags & PacketAccessBit)
                      && (ColsAtCompileTime % ei_packet_traits<Scalar>::size == 0),
@@ -86,7 +86,7 @@ template<typename LhsNested, typename RhsNested> class Product<LhsNested, RhsNes
     typedef typename ei_traits<Product>::_RhsNested _RhsNested;
 
     enum {
-      RhsIsDiagonal = (_RhsNested::Flags&Diagonal)==Diagonal
+      RhsIsDiagonal = ei_is_diagonal<_RhsNested>::ret
     };
 
   public:

Eigen/src/Core/MatrixBase.h

@@ -167,9 +167,12 @@ template<typename Derived> class MatrixBase
     inline int rows() const { return derived().rows(); }
     /** \returns the number of columns. \sa rows(), ColsAtCompileTime*/
     inline int cols() const { return derived().cols(); }
-    /** \returns the number of coefficients, which is \a rows()*cols().
+    /** \returns the number of coefficients, which is rows()*cols().
       * \sa rows(), cols(), SizeAtCompileTime. */
     inline int size() const { return rows() * cols(); }
+    /** \returns the size of the main diagonal, which is min(rows(),cols()).
+      * \sa rows(), cols(), SizeAtCompileTime. */
+    inline int diagonalSize() const { return std::min(rows(),cols()); }
     /** \returns the number of nonzero coefficients which is in practice the number
       * of stored coefficients. */
     inline int nonZeros() const { return derived().nonZeros(); }
@@ -419,12 +422,15 @@ template<typename Derived> class MatrixBase
     template<int Size> typename BlockReturnType<Derived,Size>::SubVectorType segment(int start);
     template<int Size> const typename BlockReturnType<Derived,Size>::SubVectorType segment(int start) const;
 
-    DiagonalCoeffs<Derived> diagonal();
-    const DiagonalCoeffs<Derived> diagonal() const;
-
-    template<int Id> DiagonalCoeffs<Derived,Id> diagonal();
-    template<int Id> const DiagonalCoeffs<Derived,Id> diagonal() const;
+    Diagonal<Derived,0> diagonal();
+    const Diagonal<Derived,0> diagonal() const;
 
+    template<int Index> Diagonal<Derived,Index> diagonal();
+    template<int Index> const Diagonal<Derived,Index> diagonal() const;
+    
+    Diagonal<Derived, Dynamic> diagonal(int index);
+    const Diagonal<Derived, Dynamic> diagonal(int index) const;
+    
     template<unsigned int Mode> Part<Derived, Mode> part();
     template<unsigned int Mode> const Part<Derived, Mode> part() const;
 

Eigen/src/Core/Product.h

@@ -84,7 +84,7 @@ template<typename Lhs, typename Rhs> struct ei_product_mode
 {
   enum{
 
-    value = ((Rhs::Flags&Diagonal)==Diagonal) || ((Lhs::Flags&Diagonal)==Diagonal)
+    value = ei_is_diagonal<Rhs>::ret || ei_is_diagonal<Lhs>::ret
           ? DiagonalProduct
           : Lhs::MaxColsAtCompileTime == Dynamic
             && ( Lhs::MaxRowsAtCompileTime == Dynamic

Eigen/src/Core/Transpose.h

@@ -138,7 +138,7 @@ template<typename MatrixType> class Transpose
   * m = m.transpose().eval();
   * \endcode
   *
-  * \sa transposeInPlace(), adjoint(), class DiagonalCoeffs */
+  * \sa transposeInPlace(), adjoint() */
 template<typename Derived>
 inline Transpose<Derived>
 MatrixBase<Derived>::transpose()

Eigen/src/Core/util/Constants.h

@@ -140,7 +140,7 @@ const unsigned int LinearAccessBit = 0x10;
   * First, references to the coefficients must be available through coeffRef(int, int). This rules out read-only
   * expressions whose coefficients are computed on demand by coeff(int, int). Second, the memory layout of the
   * array of coefficients must be exactly the natural one suggested by rows(), cols(), stride(), and the RowMajorBit.
-  * This rules out expressions such as DiagonalCoeffs, whose coefficients, though referencable, do not have
+  * This rules out expressions such as Diagonal, whose coefficients, though referencable, do not have
   * such a regular memory layout.
   */
 const unsigned int DirectAccessBit = 0x20;
@@ -186,17 +186,24 @@ const unsigned int HereditaryBits = RowMajorBit
                                   | EvalBeforeAssigningBit
                                   | SparseBit;
 
-// Possible values for the Mode parameter of part() and of extract()
+// diagonal means both upper and lower triangular
+const unsigned DiagonalBits = UpperTriangularBit | LowerTriangularBit;
+    
+// Possible values for the Mode parameter of part()
 const unsigned int UpperTriangular = UpperTriangularBit;
 const unsigned int StrictlyUpperTriangular = UpperTriangularBit | ZeroDiagBit;
 const unsigned int LowerTriangular = LowerTriangularBit;
 const unsigned int StrictlyLowerTriangular = LowerTriangularBit | ZeroDiagBit;
 const unsigned int SelfAdjoint = SelfAdjointBit;
-
-// additional possible values for the Mode parameter of extract()
 const unsigned int UnitUpperTriangular = UpperTriangularBit | UnitDiagBit;
 const unsigned int UnitLowerTriangular = LowerTriangularBit | UnitDiagBit;
-const unsigned int Diagonal = UpperTriangular | LowerTriangular;
+
+template<typename T> struct ei_is_diagonal
+{
+  enum {
+    ret = ( (unsigned int)(T::Flags) & DiagonalBits ) == DiagonalBits
+  };
+};
 
 enum { Aligned, Unaligned };
 enum { ForceAligned, AsRequested };
@@ -227,10 +234,10 @@ enum {
 enum {
   ColMajor = 0,
   RowMajor = 0x1,  // it is only a coincidence that this is equal to RowMajorBit -- don't rely on that
-  /** \internal Don't require alignment for the matrix itself (the array of coefficients, if dynamically allocated, may still be
-                requested to be aligned) */
   /** \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) */
   DontAlign = 0x2
 };
 

Eigen/src/Core/util/ForwardDeclarations.h

@@ -48,7 +48,7 @@ template<typename Lhs, typename Rhs, int ProductMode> class Product;
 template<typename CoeffsVectorType, typename Derived> class DiagonalMatrixBase;
 template<typename CoeffsVectorType> class DiagonalMatrixWrapper;
 template<typename _Scalar, int _Size> class DiagonalMatrix;
-template<typename MatrixType, int DiagId=0> class DiagonalCoeffs;
+template<typename MatrixType, int Index> class Diagonal;
 template<typename MatrixType, int PacketAccess = AsRequested> class Map;
 template<typename MatrixType, unsigned int Mode> class Part;
 template<typename MatrixType, unsigned int Mode> class Extract;

Eigen/src/LU/LU.h

@@ -333,7 +333,7 @@ LU<MatrixType>::LU(const MatrixType& matrix)
     m_p(matrix.rows()),
     m_q(matrix.cols())
 {
-  const int size = matrix.diagonal().size();
+  const int size = matrix.diagonalSize();
   const int rows = matrix.rows();
   const int cols = matrix.cols();
   
@@ -402,7 +402,7 @@ LU<MatrixType>::LU(const MatrixType& matrix)
 template<typename MatrixType>
 typename ei_traits<MatrixType>::Scalar LU<MatrixType>::determinant() const
 {
-  return Scalar(m_det_pq) * m_lu.diagonal().redux(ei_scalar_product_op<Scalar>());
+  return Scalar(m_det_pq) * m_lu.diagonal().prod();
 }
 
 template<typename MatrixType>

Eigen/src/QR/HessenbergDecomposition.h

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

Eigen/src/QR/Tridiagonalization.h

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

Eigen/src/Sparse/SparseDiagonalProduct.h

@@ -42,7 +42,7 @@ struct ei_traits<SparseDiagonalProduct<Lhs, Rhs> > : ei_traits<SparseProduct<Lhs
   typedef typename ei_cleantype<Lhs>::type _Lhs;
   typedef typename ei_cleantype<Rhs>::type _Rhs;
   enum {
-    SparseFlags = ((int(_Lhs::Flags)&Diagonal)==Diagonal) ? int(_Rhs::Flags) : int(_Lhs::Flags),
+    SparseFlags = ei_is_diagonal<_Lhs>::ret ? int(_Rhs::Flags) : int(_Lhs::Flags),
     Flags = SparseBit | (SparseFlags&RowMajorBit)
   };
 };
@@ -58,9 +58,9 @@ class SparseDiagonalProduct : public SparseMatrixBase<SparseDiagonalProduct<LhsN
     typedef typename ei_traits<SparseDiagonalProduct>::_RhsNested _RhsNested;
     
     enum {
-      LhsMode = (_LhsNested::Flags&Diagonal)==Diagonal ? SDP_IsDiagonal
+      LhsMode = ei_is_diagonal<_LhsNested>::ret ? SDP_IsDiagonal
               : (_LhsNested::Flags&RowMajorBit) ? SDP_IsSparseRowMajor : SDP_IsSparseColMajor,
-      RhsMode = (_RhsNested::Flags&Diagonal)==Diagonal ? SDP_IsDiagonal
+      RhsMode = ei_is_diagonal<_RhsNested>::ret ? SDP_IsDiagonal
               : (_RhsNested::Flags&RowMajorBit) ? SDP_IsSparseRowMajor : SDP_IsSparseColMajor
     };
 

Eigen/src/Sparse/SparseMatrixBase.h

@@ -384,8 +384,8 @@ template<typename Derived> class SparseMatrixBase
 //     template<int Size> typename BlockReturnType<Derived,Size>::SubVectorType segment(int start);
 //     template<int Size> const typename BlockReturnType<Derived,Size>::SubVectorType segment(int start) const;
 
-//     DiagonalCoeffs<Derived> diagonal();
-//     const DiagonalCoeffs<Derived> diagonal() const;
+//     Diagonal<Derived> diagonal();
+//     const Diagonal<Derived> diagonal() const;
 
 //     template<unsigned int Mode> Part<Derived, Mode> part();
 //     template<unsigned int Mode> const Part<Derived, Mode> part() const;

Eigen/src/Sparse/SparseProduct.h

@@ -29,7 +29,7 @@ template<typename Lhs, typename Rhs> struct ei_sparse_product_mode
 {
   enum {
 
-    value = ((Lhs::Flags&Diagonal)==Diagonal || (Rhs::Flags&Diagonal)==Diagonal)
+    value = ei_is_diagonal<Lhs>::ret || ei_is_diagonal<Rhs>::ret
           ? DiagonalProduct
           :  (Rhs::Flags&Lhs::Flags&SparseBit)==SparseBit
           ? SparseTimeSparseProduct

doc/snippets/MatrixBase_diagonal_int.cpp

@@ -1,5 +1,5 @@
 Matrix4i m = Matrix4i::Random();
 cout << "Here is the matrix m:" << endl << m << endl;
 cout << "Here are the coefficients on the 1st super-diagonal and 2nd sub-diagonal of m:" << endl
-     << m.diagonal<1>().transpose() << endl
-     << m.diagonal<-2>().transpose() << endl;
+     << m.diagonal(1).transpose() << endl
+     << m.diagonal(-2).transpose() << endl;

doc/snippets/MatrixBase_diagonal_template_int.cpp

@@ -0,0 +1,5 @@
+Matrix4i m = Matrix4i::Random();
+cout << "Here is the matrix m:" << endl << m << endl;
+cout << "Here are the coefficients on the 1st super-diagonal and 2nd sub-diagonal of m:" << endl
+     << m.diagonal<1>().transpose() << endl
+     << m.diagonal<-2>().transpose() << endl;

test/submatrices.cpp

@@ -109,7 +109,6 @@ template<typename MatrixType> void submatrices(const MatrixType& m)
   VERIFY_IS_APPROX(m1.diagonal(), m1.transpose().diagonal());
   m2.diagonal() = 2 * m1.diagonal();
   m2.diagonal()[0] *= 3;
-  VERIFY_IS_APPROX(m2.diagonal()[0], static_cast<Scalar>(6) * m1.diagonal()[0]);
 
   const int BlockRows = EIGEN_ENUM_MIN(MatrixType::RowsAtCompileTime,2);
   const int BlockCols = EIGEN_ENUM_MIN(MatrixType::ColsAtCompileTime,5);
@@ -152,6 +151,14 @@ template<typename MatrixType> void submatrices(const MatrixType& m)
     m2.template diagonal<N2>() = 2 * m1.template diagonal<N2>();
     m2.template diagonal<N2>()[0] *= 3;
     VERIFY_IS_APPROX(m2.template diagonal<N2>()[0], static_cast<Scalar>(6) * m1.template diagonal<N2>()[0]);
+
+    m2.diagonal(N1) = 2 * m1.diagonal(N1);
+    m2.diagonal(N1)[0] *= 3;
+    VERIFY_IS_APPROX(m2.diagonal(N1)[0], static_cast<Scalar>(6) * m1.diagonal(N1)[0]);
+
+    m2.diagonal(N2) = 2 * m1.diagonal(N2);
+    m2.diagonal(N2)[0] *= 3;
+    VERIFY_IS_APPROX(m2.diagonal(N2)[0], static_cast<Scalar>(6) * m1.diagonal(N2)[0]);
   }
 
   // stress some basic stuffs with block matrices