自学教程：C++ CALL_SUBTEST_2函数代码示例

void test_sparse_extra(){    for (int i = 0; i < g_repeat; i++)    {        CALL_SUBTEST_1(sparse_extra(SparseMatrix<double>(8, 8)));        CALL_SUBTEST_2(sparse_extra(SparseMatrix<std::complex<double>>(16, 16)));        CALL_SUBTEST_1(sparse_extra(SparseMatrix<double>(33, 33)));        CALL_SUBTEST_3(sparse_extra(DynamicSparseMatrix<double>(8, 8)));    }}

void test_eigen2_inverse(){  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1( inverse(Matrix<double,1,1>()) );    CALL_SUBTEST_2( inverse(Matrix2d()) );    CALL_SUBTEST_3( inverse(Matrix3f()) );    CALL_SUBTEST_4( inverse(Matrix4f()) );    CALL_SUBTEST_5( inverse(MatrixXf(8,8)) );    CALL_SUBTEST_6( inverse(MatrixXcd(7,7)) );  }}

void test_array_replicate(){  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1( replicate(Matrix<float, 1, 1>()) );    CALL_SUBTEST_2( replicate(Vector2f()) );    CALL_SUBTEST_3( replicate(Vector3d()) );    CALL_SUBTEST_4( replicate(Vector4f()) );    CALL_SUBTEST_5( replicate(VectorXf(16)) );    CALL_SUBTEST_6( replicate(VectorXcd(10)) );  }}

void test_matrix_exponential(){  CALL_SUBTEST_2(test2dRotation<double>(1e-13));  CALL_SUBTEST_1(test2dRotation<float>(2e-5));  // was 1e-5, relaxed for clang 2.8 / linux / x86-64  CALL_SUBTEST_8(test2dRotation<long double>(1e-13));   CALL_SUBTEST_2(test2dHyperbolicRotation<double>(1e-14));  CALL_SUBTEST_1(test2dHyperbolicRotation<float>(1e-5));  CALL_SUBTEST_8(test2dHyperbolicRotation<long double>(1e-14));  CALL_SUBTEST_6(testPascal<float>(1e-6));  CALL_SUBTEST_5(testPascal<double>(1e-15));  CALL_SUBTEST_2(randomTest(Matrix2d(), 1e-13));  CALL_SUBTEST_7(randomTest(Matrix<double,3,3,RowMajor>(), 1e-13));  CALL_SUBTEST_3(randomTest(Matrix4cd(), 1e-13));  CALL_SUBTEST_4(randomTest(MatrixXd(8,8), 1e-13));  CALL_SUBTEST_1(randomTest(Matrix2f(), 1e-4));  CALL_SUBTEST_5(randomTest(Matrix3cf(), 1e-4));  CALL_SUBTEST_1(randomTest(Matrix4f(), 1e-4));  CALL_SUBTEST_6(randomTest(MatrixXf(8,8), 1e-4));  CALL_SUBTEST_9(randomTest(Matrix<long double,Dynamic,Dynamic>(7,7), 1e-13));}

void test_ref(){  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1( ref_vector(Matrix<float, 1, 1>()) );    CALL_SUBTEST_1( check_const_correctness(Matrix<float, 1, 1>()) );    CALL_SUBTEST_2( ref_vector(Vector4d()) );    CALL_SUBTEST_2( check_const_correctness(Matrix4d()) );    CALL_SUBTEST_3( ref_vector(Vector4cf()) );    CALL_SUBTEST_4( ref_vector(VectorXcf(8)) );    CALL_SUBTEST_5( ref_vector(VectorXi(12)) );    CALL_SUBTEST_5( check_const_correctness(VectorXi(12)) );    CALL_SUBTEST_1( ref_matrix(Matrix<float, 1, 1>()) );    CALL_SUBTEST_2( ref_matrix(Matrix4d()) );    CALL_SUBTEST_1( ref_matrix(Matrix<float,3,5>()) );    CALL_SUBTEST_4( ref_matrix(MatrixXcf(internal::random<int>(1,10),internal::random<int>(1,10))) );    CALL_SUBTEST_4( ref_matrix(Matrix<std::complex<double>,10,15>()) );    CALL_SUBTEST_5( ref_matrix(MatrixXi(internal::random<int>(1,10),internal::random<int>(1,10))) );    CALL_SUBTEST_6( call_ref() );  }}

