From 8acd43bbdbdcf24a98fff86499599a0ac971bc37 Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Tue, 25 Jan 2011 08:37:18 -0500 Subject: let eigen2 tests use the same ei_add_test macro, which required to prefix them with eigen2_ ; rename buildtests_eigen2 to eigen2_buildtests, etc. --- test/eigen2/eigen2_cholesky.cpp | 131 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 131 insertions(+) create mode 100644 test/eigen2/eigen2_cholesky.cpp (limited to 'test/eigen2/eigen2_cholesky.cpp') diff --git a/test/eigen2/eigen2_cholesky.cpp b/test/eigen2/eigen2_cholesky.cpp new file mode 100644 index 000000000..e260852f8 --- /dev/null +++ b/test/eigen2/eigen2_cholesky.cpp @@ -0,0 +1,131 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. Eigen itself is part of the KDE project. +// +// Copyright (C) 2008 Gael Guennebaud +// +// Eigen is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// Alternatively, you can redistribute it and/or +// modify it under the terms of the GNU General Public License as +// published by the Free Software Foundation; either version 2 of +// the License, or (at your option) any later version. +// +// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and a copy of the GNU General Public License along with +// Eigen. If not, see . + +#define EIGEN_NO_ASSERTION_CHECKING +#include "main.h" +#include +#include + +#ifdef HAS_GSL +#include "gsl_helper.h" +#endif + +template void cholesky(const MatrixType& m) +{ + /* this test covers the following files: + LLT.h LDLT.h + */ + int rows = m.rows(); + int cols = m.cols(); + + typedef typename MatrixType::Scalar Scalar; + typedef typename NumTraits::Real RealScalar; + typedef Matrix SquareMatrixType; + typedef Matrix VectorType; + + MatrixType a0 = MatrixType::Random(rows,cols); + VectorType vecB = VectorType::Random(rows), vecX(rows); + MatrixType matB = MatrixType::Random(rows,cols), matX(rows,cols); + SquareMatrixType symm = a0 * a0.adjoint(); + // let's make sure the matrix is not singular or near singular + MatrixType a1 = MatrixType::Random(rows,cols); + symm += a1 * a1.adjoint(); + + #ifdef HAS_GSL + if (ei_is_same_type::ret) + { + typedef GslTraits Gsl; + typename Gsl::Matrix gMatA=0, gSymm=0; + typename Gsl::Vector gVecB=0, gVecX=0; + convert(symm, gSymm); + convert(symm, gMatA); + convert(vecB, gVecB); + convert(vecB, gVecX); + Gsl::cholesky(gMatA); + Gsl::cholesky_solve(gMatA, gVecB, gVecX); + VectorType vecX(rows), _vecX, _vecB; + convert(gVecX, _vecX); + symm.llt().solve(vecB, &vecX); + Gsl::prod(gSymm, gVecX, gVecB); + convert(gVecB, _vecB); + // test gsl itself ! + VERIFY_IS_APPROX(vecB, _vecB); + VERIFY_IS_APPROX(vecX, _vecX); + + Gsl::free(gMatA); + Gsl::free(gSymm); + Gsl::free(gVecB); + Gsl::free(gVecX); + } + #endif + + { + LDLT ldlt(symm); + VERIFY(ldlt.isPositiveDefinite()); + VERIFY_IS_APPROX(symm, ldlt.matrixL() * ldlt.vectorD().asDiagonal() * ldlt.matrixL().adjoint()); + ldlt.solve(vecB, &vecX); + VERIFY_IS_APPROX(symm * vecX, vecB); + ldlt.solve(matB, &matX); + VERIFY_IS_APPROX(symm * matX, matB); + } + + { + LLT chol(symm); + VERIFY(chol.isPositiveDefinite()); + VERIFY_IS_APPROX(symm, chol.matrixL() * chol.matrixL().adjoint()); + chol.solve(vecB, &vecX); + VERIFY_IS_APPROX(symm * vecX, vecB); + chol.solve(matB, &matX); + VERIFY_IS_APPROX(symm * matX, matB); + } + +#if 0 // cholesky is not rank-revealing anyway + // test isPositiveDefinite on non definite matrix + if (rows>4) + { + SquareMatrixType symm = a0.block(0,0,rows,cols-4) * a0.block(0,0,rows,cols-4).adjoint(); + LLT chol(symm); + VERIFY(!chol.isPositiveDefinite()); + LDLT cholnosqrt(symm); + VERIFY(!cholnosqrt.isPositiveDefinite()); + } +#endif +} + +void test_eigen2_cholesky() +{ + for(int i = 0; i < g_repeat; i++) { + CALL_SUBTEST( cholesky(Matrix()) ); + CALL_SUBTEST( cholesky(Matrix2d()) ); + CALL_SUBTEST( cholesky(Matrix3f()) ); + CALL_SUBTEST( cholesky(Matrix4d()) ); + CALL_SUBTEST( cholesky(MatrixXcd(7,7)) ); + CALL_SUBTEST( cholesky(MatrixXf(17,17)) ); + CALL_SUBTEST( cholesky(MatrixXd(33,33)) ); + } + + MatrixXf m = MatrixXf::Zero(10,10); + VectorXf b = VectorXf::Zero(10); + VERIFY(!m.llt().isPositiveDefinite()); +} -- cgit v1.2.3 From 3e2469f9519fdc4f185e42dda3aeb4fda0a5547b Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Tue, 25 Jan 2011 09:02:59 -0500 Subject: eigen2: split tests --- test/eigen2/eigen2_adjoint.cpp | 14 ++--- test/eigen2/eigen2_alignedbox.cpp | 6 +- test/eigen2/eigen2_array.cpp | 34 ++++++------ test/eigen2/eigen2_basicstuff.cpp | 14 ++--- test/eigen2/eigen2_cholesky.cpp | 16 +++--- test/eigen2/eigen2_cwiseop.cpp | 12 ++-- test/eigen2/eigen2_determinant.cpp | 14 ++--- test/eigen2/eigen2_eigensolver.cpp | 16 +++--- test/eigen2/eigen2_geometry.cpp | 4 +- test/eigen2/eigen2_hyperplane.cpp | 12 ++-- test/eigen2/eigen2_inverse.cpp | 12 ++-- test/eigen2/eigen2_linearstructure.cpp | 16 +++--- test/eigen2/eigen2_lu.cpp | 18 +++--- test/eigen2/eigen2_map.cpp | 30 +++++----- test/eigen2/eigen2_miscmatrices.cpp | 10 ++-- test/eigen2/eigen2_mixingtypes.cpp | 6 +- test/eigen2/eigen2_newstdvector.cpp | 32 +++++------ test/eigen2/eigen2_nomalloc.cpp | 6 +- test/eigen2/eigen2_packetmath.cpp | 8 +-- test/eigen2/eigen2_parametrizedline.cpp | 8 +-- test/eigen2/eigen2_prec_inverse_4x4.cpp | 12 ++-- test/eigen2/eigen2_product_large.cpp | 12 ++-- test/eigen2/eigen2_product_small.cpp | 10 ++-- test/eigen2/eigen2_qr.cpp | 13 +++-- test/eigen2/eigen2_qtvector.cpp | 34 ++++++------ test/eigen2/eigen2_regression.cpp | 11 +++- test/eigen2/eigen2_sparse_basic.cpp | 8 +-- test/eigen2/eigen2_sparse_product.cpp | 8 +-- test/eigen2/eigen2_sparse_solvers.cpp | 6 +- test/eigen2/eigen2_sparse_vector.cpp | 6 +- test/eigen2/eigen2_stdvector.cpp | 34 ++++++------ test/eigen2/eigen2_submatrices.cpp | 12 ++-- test/eigen2/eigen2_sum.cpp | 18 +++--- test/eigen2/eigen2_svd.cpp | 8 +-- test/eigen2/eigen2_swap.cpp | 8 +-- test/eigen2/eigen2_triangular.cpp | 14 ++--- test/eigen2/eigen2_visitor.cpp | 20 +++---- test/eigen2/main.h | 98 +++++++++++++++++++++++++++++++++ 38 files changed, 366 insertions(+), 254 deletions(-) (limited to 'test/eigen2/eigen2_cholesky.cpp') diff --git a/test/eigen2/eigen2_adjoint.cpp b/test/eigen2/eigen2_adjoint.cpp index 50b9e2bf6..c090b9650 100644 --- a/test/eigen2/eigen2_adjoint.cpp +++ b/test/eigen2/eigen2_adjoint.cpp @@ -103,14 +103,14 @@ template void adjoint(const MatrixType& m) void test_eigen2_adjoint() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( adjoint(Matrix()) ); - CALL_SUBTEST( adjoint(Matrix3d()) ); - CALL_SUBTEST( adjoint(Matrix4f()) ); - CALL_SUBTEST( adjoint(MatrixXcf(4, 4)) ); - CALL_SUBTEST( adjoint(MatrixXi(8, 12)) ); - CALL_SUBTEST( adjoint(MatrixXf(21, 21)) ); + CALL_SUBTEST_1( adjoint(Matrix()) ); + 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( adjoint(Matrix()) ); + CALL_SUBTEST_7( adjoint(Matrix()) ); } diff --git a/test/eigen2/eigen2_alignedbox.cpp b/test/eigen2/eigen2_alignedbox.cpp index 5d787184e..c24c11d03 100644 --- a/test/eigen2/eigen2_alignedbox.cpp +++ b/test/eigen2/eigen2_alignedbox.cpp @@ -68,8 +68,8 @@ template void alignedbox(const BoxType& _box) void test_eigen2_alignedbox() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( alignedbox(AlignedBox()) ); - CALL_SUBTEST( alignedbox(AlignedBox()) ); - CALL_SUBTEST( alignedbox(AlignedBox()) ); + CALL_SUBTEST_1( alignedbox(AlignedBox()) ); + CALL_SUBTEST_2( alignedbox(AlignedBox()) ); + CALL_SUBTEST_3( alignedbox(AlignedBox()) ); } } diff --git a/test/eigen2/eigen2_array.cpp b/test/eigen2/eigen2_array.cpp index 07aa07456..03977e446 100644 --- a/test/eigen2/eigen2_array.cpp +++ b/test/eigen2/eigen2_array.cpp @@ -132,26 +132,26 @@ template void lpNorm(const VectorType& v) void test_eigen2_array() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( array(Matrix()) ); - CALL_SUBTEST( array(Matrix2f()) ); - CALL_SUBTEST( array(Matrix4d()) ); - CALL_SUBTEST( array(MatrixXcf(3, 3)) ); - CALL_SUBTEST( array(MatrixXf(8, 12)) ); - CALL_SUBTEST( array(MatrixXi(8, 12)) ); + CALL_SUBTEST_1( array(Matrix()) ); + CALL_SUBTEST_2( array(Matrix2f()) ); + CALL_SUBTEST_3( array(Matrix4d()) ); + CALL_SUBTEST_4( array(MatrixXcf(3, 3)) ); + CALL_SUBTEST_5( array(MatrixXf(8, 12)) ); + CALL_SUBTEST_6( array(MatrixXi(8, 12)) ); } for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( comparisons(Matrix()) ); - CALL_SUBTEST( comparisons(Matrix2f()) ); - CALL_SUBTEST( comparisons(Matrix4d()) ); - CALL_SUBTEST( comparisons(MatrixXf(8, 12)) ); - CALL_SUBTEST( comparisons(MatrixXi(8, 12)) ); + CALL_SUBTEST_1( comparisons(Matrix()) ); + CALL_SUBTEST_2( comparisons(Matrix2f()) ); + CALL_SUBTEST_3( comparisons(Matrix4d()) ); + CALL_SUBTEST_5( comparisons(MatrixXf(8, 12)) ); + CALL_SUBTEST_6( comparisons(MatrixXi(8, 12)) ); } for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( lpNorm(Matrix()) ); - CALL_SUBTEST( lpNorm(Vector2f()) ); - CALL_SUBTEST( lpNorm(Vector3d()) ); - CALL_SUBTEST( lpNorm(Vector4f()) ); - CALL_SUBTEST( lpNorm(VectorXf(16)) ); - CALL_SUBTEST( lpNorm(VectorXcd(10)) ); + CALL_SUBTEST_1( lpNorm(Matrix()) ); + CALL_SUBTEST_2( lpNorm(Vector2f()) ); + CALL_SUBTEST_3( lpNorm(Vector3d()) ); + CALL_SUBTEST_4( lpNorm(Vector4f()) ); + CALL_SUBTEST_5( lpNorm(VectorXf(16)) ); + CALL_SUBTEST_7( lpNorm(VectorXcd(10)) ); } } diff --git a/test/eigen2/eigen2_basicstuff.cpp b/test/eigen2/eigen2_basicstuff.cpp index 18be5d133..a09930fae 100644 --- a/test/eigen2/eigen2_basicstuff.cpp +++ b/test/eigen2/eigen2_basicstuff.cpp @@ -112,12 +112,12 @@ template void basicStuff(const MatrixType& m) void test_eigen2_basicstuff() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( basicStuff(Matrix()) ); - CALL_SUBTEST( basicStuff(Matrix4d()) ); - CALL_SUBTEST( basicStuff(MatrixXcf(3, 3)) ); - CALL_SUBTEST( basicStuff(MatrixXi(8, 12)) ); - CALL_SUBTEST( basicStuff(MatrixXcd(20, 20)) ); - CALL_SUBTEST( basicStuff(Matrix()) ); - CALL_SUBTEST( basicStuff(Matrix(10,10)) ); + CALL_SUBTEST_1( basicStuff(Matrix()) ); + 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()) ); + CALL_SUBTEST_7( basicStuff(Matrix(10,10)) ); } } diff --git a/test/eigen2/eigen2_cholesky.cpp b/test/eigen2/eigen2_cholesky.cpp index e260852f8..d1a23dd05 100644 --- a/test/eigen2/eigen2_cholesky.cpp +++ b/test/eigen2/eigen2_cholesky.cpp @@ -116,16 +116,18 @@ template void cholesky(const MatrixType& m) void test_eigen2_cholesky() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( cholesky(Matrix()) ); - CALL_SUBTEST( cholesky(Matrix2d()) ); - CALL_SUBTEST( cholesky(Matrix3f()) ); - CALL_SUBTEST( cholesky(Matrix4d()) ); - CALL_SUBTEST( cholesky(MatrixXcd(7,7)) ); - CALL_SUBTEST( cholesky(MatrixXf(17,17)) ); - CALL_SUBTEST( cholesky(MatrixXd(33,33)) ); + CALL_SUBTEST_1( cholesky(Matrix()) ); + CALL_SUBTEST_2( cholesky(Matrix2d()) ); + CALL_SUBTEST_3( cholesky(Matrix3f()) ); + CALL_SUBTEST_4( cholesky(Matrix4d()) ); + CALL_SUBTEST_5( cholesky(MatrixXcd(7,7)) ); + CALL_SUBTEST_6( cholesky(MatrixXf(17,17)) ); + CALL_SUBTEST_7( cholesky(MatrixXd(33,33)) ); } +#ifdef EIGEN_TEST_PART_6 MatrixXf m = MatrixXf::Zero(10,10); VectorXf b = VectorXf::Zero(10); VERIFY(!m.llt().isPositiveDefinite()); +#endif } diff --git a/test/eigen2/eigen2_cwiseop.cpp b/test/eigen2/eigen2_cwiseop.cpp index d9c851396..cc647d372 100644 --- a/test/eigen2/eigen2_cwiseop.cpp +++ b/test/eigen2/eigen2_cwiseop.cpp @@ -163,11 +163,11 @@ template void cwiseops(const MatrixType& m) void test_eigen2_cwiseop() { for(int i = 0; i < g_repeat ; i++) { - CALL_SUBTEST( cwiseops(Matrix()) ); - CALL_SUBTEST( cwiseops(Matrix4d()) ); - CALL_SUBTEST( cwiseops(MatrixXf(3, 3)) ); - CALL_SUBTEST( cwiseops(MatrixXf(22, 22)) ); - CALL_SUBTEST( cwiseops(MatrixXi(8, 12)) ); - CALL_SUBTEST( cwiseops(MatrixXd(20, 20)) ); + CALL_SUBTEST_1( cwiseops(Matrix()) ); + CALL_SUBTEST_2( cwiseops(Matrix4d()) ); + CALL_SUBTEST_3( cwiseops(MatrixXf(3, 3)) ); + CALL_SUBTEST_3( cwiseops(MatrixXf(22, 22)) ); + CALL_SUBTEST_4( cwiseops(MatrixXi(8, 12)) ); + CALL_SUBTEST_5( cwiseops(MatrixXd(20, 20)) ); } } diff --git a/test/eigen2/eigen2_determinant.cpp b/test/eigen2/eigen2_determinant.cpp index edf4bd81f..5a01856bf 100644 --- a/test/eigen2/eigen2_determinant.cpp +++ b/test/eigen2/eigen2_determinant.cpp @@ -65,12 +65,12 @@ template void determinant(const MatrixType& m) void test_eigen2_determinant() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( determinant(Matrix()) ); - CALL_SUBTEST( determinant(Matrix()) ); - CALL_SUBTEST( determinant(Matrix()) ); - CALL_SUBTEST( determinant(Matrix()) ); - CALL_SUBTEST( determinant(Matrix, 10, 10>()) ); - CALL_SUBTEST( determinant(MatrixXd(20, 20)) ); + CALL_SUBTEST_1( determinant(Matrix()) ); + CALL_SUBTEST_2( determinant(Matrix()) ); + CALL_SUBTEST_3( determinant(Matrix()) ); + CALL_SUBTEST_4( determinant(Matrix()) ); + CALL_SUBTEST_5( determinant(Matrix, 10, 10>()) ); + CALL_SUBTEST_6( determinant(MatrixXd(20, 20)) ); } - CALL_SUBTEST( determinant(MatrixXd(200, 200)) ); + CALL_SUBTEST_6( determinant(MatrixXd(200, 200)) ); } diff --git a/test/eigen2/eigen2_eigensolver.cpp b/test/eigen2/eigen2_eigensolver.cpp index 2bc387889..17111d559 100644 --- a/test/eigen2/eigen2_eigensolver.cpp +++ b/test/eigen2/eigen2_eigensolver.cpp @@ -149,14 +149,14 @@ 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( selfadjointeigensolver(Matrix3f()) ); - CALL_SUBTEST( selfadjointeigensolver(Matrix4d()) ); - CALL_SUBTEST( selfadjointeigensolver(MatrixXf(7,7)) ); - CALL_SUBTEST( selfadjointeigensolver(MatrixXcd(5,5)) ); - CALL_SUBTEST( selfadjointeigensolver(MatrixXd(19,19)) ); - - CALL_SUBTEST( eigensolver(Matrix4f()) ); - CALL_SUBTEST( eigensolver(MatrixXd(17,17)) ); + 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)) ); } } diff --git a/test/eigen2/eigen2_geometry.cpp b/test/eigen2/eigen2_geometry.cpp index 62b24c67e..cec413a9b 100644 --- a/test/eigen2/eigen2_geometry.cpp +++ b/test/eigen2/eigen2_geometry.cpp @@ -440,7 +440,7 @@ template void geometry(void) void test_eigen2_geometry() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( geometry() ); - CALL_SUBTEST( geometry() ); + CALL_SUBTEST_1( geometry() ); + CALL_SUBTEST_2( geometry() ); } } diff --git a/test/eigen2/eigen2_hyperplane.cpp b/test/eigen2/eigen2_hyperplane.cpp index 681e9a67a..de6265ec0 100644 --- a/test/eigen2/eigen2_hyperplane.cpp +++ b/test/eigen2/eigen2_hyperplane.cpp @@ -131,11 +131,11 @@ template void lines() void test_eigen2_hyperplane() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( hyperplane(Hyperplane()) ); - CALL_SUBTEST( hyperplane(Hyperplane()) ); - CALL_SUBTEST( hyperplane(Hyperplane()) ); - CALL_SUBTEST( hyperplane(Hyperplane,5>()) ); - CALL_SUBTEST( lines() ); - CALL_SUBTEST( lines() ); + CALL_SUBTEST_1( hyperplane(Hyperplane()) ); + CALL_SUBTEST_2( hyperplane(Hyperplane()) ); + CALL_SUBTEST_3( hyperplane(Hyperplane()) ); + CALL_SUBTEST_4( hyperplane(Hyperplane,5>()) ); + CALL_SUBTEST_5( lines() ); + CALL_SUBTEST_6( lines() ); } } diff --git a/test/eigen2/eigen2_inverse.cpp b/test/eigen2/eigen2_inverse.cpp index 493151e58..aa8b1146a 100644 --- a/test/eigen2/eigen2_inverse.cpp +++ b/test/eigen2/eigen2_inverse.cpp @@ -68,11 +68,11 @@ template void inverse(const MatrixType& m) void test_eigen2_inverse() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( inverse(Matrix()) ); - CALL_SUBTEST( inverse(Matrix2d()) ); - CALL_SUBTEST( inverse(Matrix3f()) ); - CALL_SUBTEST( inverse(Matrix4f()) ); - CALL_SUBTEST( inverse(MatrixXf(8,8)) ); - CALL_SUBTEST( inverse(MatrixXcd(7,7)) ); + CALL_SUBTEST_1( inverse(Matrix()) ); + 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)) ); } } diff --git a/test/eigen2/eigen2_linearstructure.cpp b/test/eigen2/eigen2_linearstructure.cpp index e951d17df..0e970df55 100644 --- a/test/eigen2/eigen2_linearstructure.cpp +++ b/test/eigen2/eigen2_linearstructure.cpp @@ -87,13 +87,13 @@ template void linearStructure(const MatrixType& m) void test_eigen2_linearstructure() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( linearStructure(Matrix()) ); - CALL_SUBTEST( linearStructure(Matrix2f()) ); - CALL_SUBTEST( linearStructure(Vector3d()) ); - CALL_SUBTEST( linearStructure(Matrix4d()) ); - CALL_SUBTEST( linearStructure(MatrixXcf(3, 3)) ); - CALL_SUBTEST( linearStructure(MatrixXf(8, 12)) ); - CALL_SUBTEST( linearStructure(MatrixXi(8, 12)) ); - CALL_SUBTEST( linearStructure(MatrixXcd(20, 20)) ); + CALL_SUBTEST_1( linearStructure(Matrix()) ); + 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)) ); } } diff --git a/test/eigen2/eigen2_lu.cpp b/test/eigen2/eigen2_lu.cpp index 5c608209c..c6c8d577d 100644 --- a/test/eigen2/eigen2_lu.cpp +++ b/test/eigen2/eigen2_lu.cpp @@ -123,19 +123,21 @@ template void lu_invertible() void test_eigen2_lu() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( lu_non_invertible() ); - CALL_SUBTEST( lu_non_invertible() ); - CALL_SUBTEST( lu_non_invertible() ); - CALL_SUBTEST( lu_non_invertible() ); - CALL_SUBTEST( lu_invertible() ); - CALL_SUBTEST( lu_invertible() ); - CALL_SUBTEST( lu_invertible() ); - CALL_SUBTEST( lu_invertible() ); + CALL_SUBTEST_1( lu_non_invertible() ); + CALL_SUBTEST_2( lu_non_invertible() ); + CALL_SUBTEST_3( lu_non_invertible() ); + CALL_SUBTEST_4( lu_non_invertible() ); + CALL_SUBTEST_1( lu_invertible() ); + CALL_SUBTEST_2( lu_invertible() ); + CALL_SUBTEST_3( lu_invertible() ); + CALL_SUBTEST_4( lu_invertible() ); } +#ifdef EIGEN_TEST_PART_1 MatrixXf m = MatrixXf::Zero(10,10); VectorXf b = VectorXf::Zero(10); VectorXf x = VectorXf::Random(10); VERIFY(m.lu().solve(b,&x)); VERIFY(x.isZero()); +#endif } diff --git a/test/eigen2/eigen2_map.cpp b/test/eigen2/eigen2_map.cpp index 39aad1570..296902a8f 100644 --- a/test/eigen2/eigen2_map.cpp +++ b/test/eigen2/eigen2_map.cpp @@ -108,22 +108,22 @@ template void map_static_methods(const VectorType& m) void test_eigen2_map() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( map_class_vector(Matrix()) ); - CALL_SUBTEST( map_class_vector(Vector4d()) ); - CALL_SUBTEST( map_class_vector(RowVector4f()) ); - CALL_SUBTEST( map_class_vector(VectorXcf(8)) ); - CALL_SUBTEST( map_class_vector(VectorXi(12)) ); + CALL_SUBTEST_1( map_class_vector(Matrix()) ); + 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( map_class_matrix(Matrix()) ); - CALL_SUBTEST( map_class_matrix(Matrix4d()) ); - CALL_SUBTEST( map_class_matrix(Matrix()) ); - CALL_SUBTEST( map_class_matrix(MatrixXcf(ei_random(1,10),ei_random(1,10))) ); - CALL_SUBTEST( map_class_matrix(MatrixXi(ei_random(1,10),ei_random(1,10))) ); + CALL_SUBTEST_1( map_class_matrix(Matrix()) ); + CALL_SUBTEST_2( map_class_matrix(Matrix4d()) ); + CALL_SUBTEST_6( map_class_matrix(Matrix()) ); + CALL_SUBTEST_4( map_class_matrix(MatrixXcf(ei_random(1,10),ei_random(1,10))) ); + CALL_SUBTEST_5( map_class_matrix(MatrixXi(ei_random(1,10),ei_random(1,10))) ); - CALL_SUBTEST( map_static_methods(Matrix()) ); - CALL_SUBTEST( map_static_methods(Vector3f()) ); - CALL_SUBTEST( map_static_methods(RowVector3d()) ); - CALL_SUBTEST( map_static_methods(VectorXcd(8)) ); - CALL_SUBTEST( map_static_methods(VectorXf(12)) ); + CALL_SUBTEST_1( map_static_methods(Matrix()) ); + 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)) ); } } diff --git a/test/eigen2/eigen2_miscmatrices.cpp b/test/eigen2/eigen2_miscmatrices.cpp index f55ac6c98..95cfa3df9 100644 --- a/test/eigen2/eigen2_miscmatrices.cpp +++ b/test/eigen2/eigen2_miscmatrices.cpp @@ -54,10 +54,10 @@ template void miscMatrices(const MatrixType& m) void test_eigen2_miscmatrices() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( miscMatrices(Matrix()) ); - CALL_SUBTEST( miscMatrices(Matrix4d()) ); - CALL_SUBTEST( miscMatrices(MatrixXcf(3, 3)) ); - CALL_SUBTEST( miscMatrices(MatrixXi(8, 12)) ); - CALL_SUBTEST( miscMatrices(MatrixXcd(20, 20)) ); + CALL_SUBTEST_1( miscMatrices(Matrix()) ); + CALL_SUBTEST_2( miscMatrices(Matrix4d()) ); + CALL_SUBTEST_3( miscMatrices(MatrixXcf(3, 3)) ); + CALL_SUBTEST_4( miscMatrices(MatrixXi(8, 12)) ); + CALL_SUBTEST_5( miscMatrices(MatrixXcd(20, 20)) ); } } diff --git a/test/eigen2/eigen2_mixingtypes.cpp b/test/eigen2/eigen2_mixingtypes.cpp index 347cf9888..3721a0047 100644 --- a/test/eigen2/eigen2_mixingtypes.cpp +++ b/test/eigen2/eigen2_mixingtypes.cpp @@ -82,7 +82,7 @@ template void mixingtypes(int size = SizeAtCompileType) void test_eigen2_mixingtypes() { // check that our operator new is indeed called: - CALL_SUBTEST(mixingtypes<3>()); - CALL_SUBTEST(mixingtypes<4>()); - CALL_SUBTEST(mixingtypes(20)); + CALL_SUBTEST_1(mixingtypes<3>()); + CALL_SUBTEST_2(mixingtypes<4>()); + CALL_SUBTEST_3(mixingtypes(20)); } diff --git a/test/eigen2/eigen2_newstdvector.cpp b/test/eigen2/eigen2_newstdvector.cpp index d8b52cbb9..c107f4f8d 100644 --- a/test/eigen2/eigen2_newstdvector.cpp +++ b/test/eigen2/eigen2_newstdvector.cpp @@ -136,29 +136,29 @@ void check_stdvector_quaternion(const QuaternionType&) void test_eigen2_newstdvector() { // some non vectorizable fixed sizes - CALL_SUBTEST(check_stdvector_matrix(Vector2f())); - CALL_SUBTEST(check_stdvector_matrix(Matrix3f())); - CALL_SUBTEST(check_stdvector_matrix(Matrix3d())); + CALL_SUBTEST_1(check_stdvector_matrix(Vector2f())); + CALL_SUBTEST_1(check_stdvector_matrix(Matrix3f())); + CALL_SUBTEST_1(check_stdvector_matrix(Matrix3d())); // some vectorizable fixed sizes - CALL_SUBTEST(check_stdvector_matrix(Matrix2f())); - CALL_SUBTEST(check_stdvector_matrix(Vector4f())); - CALL_SUBTEST(check_stdvector_matrix(Matrix4f())); - CALL_SUBTEST(check_stdvector_matrix(Matrix4d())); + CALL_SUBTEST_2(check_stdvector_matrix(Matrix2f())); + CALL_SUBTEST_2(check_stdvector_matrix(Vector4f())); + CALL_SUBTEST_2(check_stdvector_matrix(Matrix4f())); + CALL_SUBTEST_2(check_stdvector_matrix(Matrix4d())); // some dynamic sizes - CALL_SUBTEST(check_stdvector_matrix(MatrixXd(1,1))); - CALL_SUBTEST(check_stdvector_matrix(VectorXd(20))); - CALL_SUBTEST(check_stdvector_matrix(RowVectorXf(20))); - CALL_SUBTEST(check_stdvector_matrix(MatrixXcf(10,10))); + CALL_SUBTEST_3(check_stdvector_matrix(MatrixXd(1,1))); + CALL_SUBTEST_3(check_stdvector_matrix(VectorXd(20))); + CALL_SUBTEST_3(check_stdvector_matrix(RowVectorXf(20))); + CALL_SUBTEST_3(check_stdvector_matrix(MatrixXcf(10,10))); // some Transform - CALL_SUBTEST(check_stdvector_transform(Transform2f())); - CALL_SUBTEST(check_stdvector_transform(Transform3f())); - CALL_SUBTEST(check_stdvector_transform(Transform3d())); + CALL_SUBTEST_4(check_stdvector_transform(Transform2f())); + CALL_SUBTEST_4(check_stdvector_transform(Transform3f())); + CALL_SUBTEST_4(check_stdvector_transform(Transform3d())); //CALL_SUBTEST(check_stdvector_transform(Transform4d())); // some Quaternion - CALL_SUBTEST(check_stdvector_quaternion(Quaternionf())); - CALL_SUBTEST(check_stdvector_quaternion(Quaterniond())); + CALL_SUBTEST_5(check_stdvector_quaternion(Quaternionf())); + CALL_SUBTEST_5(check_stdvector_quaternion(Quaterniond())); } diff --git a/test/eigen2/eigen2_nomalloc.cpp b/test/eigen2/eigen2_nomalloc.cpp index d523511bf..7d28e4cca 100644 --- a/test/eigen2/eigen2_nomalloc.cpp +++ b/test/eigen2/eigen2_nomalloc.cpp @@ -72,7 +72,7 @@ void test_eigen2_nomalloc() { // check that our operator new is indeed called: VERIFY_RAISES_ASSERT(MatrixXd dummy = MatrixXd::Random(3,3)); - CALL_SUBTEST( nomalloc(Matrix()) ); - CALL_SUBTEST( nomalloc(Matrix4d()) ); - CALL_SUBTEST( nomalloc(Matrix()) ); + CALL_SUBTEST_1( nomalloc(Matrix()) ); + CALL_SUBTEST_2( nomalloc(Matrix4d()) ); + CALL_SUBTEST_3( nomalloc(Matrix()) ); } diff --git a/test/eigen2/eigen2_packetmath.cpp b/test/eigen2/eigen2_packetmath.cpp index a64d3b84d..11384b1a8 100644 --- a/test/eigen2/eigen2_packetmath.cpp +++ b/test/eigen2/eigen2_packetmath.cpp @@ -139,9 +139,9 @@ template void packetmath() void test_eigen2_packetmath() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( packetmath() ); - CALL_SUBTEST( packetmath() ); - CALL_SUBTEST( packetmath() ); - CALL_SUBTEST( packetmath >() ); + CALL_SUBTEST_1( packetmath() ); + CALL_SUBTEST_2( packetmath() ); + CALL_SUBTEST_3( packetmath() ); + CALL_SUBTEST_4( packetmath >() ); } } diff --git a/test/eigen2/eigen2_parametrizedline.cpp b/test/eigen2/eigen2_parametrizedline.cpp index c031d03da..a301be815 100644 --- a/test/eigen2/eigen2_parametrizedline.cpp +++ b/test/eigen2/eigen2_parametrizedline.cpp @@ -69,9 +69,9 @@ template void parametrizedline(const LineType& _line) void test_eigen2_parametrizedline() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( parametrizedline(ParametrizedLine()) ); - CALL_SUBTEST( parametrizedline(ParametrizedLine()) ); - CALL_SUBTEST( parametrizedline(ParametrizedLine()) ); - CALL_SUBTEST( parametrizedline(ParametrizedLine,5>()) ); + CALL_SUBTEST_1( parametrizedline(ParametrizedLine()) ); + CALL_SUBTEST_2( parametrizedline(ParametrizedLine()) ); + CALL_SUBTEST_3( parametrizedline(ParametrizedLine()) ); + CALL_SUBTEST_4( parametrizedline(ParametrizedLine,5>()) ); } } diff --git a/test/eigen2/eigen2_prec_inverse_4x4.cpp b/test/eigen2/eigen2_prec_inverse_4x4.cpp index 1160563a2..5117c8095 100644 --- a/test/eigen2/eigen2_prec_inverse_4x4.cpp +++ b/test/eigen2/eigen2_prec_inverse_4x4.cpp @@ -88,12 +88,12 @@ template void inverse_general_4x4(int repeat) void test_eigen2_prec_inverse_4x4() { - CALL_SUBTEST((inverse_permutation_4x4())); - CALL_SUBTEST(( inverse_general_4x4(200000 * g_repeat) )); + CALL_SUBTEST_1((inverse_permutation_4x4())); + CALL_SUBTEST_1(( inverse_general_4x4(200000 * g_repeat) )); - CALL_SUBTEST((inverse_permutation_4x4 >())); - CALL_SUBTEST(( inverse_general_4x4 >(200000 * g_repeat) )); + CALL_SUBTEST_2((inverse_permutation_4x4 >())); + CALL_SUBTEST_2(( inverse_general_4x4 >(200000 * g_repeat) )); - CALL_SUBTEST((inverse_permutation_4x4())); - CALL_SUBTEST((inverse_general_4x4(50000 * g_repeat))); + CALL_SUBTEST_3((inverse_permutation_4x4())); + CALL_SUBTEST_3((inverse_general_4x4(50000 * g_repeat))); } diff --git a/test/eigen2/eigen2_product_large.cpp b/test/eigen2/eigen2_product_large.cpp index 5dc09dfa7..0ecc5d623 100644 --- a/test/eigen2/eigen2_product_large.cpp +++ b/test/eigen2/eigen2_product_large.cpp @@ -27,13 +27,14 @@ void test_eigen2_product_large() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( product(MatrixXf(ei_random(1,320), ei_random(1,320))) ); - CALL_SUBTEST( product(MatrixXd(ei_random(1,320), ei_random(1,320))) ); - CALL_SUBTEST( product(MatrixXi(ei_random(1,320), ei_random(1,320))) ); - CALL_SUBTEST( product(MatrixXcf(ei_random(1,50), ei_random(1,50))) ); - CALL_SUBTEST( product(Matrix(ei_random(1,320), ei_random(1,320))) ); + CALL_SUBTEST_1( product(MatrixXf(ei_random(1,320), ei_random(1,320))) ); + CALL_SUBTEST_2( product(MatrixXd(ei_random(1,320), ei_random(1,320))) ); + CALL_SUBTEST_3( product(MatrixXi(ei_random(1,320), ei_random(1,320))) ); + CALL_SUBTEST_4( product(MatrixXcf(ei_random(1,50), ei_random(1,50))) ); + CALL_SUBTEST_5( product(Matrix(ei_random(1,320), ei_random(1,320))) ); } +#ifdef EIGEN_TEST_PART_6 { // test a specific issue in DiagonalProduct int N = 1000000; @@ -55,4 +56,5 @@ void test_eigen2_product_large() MatrixXf result = mat1.row(2)*mat2.transpose(); VERIFY_IS_APPROX(result, (mat1.row(2)*mat2.transpose()).eval()); } +#endif } diff --git a/test/eigen2/eigen2_product_small.cpp b/test/eigen2/eigen2_product_small.cpp index 641b4151d..2a445d12a 100644 --- a/test/eigen2/eigen2_product_small.cpp +++ b/test/eigen2/eigen2_product_small.cpp @@ -28,10 +28,10 @@ void test_eigen2_product_small() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( product(Matrix()) ); - CALL_SUBTEST( product(Matrix()) ); - CALL_SUBTEST( product(Matrix3d()) ); - CALL_SUBTEST( product(Matrix4d()) ); - CALL_SUBTEST( product(Matrix4f()) ); + CALL_SUBTEST_1( product(Matrix()) ); + CALL_SUBTEST_2( product(Matrix()) ); + CALL_SUBTEST_3( product(Matrix3d()) ); + CALL_SUBTEST_4( product(Matrix4d()) ); + CALL_SUBTEST_5( product(Matrix4f()) ); } } diff --git a/test/eigen2/eigen2_qr.cpp b/test/eigen2/eigen2_qr.cpp index f644ded5c..438d40440 100644 --- a/test/eigen2/eigen2_qr.cpp +++ b/test/eigen2/eigen2_qr.cpp @@ -60,13 +60,14 @@ template void qr(const MatrixType& m) void test_eigen2_qr() { for(int i = 0; i < 1; i++) { - CALL_SUBTEST( qr(Matrix2f()) ); - CALL_SUBTEST( qr(Matrix4d()) ); - CALL_SUBTEST( qr(MatrixXf(12,8)) ); - CALL_SUBTEST( qr(MatrixXcd(5,5)) ); - CALL_SUBTEST( qr(MatrixXcd(7,3)) ); + CALL_SUBTEST_1( qr(Matrix2f()) ); + CALL_SUBTEST_2( qr(Matrix4d()) ); + CALL_SUBTEST_3( qr(MatrixXf(12,8)) ); + CALL_SUBTEST_4( qr(MatrixXcd(5,5)) ); + CALL_SUBTEST_4( qr(MatrixXcd(7,3)) ); } +#ifdef EIGEN_TEST_PART_5 // small isFullRank test { Matrix3d mat; @@ -82,4 +83,6 @@ void test_eigen2_qr() VERIFY(m.qr().solve(b,&x)); VERIFY(x.isZero()); } + +#endif } diff --git a/test/eigen2/eigen2_qtvector.cpp b/test/eigen2/eigen2_qtvector.cpp index 8bd000083..8c4446637 100644 --- a/test/eigen2/eigen2_qtvector.cpp +++ b/test/eigen2/eigen2_qtvector.cpp @@ -145,29 +145,29 @@ void check_qtvector_quaternion(const QuaternionType&) void test_eigen2_qtvector() { // some non vectorizable fixed sizes - CALL_SUBTEST(check_qtvector_matrix(Vector2f())); - CALL_SUBTEST(check_qtvector_matrix(Matrix3f())); - CALL_SUBTEST(check_qtvector_matrix(Matrix3d())); + CALL_SUBTEST_1(check_qtvector_matrix(Vector2f())); + CALL_SUBTEST_1(check_qtvector_matrix(Matrix3f())); + CALL_SUBTEST_1(check_qtvector_matrix(Matrix3d())); // some vectorizable fixed sizes - CALL_SUBTEST(check_qtvector_matrix(Matrix2f())); - CALL_SUBTEST(check_qtvector_matrix(Vector4f())); - CALL_SUBTEST(check_qtvector_matrix(Matrix4f())); - CALL_SUBTEST(check_qtvector_matrix(Matrix4d())); + CALL_SUBTEST_2(check_qtvector_matrix(Matrix2f())); + CALL_SUBTEST_2(check_qtvector_matrix(Vector4f())); + CALL_SUBTEST_2(check_qtvector_matrix(Matrix4f())); + CALL_SUBTEST_2(check_qtvector_matrix(Matrix4d())); // some dynamic sizes - CALL_SUBTEST(check_qtvector_matrix(MatrixXd(1,1))); - CALL_SUBTEST(check_qtvector_matrix(VectorXd(20))); - CALL_SUBTEST(check_qtvector_matrix(RowVectorXf(20))); - CALL_SUBTEST(check_qtvector_matrix(MatrixXcf(10,10))); + CALL_SUBTEST_3(check_qtvector_matrix(MatrixXd(1,1))); + CALL_SUBTEST_3(check_qtvector_matrix(VectorXd(20))); + CALL_SUBTEST_3(check_qtvector_matrix(RowVectorXf(20))); + CALL_SUBTEST_3(check_qtvector_matrix(MatrixXcf(10,10))); // some Transform - CALL_SUBTEST(check_qtvector_transform(Transform2f())); - CALL_SUBTEST(check_qtvector_transform(Transform3f())); - CALL_SUBTEST(check_qtvector_transform(Transform3d())); - //CALL_SUBTEST(check_qtvector_transform(Transform4d())); + CALL_SUBTEST_4(check_qtvector_transform(Transform2f())); + CALL_SUBTEST_4(check_qtvector_transform(Transform3f())); + CALL_SUBTEST_4(check_qtvector_transform(Transform3d())); + //CALL_SUBTEST_4(check_qtvector_transform(Transform4d())); // some Quaternion - CALL_SUBTEST(check_qtvector_quaternion(Quaternionf())); - CALL_SUBTEST(check_qtvector_quaternion(Quaternionf())); + CALL_SUBTEST_5(check_qtvector_quaternion(Quaternionf())); + CALL_SUBTEST_5(check_qtvector_quaternion(Quaternionf())); } diff --git a/test/eigen2/eigen2_regression.cpp b/test/eigen2/eigen2_regression.cpp index 035840e9d..9bc41de87 100644 --- a/test/eigen2/eigen2_regression.cpp +++ b/test/eigen2/eigen2_regression.cpp @@ -95,6 +95,7 @@ void test_eigen2_regression() { for(int i = 0; i < g_repeat; i++) { +#ifdef EIGEN_TEST_PART_1 { Vector2f points2f [1000]; Vector2f *points2f_ptrs [1000]; @@ -108,7 +109,8 @@ void test_eigen2_regression() CALL_SUBTEST(check_linearRegression(100, points2f_ptrs, coeffs2f, 0.01f)); CALL_SUBTEST(check_linearRegression(1000, points2f_ptrs, coeffs2f, 0.002f)); } - +#endif +#ifdef EIGEN_TEST_PART_2 { Vector2f points2f [1000]; Vector2f *points2f_ptrs [1000]; @@ -119,7 +121,8 @@ void test_eigen2_regression() CALL_SUBTEST(check_fitHyperplane(100, points2f_ptrs, coeffs3f, 0.01f)); CALL_SUBTEST(check_fitHyperplane(1000, points2f_ptrs, coeffs3f, 0.002f)); } - +#endif +#ifdef EIGEN_TEST_PART_3 { Vector4d points4d [1000]; Vector4d *points4d_ptrs [1000]; @@ -130,7 +133,8 @@ void test_eigen2_regression() CALL_SUBTEST(check_fitHyperplane(100, points4d_ptrs, coeffs5d, 0.01)); CALL_SUBTEST(check_fitHyperplane(1000, points4d_ptrs, coeffs5d, 0.002)); } - +#endif +#ifdef EIGEN_TEST_PART_4 { VectorXcd *points11cd_ptrs[1000]; for(int i = 0; i < 1000; i++) points11cd_ptrs[i] = new VectorXcd(11); @@ -141,5 +145,6 @@ void test_eigen2_regression() delete coeffs12cd; for(int i = 0; i < 1000; i++) delete points11cd_ptrs[i]; } +#endif } } diff --git a/test/eigen2/eigen2_sparse_basic.cpp b/test/eigen2/eigen2_sparse_basic.cpp index 55f006bd9..4e9f8e9f2 100644 --- a/test/eigen2/eigen2_sparse_basic.cpp +++ b/test/eigen2/eigen2_sparse_basic.cpp @@ -323,10 +323,10 @@ template void sparse_basic(const SparseMatrixType& re void test_eigen2_sparse_basic() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( sparse_basic(SparseMatrix(8, 8)) ); - CALL_SUBTEST( sparse_basic(SparseMatrix >(16, 16)) ); - CALL_SUBTEST( sparse_basic(SparseMatrix(33, 33)) ); + CALL_SUBTEST_1( sparse_basic(SparseMatrix(8, 8)) ); + CALL_SUBTEST_2( sparse_basic(SparseMatrix >(16, 16)) ); + CALL_SUBTEST_1( sparse_basic(SparseMatrix(33, 33)) ); - CALL_SUBTEST( sparse_basic(DynamicSparseMatrix(8, 8)) ); + CALL_SUBTEST_3( sparse_basic(DynamicSparseMatrix(8, 8)) ); } } diff --git a/test/eigen2/eigen2_sparse_product.cpp b/test/eigen2/eigen2_sparse_product.cpp index 3de0844db..6260cdddb 100644 --- a/test/eigen2/eigen2_sparse_product.cpp +++ b/test/eigen2/eigen2_sparse_product.cpp @@ -121,10 +121,10 @@ template void sparse_product(const SparseMatrixType& void test_eigen2_sparse_product() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( sparse_product(SparseMatrix(8, 8)) ); - CALL_SUBTEST( sparse_product(SparseMatrix >(16, 16)) ); - CALL_SUBTEST( sparse_product(SparseMatrix(33, 33)) ); + CALL_SUBTEST_1( sparse_product(SparseMatrix(8, 8)) ); + CALL_SUBTEST_2( sparse_product(SparseMatrix >(16, 16)) ); + CALL_SUBTEST_1( sparse_product(SparseMatrix(33, 33)) ); - CALL_SUBTEST( sparse_product(DynamicSparseMatrix(8, 8)) ); + CALL_SUBTEST_3( sparse_product(DynamicSparseMatrix(8, 8)) ); } } diff --git a/test/eigen2/eigen2_sparse_solvers.cpp b/test/eigen2/eigen2_sparse_solvers.cpp index a449fedda..f141af314 100644 --- a/test/eigen2/eigen2_sparse_solvers.cpp +++ b/test/eigen2/eigen2_sparse_solvers.cpp @@ -208,8 +208,8 @@ template void sparse_solvers(int rows, int cols) void test_eigen2_sparse_solvers() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( sparse_solvers(8, 8) ); - CALL_SUBTEST( sparse_solvers >(16, 16) ); - CALL_SUBTEST( sparse_solvers(101, 101) ); + CALL_SUBTEST_1( sparse_solvers(8, 8) ); + CALL_SUBTEST_2( sparse_solvers >(16, 16) ); + CALL_SUBTEST_1( sparse_solvers(101, 101) ); } } diff --git a/test/eigen2/eigen2_sparse_vector.cpp b/test/eigen2/eigen2_sparse_vector.cpp index a092d8f84..3289cbd20 100644 --- a/test/eigen2/eigen2_sparse_vector.cpp +++ b/test/eigen2/eigen2_sparse_vector.cpp @@ -91,9 +91,9 @@ template void sparse_vector(int rows, int cols) void test_eigen2_sparse_vector() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( sparse_vector(8, 8) ); - CALL_SUBTEST( sparse_vector >(16, 16) ); - CALL_SUBTEST( sparse_vector(299, 535) ); + CALL_SUBTEST_1( sparse_vector(8, 8) ); + CALL_SUBTEST_2( sparse_vector >(16, 16) ); + CALL_SUBTEST_1( sparse_vector(299, 535) ); } } diff --git a/test/eigen2/eigen2_stdvector.cpp b/test/eigen2/eigen2_stdvector.cpp index a05a00239..46d0bf7dc 100644 --- a/test/eigen2/eigen2_stdvector.cpp +++ b/test/eigen2/eigen2_stdvector.cpp @@ -135,29 +135,29 @@ void check_stdvector_quaternion(const QuaternionType&) void test_eigen2_stdvector() { // some non vectorizable fixed sizes - CALL_SUBTEST(check_stdvector_matrix(Vector2f())); - CALL_SUBTEST(check_stdvector_matrix(Matrix3f())); - CALL_SUBTEST(check_stdvector_matrix(Matrix3d())); + CALL_SUBTEST_1(check_stdvector_matrix(Vector2f())); + CALL_SUBTEST_1(check_stdvector_matrix(Matrix3f())); + CALL_SUBTEST_1(check_stdvector_matrix(Matrix3d())); // some vectorizable fixed sizes - CALL_SUBTEST(check_stdvector_matrix(Matrix2f())); - CALL_SUBTEST(check_stdvector_matrix(Vector4f())); - CALL_SUBTEST(check_stdvector_matrix(Matrix4f())); - CALL_SUBTEST(check_stdvector_matrix(Matrix4d())); + CALL_SUBTEST_2(check_stdvector_matrix(Matrix2f())); + CALL_SUBTEST_2(check_stdvector_matrix(Vector4f())); + CALL_SUBTEST_2(check_stdvector_matrix(Matrix4f())); + CALL_SUBTEST_2(check_stdvector_matrix(Matrix4d())); // some dynamic sizes - CALL_SUBTEST(check_stdvector_matrix(MatrixXd(1,1))); - CALL_SUBTEST(check_stdvector_matrix(VectorXd(20))); - CALL_SUBTEST(check_stdvector_matrix(RowVectorXf(20))); - CALL_SUBTEST(check_stdvector_matrix(MatrixXcf(10,10))); + CALL_SUBTEST_3(check_stdvector_matrix(MatrixXd(1,1))); + CALL_SUBTEST_3(check_stdvector_matrix(VectorXd(20))); + CALL_SUBTEST_3(check_stdvector_matrix(RowVectorXf(20))); + CALL_SUBTEST_3(check_stdvector_matrix(MatrixXcf(10,10))); // some Transform - CALL_SUBTEST(check_stdvector_transform(Transform2f())); - CALL_SUBTEST(check_stdvector_transform(Transform3f())); - CALL_SUBTEST(check_stdvector_transform(Transform3d())); - //CALL_SUBTEST(check_stdvector_transform(Transform4d())); + CALL_SUBTEST_4(check_stdvector_transform(Transform2f())); + CALL_SUBTEST_4(check_stdvector_transform(Transform3f())); + CALL_SUBTEST_4(check_stdvector_transform(Transform3d())); + //CALL_SUBTEST_4(check_stdvector_transform(Transform4d())); // some Quaternion - CALL_SUBTEST(check_stdvector_quaternion(Quaternionf())); - CALL_SUBTEST(check_stdvector_quaternion(Quaternionf())); + CALL_SUBTEST_5(check_stdvector_quaternion(Quaternionf())); + CALL_SUBTEST_5(check_stdvector_quaternion(Quaternionf())); } diff --git a/test/eigen2/eigen2_submatrices.cpp b/test/eigen2/eigen2_submatrices.cpp index d95b0edaf..37a084286 100644 --- a/test/eigen2/eigen2_submatrices.cpp +++ b/test/eigen2/eigen2_submatrices.cpp @@ -153,11 +153,11 @@ template void submatrices(const MatrixType& m) void test_eigen2_submatrices() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( submatrices(Matrix()) ); - CALL_SUBTEST( submatrices(Matrix4d()) ); - CALL_SUBTEST( submatrices(MatrixXcf(3, 3)) ); - CALL_SUBTEST( submatrices(MatrixXi(8, 12)) ); - CALL_SUBTEST( submatrices(MatrixXcd(20, 20)) ); - CALL_SUBTEST( submatrices(MatrixXf(20, 20)) ); + CALL_SUBTEST_1( submatrices(Matrix()) ); + CALL_SUBTEST_2( submatrices(Matrix4d()) ); + CALL_SUBTEST_3( submatrices(MatrixXcf(3, 3)) ); + CALL_SUBTEST_4( submatrices(MatrixXi(8, 12)) ); + CALL_SUBTEST_5( submatrices(MatrixXcd(20, 20)) ); + CALL_SUBTEST_6( submatrices(MatrixXf(20, 20)) ); } } diff --git a/test/eigen2/eigen2_sum.cpp b/test/eigen2/eigen2_sum.cpp index f22f18d4e..aabf49c22 100644 --- a/test/eigen2/eigen2_sum.cpp +++ b/test/eigen2/eigen2_sum.cpp @@ -71,16 +71,16 @@ template void vectorSum(const VectorType& w) void test_eigen2_sum() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( matrixSum(Matrix()) ); - CALL_SUBTEST( matrixSum(Matrix2f()) ); - CALL_SUBTEST( matrixSum(Matrix4d()) ); - CALL_SUBTEST( matrixSum(MatrixXcf(3, 3)) ); - CALL_SUBTEST( matrixSum(MatrixXf(8, 12)) ); - CALL_SUBTEST( matrixSum(MatrixXi(8, 12)) ); + CALL_SUBTEST_1( matrixSum(Matrix()) ); + CALL_SUBTEST_2( matrixSum(Matrix2f()) ); + CALL_SUBTEST_3( matrixSum(Matrix4d()) ); + CALL_SUBTEST_4( matrixSum(MatrixXcf(3, 3)) ); + CALL_SUBTEST_5( matrixSum(MatrixXf(8, 12)) ); + CALL_SUBTEST_6( matrixSum(MatrixXi(8, 12)) ); } for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( vectorSum(VectorXf(5)) ); - CALL_SUBTEST( vectorSum(VectorXd(10)) ); - CALL_SUBTEST( vectorSum(VectorXf(33)) ); + CALL_SUBTEST_5( vectorSum(VectorXf(5)) ); + CALL_SUBTEST_7( vectorSum(VectorXd(10)) ); + CALL_SUBTEST_5( vectorSum(VectorXf(33)) ); } } diff --git a/test/eigen2/eigen2_svd.cpp b/test/eigen2/eigen2_svd.cpp index c85a466d7..f74b13ea7 100644 --- a/test/eigen2/eigen2_svd.cpp +++ b/test/eigen2/eigen2_svd.cpp @@ -88,10 +88,10 @@ template void svd(const MatrixType& m) void test_eigen2_svd() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( svd(Matrix3f()) ); - CALL_SUBTEST( svd(Matrix4d()) ); - CALL_SUBTEST( svd(MatrixXf(7,7)) ); - CALL_SUBTEST( svd(MatrixXd(14,7)) ); + 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)) ); diff --git a/test/eigen2/eigen2_swap.cpp b/test/eigen2/eigen2_swap.cpp index 9c934a759..29688bd33 100644 --- a/test/eigen2/eigen2_swap.cpp +++ b/test/eigen2/eigen2_swap.cpp @@ -91,8 +91,8 @@ template void swap(const MatrixType& m) void test_eigen2_swap() { - CALL_SUBTEST( swap(Matrix3f()) ); // fixed size, no vectorization - CALL_SUBTEST( swap(Matrix4d()) ); // fixed size, possible vectorization - CALL_SUBTEST( swap(MatrixXd(3,3)) ); // dyn size, no vectorization - CALL_SUBTEST( swap(MatrixXf(30,30)) ); // dyn size, possible vectorization + CALL_SUBTEST( swap_1(Matrix3f()) ); // fixed size, no vectorization + CALL_SUBTEST( swap_2(Matrix4d()) ); // fixed size, possible vectorization + CALL_SUBTEST( swap_3(MatrixXd(3,3)) ); // dyn size, no vectorization + CALL_SUBTEST( swap_4(MatrixXf(30,30)) ); // dyn size, possible vectorization } diff --git a/test/eigen2/eigen2_triangular.cpp b/test/eigen2/eigen2_triangular.cpp index 279db9aac..c81fad0da 100644 --- a/test/eigen2/eigen2_triangular.cpp +++ b/test/eigen2/eigen2_triangular.cpp @@ -127,12 +127,12 @@ template void triangular(const MatrixType& m) void test_eigen2_triangular() { for(int i = 0; i < g_repeat ; i++) { - CALL_SUBTEST( triangular(Matrix()) ); - CALL_SUBTEST( triangular(Matrix()) ); - CALL_SUBTEST( triangular(Matrix3d()) ); - CALL_SUBTEST( triangular(MatrixXcf(4, 4)) ); - CALL_SUBTEST( triangular(Matrix,8, 8>()) ); - CALL_SUBTEST( triangular(MatrixXd(17,17)) ); - CALL_SUBTEST( triangular(Matrix(5, 5)) ); + CALL_SUBTEST_1( triangular(Matrix()) ); + CALL_SUBTEST_2( triangular(Matrix()) ); + CALL_SUBTEST_3( triangular(Matrix3d()) ); + CALL_SUBTEST_4( triangular(MatrixXcf(4, 4)) ); + CALL_SUBTEST_5( triangular(Matrix,8, 8>()) ); + CALL_SUBTEST_6( triangular(MatrixXd(17,17)) ); + CALL_SUBTEST_7( triangular(Matrix(5, 5)) ); } } diff --git a/test/eigen2/eigen2_visitor.cpp b/test/eigen2/eigen2_visitor.cpp index 55fca8e21..db650b73d 100644 --- a/test/eigen2/eigen2_visitor.cpp +++ b/test/eigen2/eigen2_visitor.cpp @@ -115,17 +115,17 @@ template void vectorVisitor(const VectorType& w) void test_eigen2_visitor() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( matrixVisitor(Matrix()) ); - CALL_SUBTEST( matrixVisitor(Matrix2f()) ); - CALL_SUBTEST( matrixVisitor(Matrix4d()) ); - CALL_SUBTEST( matrixVisitor(MatrixXd(8, 12)) ); - CALL_SUBTEST( matrixVisitor(Matrix(20, 20)) ); - CALL_SUBTEST( matrixVisitor(MatrixXi(8, 12)) ); + CALL_SUBTEST_1( matrixVisitor(Matrix()) ); + CALL_SUBTEST_2( matrixVisitor(Matrix2f()) ); + CALL_SUBTEST_3( matrixVisitor(Matrix4d()) ); + CALL_SUBTEST_4( matrixVisitor(MatrixXd(8, 12)) ); + CALL_SUBTEST_5( matrixVisitor(Matrix(20, 20)) ); + CALL_SUBTEST_6( matrixVisitor(MatrixXi(8, 12)) ); } for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST( vectorVisitor(Vector4f()) ); - CALL_SUBTEST( vectorVisitor(VectorXd(10)) ); - CALL_SUBTEST( vectorVisitor(RowVectorXd(10)) ); - CALL_SUBTEST( vectorVisitor(VectorXf(33)) ); + CALL_SUBTEST_7( vectorVisitor(Vector4f()) ); + CALL_SUBTEST_4( vectorVisitor(VectorXd(10)) ); + CALL_SUBTEST_4( vectorVisitor(RowVectorXd(10)) ); + CALL_SUBTEST_8( vectorVisitor(VectorXf(33)) ); } } diff --git a/test/eigen2/main.h b/test/eigen2/main.h index e144a28b1..5b6c715e7 100644 --- a/test/eigen2/main.h +++ b/test/eigen2/main.h @@ -240,6 +240,104 @@ void EI_PP_CAT(test_,EIGEN_TEST_FUNC)(); using namespace Eigen; +#ifdef EIGEN_TEST_PART_1 +#define CALL_SUBTEST_1(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_1(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_2 +#define CALL_SUBTEST_2(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_2(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_3 +#define CALL_SUBTEST_3(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_3(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_4 +#define CALL_SUBTEST_4(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_4(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_5 +#define CALL_SUBTEST_5(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_5(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_6 +#define CALL_SUBTEST_6(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_6(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_7 +#define CALL_SUBTEST_7(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_7(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_8 +#define CALL_SUBTEST_8(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_8(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_9 +#define CALL_SUBTEST_9(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_9(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_10 +#define CALL_SUBTEST_10(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_10(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_11 +#define CALL_SUBTEST_11(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_11(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_12 +#define CALL_SUBTEST_12(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_12(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_13 +#define CALL_SUBTEST_13(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_13(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_14 +#define CALL_SUBTEST_14(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_14(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_15 +#define CALL_SUBTEST_15(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_15(FUNC) +#endif + +#ifdef EIGEN_TEST_PART_16 +#define CALL_SUBTEST_16(FUNC) CALL_SUBTEST(FUNC) +#else +#define CALL_SUBTEST_16(FUNC) +#endif + + + int main(int argc, char *argv[]) { bool has_set_repeat = false; -- cgit v1.2.3