From a20a744adc5414f9a79ae0637de9c3227c3dd420 Mon Sep 17 00:00:00 2001
From: Benoit Jacob <jacob.benoit.1@gmail.com>
Date: Thu, 19 Nov 2009 17:07:55 -0500
Subject: TriangularMatrix: extend to rectangular matrices

---
 test/triangular.cpp | 183 ++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 143 insertions(+), 40 deletions(-)

(limited to 'test/triangular.cpp')

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<typename MatrixType> void triangular(const MatrixType& m)
+
+
+template<typename MatrixType> void triangular_square(const MatrixType& m)
 {
   typedef typename MatrixType::Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;
@@ -51,8 +53,8 @@ template<typename MatrixType> void triangular(const MatrixType& m)
              v2 = VectorType::Random(rows),
              vzero = VectorType::Zero(rows);
 
-  MatrixType m1up = m1.template triangularView<Eigen::UpperTriangular>();
-  MatrixType m2up = m2.template triangularView<Eigen::UpperTriangular>();
+  MatrixType m1up = m1.template triangularView<UpperTriangular>();
+  MatrixType m2up = m2.template triangularView<UpperTriangular>();
 
   if (rows*cols>1)
   {
@@ -66,20 +68,20 @@ template<typename MatrixType> void triangular(const MatrixType& m)
   // test overloaded operator+=
   r1.setZero();
   r2.setZero();
-  r1.template triangularView<Eigen::UpperTriangular>() +=  m1;
+  r1.template triangularView<UpperTriangular>() +=  m1;
   r2 += m1up;
   VERIFY_IS_APPROX(r1,r2);
 
   // test overloaded operator=
   m1.setZero();
-  m1.template triangularView<Eigen::UpperTriangular>() = m2.transpose() + m2;
+  m1.template triangularView<UpperTriangular>() = m2.transpose() + m2;
   m3 = m2.transpose() + m2;
-  VERIFY_IS_APPROX(m3.template triangularView<Eigen::LowerTriangular>().transpose().toDense(), m1);
+  VERIFY_IS_APPROX(m3.template triangularView<LowerTriangular>().transpose().toDenseMatrix(), m1);
 
   // test overloaded operator=
   m1.setZero();
-  m1.template triangularView<Eigen::LowerTriangular>() = m2.transpose() + m2;
-  VERIFY_IS_APPROX(m3.template triangularView<Eigen::LowerTriangular>().toDense(), m1);
+  m1.template triangularView<LowerTriangular>() = m2.transpose() + m2;
+  VERIFY_IS_APPROX(m3.template triangularView<LowerTriangular>().toDenseMatrix(), m1);
 
   m1 = MatrixType::Random(rows, cols);
   for (int i=0; i<rows; ++i)
@@ -87,49 +89,143 @@ template<typename MatrixType> void triangular(const MatrixType& m)
 
   Transpose<MatrixType> trm4(m4);
   // test back and forward subsitution with a vector as the rhs
-  m3 = m1.template triangularView<Eigen::UpperTriangular>();
-  VERIFY(v2.isApprox(m3.adjoint() * (m1.adjoint().template triangularView<Eigen::LowerTriangular>().solve(v2)), largerEps));
-  m3 = m1.template triangularView<Eigen::LowerTriangular>();
-  VERIFY(v2.isApprox(m3.transpose() * (m1.transpose().template triangularView<Eigen::UpperTriangular>().solve(v2)), largerEps));
-  m3 = m1.template triangularView<Eigen::UpperTriangular>();
-  VERIFY(v2.isApprox(m3 * (m1.template triangularView<Eigen::UpperTriangular>().solve(v2)), largerEps));
-  m3 = m1.template triangularView<Eigen::LowerTriangular>();
-  VERIFY(v2.isApprox(m3.conjugate() * (m1.conjugate().template triangularView<Eigen::LowerTriangular>().solve(v2)), largerEps));
+  m3 = m1.template triangularView<UpperTriangular>();
+  VERIFY(v2.isApprox(m3.adjoint() * (m1.adjoint().template triangularView<LowerTriangular>().solve(v2)), largerEps));
+  m3 = m1.template triangularView<LowerTriangular>();
+  VERIFY(v2.isApprox(m3.transpose() * (m1.transpose().template triangularView<UpperTriangular>().solve(v2)), largerEps));
+  m3 = m1.template triangularView<UpperTriangular>();
+  VERIFY(v2.isApprox(m3 * (m1.template triangularView<UpperTriangular>().solve(v2)), largerEps));
+  m3 = m1.template triangularView<LowerTriangular>();
+  VERIFY(v2.isApprox(m3.conjugate() * (m1.conjugate().template triangularView<LowerTriangular>().solve(v2)), largerEps));
 
   // test back and forward subsitution with a matrix as the rhs
-  m3 = m1.template triangularView<Eigen::UpperTriangular>();
-  VERIFY(m2.isApprox(m3.adjoint() * (m1.adjoint().template triangularView<Eigen::LowerTriangular>().solve(m2)), largerEps));
-  m3 = m1.template triangularView<Eigen::LowerTriangular>();
-  VERIFY(m2.isApprox(m3.transpose() * (m1.transpose().template triangularView<Eigen::UpperTriangular>().solve(m2)), largerEps));
-  m3 = m1.template triangularView<Eigen::UpperTriangular>();
-  VERIFY(m2.isApprox(m3 * (m1.template triangularView<Eigen::UpperTriangular>().solve(m2)), largerEps));
-  m3 = m1.template triangularView<Eigen::LowerTriangular>();
-  VERIFY(m2.isApprox(m3.conjugate() * (m1.conjugate().template triangularView<Eigen::LowerTriangular>().solve(m2)), largerEps));
+  m3 = m1.template triangularView<UpperTriangular>();
+  VERIFY(m2.isApprox(m3.adjoint() * (m1.adjoint().template triangularView<LowerTriangular>().solve(m2)), largerEps));
+  m3 = m1.template triangularView<LowerTriangular>();
+  VERIFY(m2.isApprox(m3.transpose() * (m1.transpose().template triangularView<UpperTriangular>().solve(m2)), largerEps));
+  m3 = m1.template triangularView<UpperTriangular>();
+  VERIFY(m2.isApprox(m3 * (m1.template triangularView<UpperTriangular>().solve(m2)), largerEps));
+  m3 = m1.template triangularView<LowerTriangular>();
+  VERIFY(m2.isApprox(m3.conjugate() * (m1.conjugate().template triangularView<LowerTriangular>().solve(m2)), largerEps));
 
   // check M * inv(L) using in place API
   m4 = m3;
-  m3.transpose().template triangularView<Eigen::UpperTriangular>().solveInPlace(trm4);
+  m3.transpose().template triangularView<UpperTriangular>().solveInPlace(trm4);
   VERIFY(m4.cwise().abs().isIdentity(test_precision<RealScalar>()));
 
   // check M * inv(U) using in place API
-  m3 = m1.template triangularView<Eigen::UpperTriangular>();
+  m3 = m1.template triangularView<UpperTriangular>();
   m4 = m3;
-  m3.transpose().template triangularView<Eigen::LowerTriangular>().solveInPlace(trm4);
+  m3.transpose().template triangularView<LowerTriangular>().solveInPlace(trm4);
   VERIFY(m4.cwise().abs().isIdentity(test_precision<RealScalar>()));
 
   // check solve with unit diagonal
-  m3 = m1.template triangularView<Eigen::UnitUpperTriangular>();
-  VERIFY(m2.isApprox(m3 * (m1.template triangularView<Eigen::UnitUpperTriangular>().solve(m2)), largerEps));
+  m3 = m1.template triangularView<UnitUpperTriangular>();
+  VERIFY(m2.isApprox(m3 * (m1.template triangularView<UnitUpperTriangular>().solve(m2)), largerEps));
+
+//   VERIFY((  m1.template triangularView<UpperTriangular>()
+//           * m2.template triangularView<UpperTriangular>()).isUpperTriangular());
+
+  // test swap
+  m1.setOnes();
+  m2.setZero();
+  m2.template triangularView<UpperTriangular>().swap(m1);
+  m3.setZero();
+  m3.template triangularView<UpperTriangular>().setOnes();
+  VERIFY_IS_APPROX(m2,m3);
+
+}
+
+
+template<typename MatrixType> void triangular_rect(const MatrixType& m)
+{
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename NumTraits<Scalar>::Real RealScalar;
+  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> 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<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime>
+                              ::Identity(rows, rows),
+             square = Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime>
+                              ::Random(rows, rows);
+  VectorType v1 = VectorType::Random(rows),
+             v2 = VectorType::Random(rows),
+             vzero = VectorType::Zero(rows);
+
+  MatrixType m1up = m1.template triangularView<UpperTriangular>();
+  MatrixType m2up = m2.template triangularView<UpperTriangular>();
+
+  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<Eigen::UpperTriangular>()
-//           * m2.template triangularView<Eigen::UpperTriangular>()).isUpperTriangular());
+  // test overloaded operator+=
+  r1.setZero();
+  r2.setZero();
+  r1.template triangularView<UpperTriangular>() +=  m1;
+  r2 += m1up;
+  VERIFY_IS_APPROX(r1,r2);
 
+  // test overloaded operator=
+  m1.setZero();
+  m1.template triangularView<UpperTriangular>() = 3 * m2;
+  m3 = 3 * m2;
+  VERIFY_IS_APPROX(m3.template triangularView<UpperTriangular>().toDenseMatrix(), m1);
+
+  m1.setZero();
+  m1.template triangularView<LowerTriangular>() = 3 * m2;
+  VERIFY_IS_APPROX(m3.template triangularView<LowerTriangular>().toDenseMatrix(), m1);
+
+  m1.setZero();
+  m1.template triangularView<StrictlyUpperTriangular>() = 3 * m2;
+  VERIFY_IS_APPROX(m3.template triangularView<StrictlyUpperTriangular>().toDenseMatrix(), m1);
+
+  m1.setZero();
+  m1.template triangularView<StrictlyLowerTriangular>() = 3 * m2;
+  VERIFY_IS_APPROX(m3.template triangularView<StrictlyLowerTriangular>().toDenseMatrix(), m1);
+
+  m1.setRandom();
+  m2 = m1.template triangularView<UpperTriangular>();
+  VERIFY(m2.isUpperTriangular());
+  VERIFY(!m2.isLowerTriangular());
+  m2 = m1.template triangularView<StrictlyUpperTriangular>();
+  VERIFY(m2.isUpperTriangular());
+  VERIFY(m2.diagonal().isMuchSmallerThan(RealScalar(1)));
+  m2 = m1.template triangularView<UnitUpperTriangular>();
+  VERIFY(m2.isUpperTriangular());
+  m2.diagonal().cwise() -= Scalar(1);
+  VERIFY(m2.diagonal().isMuchSmallerThan(RealScalar(1)));
+  m2 = m1.template triangularView<LowerTriangular>();
+  VERIFY(m2.isLowerTriangular());
+  VERIFY(!m2.isUpperTriangular());
+  m2 = m1.template triangularView<StrictlyLowerTriangular>();
+  VERIFY(m2.isLowerTriangular());
+  VERIFY(m2.diagonal().isMuchSmallerThan(RealScalar(1)));
+  m2 = m1.template triangularView<UnitLowerTriangular>();
+  VERIFY(m2.isLowerTriangular());
+  m2.diagonal().cwise() -= Scalar(1);
+  VERIFY(m2.diagonal().isMuchSmallerThan(RealScalar(1)));
   // test swap
   m1.setOnes();
   m2.setZero();
-  m2.template triangularView<Eigen::UpperTriangular>().swap(m1);
+  m2.template triangularView<UpperTriangular>().swap(m1);
   m3.setZero();
-  m3.template triangularView<Eigen::UpperTriangular>().setOnes();
+  m3.template triangularView<UpperTriangular>().setOnes();
   VERIFY_IS_APPROX(m2,m3);
 
 }
@@ -137,12 +233,19 @@ template<typename MatrixType> void triangular(const MatrixType& m)
 void test_triangular()
 {
   for(int i = 0; i < g_repeat ; i++) {
-    CALL_SUBTEST_1( triangular(Matrix<float, 1, 1>()) );
-    CALL_SUBTEST_2( triangular(Matrix<float, 2, 2>()) );
-    CALL_SUBTEST_3( triangular(Matrix3d()) );
-    CALL_SUBTEST_4( triangular(MatrixXcf(4, 4)) );
-    CALL_SUBTEST_5( triangular(Matrix<std::complex<float>,8, 8>()) );
-    CALL_SUBTEST_6( triangular(MatrixXcd(17,17)) );
-    CALL_SUBTEST_7( triangular(Matrix<float,Dynamic,Dynamic,RowMajor>(5, 5)) );
+    CALL_SUBTEST_1( triangular_square(Matrix<float, 1, 1>()) );
+    CALL_SUBTEST_2( triangular_square(Matrix<float, 2, 2>()) );
+    CALL_SUBTEST_3( triangular_square(Matrix3d()) );
+    CALL_SUBTEST_4( triangular_square(MatrixXcf(4, 4)) );
+    CALL_SUBTEST_5( triangular_square(Matrix<std::complex<float>,8, 8>()) );
+    CALL_SUBTEST_6( triangular_square(MatrixXcd(17,17)) );
+    CALL_SUBTEST_7( triangular_square(Matrix<float,Dynamic,Dynamic,RowMajor>(5, 5)) );
+
+    CALL_SUBTEST_8( triangular_rect(Matrix<float, 4, 5>()) );
+    CALL_SUBTEST_9( triangular_rect(Matrix<double, 6, 2>()) );
+    CALL_SUBTEST_4( triangular_rect(MatrixXcf(4, 10)) );
+    CALL_SUBTEST_6( triangular_rect(MatrixXcd(11, 3)) );
+    CALL_SUBTEST_7( triangular_rect(Matrix<float,Dynamic,Dynamic,RowMajor>(7, 6)) );
+
   }
 }
-- 
cgit v1.2.3


From 88b551e89bd34367c12f0ba540ee1134c6897ba1 Mon Sep 17 00:00:00 2001
From: Benoit Jacob <jacob.benoit.1@gmail.com>
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 'test/triangular.cpp')

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<typename Derived1, typename Derived2, unsigned int Mode, bool ClearOpposite>
-struct ei_triangular_assignment_selector<Derived1, Derived2, Mode, 1, ClearOpposite>
-{
-  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<typename Derived1, typename Derived2, unsigned int Mode, bool ClearOpposite>
 struct ei_triangular_assignment_selector<Derived1, Derived2, Mode, 0, ClearOpposite>
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<typename MatrixType> void triangular_rect(const MatrixType& m)
 {
   typedef typename MatrixType::Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;
-  typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
+  enum { Rows =  MatrixType::RowsAtCompileTime, Cols =  MatrixType::ColsAtCompileTime };
+  typedef Matrix<Scalar, Rows, 1> VectorType;
+  typedef Matrix<Scalar, Rows, Rows> RMatrixType;
+  
 
   int rows = m.rows();
   int cols = m.cols();
@@ -153,10 +156,10 @@ template<typename MatrixType> void triangular_rect(const MatrixType& m)
              r1(rows, cols),
              r2(rows, cols),
              mzero = MatrixType::Zero(rows, cols),
-             mones = MatrixType::Ones(rows, cols),
-             identity = Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime>
+             mones = MatrixType::Ones(rows, cols);
+  RMatrixType identity = Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime>
                               ::Identity(rows, rows),
-             square = Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime>
+              square = Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime>
                               ::Random(rows, rows);
   VectorType v1 = VectorType::Random(rows),
              v2 = VectorType::Random(rows),
@@ -172,8 +175,6 @@ template<typename MatrixType> 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<typename MatrixType> void triangular_rect(const MatrixType& m)
   m3.setZero();
   m3.template triangularView<UpperTriangular>().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<int>(2,20);
+    int c = ei_random<int>(2,20);
+#endif
+
     CALL_SUBTEST_1( triangular_square(Matrix<float, 1, 1>()) );
     CALL_SUBTEST_2( triangular_square(Matrix<float, 2, 2>()) );
     CALL_SUBTEST_3( triangular_square(Matrix3d()) );
     CALL_SUBTEST_4( triangular_square(MatrixXcf(4, 4)) );
     CALL_SUBTEST_5( triangular_square(Matrix<std::complex<float>,8, 8>()) );
     CALL_SUBTEST_6( triangular_square(MatrixXcd(17,17)) );
-    CALL_SUBTEST_7( triangular_square(Matrix<float,Dynamic,Dynamic,RowMajor>(5, 5)) );
+    CALL_SUBTEST_7( triangular_square(Matrix<float,Dynamic,Dynamic,RowMajor>(r, r)) );
 
     CALL_SUBTEST_8( triangular_rect(Matrix<float, 4, 5>()) );
     CALL_SUBTEST_9( triangular_rect(Matrix<double, 6, 2>()) );
     CALL_SUBTEST_4( triangular_rect(MatrixXcf(4, 10)) );
     CALL_SUBTEST_6( triangular_rect(MatrixXcd(11, 3)) );
-    CALL_SUBTEST_7( triangular_rect(Matrix<float,Dynamic,Dynamic,RowMajor>(7, 6)) );
-
+    CALL_SUBTEST_7( triangular_rect(Matrix<float,Dynamic,Dynamic,RowMajor>(r, c)) );
   }
 }
