initializer_list_construction.cpp File Reference

#include "main.h"

Classes
struct	TestMethodDispatching< Scalar, is_integer >
struct	TestMethodDispatching< Scalar, 1 >

Macros
#define	CHECK_MIXSCALAR_V5_APPROX(V, A0, A1, A2, A3, A4)
#define	CHECK_MIXSCALAR_V5(VEC5, A0, A1, A2, A3, A4)

Functions
template<typename Vec4 , typename Vec5 >
void	fixedsizeVariadicVectorConstruction2 ()
template<int >
void	fixedsizeVariadicVectorConstruction3 ()
template<typename Scalar >
void	fixedsizeVariadicVectorConstruction ()
template<typename Scalar >
void	initializerListVectorConstruction ()
template<typename Scalar >
void	initializerListMatrixConstruction ()
template<typename Scalar >
void	initializerListArrayConstruction ()
template<typename Scalar >
void	dynamicVectorConstruction ()
	EIGEN_DECLARE_TEST (initializer_list_construction)

Macro Definition Documentation

CHECK_MIXSCALAR_V5

#define CHECK_MIXSCALAR_V5	(		VEC5,
			A0,
			A1,
			A2,
			A3,
			A4
	)

Value:

  {                                                   \
    typedef VEC5::Scalar Scalar;                      \
    VEC5 v = {A0, A1, A2, A3, A4};                    \
    CHECK_MIXSCALAR_V5_APPROX(v, A0, A1, A2, A3, A4); \
  }

CHECK_MIXSCALAR_V5_APPROX

#define CHECK_MIXSCALAR_V5_APPROX	(		V,
			A0,
			A1,
			A2,
			A3,
			A4
	)

Value:

  {                                                      \
    VERIFY_IS_APPROX(V[0], Scalar(A0));                  \
    VERIFY_IS_APPROX(V[1], Scalar(A1));                  \
    VERIFY_IS_APPROX(V[2], Scalar(A2));                  \
    VERIFY_IS_APPROX(V[3], Scalar(A3));                  \
    VERIFY_IS_APPROX(V[4], Scalar(A4));                  \
  }

Function Documentation

dynamicVectorConstruction()

template<typename Scalar >

void dynamicVectorConstruction

(

)

                                 {
  const Index size = 4;
  Scalar raw[size];
  for (int i = 0; i < size; ++i) {
    raw[i] = internal::random<Scalar>();
  }
 
  typedef Matrix<Scalar, Dynamic, 1> VectorX;
 
  {
    VectorX v{{raw[0], raw[1], raw[2], raw[3]}};
    for (int i = 0; i < size; ++i) {
      VERIFY(v(i) == raw[i]);
    }
    VERIFY(v.rows() == size);
    VERIFY(v.cols() == 1);
    VERIFY_IS_EQUAL(v, (VectorX{{raw[0], raw[1], raw[2], raw[3]}}));
  }
}

References i, size, v, VERIFY, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST

(

initializer_list_construction

)

                                                  {
  CALL_SUBTEST_1(initializerListVectorConstruction<unsigned char>());
  CALL_SUBTEST_1(initializerListVectorConstruction<float>());
  CALL_SUBTEST_1(initializerListVectorConstruction<double>());
  CALL_SUBTEST_1(initializerListVectorConstruction<int>());
  CALL_SUBTEST_1(initializerListVectorConstruction<long int>());
  CALL_SUBTEST_1(initializerListVectorConstruction<std::ptrdiff_t>());
  CALL_SUBTEST_1(initializerListVectorConstruction<std::complex<double>>());
  CALL_SUBTEST_1(initializerListVectorConstruction<std::complex<float>>());
 
  CALL_SUBTEST_2(initializerListMatrixConstruction<unsigned char>());
  CALL_SUBTEST_2(initializerListMatrixConstruction<float>());
  CALL_SUBTEST_2(initializerListMatrixConstruction<double>());
  CALL_SUBTEST_2(initializerListMatrixConstruction<int>());
  CALL_SUBTEST_2(initializerListMatrixConstruction<long int>());
  CALL_SUBTEST_2(initializerListMatrixConstruction<std::ptrdiff_t>());
  CALL_SUBTEST_2(initializerListMatrixConstruction<std::complex<double>>());
  CALL_SUBTEST_2(initializerListMatrixConstruction<std::complex<float>>());
 
  CALL_SUBTEST_3(initializerListArrayConstruction<unsigned char>());
  CALL_SUBTEST_3(initializerListArrayConstruction<float>());
  CALL_SUBTEST_3(initializerListArrayConstruction<double>());
  CALL_SUBTEST_3(initializerListArrayConstruction<int>());
  CALL_SUBTEST_3(initializerListArrayConstruction<long int>());
  CALL_SUBTEST_3(initializerListArrayConstruction<std::ptrdiff_t>());
  CALL_SUBTEST_3(initializerListArrayConstruction<std::complex<double>>());
  CALL_SUBTEST_3(initializerListArrayConstruction<std::complex<float>>());
 
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<unsigned char>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<float>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<double>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<int>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<long int>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<std::ptrdiff_t>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<std::complex<double>>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<std::complex<float>>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction3<0>());
 
  CALL_SUBTEST_5(TestMethodDispatching<int>::run());
  CALL_SUBTEST_5(TestMethodDispatching<long int>::run());
 
  CALL_SUBTEST_6(dynamicVectorConstruction<unsigned char>());
  CALL_SUBTEST_6(dynamicVectorConstruction<float>());
  CALL_SUBTEST_6(dynamicVectorConstruction<double>());
  CALL_SUBTEST_6(dynamicVectorConstruction<int>());
  CALL_SUBTEST_6(dynamicVectorConstruction<long int>());
  CALL_SUBTEST_6(dynamicVectorConstruction<std::ptrdiff_t>());
  CALL_SUBTEST_6(dynamicVectorConstruction<std::complex<double>>());
  CALL_SUBTEST_6(dynamicVectorConstruction<std::complex<float>>());
}

