new implementation of diagonal matrices and diagonal matrix expressions

6 files changed, 102 insertions, 12 deletions

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index a266ec482..68c42579e 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -98,6 +98,7 @@ ei_add_test(redux)
 ei_add_test(product_small)
 ei_add_test(product_large ${EI_OFLAG})
 ei_add_test(product_selfadjoint)
+ei_add_test(diagonalmatrices)
 ei_add_test(adjoint)
 ei_add_test(submatrices)
 ei_add_test(miscmatrices)
diff --git a/test/diagonalmatrices.cpp b/test/diagonalmatrices.cpp
new file mode 100644
index 000000000..0a8b7086b
--- /dev/null
+++ b/test/diagonalmatrices.cpp
@@ -0,0 +1,95 @@
+// 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/>.
+
+#include "main.h"
+
+template<typename MatrixType> void diagonalmatrices(const MatrixType& m)
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  enum { Rows = MatrixType::RowsAtCompileTime, Cols = MatrixType::ColsAtCompileTime };
+  typedef Matrix<Scalar, Rows, 1> VectorType;
+  typedef Matrix<Scalar, 1, Cols> RowVectorType;
+  typedef Matrix<Scalar, Rows, Rows> SquareMatrixType;
+  typedef DiagonalMatrix<Scalar, Rows> LeftDiagonalMatrix;
+  typedef DiagonalMatrix<Scalar, Cols> RightDiagonalMatrix;
+  
+  int rows = m.rows();
+  int cols = m.cols();
+
+  MatrixType m1 = MatrixType::Random(rows, cols),
+             m2 = MatrixType::Random(rows, cols);
+  VectorType v1 = VectorType::Random(rows),
+             v2 = VectorType::Random(rows);
+  RowVectorType rv1 = RowVectorType::Random(cols),
+             rv2 = RowVectorType::Random(cols);
+  LeftDiagonalMatrix ldm1(v1), ldm2(v2);
+  RightDiagonalMatrix rdm1(rv1), rdm2(rv2);
+  
+  int i = ei_random<int>(0, rows-1);
+  int j = ei_random<int>(0, cols-1);
+  
+  VERIFY_IS_APPROX( ((ldm1 * m1)(i,j))  , ldm1.diagonal()(i) * m1(i,j) );
+  VERIFY_IS_APPROX( ((ldm1 * (m1+m2))(i,j))  , ldm1.diagonal()(i) * (m1+m2)(i,j) );
+  VERIFY_IS_APPROX( ((m1 * rdm1)(i,j))  , rdm1.diagonal()(j) * m1(i,j) );
+  VERIFY_IS_APPROX( ((v1.asDiagonal() * m1)(i,j))  , v1(i) * m1(i,j) );
+  VERIFY_IS_APPROX( ((m1 * rv1.asDiagonal())(i,j))  , rv1(j) * m1(i,j) );
+  VERIFY_IS_APPROX( (((v1+v2).asDiagonal() * m1)(i,j))  , (v1+v2)(i) * m1(i,j) );
+  VERIFY_IS_APPROX( (((v1+v2).asDiagonal() * (m1+m2))(i,j))  , (v1+v2)(i) * (m1+m2)(i,j) );
+  VERIFY_IS_APPROX( ((m1 * (rv1+rv2).asDiagonal())(i,j))  , (rv1+rv2)(j) * m1(i,j) );
+  VERIFY_IS_APPROX( (((m1+m2) * (rv1+rv2).asDiagonal())(i,j))  , (rv1+rv2)(j) * (m1+m2)(i,j) );
+  
+  SquareMatrixType sq_m1 (v1.asDiagonal());
+  VERIFY_IS_APPROX(sq_m1, v1.asDiagonal().toDenseMatrix());
+  sq_m1 = v1.asDiagonal();
+  VERIFY_IS_APPROX(sq_m1, v1.asDiagonal().toDenseMatrix());
+  SquareMatrixType sq_m2 = v1.asDiagonal();
+  VERIFY_IS_APPROX(sq_m1, sq_m2);
+  
+  ldm1 = v1.asDiagonal();
+  LeftDiagonalMatrix ldm3(v1);
+  VERIFY_IS_APPROX(ldm1.diagonal(), ldm3.diagonal());
+  LeftDiagonalMatrix ldm4 = v1.asDiagonal();
+  VERIFY_IS_APPROX(ldm1.diagonal(), ldm4.diagonal());
+  
+  sq_m1.block(0,0,rows,rows) = ldm1;
+  VERIFY_IS_APPROX(sq_m1, ldm1.toDenseMatrix());
+  sq_m1.transpose() = ldm1;
+  VERIFY_IS_APPROX(sq_m1, ldm1.toDenseMatrix());
+}
+
+void test_diagonalmatrices()
+{
+  for(int i = 0; i < g_repeat; i++) {
+    CALL_SUBTEST( diagonalmatrices(Matrix<float, 1, 1>()) );
+    CALL_SUBTEST( diagonalmatrices(Matrix3f()) );
+    CALL_SUBTEST( diagonalmatrices(Matrix<double,3,3,RowMajor>()) );
+    CALL_SUBTEST( diagonalmatrices(Matrix4d()) );
+    CALL_SUBTEST( diagonalmatrices(Matrix<float,4,4,RowMajor>()) );
+    CALL_SUBTEST( diagonalmatrices(MatrixXcf(3, 5)) );
+    CALL_SUBTEST( diagonalmatrices(MatrixXi(10, 8)) );
+    CALL_SUBTEST( diagonalmatrices(Matrix<double,Dynamic,Dynamic,RowMajor>(20, 20)) );
+    CALL_SUBTEST( diagonalmatrices(MatrixXf(21, 24)) );
+  }
+}
diff --git a/test/eigensolver_generic.cpp b/test/eigensolver_generic.cpp
index b7202ab34..2be49faf4 100644
--- a/test/eigensolver_generic.cpp
+++ b/test/eigensolver_generic.cpp
@@ -57,7 +57,7 @@ template<typename MatrixType> void eigensolver(const MatrixType& m)
   EigenSolver<MatrixType> ei1(a);
   VERIFY_IS_APPROX(a * ei1.pseudoEigenvectors(), ei1.pseudoEigenvectors() * ei1.pseudoEigenvalueMatrix());
   VERIFY_IS_APPROX(a.template cast<Complex>() * ei1.eigenvectors(),
-                   ei1.eigenvectors() * ei1.eigenvalues().asDiagonal().eval());
+                   ei1.eigenvectors() * ei1.eigenvalues().asDiagonal());
 
 }
 