-- 
cgit v1.2.3


From eac3232095baf7c69e8ff7a6b636ffcf03db156b Mon Sep 17 00:00:00 2001
From: Benoit Jacob <jacob.benoit.1@gmail.com>
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 'test/triangular.cpp')

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<typename _MatrixType, unsigned int _Mode> 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<typename MatrixType> void triangular_square(const MatrixType& m)
 
   m1 = MatrixType::Random(rows, cols);
   for (int i=0; i<rows; ++i)
-    while (ei_abs2(m1(i,i))<1e-3) m1(i,i) = ei_random<Scalar>();
+    while (ei_abs2(m1(i,i))<1e-1) m1(i,i) = ei_random<Scalar>();
 
   Transpose<MatrixType> 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 <jacob.benoit.1@gmail.com>
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 'test/triangular.cpp')

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<Derived1, Derived2, StrictlyLowerTriang
     {
       for(int i = j+1; i < dst.rows(); ++i)
         dst.copyCoeff(i, j, src);
-      int maxi = std::min(j, dst.rows());
+      int maxi = std::min(j, dst.rows()-1);
       if (ClearOpposite)
         for(int i = 0; i <= maxi; ++i)
           dst.coeffRef(i, j) = 0;
@@ -432,9 +432,9 @@ struct ei_triangular_assignment_selector<Derived1, Derived2, UnitUpperTriangular
       {
         for(int i = maxi+1; i < dst.rows(); ++i)
           dst.coeffRef(i, j) = 0;
-        dst.coeffRef(j, j) = 1;
       }
     }
