From d1d7a1ade9da009f11b8ff47222c6498fdd93aa2 Mon Sep 17 00:00:00 2001 From: Gael Guennebaud Date: Sun, 23 Jun 2013 19:11:32 +0200 Subject: [PATCH] Workaround a bunch of stupid warnings in unit tests --- test/cholesky.cpp | 39 ++-- test/determinant.cpp | 5 +- test/eigensolver_complex.cpp | 6 +- test/eigensolver_generalized_real.cpp | 6 +- test/eigensolver_generic.cpp | 5 +- test/eigensolver_selfadjoint.cpp | 7 +- test/evaluators.cpp | 313 +++++++++++++------------- test/inverse.cpp | 5 +- test/jacobisvd.cpp | 8 +- test/main.h | 27 ++- test/product_notemporary.cpp | 2 +- test/product_selfadjoint.cpp | 3 +- test/product_trmv.cpp | 3 +- test/real_qz.cpp | 3 +- test/redux.cpp | 1 + test/ref.cpp | 2 +- test/selfadjoint.cpp | 3 +- test/sparse_basic.cpp | 114 +++++----- test/sparse_solver.h | 81 +++---- test/triangular.cpp | 4 +- 20 files changed, 334 insertions(+), 303 deletions(-) diff --git a/test/cholesky.cpp b/test/cholesky.cpp index a3b16bfc2..d084ec72c 100644 --- a/test/cholesky.cpp +++ b/test/cholesky.cpp @@ -82,14 +82,14 @@ template void cholesky(const MatrixType& m) symm += a1 * a1.adjoint(); } - SquareMatrixType symmUp = symm.template triangularView(); - SquareMatrixType symmLo = symm.template triangularView(); - // to test if really Cholesky only uses the upper triangular part, uncomment the following // FIXME: currently that fails !! //symm.template part().setZero(); { + SquareMatrixType symmUp = symm.template triangularView(); + SquareMatrixType symmLo = symm.template triangularView(); + LLT chollo(symmLo); VERIFY_IS_APPROX(symm, chollo.reconstructedMatrix()); vecX = chollo.solve(vecB); @@ -113,6 +113,21 @@ template void cholesky(const MatrixType& m) VERIFY_IS_APPROX(MatrixType(chollo.matrixU().transpose().conjugate()), MatrixType(chollo.matrixL())); VERIFY_IS_APPROX(MatrixType(cholup.matrixL().transpose().conjugate()), MatrixType(cholup.matrixU())); VERIFY_IS_APPROX(MatrixType(cholup.matrixU().transpose().conjugate()), MatrixType(cholup.matrixL())); + + // test some special use cases of SelfCwiseBinaryOp: + MatrixType m1 = MatrixType::Random(rows,cols), m2(rows,cols); + m2 = m1; + m2 += symmLo.template selfadjointView().llt().solve(matB); + VERIFY_IS_APPROX(m2, m1 + symmLo.template selfadjointView().llt().solve(matB)); + m2 = m1; + m2 -= symmLo.template selfadjointView().llt().solve(matB); + VERIFY_IS_APPROX(m2, m1 - symmLo.template selfadjointView().llt().solve(matB)); + m2 = m1; + m2.noalias() += symmLo.template selfadjointView().llt().solve(matB); + VERIFY_IS_APPROX(m2, m1 + symmLo.template selfadjointView().llt().solve(matB)); + m2 = m1; + m2.noalias() -= symmLo.template selfadjointView().llt().solve(matB); + VERIFY_IS_APPROX(m2, m1 - symmLo.template selfadjointView().llt().solve(matB)); } // LDLT @@ -166,21 +181,6 @@ template void cholesky(const MatrixType& m) symm = -symm; } - // test some special use cases of SelfCwiseBinaryOp: - MatrixType m1 = MatrixType::Random(rows,cols), m2(rows,cols); - m2 = m1; - m2 += symmLo.template selfadjointView().llt().solve(matB); - VERIFY_IS_APPROX(m2, m1 + symmLo.template selfadjointView().llt().solve(matB)); - m2 = m1; - m2 -= symmLo.template selfadjointView().llt().solve(matB); - VERIFY_IS_APPROX(m2, m1 - symmLo.template selfadjointView().llt().solve(matB)); - m2 = m1; - m2.noalias() += symmLo.template selfadjointView().llt().solve(matB); - VERIFY_IS_APPROX(m2, m1 + symmLo.template selfadjointView().llt().solve(matB)); - m2 = m1; - m2.noalias() -= symmLo.template selfadjointView().llt().solve(matB); - VERIFY_IS_APPROX(m2, m1 - symmLo.template selfadjointView().llt().solve(matB)); - // update/downdate CALL_SUBTEST(( test_chol_update(symm) )); CALL_SUBTEST(( test_chol_update(symm) )); @@ -304,7 +304,8 @@ template void cholesky_verify_assert() void test_cholesky() { - int s; + int s = 0; + s = s; // shuts down ICC's remark #593: variable "s" was set but never used for(int i = 0; i < g_repeat; i++) { CALL_SUBTEST_1( cholesky(Matrix()) ); CALL_SUBTEST_3( cholesky(Matrix2d()) ); diff --git a/test/determinant.cpp b/test/determinant.cpp index edf83fda9..81ab4b084 100644 --- a/test/determinant.cpp +++ b/test/determinant.cpp @@ -53,8 +53,9 @@ template void determinant(const MatrixType& m) void test_determinant() { - int s; for(int i = 0; i < g_repeat; i++) { + int s = 0; + s = s; // shuts down ICC's remark #593: variable "s" was set but never used CALL_SUBTEST_1( determinant(Matrix()) ); CALL_SUBTEST_2( determinant(Matrix()) ); CALL_SUBTEST_3( determinant(Matrix()) ); @@ -62,6 +63,6 @@ void test_determinant() CALL_SUBTEST_5( determinant(Matrix, 10, 10>()) ); s = internal::random(1,EIGEN_TEST_MAX_SIZE/4); CALL_SUBTEST_6( determinant(MatrixXd(s, s)) ); + EIGEN_UNUSED_VARIABLE(s) } - EIGEN_UNUSED_VARIABLE(s) } diff --git a/test/eigensolver_complex.cpp b/test/eigensolver_complex.cpp index 817fbf2c2..9a52cfa5e 100644 --- a/test/eigensolver_complex.cpp +++ b/test/eigensolver_complex.cpp @@ -101,7 +101,8 @@ template void eigensolver_verify_assert(const MatrixType& m void test_eigensolver_complex() { - int s; + int s = 0; + s = s; // shuts down ICC's remark #593: variable "s" was set but never used for(int i = 0; i < g_repeat; i++) { CALL_SUBTEST_1( eigensolver(Matrix4cf()) ); s = internal::random(1,EIGEN_TEST_MAX_SIZE/4); @@ -109,7 +110,6 @@ void test_eigensolver_complex() CALL_SUBTEST_3( eigensolver(Matrix, 1, 1>()) ); CALL_SUBTEST_4( eigensolver(Matrix3f()) ); } - CALL_SUBTEST_1( eigensolver_verify_assert(Matrix4cf()) ); s = internal::random(1,EIGEN_TEST_MAX_SIZE/4); CALL_SUBTEST_2( eigensolver_verify_assert(MatrixXcd(s,s)) ); @@ -117,7 +117,7 @@ void test_eigensolver_complex() CALL_SUBTEST_4( eigensolver_verify_assert(Matrix3f()) ); // Test problem size constructors - CALL_SUBTEST_5(ComplexEigenSolver(s)); + CALL_SUBTEST_5(ComplexEigenSolver tmp(s)); EIGEN_UNUSED_VARIABLE(s) } diff --git a/test/eigensolver_generalized_real.cpp b/test/eigensolver_generalized_real.cpp index b8775871d..c4dc8a775 100644 --- a/test/eigensolver_generalized_real.cpp +++ b/test/eigensolver_generalized_real.cpp @@ -43,8 +43,9 @@ template void generalized_eigensolver_real(const MatrixType void test_eigensolver_generalized_real() { - int s; for(int i = 0; i < g_repeat; i++) { + int s = 0; + s = s; // shuts down ICC's remark #593: variable "s" was set but never used CALL_SUBTEST_1( generalized_eigensolver_real(Matrix4f()) ); s = internal::random(1,EIGEN_TEST_MAX_SIZE/4); CALL_SUBTEST_2( generalized_eigensolver_real(MatrixXd(s,s)) ); @@ -54,7 +55,6 @@ void test_eigensolver_generalized_real() CALL_SUBTEST_2( generalized_eigensolver_real(MatrixXd(2,2)) ); CALL_SUBTEST_3( generalized_eigensolver_real(Matrix()) ); CALL_SUBTEST_4( generalized_eigensolver_real(Matrix2d()) ); + EIGEN_UNUSED_VARIABLE(s) } - - EIGEN_UNUSED_VARIABLE(s) } diff --git a/test/eigensolver_generic.cpp b/test/eigensolver_generic.cpp index a8bbf9007..0e1e508ae 100644 --- a/test/eigensolver_generic.cpp +++ b/test/eigensolver_generic.cpp @@ -88,7 +88,8 @@ template void eigensolver_verify_assert(const MatrixType& m void test_eigensolver_generic() { - int s; + int s = 0; + s = s; // shuts down ICC's remark #593: variable "s" was set but never used for(int i = 0; i < g_repeat; i++) { CALL_SUBTEST_1( eigensolver(Matrix4f()) ); s = internal::random(1,EIGEN_TEST_MAX_SIZE/4); @@ -108,7 +109,7 @@ void test_eigensolver_generic() CALL_SUBTEST_4( eigensolver_verify_assert(Matrix2d()) ); // Test problem size constructors - CALL_SUBTEST_5(EigenSolver(s)); + CALL_SUBTEST_5(EigenSolver tmp(s)); // regression test for bug 410 CALL_SUBTEST_2( diff --git a/test/eigensolver_selfadjoint.cpp b/test/eigensolver_selfadjoint.cpp index 55b7eea8d..67d4c543b 100644 --- a/test/eigensolver_selfadjoint.cpp +++ b/test/eigensolver_selfadjoint.cpp @@ -110,7 +110,8 @@ template void selfadjointeigensolver(const MatrixType& m) void test_eigensolver_selfadjoint() { - int s; + int s = 0; + s = s; // shuts down ICC's remark #593: variable "s" was set but never used for(int i = 0; i < g_repeat; i++) { // very important to test 3x3 and 2x2 matrices since we provide special paths for them CALL_SUBTEST_1( selfadjointeigensolver(Matrix2d()) ); @@ -135,8 +136,8 @@ void test_eigensolver_selfadjoint() // Test problem size constructors s = internal::random(1,EIGEN_TEST_MAX_SIZE/4); - CALL_SUBTEST_8(SelfAdjointEigenSolver(s)); - CALL_SUBTEST_8(Tridiagonalization(s)); + CALL_SUBTEST_8(SelfAdjointEigenSolver tmp1(s)); + CALL_SUBTEST_8(Tridiagonalization tmp2(s)); EIGEN_UNUSED_VARIABLE(s) } diff --git a/test/evaluators.cpp b/test/evaluators.cpp index 3081d7858..e3922c1be 100644 --- a/test/evaluators.cpp +++ b/test/evaluators.cpp @@ -29,25 +29,27 @@ void test_evaluators() VERIFY_IS_APPROX(w,v_const.transpose().eval()); // Testing Array evaluator - ArrayXXf a(2,3); - ArrayXXf b(3,2); - a << 1,2,3, 4,5,6; - const ArrayXXf a_const(a); + { + ArrayXXf a(2,3); + ArrayXXf b(3,2); + a << 1,2,3, 4,5,6; + const ArrayXXf a_const(a); - VERIFY_IS_APPROX_EVALUATOR(b, a.transpose()); + VERIFY_IS_APPROX_EVALUATOR(b, a.transpose()); - VERIFY_IS_APPROX_EVALUATOR(b, a_const.transpose()); + VERIFY_IS_APPROX_EVALUATOR(b, a_const.transpose()); - // Testing CwiseNullaryOp evaluator - copy_using_evaluator(w, RowVector2d::Random()); - VERIFY((w.array() >= -1).all() && (w.array() <= 1).all()); // not easy to test ... + // Testing CwiseNullaryOp evaluator + copy_using_evaluator(w, RowVector2d::Random()); + VERIFY((w.array() >= -1).all() && (w.array() <= 1).all()); // not easy to test ... - VERIFY_IS_APPROX_EVALUATOR(w, RowVector2d::Zero()); + VERIFY_IS_APPROX_EVALUATOR(w, RowVector2d::Zero()); - VERIFY_IS_APPROX_EVALUATOR(w, RowVector2d::Constant(3)); - - // mix CwiseNullaryOp and transpose - VERIFY_IS_APPROX_EVALUATOR(w, Vector2d::Zero().transpose()); + VERIFY_IS_APPROX_EVALUATOR(w, RowVector2d::Constant(3)); + + // mix CwiseNullaryOp and transpose + VERIFY_IS_APPROX_EVALUATOR(w, Vector2d::Zero().transpose()); + } { // test product expressions @@ -114,164 +116,171 @@ void test_evaluators() VERIFY_IS_APPROX_EVALUATOR2(resXX, prod(mXX,mXX), mXX*mXX); } - // this does not work because Random is eval-before-nested: - // copy_using_evaluator(w, Vector2d::Random().transpose()); - - // test CwiseUnaryOp - VERIFY_IS_APPROX_EVALUATOR(v2, 3 * v); - VERIFY_IS_APPROX_EVALUATOR(w, (3 * v).transpose()); - VERIFY_IS_APPROX_EVALUATOR(b, (a + 3).transpose()); - VERIFY_IS_APPROX_EVALUATOR(b, (2 * a_const + 3).transpose()); + { + ArrayXXf a(2,3); + ArrayXXf b(3,2); + a << 1,2,3, 4,5,6; + const ArrayXXf a_const(a); + + // this does not work because Random is eval-before-nested: + // copy_using_evaluator(w, Vector2d::Random().transpose()); + + // test CwiseUnaryOp + VERIFY_IS_APPROX_EVALUATOR(v2, 3 * v); + VERIFY_IS_APPROX_EVALUATOR(w, (3 * v).transpose()); + VERIFY_IS_APPROX_EVALUATOR(b, (a + 3).transpose()); + VERIFY_IS_APPROX_EVALUATOR(b, (2 * a_const + 3).transpose()); - // test CwiseBinaryOp - VERIFY_IS_APPROX_EVALUATOR(v2, v + Vector2d::Ones()); - VERIFY_IS_APPROX_EVALUATOR(w, (v + Vector2d::Ones()).transpose().cwiseProduct(RowVector2d::Constant(3))); + // test CwiseBinaryOp + VERIFY_IS_APPROX_EVALUATOR(v2, v + Vector2d::Ones()); + VERIFY_IS_APPROX_EVALUATOR(w, (v + Vector2d::Ones()).transpose().cwiseProduct(RowVector2d::Constant(3))); - // dynamic matrices and arrays - MatrixXd mat1(6,6), mat2(6,6); - VERIFY_IS_APPROX_EVALUATOR(mat1, MatrixXd::Identity(6,6)); - VERIFY_IS_APPROX_EVALUATOR(mat2, mat1); - copy_using_evaluator(mat2.transpose(), mat1); - VERIFY_IS_APPROX(mat2.transpose(), mat1); + // dynamic matrices and arrays + MatrixXd mat1(6,6), mat2(6,6); + VERIFY_IS_APPROX_EVALUATOR(mat1, MatrixXd::Identity(6,6)); + VERIFY_IS_APPROX_EVALUATOR(mat2, mat1); + copy_using_evaluator(mat2.transpose(), mat1); + VERIFY_IS_APPROX(mat2.transpose(), mat1); - ArrayXXd arr1(6,6), arr2(6,6); - VERIFY_IS_APPROX_EVALUATOR(arr1, ArrayXXd::Constant(6,6, 3.0)); - VERIFY_IS_APPROX_EVALUATOR(arr2, arr1); - - // test automatic resizing - mat2.resize(3,3); - VERIFY_IS_APPROX_EVALUATOR(mat2, mat1); - arr2.resize(9,9); - VERIFY_IS_APPROX_EVALUATOR(arr2, arr1); + ArrayXXd arr1(6,6), arr2(6,6); + VERIFY_IS_APPROX_EVALUATOR(arr1, ArrayXXd::Constant(6,6, 3.0)); + VERIFY_IS_APPROX_EVALUATOR(arr2, arr1); + + // test automatic resizing + mat2.resize(3,3); + VERIFY_IS_APPROX_EVALUATOR(mat2, mat1); + arr2.resize(9,9); + VERIFY_IS_APPROX_EVALUATOR(arr2, arr1); - // test direct traversal - Matrix3f m3; - Array33f a3; - VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Identity()); // matrix, nullary - // TODO: find a way to test direct traversal with array - VERIFY_IS_APPROX_EVALUATOR(m3.transpose(), Matrix3f::Identity().transpose()); // transpose - VERIFY_IS_APPROX_EVALUATOR(m3, 2 * Matrix3f::Identity()); // unary - VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Identity() + Matrix3f::Zero()); // binary - VERIFY_IS_APPROX_EVALUATOR(m3.block(0,0,2,2), Matrix3f::Identity().block(1,1,2,2)); // block + // test direct traversal + Matrix3f m3; + Array33f a3; + VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Identity()); // matrix, nullary + // TODO: find a way to test direct traversal with array + VERIFY_IS_APPROX_EVALUATOR(m3.transpose(), Matrix3f::Identity().transpose()); // transpose + VERIFY_IS_APPROX_EVALUATOR(m3, 2 * Matrix3f::Identity()); // unary + VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Identity() + Matrix3f::Zero()); // binary + VERIFY_IS_APPROX_EVALUATOR(m3.block(0,0,2,2), Matrix3f::Identity().block(1,1,2,2)); // block - // test linear traversal - VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Zero()); // matrix, nullary - VERIFY_IS_APPROX_EVALUATOR(a3, Array33f::Zero()); // array - VERIFY_IS_APPROX_EVALUATOR(m3.transpose(), Matrix3f::Zero().transpose()); // transpose - VERIFY_IS_APPROX_EVALUATOR(m3, 2 * Matrix3f::Zero()); // unary - VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Zero() + m3); // binary + // test linear traversal + VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Zero()); // matrix, nullary + VERIFY_IS_APPROX_EVALUATOR(a3, Array33f::Zero()); // array + VERIFY_IS_APPROX_EVALUATOR(m3.transpose(), Matrix3f::Zero().transpose()); // transpose + VERIFY_IS_APPROX_EVALUATOR(m3, 2 * Matrix3f::Zero()); // unary + VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Zero() + m3); // binary - // test inner vectorization - Matrix4f m4, m4src = Matrix4f::Random(); - Array44f a4, a4src = Matrix4f::Random(); - VERIFY_IS_APPROX_EVALUATOR(m4, m4src); // matrix - VERIFY_IS_APPROX_EVALUATOR(a4, a4src); // array - VERIFY_IS_APPROX_EVALUATOR(m4.transpose(), m4src.transpose()); // transpose - // TODO: find out why Matrix4f::Zero() does not allow inner vectorization - VERIFY_IS_APPROX_EVALUATOR(m4, 2 * m4src); // unary - VERIFY_IS_APPROX_EVALUATOR(m4, m4src + m4src); // binary + // test inner vectorization + Matrix4f m4, m4src = Matrix4f::Random(); + Array44f a4, a4src = Matrix4f::Random(); + VERIFY_IS_APPROX_EVALUATOR(m4, m4src); // matrix + VERIFY_IS_APPROX_EVALUATOR(a4, a4src); // array + VERIFY_IS_APPROX_EVALUATOR(m4.transpose(), m4src.transpose()); // transpose + // TODO: find out why Matrix4f::Zero() does not allow inner vectorization + VERIFY_IS_APPROX_EVALUATOR(m4, 2 * m4src); // unary + VERIFY_IS_APPROX_EVALUATOR(m4, m4src + m4src); // binary - // test linear vectorization - MatrixXf mX(6,6), mXsrc = MatrixXf::Random(6,6); - ArrayXXf aX(6,6), aXsrc = ArrayXXf::Random(6,6); - VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc); // matrix - VERIFY_IS_APPROX_EVALUATOR(aX, aXsrc); // array - VERIFY_IS_APPROX_EVALUATOR(mX.transpose(), mXsrc.transpose()); // transpose - VERIFY_IS_APPROX_EVALUATOR(mX, MatrixXf::Zero(6,6)); // nullary - VERIFY_IS_APPROX_EVALUATOR(mX, 2 * mXsrc); // unary - VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc + mXsrc); // binary + // test linear vectorization + MatrixXf mX(6,6), mXsrc = MatrixXf::Random(6,6); + ArrayXXf aX(6,6), aXsrc = ArrayXXf::Random(6,6); + VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc); // matrix + VERIFY_IS_APPROX_EVALUATOR(aX, aXsrc); // array + VERIFY_IS_APPROX_EVALUATOR(mX.transpose(), mXsrc.transpose()); // transpose + VERIFY_IS_APPROX_EVALUATOR(mX, MatrixXf::Zero(6,6)); // nullary + VERIFY_IS_APPROX_EVALUATOR(mX, 2 * mXsrc); // unary + VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc + mXsrc); // binary - // test blocks and slice vectorization - VERIFY_IS_APPROX_EVALUATOR(m4, (mXsrc.block<4,4>(1,0))); - VERIFY_IS_APPROX_EVALUATOR(aX, ArrayXXf::Constant(10, 10, 3.0).block(2, 3, 6, 6)); + // test blocks and slice vectorization + VERIFY_IS_APPROX_EVALUATOR(m4, (mXsrc.block<4,4>(1,0))); + VERIFY_IS_APPROX_EVALUATOR(aX, ArrayXXf::Constant(10, 10, 3.0).block(2, 3, 6, 6)); - Matrix4f m4ref = m4; - copy_using_evaluator(m4.block(1, 1, 2, 3), m3.bottomRows(2)); - m4ref.block(1, 1, 2, 3) = m3.bottomRows(2); - VERIFY_IS_APPROX(m4, m4ref); + Matrix4f m4ref = m4; + copy_using_evaluator(m4.block(1, 1, 2, 3), m3.bottomRows(2)); + m4ref.block(1, 1, 2, 3) = m3.bottomRows(2); + VERIFY_IS_APPROX(m4, m4ref); - mX.setIdentity(20,20); - MatrixXf mXref = MatrixXf::Identity(20,20); - mXsrc = MatrixXf::Random(9,12); - copy_using_evaluator(mX.block(4, 4, 9, 12), mXsrc); - mXref.block(4, 4, 9, 12) = mXsrc; - VERIFY_IS_APPROX(mX, mXref); + mX.setIdentity(20,20); + MatrixXf mXref = MatrixXf::Identity(20,20); + mXsrc = MatrixXf::Random(9,12); + copy_using_evaluator(mX.block(4, 4, 9, 12), mXsrc); + mXref.block(4, 4, 9, 12) = mXsrc; + VERIFY_IS_APPROX(mX, mXref); - // test Map - const float raw[3] = {1,2,3}; - float buffer[3] = {0,0,0}; - Vector3f v3; - Array3f a3f; - VERIFY_IS_APPROX_EVALUATOR(v3, Map(raw)); - VERIFY_IS_APPROX_EVALUATOR(a3f, Map(raw)); - Vector3f::Map(buffer) = 2*v3; - VERIFY(buffer[0] == 2); - VERIFY(buffer[1] == 4); - VERIFY(buffer[2] == 6); + // test Map + const float raw[3] = {1,2,3}; + float buffer[3] = {0,0,0}; + Vector3f v3; + Array3f a3f; + VERIFY_IS_APPROX_EVALUATOR(v3, Map(raw)); + VERIFY_IS_APPROX_EVALUATOR(a3f, Map(raw)); + Vector3f::Map(buffer) = 2*v3; + VERIFY(buffer[0] == 2); + VERIFY(buffer[1] == 4); + VERIFY(buffer[2] == 6); - // test CwiseUnaryView - mat1.setRandom(); - mat2.setIdentity(); - MatrixXcd matXcd(6,6), matXcd_ref(6,6); - copy_using_evaluator(matXcd.real(), mat1); - copy_using_evaluator(matXcd.imag(), mat2); - matXcd_ref.real() = mat1; - matXcd_ref.imag() = mat2; - VERIFY_IS_APPROX(matXcd, matXcd_ref); + // test CwiseUnaryView + mat1.setRandom(); + mat2.setIdentity(); + MatrixXcd matXcd(6,6), matXcd_ref(6,6); + copy_using_evaluator(matXcd.real(), mat1); + copy_using_evaluator(matXcd.imag(), mat2); + matXcd_ref.real() = mat1; + matXcd_ref.imag() = mat2; + VERIFY_IS_APPROX(matXcd, matXcd_ref); - // test Select - VERIFY_IS_APPROX_EVALUATOR(aX, (aXsrc > 0).select(aXsrc, -aXsrc)); + // test Select + VERIFY_IS_APPROX_EVALUATOR(aX, (aXsrc > 0).select(aXsrc, -aXsrc)); - // test Replicate - mXsrc = MatrixXf::Random(6, 6); - VectorXf vX = VectorXf::Random(6); - mX.resize(6, 6); - VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc.colwise() + vX); - matXcd.resize(12, 12); - VERIFY_IS_APPROX_EVALUATOR(matXcd, matXcd_ref.replicate(2,2)); - VERIFY_IS_APPROX_EVALUATOR(matXcd, (matXcd_ref.replicate<2,2>())); + // test Replicate + mXsrc = MatrixXf::Random(6, 6); + VectorXf vX = VectorXf::Random(6); + mX.resize(6, 6); + VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc.colwise() + vX); + matXcd.resize(12, 12); + VERIFY_IS_APPROX_EVALUATOR(matXcd, matXcd_ref.replicate(2,2)); + VERIFY_IS_APPROX_EVALUATOR(matXcd, (matXcd_ref.replicate<2,2>())); - // test partial reductions - VectorXd vec1(6); - VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.rowwise().sum()); - VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.colwise().sum().transpose()); + // test partial reductions + VectorXd vec1(6); + VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.rowwise().sum()); + VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.colwise().sum().transpose()); - // test MatrixWrapper and ArrayWrapper - mat1.setRandom(6,6); - arr1.setRandom(6,6); - VERIFY_IS_APPROX_EVALUATOR(mat2, arr1.matrix()); - VERIFY_IS_APPROX_EVALUATOR(arr2, mat1.array()); - VERIFY_IS_APPROX_EVALUATOR(mat2, (arr1 + 2).matrix()); - VERIFY_IS_APPROX_EVALUATOR(arr2, mat1.array() + 2); - mat2.array() = arr1 * arr1; - VERIFY_IS_APPROX(mat2, (arr1 * arr1).matrix()); - arr2.matrix() = MatrixXd::Identity(6,6); - VERIFY_IS_APPROX(arr2, MatrixXd::Identity(6,6).array()); + // test MatrixWrapper and ArrayWrapper + mat1.setRandom(6,6); + arr1.setRandom(6,6); + VERIFY_IS_APPROX_EVALUATOR(mat2, arr1.matrix()); + VERIFY_IS_APPROX_EVALUATOR(arr2, mat1.array()); + VERIFY_IS_APPROX_EVALUATOR(mat2, (arr1 + 2).matrix()); + VERIFY_IS_APPROX_EVALUATOR(arr2, mat1.array() + 2); + mat2.array() = arr1 * arr1; + VERIFY_IS_APPROX(mat2, (arr1 * arr1).matrix()); + arr2.matrix() = MatrixXd::Identity(6,6); + VERIFY_IS_APPROX(arr2, MatrixXd::Identity(6,6).array()); - // test Reverse - VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.reverse()); - VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.colwise().reverse()); - VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.rowwise().reverse()); - arr2.reverse() = arr1; - VERIFY_IS_APPROX(arr2, arr1.reverse()); - mat2.array() = mat1.array().reverse(); - VERIFY_IS_APPROX(mat2.array(), mat1.array().reverse()); + // test Reverse + VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.reverse()); + VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.colwise().reverse()); + VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.rowwise().reverse()); + arr2.reverse() = arr1; + VERIFY_IS_APPROX(arr2, arr1.reverse()); + mat2.array() = mat1.array().reverse(); + VERIFY_IS_APPROX(mat2.array(), mat1.array().reverse()); - // test Diagonal - VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal()); - vec1.resize(5); - VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal(1)); - VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal<-1>()); - vec1.setRandom(); + // test Diagonal + VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal()); + vec1.resize(5); + VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal(1)); + VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal<-1>()); + vec1.setRandom(); - mat2 = mat1; - copy_using_evaluator(mat1.diagonal(1), vec1); - mat2.diagonal(1) = vec1; - VERIFY_IS_APPROX(mat1, mat2); + mat2 = mat1; + copy_using_evaluator(mat1.diagonal(1), vec1); + mat2.diagonal(1) = vec1; + VERIFY_IS_APPROX(mat1, mat2); - copy_using_evaluator(mat1.diagonal<-1>(), mat1.diagonal(1)); - mat2.diagonal<-1>() = mat2.diagonal(1); - VERIFY_IS_APPROX(mat1, mat2); + copy_using_evaluator(mat1.diagonal<-1>(), mat1.diagonal(1)); + mat2.diagonal<-1>() = mat2.diagonal(1); + VERIFY_IS_APPROX(mat1, mat2); + } { // test swapping diff --git a/test/inverse.cpp b/test/inverse.cpp index 8978a1877..8dd35f6ac 100644 --- a/test/inverse.cpp +++ b/test/inverse.cpp @@ -86,14 +86,15 @@ template void inverse(const MatrixType& m) void test_inverse() { - int s; + int s = 0; + s = s; // ICC shuts down ICC's remark #593: variable "s" was set but never used for(int i = 0; i < g_repeat; i++) { CALL_SUBTEST_1( inverse(Matrix()) ); CALL_SUBTEST_2( inverse(Matrix2d()) ); CALL_SUBTEST_3( inverse(Matrix3f()) ); CALL_SUBTEST_4( inverse(Matrix4f()) ); CALL_SUBTEST_4( inverse(Matrix()) ); - s = internal::random(50,320); + s = internal::random(50,320); CALL_SUBTEST_5( inverse(MatrixXf(s,s)) ); s = internal::random(25,100); CALL_SUBTEST_6( inverse(MatrixXcd(s,s)) ); diff --git a/test/jacobisvd.cpp b/test/jacobisvd.cpp index 26da05037..8fda8d261 100644 --- a/test/jacobisvd.cpp +++ b/test/jacobisvd.cpp @@ -96,6 +96,10 @@ void jacobisvd_test_all_computation_options(const MatrixType& m) jacobisvd_check_full(m, fullSvd); jacobisvd_solve(m, ComputeFullU | ComputeFullV); + #if defined __INTEL_COMPILER + // remark #111: statement is unreachable + #pragma warning disable 111 + #endif if(QRPreconditioner == FullPivHouseholderQRPreconditioner) return; @@ -257,7 +261,7 @@ void jacobisvd_preallocate() MatrixXf m = v.asDiagonal(); internal::set_is_malloc_allowed(false); - VERIFY_RAISES_ASSERT(VectorXf v(10);) + VERIFY_RAISES_ASSERT(VectorXf tmp(10);) JacobiSVD svd; internal::set_is_malloc_allowed(true); svd.compute(m); @@ -320,6 +324,8 @@ void test_jacobisvd() int r = internal::random(1, 30), c = internal::random(1, 30); + r = r; // shuts down ICC's remark #593: variable "s" was set but never used + c = c; CALL_SUBTEST_7(( jacobisvd(MatrixXf(r,c)) )); CALL_SUBTEST_8(( jacobisvd(MatrixXcd(r,c)) )); (void) r; diff --git a/test/main.h b/test/main.h index 93163c3cb..1094b6b36 100644 --- a/test/main.h +++ b/test/main.h @@ -49,11 +49,6 @@ #define DEFAULT_REPEAT 10 -#ifdef __ICC -// disable warning #279: controlling expression is constant -#pragma warning disable 279 -#endif - namespace Eigen { static std::vector g_test_stack; @@ -170,7 +165,7 @@ namespace Eigen #define EIGEN_INTERNAL_DEBUGGING #include // required for createRandomPIMatrixOfRank -static inline void verify_impl(bool condition, const char *testname, const char *file, int line, const char *condition_as_string) +inline void verify_impl(bool condition, const char *testname, const char *file, int line, const char *condition_as_string) { if (!condition) { @@ -297,7 +292,7 @@ inline bool test_isUnitary(const MatrixBase& m) } template -static bool test_is_equal(const T& actual, const U& expected) +inline bool test_is_equal(const T& actual, const U& expected) { if (actual==expected) return true; @@ -313,8 +308,11 @@ static bool test_is_equal(const T& actual, const U& expected) * A partial isometry is a matrix all of whose singular values are either 0 or 1. * This is very useful to test rank-revealing algorithms. */ +// Forward declaration to avoid ICC warning template -static void createRandomPIMatrixOfRank(typename MatrixType::Index desired_rank, typename MatrixType::Index rows, typename MatrixType::Index cols, MatrixType& m) +void createRandomPIMatrixOfRank(typename MatrixType::Index desired_rank, typename MatrixType::Index rows, typename MatrixType::Index cols, MatrixType& m); +template +void createRandomPIMatrixOfRank(typename MatrixType::Index desired_rank, typename MatrixType::Index rows, typename MatrixType::Index cols, MatrixType& m) { typedef typename internal::traits::Index Index; typedef typename internal::traits::Scalar Scalar; @@ -351,8 +349,11 @@ static void createRandomPIMatrixOfRank(typename MatrixType::Index desired_rank, m = qra.householderQ() * d * qrb.householderQ(); } +// Forward declaration to avoid ICC warning template -static void randomPermutationVector(PermutationVectorType& v, typename PermutationVectorType::Index size) +void randomPermutationVector(PermutationVectorType& v, typename PermutationVectorType::Index size); +template +void randomPermutationVector(PermutationVectorType& v, typename PermutationVectorType::Index size) { typedef typename PermutationVectorType::Index Index; typedef typename PermutationVectorType::Scalar Scalar; @@ -392,7 +393,7 @@ void EIGEN_CAT(test_,EIGEN_TEST_FUNC)(); using namespace Eigen; -static void set_repeat_from_string(const char *str) +inline void set_repeat_from_string(const char *str) { errno = 0; g_repeat = int(strtoul(str, 0, 10)); @@ -404,7 +405,7 @@ static void set_repeat_from_string(const char *str) g_has_set_repeat = true; } -static void set_seed_from_string(const char *str) +inline void set_seed_from_string(const char *str) { errno = 0; g_seed = int(strtoul(str, 0, 10)); @@ -488,5 +489,7 @@ int main(int argc, char *argv[]) // -> this warning is raised even for legal usage as: g_test_stack.push_back("foo"); where g_test_stack is a std::vector // remark #1418: external function definition with no prior declaration // -> this warning is raised for all our test functions. Declaring them static would fix the issue. - #pragma warning disable 383 1418 + // warning #279: controlling expression is constant + // remark #1572: floating-point equality and inequality comparisons are unreliable + #pragma warning disable 279 383 1418 1572 #endif diff --git a/test/product_notemporary.cpp b/test/product_notemporary.cpp index a30a8b4c7..258d238e2 100644 --- a/test/product_notemporary.cpp +++ b/test/product_notemporary.cpp @@ -9,7 +9,7 @@ static int nb_temporaries; -void on_temporary_creation(int size) { +inline void on_temporary_creation(int size) { // here's a great place to set a breakpoint when debugging failures in this test! if(size!=0) nb_temporaries++; } diff --git a/test/product_selfadjoint.cpp b/test/product_selfadjoint.cpp index 58e2ea90d..e3e2b2cf1 100644 --- a/test/product_selfadjoint.cpp +++ b/test/product_selfadjoint.cpp @@ -62,7 +62,8 @@ template void product_selfadjoint(const MatrixType& m) void test_product_selfadjoint() { - int s; + int s = 0; + s = s; // shuts down ICC's remark #593: variable "s" was set but never used for(int i = 0; i < g_repeat ; i++) { CALL_SUBTEST_1( product_selfadjoint(Matrix()) ); CALL_SUBTEST_2( product_selfadjoint(Matrix()) ); diff --git a/test/product_trmv.cpp b/test/product_trmv.cpp index 435018e8e..50a414b29 100644 --- a/test/product_trmv.cpp +++ b/test/product_trmv.cpp @@ -73,7 +73,8 @@ template void trmv(const MatrixType& m) void test_product_trmv() { - int s; + int s = 0; + s = s; // shuts down ICC's remark #593: variable "s" was set but never used for(int i = 0; i < g_repeat ; i++) { CALL_SUBTEST_1( trmv(Matrix()) ); CALL_SUBTEST_2( trmv(Matrix()) ); diff --git a/test/real_qz.cpp b/test/real_qz.cpp index b48bac361..ed11e17f3 100644 --- a/test/real_qz.cpp +++ b/test/real_qz.cpp @@ -48,7 +48,8 @@ template void real_qz(const MatrixType& m) void test_real_qz() { - int s; + int s = 0; + s = s; // shuts down ICC's remark #593: variable "s" was set but never used for(int i = 0; i < g_repeat; i++) { CALL_SUBTEST_1( real_qz(Matrix4f()) ); s = internal::random(1,EIGEN_TEST_MAX_SIZE/4); diff --git a/test/redux.cpp b/test/redux.cpp index bf68d2212..26082527e 100644 --- a/test/redux.cpp +++ b/test/redux.cpp @@ -133,6 +133,7 @@ void test_redux() { // the max size cannot be too large, otherwise reduxion operations obviously generate large errors. int maxsize = (std::min)(100,EIGEN_TEST_MAX_SIZE); + maxsize = maxsize; // shuts down ICC's remark #593: variable "s" was set but never used EIGEN_UNUSED_VARIABLE(maxsize); for(int i = 0; i < g_repeat; i++) { CALL_SUBTEST_1( matrixRedux(Matrix()) ); diff --git a/test/ref.cpp b/test/ref.cpp index 7c0ccafcf..65b4f5a3e 100644 --- a/test/ref.cpp +++ b/test/ref.cpp @@ -14,7 +14,7 @@ static int nb_temporaries; -void on_temporary_creation(int size) { +inline void on_temporary_creation(int size) { // here's a great place to set a breakpoint when debugging failures in this test! if(size!=0) nb_temporaries++; } diff --git a/test/selfadjoint.cpp b/test/selfadjoint.cpp index 32791eeb5..ab8eb8173 100644 --- a/test/selfadjoint.cpp +++ b/test/selfadjoint.cpp @@ -46,7 +46,8 @@ void test_selfadjoint() { for(int i = 0; i < g_repeat ; i++) { - int s = internal::random(1,EIGEN_TEST_MAX_SIZE); EIGEN_UNUSED_VARIABLE(s); + int s = internal::random(1,EIGEN_TEST_MAX_SIZE); + s = s; // shuts down ICC's remark #593: variable "s" was set but never used CALL_SUBTEST_1( selfadjoint(Matrix()) ); CALL_SUBTEST_2( selfadjoint(Matrix()) ); diff --git a/test/sparse_basic.cpp b/test/sparse_basic.cpp index e300f2537..6954ba7f9 100644 --- a/test/sparse_basic.cpp +++ b/test/sparse_basic.cpp @@ -25,71 +25,73 @@ template void sparse_basic(const SparseMatrixType& re typedef Matrix DenseVector; Scalar eps = 1e-6; - SparseMatrixType m(rows, cols); - DenseMatrix refMat = DenseMatrix::Zero(rows, cols); - DenseVector vec1 = DenseVector::Random(rows); Scalar s1 = internal::random(); - - std::vector zeroCoords; - std::vector nonzeroCoords; - initSparse(density, refMat, m, 0, &zeroCoords, &nonzeroCoords); - - if (zeroCoords.size()==0 || nonzeroCoords.size()==0) - return; - - // test coeff and coeffRef - for (int i=0; i<(int)zeroCoords.size(); ++i) { - VERIFY_IS_MUCH_SMALLER_THAN( m.coeff(zeroCoords[i].x(),zeroCoords[i].y()), eps ); - if(internal::is_same >::value) - VERIFY_RAISES_ASSERT( m.coeffRef(zeroCoords[0].x(),zeroCoords[0].y()) = 5 ); - } - VERIFY_IS_APPROX(m, refMat); + SparseMatrixType m(rows, cols); + DenseMatrix refMat = DenseMatrix::Zero(rows, cols); + DenseVector vec1 = DenseVector::Random(rows); - m.coeffRef(nonzeroCoords[0].x(), nonzeroCoords[0].y()) = Scalar(5); - refMat.coeffRef(nonzeroCoords[0].x(), nonzeroCoords[0].y()) = Scalar(5); + std::vector zeroCoords; + std::vector nonzeroCoords; + initSparse(density, refMat, m, 0, &zeroCoords, &nonzeroCoords); - VERIFY_IS_APPROX(m, refMat); - /* - // test InnerIterators and Block expressions - for (int t=0; t<10; ++t) - { - int j = internal::random(0,cols-1); - int i = internal::random(0,rows-1); - int w = internal::random(1,cols-j-1); - int h = internal::random(1,rows-i-1); + if (zeroCoords.size()==0 || nonzeroCoords.size()==0) + return; -// VERIFY_IS_APPROX(m.block(i,j,h,w), refMat.block(i,j,h,w)); - for(int c=0; c >::value) + VERIFY_RAISES_ASSERT( m.coeffRef(zeroCoords[0].x(),zeroCoords[0].y()) = 5 ); } -// for(int r=0; r(0,cols-1); + int i = internal::random(0,rows-1); + int w = internal::random(1,cols-j-1); + int h = internal::random(1,rows-i-1); + + // VERIFY_IS_APPROX(m.block(i,j,h,w), refMat.block(i,j,h,w)); + for(int c=0; c())); - x.setZero(); - // test the analyze/factorize API - solver.analyzePattern(A); - solver.factorize(A); - if (solver.info() != Success) - { - std::cerr << "sparse solver testing: factorization failed (check_sparse_solving)\n"; - exit(0); - return; - } - x = solver.solve(b); - if (solver.info() != Success) - { - std::cerr << "sparse solver testing: solving failed\n"; - return; - } - VERIFY(oldb.isApprox(b) && "sparse solver testing: the rhs should not be modified!"); + solver.compute(A); + if (solver.info() != Success) + { + std::cerr << "sparse solver testing: factorization failed (check_sparse_solving)\n"; + exit(0); + return; + } + x = solver.solve(b); + if (solver.info() != Success) + { + std::cerr << "sparse solver testing: solving failed\n"; + return; + } + VERIFY(oldb.isApprox(b) && "sparse solver testing: the rhs should not be modified!"); - VERIFY(x.isApprox(refX,test_precision())); + VERIFY(x.isApprox(refX,test_precision())); + x.setZero(); + // test the analyze/factorize API + solver.analyzePattern(A); + solver.factorize(A); + if (solver.info() != Success) + { + std::cerr << "sparse solver testing: factorization failed (check_sparse_solving)\n"; + exit(0); + return; + } + x = solver.solve(b); + if (solver.info() != Success) + { + std::cerr << "sparse solver testing: solving failed\n"; + return; + } + VERIFY(oldb.isApprox(b) && "sparse solver testing: the rhs should not be modified!"); + + VERIFY(x.isApprox(refX,test_precision())); + } - // test Block as the result and rhs: + // test dense Block as the result and rhs: { DenseRhs x(db.rows(), db.cols()); - DenseRhs b(db), oldb(db); + DenseRhs oldb(db); x.setZero(); - x.block(0,0,x.rows(),x.cols()) = solver.solve(b.block(0,0,b.rows(),b.cols())); - VERIFY(oldb.isApprox(b) && "sparse solver testing: the rhs should not be modified!"); + x.block(0,0,x.rows(),x.cols()) = solver.solve(db.block(0,0,db.rows(),db.cols())); + VERIFY(oldb.isApprox(db) && "sparse solver testing: the rhs should not be modified!"); VERIFY(x.isApprox(refX,test_precision())); } } diff --git a/test/triangular.cpp b/test/triangular.cpp index a2a7a1475..78b2c31f7 100644 --- a/test/triangular.cpp +++ b/test/triangular.cpp @@ -211,8 +211,8 @@ void test_triangular() int maxsize = (std::min)(EIGEN_TEST_MAX_SIZE,20); for(int i = 0; i < g_repeat ; i++) { - int r = internal::random(2,maxsize); EIGEN_UNUSED_VARIABLE(r); - int c = internal::random(2,maxsize); EIGEN_UNUSED_VARIABLE(c); + int r = internal::random(2,maxsize); r=r; // shuts down ICC's remark #593: variable "s" was set but never used + int c = internal::random(2,maxsize); c=c; CALL_SUBTEST_1( triangular_square(Matrix()) ); CALL_SUBTEST_2( triangular_square(Matrix()) );