diff --git a/test/eigensolver_selfadjoint.cpp b/test/eigensolver_selfadjoint.cpp
index b8e2be98a..c93953714 100644
--- a/test/eigensolver_selfadjoint.cpp
+++ b/test/eigensolver_selfadjoint.cpp
@@ -75,7 +75,7 @@ template<typename MatrixType> void selfadjointeigensolver(const MatrixType& m)
     convert(gEvec, _evec);
 
     // test gsl itself !
-    VERIFY((symmA * _evec).isApprox(_evec * _eval.asDiagonal().eval(), largerEps));
+    VERIFY((symmA * _evec).isApprox(_evec * _eval.asDiagonal(), largerEps));
 
     // compare with eigen
     VERIFY_IS_APPROX(_eval, eiSymm.eigenvalues());
@@ -86,7 +86,7 @@ template<typename MatrixType> void selfadjointeigensolver(const MatrixType& m)
     convert(gEval, _eval);
     convert(gEvec, _evec);
     // test GSL itself:
-    VERIFY((symmA * _evec).isApprox(symmB * (_evec * _eval.asDiagonal().eval()), largerEps));
+    VERIFY((symmA * _evec).isApprox(symmB * (_evec * _eval.asDiagonal()), largerEps));
 
     // compare with eigen
 //     std::cerr << _eval.transpose() << "\n" << eiSymmGen.eigenvalues().transpose() << "\n\n";
@@ -102,11 +102,11 @@ template<typename MatrixType> void selfadjointeigensolver(const MatrixType& m)
   #endif
 
   VERIFY((symmA * eiSymm.eigenvectors()).isApprox(
-          eiSymm.eigenvectors() * eiSymm.eigenvalues().asDiagonal().eval(), largerEps));
+          eiSymm.eigenvectors() * eiSymm.eigenvalues().asDiagonal(), largerEps));
 
   // generalized eigen problem Ax = lBx
   VERIFY((symmA * eiSymmGen.eigenvectors()).isApprox(
-          symmB * (eiSymmGen.eigenvectors() * eiSymmGen.eigenvalues().asDiagonal().eval()), largerEps));
+          symmB * (eiSymmGen.eigenvectors() * eiSymmGen.eigenvalues().asDiagonal()), largerEps));
 
   MatrixType sqrtSymmA = eiSymm.operatorSqrt();
   VERIFY_IS_APPROX(symmA, sqrtSymmA*sqrtSymmA);
diff --git a/test/geo_transformations.cpp b/test/geo_transformations.cpp
index fcd247bc5..a4f75e384 100644
--- a/test/geo_transformations.cpp
+++ b/test/geo_transformations.cpp
@@ -332,12 +332,6 @@ template<typename Scalar, int Mode> void transformations(void)
   Translation<double,3> tr1d = tr1.template cast<double>();
   VERIFY_IS_APPROX(tr1d.template cast<Scalar>(),tr1);
 
-  AlignedScaling3 sc1(v0);
-  DiagonalMatrix<float,3> sc1f; sc1f = sc1.template cast<float>();
-  VERIFY_IS_APPROX(sc1f.template cast<Scalar>(),sc1);
-  DiagonalMatrix<double,3> sc1d; sc1d = (sc1.template cast<double>());
-  VERIFY_IS_APPROX(sc1d.template cast<Scalar>(),sc1);
-
   AngleAxis<float> aa1f = aa1.template cast<float>();
   VERIFY_IS_APPROX(aa1f.template cast<Scalar>(),aa1);
   AngleAxis<double> aa1d = aa1.template cast<double>();
diff --git a/test/miscmatrices.cpp b/test/miscmatrices.cpp
index 5b0367be6..bf885e252 100644
--- a/test/miscmatrices.cpp
+++ b/test/miscmatrices.cpp
@@ -43,7 +43,7 @@ template<typename MatrixType> void miscMatrices(const MatrixType& m)
   VectorType v1 = VectorType::Random(rows);
   v1[0];
   Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime>
-  square = v1.asDiagonal();
+  square(v1.asDiagonal());
   if(r==r2) VERIFY_IS_APPROX(square(r,r2), v1[r]);
   else VERIFY_IS_MUCH_SMALLER_THAN(square(r,r2), static_cast<Scalar>(1));
   square = MatrixType::Zero(rows, rows);