+    dst.diagonal().setOnes();
   }
 };
 template<typename Derived1, typename Derived2, bool ClearOpposite>
@@ -451,9 +451,9 @@ struct ei_triangular_assignment_selector<Derived1, Derived2, UnitLowerTriangular
       {
         for(int i = 0; i < maxi; ++i)
           dst.coeffRef(i, j) = 0;
-        dst.coeffRef(j, j) = 1;
       }
     }
+    dst.diagonal().setOnes();
   }
 };
 
diff --git a/test/triangular.cpp b/test/triangular.cpp
index 379f586c4..c9df13274 100644
--- a/test/triangular.cpp
+++ b/test/triangular.cpp
@@ -188,6 +188,7 @@ template<typename MatrixType> void triangular_rect(const MatrixType& m)
   m3 = 3 * m2;
   VERIFY_IS_APPROX(m3.template triangularView<UpperTriangular>().toDenseMatrix(), m1);
 
+
   m1.setZero();
   m1.template triangularView<LowerTriangular>() = 3 * m2;
   VERIFY_IS_APPROX(m3.template triangularView<LowerTriangular>().toDenseMatrix(), m1);
@@ -196,10 +197,10 @@ template<typename MatrixType> void triangular_rect(const MatrixType& m)
   m1.template triangularView<StrictlyUpperTriangular>() = 3 * m2;
   VERIFY_IS_APPROX(m3.template triangularView<StrictlyUpperTriangular>().toDenseMatrix(), m1);
 