References CALL_SUBTEST_1, CALL_SUBTEST_2, CALL_SUBTEST_3, CALL_SUBTEST_4, CALL_SUBTEST_5, CALL_SUBTEST_6, dynamicVectorConstruction(), fixedsizeVariadicVectorConstruction(), initializerListArrayConstruction(), initializerListMatrixConstruction(), and initializerListVectorConstruction().

fixedsizeVariadicVectorConstruction()

template<typename Scalar >

void fixedsizeVariadicVectorConstruction

(

)

                                           {
  CALL_SUBTEST((fixedsizeVariadicVectorConstruction2<Matrix<Scalar, 4, 1>, Matrix<Scalar, 5, 1>>()));
  CALL_SUBTEST((fixedsizeVariadicVectorConstruction2<Matrix<Scalar, 1, 4>, Matrix<Scalar, 1, 5>>()));
  CALL_SUBTEST((fixedsizeVariadicVectorConstruction2<Array<Scalar, 4, 1>, Array<Scalar, 5, 1>>()));
  CALL_SUBTEST((fixedsizeVariadicVectorConstruction2<Array<Scalar, 1, 4>, Array<Scalar, 1, 5>>()));
}

References CALL_SUBTEST, and fixedsizeVariadicVectorConstruction2().

Referenced by EIGEN_DECLARE_TEST().

fixedsizeVariadicVectorConstruction2()

template<typename Vec4 , typename Vec5 >

void fixedsizeVariadicVectorConstruction2

(

)

                                            {
  {
    Vec4 ref = Vec4::Random();
    Vec4 v{ref[0], ref[1], ref[2], ref[3]};
    VERIFY_IS_APPROX(v, ref);
    VERIFY_IS_APPROX(v, (Vec4(ref[0], ref[1], ref[2], ref[3])));
    VERIFY_IS_APPROX(v, (Vec4({ref[0], ref[1], ref[2], ref[3]})));
 
    Vec4 v2 = {ref[0], ref[1], ref[2], ref[3]};
    VERIFY_IS_APPROX(v2, ref);
  }
  {
    Vec5 ref = Vec5::Random();
    Vec5 v{ref[0], ref[1], ref[2], ref[3], ref[4]};
    VERIFY_IS_APPROX(v, ref);
    VERIFY_IS_APPROX(v, (Vec5(ref[0], ref[1], ref[2], ref[3], ref[4])));
    VERIFY_IS_APPROX(v, (Vec5({ref[0], ref[1], ref[2], ref[3], ref[4]})));
 
    Vec5 v2 = {ref[0], ref[1], ref[2], ref[3], ref[4]};
    VERIFY_IS_APPROX(v2, ref);
  }
}

References v, v2(), and VERIFY_IS_APPROX.

Referenced by fixedsizeVariadicVectorConstruction().

fixedsizeVariadicVectorConstruction3()

template<int >

void fixedsizeVariadicVectorConstruction3

(

)

                                            {
  typedef Matrix<double, 5, 1> Vec5;
  typedef Array<float, 5, 1> Arr5;
  CHECK_MIXSCALAR_V5(Vec5, 1, 2., -3, 4.121, 5.53252);
  CHECK_MIXSCALAR_V5(Arr5, 1, 2., 3.12f, 4.121, 5.53252);
}

References CHECK_MIXSCALAR_V5.

initializerListArrayConstruction()

template<typename Scalar >

