Use Matrix initializer_list constructor instead of comma initializers

Author: Gold856

gtsam/base/Matrix.h

@@ -300,7 +300,7 @@ GTSAM_EXPORT Matrix vector_scale(const Matrix& A, const Vector& v, bool inf_mask
 */
 
 inline Matrix3 skewSymmetric(double wx, double wy, double wz) {
-  return (Matrix3() << 0.0, -wz, +wy, +wz, 0.0, -wx, -wy, +wx, 0.0).finished();
+  return Matrix3{{0.0, -wz, +wy}, {+wz, 0.0, -wx}, {-wy, +wx, 0.0}};
 }
 
 template <class Derived>

gtsam/base/tests/testMatrix.cpp

@@ -195,19 +195,22 @@ TEST(Matrix, stack )
 /* ************************************************************************* */
 TEST(Matrix, column )
 {
-  Matrix A = (Matrix(4, 7) << -1., 0., 1., 0., 0., 0., -0.2, 0., -1., 0., 1.,
-      0., 0., 0.3, 1., 0., 0., 0., -1., 0., 0.2, 0., 1., 0., 0., 0., -1.,
-      -0.1).finished();
+  Matrix A{
+      {-1.,  0., 1., 0.,  0.,  0., -0.2},
+      { 0., -1., 0., 1.,  0.,  0.,  0.3},
+      { 1.,  0., 0., 0., -1.,  0.,  0.2},
+      { 0.,  1., 0., 0.,  0., -1., -0.1}
+  };
   Vector a1 = column(A, 0);
-  Vector exp1 = (Vector(4) << -1., 0., 1., 0.).finished();
+  Vector exp1{{-1., 0., 1., 0.}};
   EXPECT(assert_equal(a1, exp1));
 
   Vector a2 = column(A, 3);
-  Vector exp2 = (Vector(4) << 0., 1., 0., 0.).finished();
+  Vector exp2{{0., 1., 0., 0.}};
   EXPECT(assert_equal(a2, exp2));
 
   Vector a3 = column(A, 6);
-  Vector exp3 = (Vector(4) << -0.2, 0.3, 0.2, -0.1).finished();
+  Vector exp3{{-0.2, 0.3, 0.2, -0.1}};
   EXPECT(assert_equal(a3, exp3));
 }
 
@@ -219,9 +222,11 @@ TEST(Matrix, insert_sub )
 
   insertSub(big, small, 1, 2);
 
-  Matrix expected = (Matrix(5, 6) << 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
-      1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0,
-      0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0).finished();
+  Matrix expected{{0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+                  {0.0, 0.0, 1.0, 1.0, 1.0, 0.0},
+                  {0.0, 0.0, 1.0, 1.0, 1.0, 0.0},
+                  {0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+                  {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}};
 
   EXPECT(assert_equal(expected, big));
 }
@@ -236,16 +241,15 @@ TEST(Matrix, diagMatrices )
 
   Matrix actual = diag(Hs);
 
-  Matrix expected = (Matrix(9, 9) <<
-      1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
-      1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
-      1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
-      0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 2.0, 0.0, 0.0,
-      0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 2.0, 0.0, 0.0,
-      0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 2.0, 0.0, 0.0,
-      0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 2.0, 0.0, 0.0,
-      0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.0, 3.0,
-      0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.0, 3.0).finished();
+  Matrix expected{{1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+                  {1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+                  {1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+                  {0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 2.0, 0.0, 0.0},
+                  {0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 2.0, 0.0, 0.0},
+                  {0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 2.0, 0.0, 0.0},
+                  {0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 2.0, 0.0, 0.0},
+                  {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.0, 3.0},
+                  {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.0, 3.0}};
 
   EXPECT(assert_equal(expected, actual));
 }
@@ -287,7 +291,7 @@ TEST(Matrix, scale_columns )
   A(2, 2) = 1.;
   A(2, 3) = 1.;
 
-  Vector v = (Vector(4) << 2., 3., 4., 5.).finished();
+  Vector v{{2., 3., 4., 5.}};
 
   Matrix actual = vector_scale(A, v);
 
@@ -363,7 +367,7 @@ TEST(Matrix, scale_rows_mask )
   A(2, 2) = 1.;
   A(2, 3) = 1.;
 
-  Vector v = (Vector(3) << 2., std::numeric_limits<double>::infinity(), 4.).finished();
+  Vector v{{2., std::numeric_limits<double>::infinity(), 4.}};
 
   Matrix actual = vector_scale(v, A, true);
 
@@ -811,14 +815,14 @@ TEST(Matrix, weighted_elimination )
   // create a matrix to eliminate
   Matrix A = (Matrix(4, 6) << -1., 0., 1., 0., 0., 0., 0., -1., 0., 1., 0., 0.,
       1., 0., 0., 0., -1., 0., 0., 1., 0., 0., 0., -1.).finished();
-  Vector b = (Vector(4) << -0.2, 0.3, 0.2, -0.1).finished();
-  Vector sigmas = (Vector(4) << 0.2, 0.2, 0.1, 0.1).finished();
+  Vector b{{-0.2, 0.3, 0.2, -0.1}};
+  Vector sigmas{{0.2, 0.2, 0.1, 0.1}};
 
   //   expected values
   Matrix expectedR = (Matrix(4, 6) << 1., 0., -0.2, 0., -0.8, 0., 0., 1., 0.,
       -0.2, 0., -0.8, 0., 0., 1., 0., -1., 0., 0., 0., 0., 1., 0., -1.).finished();
-  Vector d = (Vector(4) << 0.2, -0.14, 0.0, 0.2).finished();
-  Vector newSigmas = (Vector(4) << 0.0894427, 0.0894427, 0.223607, 0.223607).finished();
+  Vector d{{0.2, -0.14, 0.0, 0.2}};
+  Vector newSigmas{{0.0894427, 0.0894427, 0.223607, 0.223607}};
 
   // perform elimination
   Matrix A1 = A;
@@ -876,19 +880,22 @@ TEST(Matrix, inverse_square_root )
 // M was generated as the covariance of a set of random numbers.  L that
 // we are checking against was generated via chol(M)' on octave
 namespace cholesky {
-Matrix M = (Matrix(5, 5) << 0.0874197, -0.0030860, 0.0116969, 0.0081463,
-    0.0048741, -0.0030860, 0.0872727, 0.0183073, 0.0125325, -0.0037363,
-    0.0116969, 0.0183073, 0.0966217, 0.0103894, -0.0021113, 0.0081463,
-    0.0125325, 0.0103894, 0.0747324, 0.0036415, 0.0048741, -0.0037363,
-    -0.0021113, 0.0036415, 0.0909464).finished();
-
-Matrix expected = (Matrix(5, 5) <<
-    0.295668226226627, 0.000000000000000, 0.000000000000000, 0.000000000000000, 0.000000000000000,
-    -0.010437374483502, 0.295235094820875, 0.000000000000000, 0.000000000000000, 0.000000000000000,
-    0.039560896175007, 0.063407813693827, 0.301721866387571, 0.000000000000000, 0.000000000000000,
-    0.027552165831157, 0.043423266737274, 0.021695600982708, 0.267613525371710, 0.000000000000000,
-    0.016485031422565, -0.012072546984405, -0.006621889326331, 0.014405837566082, 0.300462176944247).finished();
-}
+Matrix M{
+    { 0.0874197, -0.0030860,  0.0116969, 0.0081463,  0.0048741},
+    {-0.0030860,  0.0872727,  0.0183073, 0.0125325, -0.0037363},
+    { 0.0116969,  0.0183073,  0.0966217, 0.0103894, -0.0021113},
+    { 0.0081463,  0.0125325,  0.0103894, 0.0747324,  0.0036415},
+    { 0.0048741, -0.0037363, -0.0021113, 0.0036415,  0.0909464}
+};
+
+// clang-format off
+Matrix expected{{0.295668226226627, 0.000000000000000, 0.000000000000000, 0.000000000000000, 0.000000000000000},
+                {-0.010437374483502, 0.295235094820875, 0.000000000000000, 0.000000000000000, 0.000000000000000},
+                {0.039560896175007, 0.063407813693827, 0.301721866387571, 0.000000000000000, 0.000000000000000},
+                {0.027552165831157, 0.043423266737274, 0.021695600982708, 0.267613525371710, 0.000000000000000},
+                {0.016485031422565, -0.012072546984405, -0.006621889326331, 0.014405837566082, 0.300462176944247}};
+// clang-format on
+}  // namespace cholesky
 TEST(Matrix, LLt )
 {
   EQUALITY(cholesky::expected, LLt(cholesky::M));
@@ -906,24 +913,24 @@ TEST(Matrix, cholesky_inverse )
 /* ************************************************************************* */
 TEST(Matrix, linear_dependent )
 {
-  Matrix A = (Matrix(2, 3) << 1.0, 2.0, 3.0, 4.0, 5.0, 6.0).finished();
-  Matrix B = (Matrix(2, 3) << -1.0, -2.0, -3.0, 8.0, 10.0, 12.0).finished();
+  Matrix A{{1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}};
+  Matrix B{{-1.0, -2.0, -3.0}, {8.0, 10.0, 12.0}};
   EXPECT(linear_dependent(A, B));
 }
 
 /* ************************************************************************* */
 TEST(Matrix, linear_dependent2 )
 {
-  Matrix A = (Matrix(2, 3) << 0.0, 2.0, 3.0, 4.0, 5.0, 6.0).finished();
-  Matrix B = (Matrix(2, 3) << 0.0, -2.0, -3.0, 8.0, 10.0, 12.0).finished();
+  Matrix A{{0.0, 2.0, 3.0}, {4.0, 5.0, 6.0}};
+  Matrix B{{0.0, -2.0, -3.0}, {8.0, 10.0, 12.0}};
   EXPECT(linear_dependent(A, B));
 }
 
 /* ************************************************************************* */
 TEST(Matrix, linear_dependent3 )
 {
-  Matrix A = (Matrix(2, 3) << 0.0, 2.0, 3.0, 4.0, 5.0, 6.0).finished();
-  Matrix B = (Matrix(2, 3) << 0.0, -2.0, -3.0, 8.1, 10.0, 12.0).finished();
+  Matrix A{{0.0, 2.0, 3.0}, {4.0, 5.0, 6.0}};
+  Matrix B{{0.0, -2.0, -3.0}, {8.1, 10.0, 12.0}};
   EXPECT(linear_independent(A, B));
 }
 
@@ -943,7 +950,7 @@ TEST(Matrix, svd1 )
 
 /* ************************************************************************* */
 /// Sample A matrix for SVD
-static Matrix sampleA = (Matrix(3, 2) << 0.,-2., 0., 0., 3., 0.).finished();
+static Matrix sampleA{{0., -2.}, {0., 0.}, {3., 0.}};
 static Matrix sampleAt = trans(sampleA);
 
 /* ************************************************************************* */
@@ -952,9 +959,9 @@ TEST(Matrix, svd2 )
   Matrix U, V;
   Vector s;
 
-  Matrix expectedU = (Matrix(3, 2) << 0.,-1.,0.,0.,1.,0.).finished();
+  Matrix expectedU{{0., -1.}, {0., 0.}, {1., 0.}};
   Vector expected_s = Vector2(3.,2.);
-  Matrix expectedV = (Matrix(2, 2) << 1.,0.,0.,1.).finished();
+  Matrix expectedV{{1., 0.}, {0., 1.}};
 
   svd(sampleA, U, s, V);
 
@@ -975,9 +982,9 @@ TEST(Matrix, svd3 )
   Matrix U, V;
   Vector s;
 
-  Matrix expectedU = (Matrix(2, 2) << -1.,0.,0.,-1.).finished();
+  Matrix expectedU{{-1., 0.}, {0., -1.}};
   Vector expected_s = Vector2(3.0, 2.0);
-  Matrix expectedV = (Matrix(3, 2) << 0.,1.,0.,0.,-1.,0.).finished();
+  Matrix expectedV{{0., 1.}, {0., 0.}, {-1., 0.}};
 
   svd(sampleAt, U, s, V);
 
@@ -1003,21 +1010,21 @@ TEST(Matrix, svd4 )
   Matrix U, V;
   Vector s;
 
-  Matrix A = (Matrix(3, 2) <<
-      0.8147,    0.9134,
-      0.9058,    0.6324,
-      0.1270,    0.0975).finished();
+  Matrix A{//
+           {0.8147, 0.9134},
+           {0.9058, 0.6324},
+           {0.1270, 0.0975}};
 
-  Matrix expectedU = (Matrix(3, 2) <<
-     0.7397,   0.6724,
-     0.6659,   -0.7370,
-     0.0970,   -0.0689).finished();
+  Matrix expectedU{//
+                   {0.7397, 0.6724},
+                   {0.6659, -0.7370},
+                   {0.0970, -0.0689}};
 
   Vector expected_s = Vector2(1.6455, 0.1910);
 
-  Matrix expectedV = (Matrix(2, 2) <<
-     0.7403,   -0.6723,
-     0.6723,   0.7403).finished();
+  Matrix expectedV{//
+                   {0.7403, -0.6723},
+                   {0.6723, 0.7403}};
 
   svd(A, U, s, V);
 
@@ -1042,18 +1049,19 @@ TEST(Matrix, svd4 )
 /* ************************************************************************* */
 TEST(Matrix, DLT )
 {
-  Matrix A = (Matrix(8, 9) <<
-      0.21,        -0.42,       -10.71,         0.18,        -0.36,        -9.18,        -0.61,         1.22,        31.11,
-      0.44,        -0.66,       -15.84,         0.34,        -0.51,       -12.24,        -1.64,         2.46,        59.04,
-      0.69,        -8.28,       -12.19,        -0.48,         5.76,         8.48,        -1.89,        22.68,        33.39,
-      0.96,         -8.4,       -17.76,         -0.6,         5.25,         11.1,        -3.36,         29.4,        62.16,
-      1.25,          0.3,         2.75,         -3.5,        -0.84,         -7.7,        16.25,          3.9,        35.75,
-      1.56,         0.42,         4.56,        -3.38,        -0.91,        -9.88,        22.36,         6.02,        65.36,
-      1.89,         2.24,         3.99,         3.24,         3.84,         6.84,        18.09,        21.44,        38.19,
-      2.24,         2.48,         6.24,         3.08,         3.41,         8.58,        24.64,        27.28,        68.64
-  ).finished();
+  Matrix A{
+      {0.21, -0.42, -10.71,  0.18, -0.36,  -9.18, -0.61,  1.22, 31.11},
+      {0.44, -0.66, -15.84,  0.34, -0.51, -12.24, -1.64,  2.46, 59.04},
+      {0.69, -8.28, -12.19, -0.48,  5.76,   8.48, -1.89, 22.68, 33.39},
+      {0.96,  -8.4, -17.76,  -0.6,  5.25,   11.1, -3.36,  29.4, 62.16},
+      {1.25,   0.3,   2.75,  -3.5, -0.84,   -7.7, 16.25,   3.9, 35.75},
+      {1.56,  0.42,   4.56, -3.38, -0.91,  -9.88, 22.36,  6.02, 65.36},
+      {1.89,  2.24,   3.99,  3.24,  3.84,   6.84, 18.09, 21.44, 38.19},
+      {2.24,  2.48,   6.24,  3.08,  3.41,   8.58, 24.64, 27.28, 68.64}
+  };
   const auto [rank,error,actual] = DLT(A);
-  Vector expected = (Vector(9) << -0.0, 0.2357, 0.4714, -0.2357, 0.0, - 0.4714,-0.4714, 0.4714, 0.0).finished();
+  Vector expected{
+      {-0.0, 0.2357, 0.4714, -0.2357, 0.0, -0.4714, -0.4714, 0.4714, 0.0}};
   EXPECT_LONGS_EQUAL(8,rank);
   EXPECT_DOUBLES_EQUAL(0,error,1e-8);
   EXPECT(assert_equal(expected, actual, 1e-4));