+
   m1.setZero();
   m1.template triangularView<StrictlyLowerTriangular>() = 3 * m2;
   VERIFY_IS_APPROX(m3.template triangularView<StrictlyLowerTriangular>().toDenseMatrix(), m1);
-
   m1.setRandom();
   m2 = m1.template triangularView<UpperTriangular>();
   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<int>(2,20);
-    int c = ei_random<int>(2,20);
-#endif
+    EIGEN_UNUSED int r = ei_random<int>(2,20);
+    EIGEN_UNUSED int c = ei_random<int>(2,20);
 
     CALL_SUBTEST_1( triangular_square(Matrix<float, 1, 1>()) );
     CALL_SUBTEST_2( triangular_square(Matrix<float, 2, 2>()) );
     CALL_SUBTEST_3( triangular_square(Matrix3d()) );
-    CALL_SUBTEST_4( triangular_square(MatrixXcf(4, 4)) );
-    CALL_SUBTEST_5( triangular_square(Matrix<std::complex<float>,8, 8>()) );
-    CALL_SUBTEST_6( triangular_square(MatrixXcd(17,17)) );
-    CALL_SUBTEST_7( triangular_square(Matrix<float,Dynamic,Dynamic,RowMajor>(r, r)) );
-
-    CALL_SUBTEST_8( triangular_rect(Matrix<float, 4, 5>()) );
-    CALL_SUBTEST_9( triangular_rect(Matrix<double, 6, 2>()) );
-    CALL_SUBTEST_4( triangular_rect(MatrixXcf(4, 10)) );
-    CALL_SUBTEST_6( triangular_rect(MatrixXcd(11, 3)) );
-    CALL_SUBTEST_7( triangular_rect(Matrix<float,Dynamic,Dynamic,RowMajor>(r, c)) );
+    CALL_SUBTEST_4( triangular_square(Matrix<std::complex<float>,8, 8>()) );
+    CALL_SUBTEST_5( triangular_square(MatrixXcd(r,r)) );
+    CALL_SUBTEST_6( triangular_square(Matrix<float,Dynamic,Dynamic,RowMajor>(r, r)) );
+
+    CALL_SUBTEST_7( triangular_rect(Matrix<float, 4, 5>()) );
+    CALL_SUBTEST_8( triangular_rect(Matrix<double, 6, 2>()) );
+    CALL_SUBTEST_9( triangular_rect(MatrixXcf(r, c)) );
+    CALL_SUBTEST_5( triangular_rect(MatrixXcd(r, c)) );
+    CALL_SUBTEST_6( triangular_rect(Matrix<float,Dynamic,Dynamic,RowMajor>(r, c)) );
   }
 }
-- 
cgit v1.2.3