void initializerListArrayConstruction

(

)

                                        {
  const Index RowsAtCompileTime = 5;
  const Index ColsAtCompileTime = 4;
  const Index SizeAtCompileTime = RowsAtCompileTime * ColsAtCompileTime;
 
  Scalar raw[SizeAtCompileTime];
  for (int i = 0; i < SizeAtCompileTime; ++i) {
    raw[i] = internal::random<Scalar>();
  }
  {
    Array<Scalar, Dynamic, Dynamic> a{};
    VERIFY(a.cols() == 0);
    VERIFY(a.rows() == 0);
  }
  {
    Array<Scalar, 5, 4> m{{raw[0], raw[1], raw[2], raw[3]},
                          {raw[4], raw[5], raw[6], raw[7]},
                          {raw[8], raw[9], raw[10], raw[11]},
                          {raw[12], raw[13], raw[14], raw[15]},
                          {raw[16], raw[17], raw[18], raw[19]}};
 
    Array<Scalar, 5, 4> m2;
    m2 << raw[0], raw[1], raw[2], raw[3], raw[4], raw[5], raw[6], raw[7], raw[8], raw[9], raw[10], raw[11], raw[12],
        raw[13], raw[14], raw[15], raw[16], raw[17], raw[18], raw[19];
 
    int k = 0;
    for (int i = 0; i < RowsAtCompileTime; ++i) {
      for (int j = 0; j < ColsAtCompileTime; ++j) {
        VERIFY(m(i, j) == raw[k]);
        ++k;
      }
    }
    VERIFY_IS_APPROX(m, m2);
  }
  {
    Array<Scalar, Dynamic, Dynamic> m{{raw[0], raw[1], raw[2], raw[3]},
                                      {raw[4], raw[5], raw[6], raw[7]},
                                      {raw[8], raw[9], raw[10], raw[11]},
                                      {raw[12], raw[13], raw[14], raw[15]},
                                      {raw[16], raw[17], raw[18], raw[19]}};
 
    VERIFY(m.cols() == 4);
    VERIFY(m.rows() == 5);
    int k = 0;
    for (int i = 0; i < RowsAtCompileTime; ++i) {
      for (int j = 0; j < ColsAtCompileTime; ++j) {
        VERIFY(m(i, j) == raw[k]);
        ++k;
      }
    }
 
    Array<Scalar, Dynamic, Dynamic> m2(RowsAtCompileTime, ColsAtCompileTime);
    k = 0;
    for (int i = 0; i < RowsAtCompileTime; ++i) {
      for (int j = 0; j < ColsAtCompileTime; ++j) {
        m2(i, j) = raw[k];
        ++k;
      }
    }
    VERIFY_IS_APPROX(m, m2);
  }
}

References a, i, j, k, m, m2(), VERIFY, and VERIFY_IS_APPROX.

Referenced by EIGEN_DECLARE_TEST().

initializerListMatrixConstruction()

template<typename Scalar >

void initializerListMatrixConstruction

(

)

                                         {
  const Index RowsAtCompileTime = 5;
  const Index ColsAtCompileTime = 4;
  const Index SizeAtCompileTime = RowsAtCompileTime * ColsAtCompileTime;
 
  Scalar raw[SizeAtCompileTime];
  for (int i = 0; i < SizeAtCompileTime; ++i) {
    raw[i] = internal::random<Scalar>();
  }
  {
    Matrix<Scalar, Dynamic, Dynamic> m{};
    VERIFY(m.cols() == 0);
    VERIFY(m.rows() == 0);
    VERIFY_IS_EQUAL(m, (Matrix<Scalar, Dynamic, Dynamic>()));
  }
  {
    Matrix<Scalar, 5, 4> m{{raw[0], raw[1], raw[2], raw[3]},
                           {raw[4], raw[5], raw[6], raw[7]},
                           {raw[8], raw[9], raw[10], raw[11]},
                           {raw[12], raw[13], raw[14], raw[15]},
                           {raw[16], raw[17], raw[18], raw[19]}};
 
    Matrix<Scalar, 5, 4> m2;
    m2 << raw[0], raw[1], raw[2], raw[3], raw[4], raw[5], raw[6], raw[7], raw[8], raw[9], raw[10], raw[11], raw[12],
        raw[13], raw[14], raw[15], raw[16], raw[17], raw[18], raw[19];
 
    int k = 0;
    for (int i = 0; i < RowsAtCompileTime; ++i) {
      for (int j = 0; j < ColsAtCompileTime; ++j) {
        VERIFY(m(i, j) == raw[k]);
        ++k;
      }
    }
    VERIFY_IS_EQUAL(m, m2);
  }
  {
    Matrix<Scalar, Dynamic, Dynamic> m{{raw[0], raw[1], raw[2], raw[3]},
                                       {raw[4], raw[5], raw[6], raw[7]},
                                       {raw[8], raw[9], raw[10], raw[11]},
                                       {raw[12], raw[13], raw[14], raw[15]},
                                       {raw[16], raw[17], raw[18], raw[19]}};
 
    VERIFY(m.cols() == 4);
    VERIFY(m.rows() == 5);
    int k = 0;
    for (int i = 0; i < RowsAtCompileTime; ++i) {
      for (int j = 0; j < ColsAtCompileTime; ++j) {
        VERIFY(m(i, j) == raw[k]);
        ++k;
      }
    }
 
    Matrix<Scalar, Dynamic, Dynamic> m2(RowsAtCompileTime, ColsAtCompileTime);
    k = 0;
    for (int i = 0; i < RowsAtCompileTime; ++i) {
      for (int j = 0; j < ColsAtCompileTime; ++j) {
        m2(i, j) = raw[k];
        ++k;
      }
    }
    VERIFY_IS_EQUAL(m, m2);
  }
}

