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); } }