void test_nullary(){  CALL_SUBTEST_1( testMatrixType(Matrix2d()) );  CALL_SUBTEST_2( testMatrixType(MatrixXcf(50,50)) );  CALL_SUBTEST_3( testMatrixType(MatrixXf(5,7)) );  CALL_SUBTEST_4( testVectorType(VectorXd(51)) );  CALL_SUBTEST_5( testVectorType(VectorXd(41)) );  CALL_SUBTEST_6( testVectorType(Vector3d()) );  CALL_SUBTEST_7( testVectorType(VectorXf(51)) );  CALL_SUBTEST_8( testVectorType(VectorXf(41)) );  CALL_SUBTEST_9( testVectorType(Vector3f()) );}

void test_basicstuff(){  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1( basicStuff(Matrix<float, 1, 1>()) );    CALL_SUBTEST_2( basicStuff(Matrix4d()) );    CALL_SUBTEST_3( basicStuff(MatrixXcf(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );    CALL_SUBTEST_4( basicStuff(MatrixXi(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );    CALL_SUBTEST_5( basicStuff(MatrixXcd(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );    CALL_SUBTEST_6( basicStuff(Matrix<float, 100, 100>()) );    CALL_SUBTEST_7( basicStuff(Matrix<long double,Dynamic,Dynamic>(internal::random<int>(1,EIGEN_TEST_MAX_SIZE),internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );    CALL_SUBTEST_3( basicStuffComplex(MatrixXcf(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );    CALL_SUBTEST_5( basicStuffComplex(MatrixXcd(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );  }  CALL_SUBTEST_1(fixedSizeMatrixConstruction<unsigned char>());  CALL_SUBTEST_1(fixedSizeMatrixConstruction<double>());  CALL_SUBTEST_1(fixedSizeMatrixConstruction<double>());  CALL_SUBTEST_2(casting());}

void test_determinant(){  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1( determinant(Matrix<float, 1, 1>()) );    CALL_SUBTEST_2( determinant(Matrix<double, 2, 2>()) );    CALL_SUBTEST_3( determinant(Matrix<double, 3, 3>()) );    CALL_SUBTEST_4( determinant(Matrix<double, 4, 4>()) );    CALL_SUBTEST_5( determinant(Matrix<std::complex<double>, 10, 10>()) );    CALL_SUBTEST_6( determinant(MatrixXd(20, 20)) );  }  CALL_SUBTEST_6( determinant(MatrixXd(200, 200)) );}

void test_upperbidiagonalization(){  for(int i = 0; i < g_repeat; i++) {   CALL_SUBTEST_1( upperbidiag(MatrixXf(3,3)) );   CALL_SUBTEST_2( upperbidiag(MatrixXd(17,12)) );   CALL_SUBTEST_3( upperbidiag(MatrixXcf(20,20)) );   CALL_SUBTEST_4( upperbidiag(MatrixXcd(16,15)) );   CALL_SUBTEST_5( upperbidiag(Matrix<float,6,4>()) );   CALL_SUBTEST_6( upperbidiag(Matrix<float,5,5>()) );   CALL_SUBTEST_7( upperbidiag(Matrix<double,4,3>()) );  }}

void test_nomalloc(){  // check that our operator new is indeed called:  VERIFY_RAISES_ASSERT(MatrixXd dummy(MatrixXd::Random(3,3)));  CALL_SUBTEST_1(nomalloc(Matrix<float, 1, 1>()) );  CALL_SUBTEST_2(nomalloc(Matrix4d()) );  CALL_SUBTEST_3(nomalloc(Matrix<float,32,32>()) );    // Check decomposition modules with dynamic matrices that have a known compile-time max size (ctms)  CALL_SUBTEST_4(ctms_decompositions<float>());}

void test_eigensolver_complex(){  int s = 0;  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1( eigensolver(Matrix4cf()) );    s = internal::random<int>(1,EIGEN_TEST_MAX_SIZE/4);    CALL_SUBTEST_2( eigensolver(MatrixXcd(s,s)) );    CALL_SUBTEST_3( eigensolver(Matrix<std::complex<float>, 1, 1>()) );    CALL_SUBTEST_4( eigensolver(Matrix3f()) );  }  CALL_SUBTEST_1( eigensolver_verify_assert(Matrix4cf()) );  s = internal::random<int>(1,EIGEN_TEST_MAX_SIZE/4);  CALL_SUBTEST_2( eigensolver_verify_assert(MatrixXcd(s,s)) );  CALL_SUBTEST_3( eigensolver_verify_assert(Matrix<std::complex<float>, 1, 1>()) );  CALL_SUBTEST_4( eigensolver_verify_assert(Matrix3f()) );  // Test problem size constructors  CALL_SUBTEST_5(ComplexEigenSolver<MatrixXf> tmp(s));    TEST_SET_BUT_UNUSED_VARIABLE(s)}

void test_eigen2_basicstuff(){  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1( basicStuff(Matrix<float, 1, 1>()) );    CALL_SUBTEST_2( basicStuff(Matrix4d()) );    CALL_SUBTEST_3( basicStuff(MatrixXcf(3, 3)) );    CALL_SUBTEST_4( basicStuff(MatrixXi(8, 12)) );    CALL_SUBTEST_5( basicStuff(MatrixXcd(20, 20)) );    CALL_SUBTEST_6( basicStuff(Matrix<float, 100, 100>()) );    CALL_SUBTEST_7( basicStuff(Matrix<long double,Dynamic,Dynamic>(10,10)) );  }}

void test_geo_quaternion(){  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1(( quaternion<float,AutoAlign>() ));    CALL_SUBTEST_2(( quaternion<double,AutoAlign>() ));    CALL_SUBTEST_3(( quaternion<float,DontAlign>() ));    CALL_SUBTEST_4(( quaternion<double,DontAlign>() ));    CALL_SUBTEST_5(( quaternionAlignment<float>() ));    CALL_SUBTEST_6(( quaternionAlignment<double>() ));    CALL_SUBTEST( mapQuaternion<float>() );    CALL_SUBTEST( mapQuaternion<double>() );  }}

void test_householder(){  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1( householder(Matrix<double,2,2>()) );    CALL_SUBTEST_2( householder(Matrix<float,2,3>()) );    CALL_SUBTEST_3( householder(Matrix<double,3,5>()) );    CALL_SUBTEST_4( householder(Matrix<float,4,4>()) );    CALL_SUBTEST_5( householder(MatrixXd(internal::random<int>(1,EIGEN_TEST_MAX_SIZE),internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );    CALL_SUBTEST_6( householder(MatrixXcf(internal::random<int>(1,EIGEN_TEST_MAX_SIZE),internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );    CALL_SUBTEST_7( householder(MatrixXf(internal::random<int>(1,EIGEN_TEST_MAX_SIZE),internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );    CALL_SUBTEST_8( householder(Matrix<double,1,1>()) );  }}

void test_eigen2_triangular(){  CALL_SUBTEST_8( selfadjoint() );  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(MatrixXd(17,17)) );    CALL_SUBTEST_7( triangular(Matrix<float,Dynamic,Dynamic,RowMajor>(5, 5)) );  }}

void test_eigen2_map(){  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1( map_class_vector(Matrix<float, 1, 1>()) );    CALL_SUBTEST_2( map_class_vector(Vector4d()) );    CALL_SUBTEST_3( map_class_vector(RowVector4f()) );    CALL_SUBTEST_4( map_class_vector(VectorXcf(8)) );    CALL_SUBTEST_5( map_class_vector(VectorXi(12)) );    CALL_SUBTEST_1( map_class_matrix(Matrix<float, 1, 1>()) );    CALL_SUBTEST_2( map_class_matrix(Matrix4d()) );    CALL_SUBTEST_6( map_class_matrix(Matrix<float,3,5>()) );    CALL_SUBTEST_4( map_class_matrix(MatrixXcf(ei_random<int>(1,10),ei_random<int>(1,10))) );    CALL_SUBTEST_5( map_class_matrix(MatrixXi(ei_random<int>(1,10),ei_random<int>(1,10))) );    CALL_SUBTEST_1( map_static_methods(Matrix<double, 1, 1>()) );    CALL_SUBTEST_2( map_static_methods(Vector3f()) );    CALL_SUBTEST_7( map_static_methods(RowVector3d()) );    CALL_SUBTEST_4( map_static_methods(VectorXcd(8)) );    CALL_SUBTEST_5( map_static_methods(VectorXf(12)) );  }}

void test_eigen2_adjoint(){  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1( adjoint(Matrix<float, 1, 1>()) );    CALL_SUBTEST_2( adjoint(Matrix3d()) );    CALL_SUBTEST_3( adjoint(Matrix4f()) );    CALL_SUBTEST_4( adjoint(MatrixXcf(4, 4)) );    CALL_SUBTEST_5( adjoint(MatrixXi(8, 12)) );    CALL_SUBTEST_6( adjoint(MatrixXf(21, 21)) );  }  // test a large matrix only once  CALL_SUBTEST_7( adjoint(Matrix<float, 100, 100>()) );}

void test_eigen2_linearstructure(){  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1( linearStructure(Matrix<float, 1, 1>()) );    CALL_SUBTEST_2( linearStructure(Matrix2f()) );    CALL_SUBTEST_3( linearStructure(Vector3d()) );    CALL_SUBTEST_4( linearStructure(Matrix4d()) );    CALL_SUBTEST_5( linearStructure(MatrixXcf(3, 3)) );    CALL_SUBTEST_6( linearStructure(MatrixXf(8, 12)) );    CALL_SUBTEST_7( linearStructure(MatrixXi(8, 12)) );    CALL_SUBTEST_8( linearStructure(MatrixXcd(20, 20)) );  }}

void test_product_notemporary(){  int s;  for(int i = 0; i < g_repeat; i++) {    s = internal::random<int>(16,EIGEN_TEST_MAX_SIZE);    CALL_SUBTEST_1( product_notemporary(MatrixXf(s, s)) );    s = internal::random<int>(16,EIGEN_TEST_MAX_SIZE);    CALL_SUBTEST_2( product_notemporary(MatrixXd(s, s)) );    s = internal::random<int>(16,EIGEN_TEST_MAX_SIZE/2);    CALL_SUBTEST_3( product_notemporary(MatrixXcf(s,s)) );    s = internal::random<int>(16,EIGEN_TEST_MAX_SIZE/2);    CALL_SUBTEST_4( product_notemporary(MatrixXcd(s,s)) );  }}

void test_product_notemporary(){  int s;  for(int i = 0; i < g_repeat; i++) {    s = ei_random<int>(16,320);    CALL_SUBTEST_1( product_notemporary(MatrixXf(s, s)) );    s = ei_random<int>(16,320);    CALL_SUBTEST_2( product_notemporary(MatrixXd(s, s)) );    s = ei_random<int>(16,120);    CALL_SUBTEST_3( product_notemporary(MatrixXcf(s,s)) );    s = ei_random<int>(16,120);    CALL_SUBTEST_4( product_notemporary(MatrixXcd(s,s)) );  }}

void test_linearstructure(){  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1( linearStructure(Matrix<float, 1, 1>()) );    CALL_SUBTEST_2( linearStructure(Matrix2f()) );    CALL_SUBTEST_3( linearStructure(Vector3d()) );    CALL_SUBTEST_4( linearStructure(Matrix4d()) );    CALL_SUBTEST_5( linearStructure(MatrixXcf(internal::random<int>(1,EIGEN_TEST_MAX_SIZE/2), internal::random<int>(1,EIGEN_TEST_MAX_SIZE/2))) );    CALL_SUBTEST_6( linearStructure(MatrixXf (internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );    CALL_SUBTEST_7( linearStructure(MatrixXi (internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );    CALL_SUBTEST_8( linearStructure(MatrixXcd(internal::random<int>(1,EIGEN_TEST_MAX_SIZE/2), internal::random<int>(1,EIGEN_TEST_MAX_SIZE/2))) );    CALL_SUBTEST_9( linearStructure(ArrayXXf (internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );  }}

void test_eigen2_eigensolver(){  for(int i = 0; i < g_repeat; i++) {    // very important to test a 3x3 matrix since we provide a special path for it    CALL_SUBTEST_1( selfadjointeigensolver(Matrix3f()) );    CALL_SUBTEST_2( selfadjointeigensolver(Matrix4d()) );    CALL_SUBTEST_3( selfadjointeigensolver(MatrixXf(7,7)) );    CALL_SUBTEST_4( selfadjointeigensolver(MatrixXcd(5,5)) );    CALL_SUBTEST_5( selfadjointeigensolver(MatrixXd(19,19)) );    CALL_SUBTEST_6( eigensolver(Matrix4f()) );    CALL_SUBTEST_5( eigensolver(MatrixXd(17,17)) );  }}

void test_matrix_power(){  typedef Matrix<double,3,3,RowMajor>         Matrix3dRowMajor;  typedef Matrix<long double,Dynamic,Dynamic> MatrixXe;  typedef Matrix<long double,Dynamic,1>       VectorXe;  CALL_SUBTEST_2(test2dRotation<double>(1e-13));  CALL_SUBTEST_1(test2dRotation<float>(2e-5));  // was 1e-5, relaxed for clang 2.8 / linux / x86-64  CALL_SUBTEST_9(test2dRotation<long double>(1e-13));   CALL_SUBTEST_2(test2dHyperbolicRotation<double>(1e-14));  CALL_SUBTEST_1(test2dHyperbolicRotation<float>(1e-5));  CALL_SUBTEST_9(test2dHyperbolicRotation<long double>(1e-14));  CALL_SUBTEST_2(testMatrixVector(Matrix2d(),         Vector2d(),    1e-13));  CALL_SUBTEST_7(testMatrixVector(Matrix3dRowMajor(), MatrixXd(3,5), 1e-13));  CALL_SUBTEST_3(testMatrixVector(Matrix4cd(),        Vector4cd(),   1e-13));  CALL_SUBTEST_4(testMatrixVector(MatrixXd(8,8),      VectorXd(8),   2e-12));  CALL_SUBTEST_1(testMatrixVector(Matrix2f(),         Vector2f(),    1e-4));  CALL_SUBTEST_5(testMatrixVector(Matrix3cf(),        Vector3cf(),   1e-4));  CALL_SUBTEST_8(testMatrixVector(Matrix4f(),         Vector4f(),    1e-4));  CALL_SUBTEST_6(testMatrixVector(MatrixXf(8,8),      VectorXf(8),   1e-3));  CALL_SUBTEST_9(testMatrixVector(MatrixXe(7,7),      VectorXe(7),   1e-13));}

void test_determinant(){  int s;  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1( determinant(Matrix<float, 1, 1>()) );    CALL_SUBTEST_2( determinant(Matrix<double, 2, 2>()) );    CALL_SUBTEST_3( determinant(Matrix<double, 3, 3>()) );    CALL_SUBTEST_4( determinant(Matrix<double, 4, 4>()) );    CALL_SUBTEST_5( determinant(Matrix<std::complex<double>, 10, 10>()) );    s = internal::random<int>(1,EIGEN_TEST_MAX_SIZE/4);    CALL_SUBTEST_6( determinant(MatrixXd(s, s)) );  }  EIGEN_UNUSED_VARIABLE(s)}

void test_product_trmv(){  int s;  for(int i = 0; i < g_repeat ; i++) {    CALL_SUBTEST_1( trmv(Matrix<float, 1, 1>()) );    CALL_SUBTEST_2( trmv(Matrix<float, 2, 2>()) );    CALL_SUBTEST_3( trmv(Matrix3d()) );    s = ei_random<int>(1,200);    CALL_SUBTEST_4( trmv(MatrixXcf(s,s)) );    s = ei_random<int>(1,200);    CALL_SUBTEST_5( trmv(MatrixXcd(s,s)) );    s = ei_random<int>(1,320);    CALL_SUBTEST_6( trmv(Matrix<float,Dynamic,Dynamic,RowMajor>(s, s)) );  }}

void test_nullary(){  CALL_SUBTEST_1( testMatrixType(Matrix2d()) );  CALL_SUBTEST_2( testMatrixType(MatrixXcf(internal::random<int>(1,300),internal::random<int>(1,300))) );  CALL_SUBTEST_3( testMatrixType(MatrixXf(internal::random<int>(1,300),internal::random<int>(1,300))) );    for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_4( testVectorType(VectorXd(internal::random<int>(1,300))) );    CALL_SUBTEST_5( testVectorType(Vector4d()) );  // regression test for bug 232    CALL_SUBTEST_6( testVectorType(Vector3d()) );    CALL_SUBTEST_7( testVectorType(VectorXf(internal::random<int>(1,300))) );    CALL_SUBTEST_8( testVectorType(Vector3f()) );    CALL_SUBTEST_8( testVectorType(Matrix<float,1,1>()) );  }}

void test_product_symm(){  for(int i = 0; i < g_repeat ; i++)  {    CALL_SUBTEST_1(( symm<float,Dynamic,Dynamic>(ei_random<int>(1,320),ei_random<int>(1,320)) ));    CALL_SUBTEST_2(( symm<double,Dynamic,Dynamic>(ei_random<int>(1,320),ei_random<int>(1,320)) ));    CALL_SUBTEST_3(( symm<std::complex<float>,Dynamic,Dynamic>(ei_random<int>(1,200),ei_random<int>(1,200)) ));    CALL_SUBTEST_4(( symm<std::complex<double>,Dynamic,Dynamic>(ei_random<int>(1,200),ei_random<int>(1,200)) ));    CALL_SUBTEST_5(( symm<float,Dynamic,1>(ei_random<int>(1,320)) ));    CALL_SUBTEST_6(( symm<double,Dynamic,1>(ei_random<int>(1,320)) ));    CALL_SUBTEST_7(( symm<std::complex<float>,Dynamic,1>(ei_random<int>(1,320)) ));    CALL_SUBTEST_8(( symm<std::complex<double>,Dynamic,1>(ei_random<int>(1,320)) ));  }}

void test_product_syrk(){  for(int i = 0; i < g_repeat ; i++)  {    int s;    s = internal::random<int>(1,320);    CALL_SUBTEST_1( syrk(MatrixXf(s, s)) );    s = internal::random<int>(1,320);    CALL_SUBTEST_2( syrk(MatrixXd(s, s)) );    s = internal::random<int>(1,200);    CALL_SUBTEST_3( syrk(MatrixXcf(s, s)) );    s = internal::random<int>(1,200);    CALL_SUBTEST_4( syrk(MatrixXcd(s, s)) );  }}

void test_selfadjoint(){  for(int i = 0; i < g_repeat ; i++)  {    int s = internal::random<int>(1,20); EIGEN_UNUSED_VARIABLE(s);    CALL_SUBTEST_1( selfadjoint(Matrix<float, 1, 1>()) );    CALL_SUBTEST_2( selfadjoint(Matrix<float, 2, 2>()) );    CALL_SUBTEST_3( selfadjoint(Matrix3cf()) );    CALL_SUBTEST_4( selfadjoint(MatrixXcd(s,s)) );    CALL_SUBTEST_5( selfadjoint(Matrix<float,Dynamic,Dynamic,RowMajor>(s, s)) );  }    CALL_SUBTEST_1( bug_159() );}

void test_eigen2_svd(){  for(int i = 0; i < g_repeat; i++) {    CALL_SUBTEST_1( svd(Matrix3f()) );    CALL_SUBTEST_2( svd(Matrix4d()) );    CALL_SUBTEST_3( svd(MatrixXf(7,7)) );    CALL_SUBTEST_4( svd(MatrixXd(14,7)) );    // complex are not implemented yet//     CALL_SUBTEST( svd(MatrixXcd(6,6)) );//     CALL_SUBTEST( svd(MatrixXcf(3,3)) );    SVD<MatrixXf> s;    MatrixXf m = MatrixXf::Random(10,1);    s.compute(m);  }}