References i, j, k, m, m2(), VERIFY, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().

initializerListVectorConstruction()

template<typename Scalar >

void initializerListVectorConstruction

(

)

                                         {
  Scalar raw[4];
  for (int k = 0; k < 4; ++k) {
    raw[k] = internal::random<Scalar>();
  }
  {
    Matrix<Scalar, 4, 1> m{{raw[0]}, {raw[1]}, {raw[2]}, {raw[3]}};
    Array<Scalar, 4, 1> a{{raw[0]}, {raw[1]}, {raw[2]}, {raw[3]}};
    for (int k = 0; k < 4; ++k) {
      VERIFY(m(k) == raw[k]);
    }
    for (int k = 0; k < 4; ++k) {
      VERIFY(a(k) == raw[k]);
    }
    VERIFY_IS_EQUAL(m, (Matrix<Scalar, 4, 1>({{raw[0]}, {raw[1]}, {raw[2]}, {raw[3]}})));
    VERIFY((a == (Array<Scalar, 4, 1>({{raw[0]}, {raw[1]}, {raw[2]}, {raw[3]}}))).all());
  }
  {
    Matrix<Scalar, 1, 4> m{{raw[0], raw[1], raw[2], raw[3]}};
    Array<Scalar, 1, 4> a{{raw[0], raw[1], raw[2], raw[3]}};
    for (int k = 0; k < 4; ++k) {
      VERIFY(m(k) == raw[k]);
    }
    for (int k = 0; k < 4; ++k) {
      VERIFY(a(k) == raw[k]);
    }
    VERIFY_IS_EQUAL(m, (Matrix<Scalar, 1, 4>({{raw[0], raw[1], raw[2], raw[3]}})));
    VERIFY((a == (Array<Scalar, 1, 4>({{raw[0], raw[1], raw[2], raw[3]}}))).all());
  }
  {
    Matrix<Scalar, 4, Dynamic> m{{raw[0]}, {raw[1]}, {raw[2]}, {raw[3]}};
    Array<Scalar, 4, Dynamic> a{{raw[0]}, {raw[1]}, {raw[2]}, {raw[3]}};
    for (int k = 0; k < 4; ++k) {
      VERIFY(m(k) == raw[k]);
    }
    for (int k = 0; k < 4; ++k) {
      VERIFY(a(k) == raw[k]);
    }
    VERIFY_IS_EQUAL(m, (Matrix<Scalar, 4, Dynamic>({{raw[0]}, {raw[1]}, {raw[2]}, {raw[3]}})));
    VERIFY((a == (Array<Scalar, 4, Dynamic>({{raw[0]}, {raw[1]}, {raw[2]}, {raw[3]}}))).all());
  }
  {
    Matrix<Scalar, Dynamic, 4> m{{raw[0], raw[1], raw[2], raw[3]}};
    Array<Scalar, Dynamic, 4> a{{raw[0], raw[1], raw[2], raw[3]}};
    for (int k = 0; k < 4; ++k) {
      VERIFY(m(k) == raw[k]);
    }
    for (int k = 0; k < 4; ++k) {
      VERIFY(a(k) == raw[k]);
    }
    VERIFY_IS_EQUAL(m, (Matrix<Scalar, Dynamic, 4>({{raw[0], raw[1], raw[2], raw[3]}})));
    VERIFY((a == (Array<Scalar, Dynamic, 4>({{raw[0], raw[1], raw[2], raw[3]}}))).all());
  }
}

References a, Eigen::placeholders::all, k, m, VERIFY, and VERIFY_IS_EQUAL.

Referenced by EIGEN_DECLARE_TEST().