DiagonalCoeffs-->Band

test/submatrices.cpp

 // 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.
 //
@@ skipping 91 matching lines @@
   m1.block(r1,c1,r2-r1+1,c2-c1+1) = s1 * m2.block(0, 0, r2-r1+1,c2-c1+1);
   m1.block(r1,c1,r2-r1+1,c2-c1+1)(r2-r1,c2-c1) = m2.block(0, 0, r2-r1+1,c2-c1+1)(0,0);
 
   //check minor()
   CheckMinor<Scalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime> checkminor(m1,r1,c1);
 
   //check diagonal()
   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);
   if (rows>=5 && cols>=8)
   {
     // test fixed block() as lvalue
     m1.template block<BlockRows,BlockCols>(1,1) *= s1;
     // test operator() on fixed block() both as constant and non-constant
     m1.template block<BlockRows,BlockCols>(1,1)(0, 3) = m1.template block<2,5>(1,1)(1,2);
     // check that fixed block() and block() agree
@@ skipping 15 matching lines @@
     VERIFY_IS_APPROX(v1.template end<2>(), v1.template segment<2>(i));
     i = ei_random(0,rows-2);
     VERIFY_IS_APPROX(v1.segment(i,2), v1.template segment<2>(i));
 
     enum {
       N1 = MatrixType::RowsAtCompileTime>1 ?  1 : 0,
       N2 = MatrixType::RowsAtCompileTime>2 ? -2 : 0
     };
 
     // check sub/super diagonal
-    m2.template diagonal<N1>() = 2 * m1.template diagonal<N1>();
-    m2.template diagonal<N1>()[0] *= 3;
-    VERIFY_IS_APPROX(m2.template diagonal<N1>()[0], static_cast<Scalar>(6) * m1.template diagonal<N1>()[0]);
+    m2.template band<N1>() = 2 * m1.template band<N1>();
+    m2.template band<N1>()[0] *= 3;
+    VERIFY_IS_APPROX(m2.template band<N1>()[0], static_cast<Scalar>(6) * m1.template band<N1>()[0]);
 
-    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.template band<N2>() = 2 * m1.template band<N2>();
+    m2.template band<N2>()[0] *= 3;
+    VERIFY_IS_APPROX(m2.template band<N2>()[0], static_cast<Scalar>(6) * m1.template band<N2>()[0]);
+
+    m2.band(N1) = 2 * m1.band(N1);
+    m2.band(N1)[0] *= 3;
+    VERIFY_IS_APPROX(m2.band(N1)[0], static_cast<Scalar>(6) * m1.band(N1)[0]);
+
+    m2.band(N2) = 2 * m1.band(N2);
+    m2.band(N2)[0] *= 3;
+    VERIFY_IS_APPROX(m2.band(N2)[0], static_cast<Scalar>(6) * m1.band(N2)[0]);
   }
 
   // stress some basic stuffs with block matrices
   VERIFY(ei_real(ones.col(c1).sum()) == RealScalar(rows));
   VERIFY(ei_real(ones.row(r1).sum()) == RealScalar(cols));
 
   VERIFY(ei_real(ones.col(c1).dot(ones.col(c2))) == RealScalar(rows));
   VERIFY(ei_real(ones.row(r1).dot(ones.row(r2))) == RealScalar(cols));
 }
 
 void test_submatrices()
 {
   for(int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST( submatrices(Matrix<float, 1, 1>()) );
     CALL_SUBTEST( submatrices(Matrix4d()) );
     CALL_SUBTEST( submatrices(MatrixXcf(3, 3)) );
     CALL_SUBTEST( submatrices(MatrixXi(8, 12)) );
     CALL_SUBTEST( submatrices(MatrixXcd(20, 20)) );
     CALL_SUBTEST( submatrices(MatrixXf(20, 20)) );
   }
 }