commainitializer.cpp File Reference

#include "main.h"

Classes
struct	test_block_recursion< depth, N >
struct	test_block_recursion< 0, N >

Functions
template<int M1, int M2, int N1, int N2>
void	test_blocks ()
void	test_basics ()
	EIGEN_DECLARE_TEST (commainitializer)

Function Documentation

EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST

(

commainitializer

)

                                     {
  CALL_SUBTEST_1(test_basics());
 
  // recursively test all block-sizes from 0 to 3:
  CALL_SUBTEST_2(test_block_recursion<8>::run());
}

References CALL_SUBTEST_1, CALL_SUBTEST_2, and test_basics().

test_basics()

void test_basics

(

)

                   {
  Matrix3d m3;
  Matrix4d m4;
 
  VERIFY_RAISES_ASSERT((m3 << 1, 2, 3, 4, 5, 6, 7, 8));
 
#ifndef _MSC_VER
  VERIFY_RAISES_ASSERT((m3 << 1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
#endif
 
  double data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  Matrix3d ref = Map<Matrix<double, 3, 3, RowMajor> >(data);
 
  m3 = Matrix3d::Random();
  m3 << 1, 2, 3, 4, 5, 6, 7, 8, 9;
  VERIFY_IS_APPROX(m3, ref);
 
  Vector3d vec[3];
  vec[0] << 1, 4, 7;
  vec[1] << 2, 5, 8;
  vec[2] << 3, 6, 9;
  m3 = Matrix3d::Random();
  m3 << vec[0], vec[1], vec[2];
  VERIFY_IS_APPROX(m3, ref);
 
  vec[0] << 1, 2, 3;
  vec[1] << 4, 5, 6;
  vec[2] << 7, 8, 9;
  m3 = Matrix3d::Random();
  m3 << vec[0].transpose(), 4, 5, 6, vec[2].transpose();
  VERIFY_IS_APPROX(m3, ref);
}

References data, VERIFY_IS_APPROX, and VERIFY_RAISES_ASSERT.

Referenced by EIGEN_DECLARE_TEST().

test_blocks()

template<int M1, int M2, int N1, int N2>

void test_blocks

(

)

                   {
  Matrix<int, M1 + M2, N1 + N2> m_fixed;
  MatrixXi m_dynamic(M1 + M2, N1 + N2);
 
  Matrix<int, M1, N1> mat11;
  mat11.setRandom();
  Matrix<int, M1, N2> mat12;
  mat12.setRandom();
  Matrix<int, M2, N1> mat21;
  mat21.setRandom();
  Matrix<int, M2, N2> mat22;
  mat22.setRandom();
 
  MatrixXi matx11 = mat11, matx12 = mat12, matx21 = mat21, matx22 = mat22;
 
  {
    VERIFY_IS_EQUAL((m_fixed << mat11, mat12, mat21, matx22).finished(),
                    (m_dynamic << mat11, matx12, mat21, matx22).finished());
    VERIFY_IS_EQUAL((m_fixed.template topLeftCorner<M1, N1>()), mat11);
    VERIFY_IS_EQUAL((m_fixed.template topRightCorner<M1, N2>()), mat12);
    VERIFY_IS_EQUAL((m_fixed.template bottomLeftCorner<M2, N1>()), mat21);
    VERIFY_IS_EQUAL((m_fixed.template bottomRightCorner<M2, N2>()), mat22);
    VERIFY_IS_EQUAL((m_fixed << mat12, mat11, matx21, mat22).finished(),
                    (m_dynamic << mat12, matx11, matx21, mat22).finished());
  }
 
  if (N1 > 0) {
    if (M1 > 0) {
      VERIFY_RAISES_ASSERT((m_fixed << mat11, mat12, mat11, mat21, mat22));
    }
    if (M2 > 0) {
      VERIFY_RAISES_ASSERT((m_fixed << mat11, mat12, mat21, mat21, mat22));
    }
  } else {
    // allow insertion of zero-column blocks:
    VERIFY_IS_EQUAL((m_fixed << mat11, mat12, mat11, mat11, mat21, mat21, mat22).finished(),
                    (m_dynamic << mat12, mat22).finished());
  }
  if (M1 != M2) {
    VERIFY_RAISES_ASSERT((m_fixed << mat11, mat21, mat12, mat22));
  }
}

References MergeRestartFiles::finished, M1, M2(), Eigen::PlainObjectBase< Derived >::setRandom(), VERIFY_IS_EQUAL, and VERIFY_RAISES_ASSERT.

Referenced by test_block_recursion< 0, N >::run().