mirror of
https://gitlab.com/libeigen/eigen.git
synced 2025-03-31 19:00:35 +08:00
Remove usage of #if EIGEN_TEST_PART_XX in unit tests that does not require them (splitting can thus be avoided for them)
This commit is contained in:
Gael Guennebaud
parent
82f0ce2726
commit
dff3a92d52
@ -145,6 +145,34 @@ template<typename MatrixType> void adjoint(const MatrixType& m)
|
||||
VERIFY_IS_APPROX(rv1.template cast<Scalar>().dot(v1), rv1.dot(v1));
|
||||
}
|
||||
|
||||
template<int>
|
||||
void adjoint_extra()
|
||||
{
|
||||
MatrixXcf a(10,10), b(10,10);
|
||||
VERIFY_RAISES_ASSERT(a = a.transpose());
|
||||
VERIFY_RAISES_ASSERT(a = a.transpose() + b);
|
||||
VERIFY_RAISES_ASSERT(a = b + a.transpose());
|
||||
VERIFY_RAISES_ASSERT(a = a.conjugate().transpose());
|
||||
VERIFY_RAISES_ASSERT(a = a.adjoint());
|
||||
VERIFY_RAISES_ASSERT(a = a.adjoint() + b);
|
||||
VERIFY_RAISES_ASSERT(a = b + a.adjoint());
|
||||
|
||||
// no assertion should be triggered for these cases:
|
||||
a.transpose() = a.transpose();
|
||||
a.transpose() += a.transpose();
|
||||
a.transpose() += a.transpose() + b;
|
||||
a.transpose() = a.adjoint();
|
||||
a.transpose() += a.adjoint();
|
||||
a.transpose() += a.adjoint() + b;
|
||||
|
||||
// regression tests for check_for_aliasing
|
||||
MatrixXd c(10,10);
|
||||
c = 1.0 * MatrixXd::Ones(10,10) + c;
|
||||
c = MatrixXd::Ones(10,10) * 1.0 + c;
|
||||
c = c + MatrixXd::Ones(10,10) .cwiseProduct( MatrixXd::Zero(10,10) );
|
||||
c = MatrixXd::Ones(10,10) * MatrixXd::Zero(10,10);
|
||||
}
|
||||
|
||||
EIGEN_DECLARE_TEST(adjoint)
|
||||
{
|
||||
for(int i = 0; i < g_repeat; i++) {
|
||||
@ -168,32 +196,6 @@ EIGEN_DECLARE_TEST(adjoint)
|
||||
// test a large static matrix only once
|
||||
CALL_SUBTEST_7( adjoint(Matrix<float, 100, 100>()) );
|
||||
|
||||
#ifdef EIGEN_TEST_PART_13
|
||||
{
|
||||
MatrixXcf a(10,10), b(10,10);
|
||||
VERIFY_RAISES_ASSERT(a = a.transpose());
|
||||
VERIFY_RAISES_ASSERT(a = a.transpose() + b);
|
||||
VERIFY_RAISES_ASSERT(a = b + a.transpose());
|
||||
VERIFY_RAISES_ASSERT(a = a.conjugate().transpose());
|
||||
VERIFY_RAISES_ASSERT(a = a.adjoint());
|
||||
VERIFY_RAISES_ASSERT(a = a.adjoint() + b);
|
||||
VERIFY_RAISES_ASSERT(a = b + a.adjoint());
|
||||
|
||||
// no assertion should be triggered for these cases:
|
||||
a.transpose() = a.transpose();
|
||||
a.transpose() += a.transpose();
|
||||
a.transpose() += a.transpose() + b;
|
||||
a.transpose() = a.adjoint();
|
||||
a.transpose() += a.adjoint();
|
||||
a.transpose() += a.adjoint() + b;
|
||||
|
||||
// regression tests for check_for_aliasing
|
||||
MatrixXd c(10,10);
|
||||
c = 1.0 * MatrixXd::Ones(10,10) + c;
|
||||
c = MatrixXd::Ones(10,10) * 1.0 + c;
|
||||
c = c + MatrixXd::Ones(10,10) .cwiseProduct( MatrixXd::Zero(10,10) );
|
||||
c = MatrixXd::Ones(10,10) * MatrixXd::Zero(10,10);
|
||||
}
|
||||
#endif
|
||||
CALL_SUBTEST_13( adjoint_extra<0>() );
|
||||
}
|
||||
|
||||
|
||||
@ -123,6 +123,15 @@ template<typename MatrixType> void reverse(const MatrixType& m)
|
||||
VERIFY_IS_APPROX(x, m1(r, cols - 1 - c));
|
||||
}
|
||||
|
||||
template<int>
|
||||
void array_reverse_extra()
|
||||
{
|
||||
Vector4f x; x << 1, 2, 3, 4;
|
||||
Vector4f y; y << 4, 3, 2, 1;
|
||||
VERIFY(x.reverse()[1] == 3);
|
||||
VERIFY(x.reverse() == y);
|
||||
}
|
||||
|
||||
EIGEN_DECLARE_TEST(array_reverse)
|
||||
{
|
||||
for(int i = 0; i < g_repeat; i++) {
|
||||
@ -136,10 +145,5 @@ EIGEN_DECLARE_TEST(array_reverse)
|
||||
CALL_SUBTEST_8( reverse(Matrix<float, 100, 100>()) );
|
||||
CALL_SUBTEST_9( reverse(Matrix<float,Dynamic,Dynamic,RowMajor>(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );
|
||||
}
|
||||
#ifdef EIGEN_TEST_PART_3
|
||||
Vector4f x; x << 1, 2, 3, 4;
|
||||
Vector4f y; y << 4, 3, 2, 1;
|
||||
VERIFY(x.reverse()[1] == 3);
|
||||
VERIFY(x.reverse() == y);
|
||||
#endif
|
||||
CALL_SUBTEST_3( array_reverse_extra<0>() );
|
||||
}
|
||||
|
||||
@ -194,7 +194,7 @@ template<typename MatrixType> void basicStuffComplex(const MatrixType& m)
|
||||
VERIFY(!static_cast<const MatrixType&>(cm).imag().isZero());
|
||||
}
|
||||
|
||||
#ifdef EIGEN_TEST_PART_2
|
||||
template<int>
|
||||
void casting()
|
||||
{
|
||||
Matrix4f m = Matrix4f::Random(), m2;
|
||||
@ -203,7 +203,6 @@ void casting()
|
||||
m2 = m.cast<float>(); // check the specialization when NewType == Type
|
||||
VERIFY(m.isApprox(m2));
|
||||
}
|
||||
#endif
|
||||
|
||||
template <typename Scalar>
|
||||
void fixedSizeMatrixConstruction()
|
||||
@ -290,5 +289,5 @@ EIGEN_DECLARE_TEST(basicstuff)
|
||||
CALL_SUBTEST_1(fixedSizeMatrixConstruction<long int>());
|
||||
CALL_SUBTEST_1(fixedSizeMatrixConstruction<std::ptrdiff_t>());
|
||||
|
||||
CALL_SUBTEST_2(casting());
|
||||
CALL_SUBTEST_2(casting<0>());
|
||||
}
|
||||
|
||||
@ -100,6 +100,34 @@ template<typename MatrixType> void eigensolver_verify_assert(const MatrixType& m
|
||||
VERIFY_RAISES_ASSERT(eig.pseudoEigenvectors());
|
||||
}
|
||||
|
||||
template<int>
|
||||
void eigensolver_generic_extra()
|
||||
{
|
||||
{
|
||||
// regression test for bug 793
|
||||
MatrixXd a(3,3);
|
||||
a << 0, 0, 1,
|
||||
1, 1, 1,
|
||||
1, 1e+200, 1;
|
||||
Eigen::EigenSolver<MatrixXd> eig(a);
|
||||
double scale = 1e-200; // scale to avoid overflow during the comparisons
|
||||
VERIFY_IS_APPROX(a * eig.pseudoEigenvectors()*scale, eig.pseudoEigenvectors() * eig.pseudoEigenvalueMatrix()*scale);
|
||||
VERIFY_IS_APPROX(a * eig.eigenvectors()*scale, eig.eigenvectors() * eig.eigenvalues().asDiagonal()*scale);
|
||||
}
|
||||
{
|
||||
// check a case where all eigenvalues are null.
|
||||
MatrixXd a(2,2);
|
||||
a << 1, 1,
|
||||
-1, -1;
|
||||
Eigen::EigenSolver<MatrixXd> eig(a);
|
||||
VERIFY_IS_APPROX(eig.pseudoEigenvectors().squaredNorm(), 2.);
|
||||
VERIFY_IS_APPROX((a * eig.pseudoEigenvectors()).norm()+1., 1.);
|
||||
VERIFY_IS_APPROX((eig.pseudoEigenvectors() * eig.pseudoEigenvalueMatrix()).norm()+1., 1.);
|
||||
VERIFY_IS_APPROX((a * eig.eigenvectors()).norm()+1., 1.);
|
||||
VERIFY_IS_APPROX((eig.eigenvectors() * eig.eigenvalues().asDiagonal()).norm()+1., 1.);
|
||||
}
|
||||
}
|
||||
|
||||
EIGEN_DECLARE_TEST(eigensolver_generic)
|
||||
{
|
||||
int s = 0;
|
||||
@ -135,31 +163,7 @@ EIGEN_DECLARE_TEST(eigensolver_generic)
|
||||
}
|
||||
);
|
||||
|
||||
#ifdef EIGEN_TEST_PART_2
|
||||
{
|
||||
// regression test for bug 793
|
||||
MatrixXd a(3,3);
|
||||
a << 0, 0, 1,
|
||||
1, 1, 1,
|
||||
1, 1e+200, 1;
|
||||
Eigen::EigenSolver<MatrixXd> eig(a);
|
||||
double scale = 1e-200; // scale to avoid overflow during the comparisons
|
||||
VERIFY_IS_APPROX(a * eig.pseudoEigenvectors()*scale, eig.pseudoEigenvectors() * eig.pseudoEigenvalueMatrix()*scale);
|
||||
VERIFY_IS_APPROX(a * eig.eigenvectors()*scale, eig.eigenvectors() * eig.eigenvalues().asDiagonal()*scale);
|
||||
}
|
||||
{
|
||||
// check a case where all eigenvalues are null.
|
||||
MatrixXd a(2,2);
|
||||
a << 1, 1,
|
||||
-1, -1;
|
||||
Eigen::EigenSolver<MatrixXd> eig(a);
|
||||
VERIFY_IS_APPROX(eig.pseudoEigenvectors().squaredNorm(), 2.);
|
||||
VERIFY_IS_APPROX((a * eig.pseudoEigenvectors()).norm()+1., 1.);
|
||||
VERIFY_IS_APPROX((eig.pseudoEigenvectors() * eig.pseudoEigenvalueMatrix()).norm()+1., 1.);
|
||||
VERIFY_IS_APPROX((a * eig.eigenvectors()).norm()+1., 1.);
|
||||
VERIFY_IS_APPROX((eig.eigenvectors() * eig.eigenvalues().asDiagonal()).norm()+1., 1.);
|
||||
}
|
||||
#endif
|
||||
CALL_SUBTEST_2( eigensolver_generic_extra<0>() );
|
||||
|
||||
TEST_SET_BUT_UNUSED_VARIABLE(s)
|
||||
}
|
||||
|
||||
@ -29,14 +29,10 @@ template<typename T, typename I> void test_incomplete_cholesky_T()
|
||||
CALL_SUBTEST( check_sparse_spd_solving(cg_illt_uplo_amd) );
|
||||
}
|
||||
|
||||
EIGEN_DECLARE_TEST(incomplete_cholesky)
|
||||
template<int>
|
||||
void bug1150()
|
||||
{
|
||||
CALL_SUBTEST_1(( test_incomplete_cholesky_T<double,int>() ));
|
||||
CALL_SUBTEST_2(( test_incomplete_cholesky_T<std::complex<double>, int>() ));
|
||||
CALL_SUBTEST_3(( test_incomplete_cholesky_T<double,long int>() ));
|
||||
|
||||
#ifdef EIGEN_TEST_PART_1
|
||||
// regression for bug 1150
|
||||
// regression for bug 1150
|
||||
for(int N = 1; N<20; ++N)
|
||||
{
|
||||
Eigen::MatrixXd b( N, N );
|
||||
@ -61,5 +57,13 @@ EIGEN_DECLARE_TEST(incomplete_cholesky)
|
||||
VERIFY(solver.preconditioner().info() == Eigen::Success);
|
||||
VERIFY(solver.info() == Eigen::Success);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
EIGEN_DECLARE_TEST(incomplete_cholesky)
|
||||
{
|
||||
CALL_SUBTEST_1(( test_incomplete_cholesky_T<double,int>() ));
|
||||
CALL_SUBTEST_2(( test_incomplete_cholesky_T<std::complex<double>, int>() ));
|
||||
CALL_SUBTEST_3(( test_incomplete_cholesky_T<double,long int>() ));
|
||||
|
||||
CALL_SUBTEST_1(( bug1150<0>() ));
|
||||
}
|
||||
|
||||
@ -131,6 +131,17 @@ template<typename MatrixType> void integer_type_tests(const MatrixType& m)
|
||||
VERIFY_IS_APPROX((m1 * m2.transpose()) * m1, m1 * (m2.transpose() * m1));
|
||||
}
|
||||
|
||||
template<int>
|
||||
void integer_types_extra()
|
||||
{
|
||||
VERIFY_IS_EQUAL(internal::scalar_div_cost<int>::value, 8);
|
||||
VERIFY_IS_EQUAL(internal::scalar_div_cost<unsigned int>::value, 8);
|
||||
if(sizeof(long)>sizeof(int)) {
|
||||
VERIFY(int(internal::scalar_div_cost<long>::value) > int(internal::scalar_div_cost<int>::value));
|
||||
VERIFY(int(internal::scalar_div_cost<unsigned long>::value) > int(internal::scalar_div_cost<int>::value));
|
||||
}
|
||||
}
|
||||
|
||||
EIGEN_DECLARE_TEST(integer_types)
|
||||
{
|
||||
for(int i = 0; i < g_repeat; i++) {
|
||||
@ -156,12 +167,5 @@ EIGEN_DECLARE_TEST(integer_types)
|
||||
|
||||
CALL_SUBTEST_8( integer_type_tests(Matrix<unsigned long long, Dynamic, 5>(1, 5)) );
|
||||
}
|
||||
#ifdef EIGEN_TEST_PART_9
|
||||
VERIFY_IS_EQUAL(internal::scalar_div_cost<int>::value, 8);
|
||||
VERIFY_IS_EQUAL(internal::scalar_div_cost<unsigned int>::value, 8);
|
||||
if(sizeof(long)>sizeof(int)) {
|
||||
VERIFY(int(internal::scalar_div_cost<long>::value) > int(internal::scalar_div_cost<int>::value));
|
||||
VERIFY(int(internal::scalar_div_cost<unsigned long>::value) > int(internal::scalar_div_cost<int>::value));
|
||||
}
|
||||
#endif
|
||||
CALL_SUBTEST_9( integer_types_extra<0>() );
|
||||
}
|
||||
|
||||
@ -11,9 +11,59 @@
|
||||
#include "main.h"
|
||||
#include <Eigen/LU>
|
||||
|
||||
template<typename MatrixType> void inverse(const MatrixType& m)
|
||||
template<typename MatrixType>
|
||||
void inverse_for_fixed_size(const MatrixType&, typename internal::enable_if<MatrixType::SizeAtCompileTime==Dynamic>::type* = 0)
|
||||
{
|
||||
}
|
||||
|
||||
template<typename MatrixType>
|
||||
void inverse_for_fixed_size(const MatrixType& m1, typename internal::enable_if<MatrixType::SizeAtCompileTime!=Dynamic>::type* = 0)
|
||||
{
|
||||
using std::abs;
|
||||
|
||||
MatrixType m2, identity = MatrixType::Identity();
|
||||
|
||||
typedef typename MatrixType::Scalar Scalar;
|
||||
typedef typename NumTraits<Scalar>::Real RealScalar;
|
||||
typedef Matrix<Scalar, MatrixType::ColsAtCompileTime, 1> VectorType;
|
||||
|
||||
//computeInverseAndDetWithCheck tests
|
||||
//First: an invertible matrix
|
||||
bool invertible;
|
||||
Scalar det;
|
||||
|
||||
m2.setZero();
|
||||
m1.computeInverseAndDetWithCheck(m2, det, invertible);
|
||||
VERIFY(invertible);
|
||||
VERIFY_IS_APPROX(identity, m1*m2);
|
||||
VERIFY_IS_APPROX(det, m1.determinant());
|
||||
|
||||
m2.setZero();
|
||||
m1.computeInverseWithCheck(m2, invertible);
|
||||
VERIFY(invertible);
|
||||
VERIFY_IS_APPROX(identity, m1*m2);
|
||||
|
||||
//Second: a rank one matrix (not invertible, except for 1x1 matrices)
|
||||
VectorType v3 = VectorType::Random();
|
||||
MatrixType m3 = v3*v3.transpose(), m4;
|
||||
m3.computeInverseAndDetWithCheck(m4, det, invertible);
|
||||
VERIFY( m1.rows()==1 ? invertible : !invertible );
|
||||
VERIFY_IS_MUCH_SMALLER_THAN(abs(det-m3.determinant()), RealScalar(1));
|
||||
m3.computeInverseWithCheck(m4, invertible);
|
||||
VERIFY( m1.rows()==1 ? invertible : !invertible );
|
||||
|
||||
// check with submatrices
|
||||
{
|
||||
Matrix<Scalar, MatrixType::RowsAtCompileTime+1, MatrixType::RowsAtCompileTime+1, MatrixType::Options> m5;
|
||||
m5.setRandom();
|
||||
m5.topLeftCorner(m1.rows(),m1.rows()) = m1;
|
||||
m2 = m5.template topLeftCorner<MatrixType::RowsAtCompileTime,MatrixType::ColsAtCompileTime>().inverse();
|
||||
VERIFY_IS_APPROX( (m5.template topLeftCorner<MatrixType::RowsAtCompileTime,MatrixType::ColsAtCompileTime>()), m2.inverse() );
|
||||
}
|
||||
}
|
||||
|
||||
template<typename MatrixType> void inverse(const MatrixType& m)
|
||||
{
|
||||
/* this test covers the following files:
|
||||
Inverse.h
|
||||
*/
|
||||
@ -39,44 +89,7 @@ template<typename MatrixType> void inverse(const MatrixType& m)
|
||||
// since for the general case we implement separately row-major and col-major, test that
|
||||
VERIFY_IS_APPROX(MatrixType(m1.transpose().inverse()), MatrixType(m1.inverse().transpose()));
|
||||
|
||||
#if !defined(EIGEN_TEST_PART_5) && !defined(EIGEN_TEST_PART_6)
|
||||
typedef typename NumTraits<Scalar>::Real RealScalar;
|
||||
typedef Matrix<Scalar, MatrixType::ColsAtCompileTime, 1> VectorType;
|
||||
|
||||
//computeInverseAndDetWithCheck tests
|
||||
//First: an invertible matrix
|
||||
bool invertible;
|
||||
Scalar det;
|
||||
|
||||
m2.setZero();
|
||||
m1.computeInverseAndDetWithCheck(m2, det, invertible);
|
||||
VERIFY(invertible);
|
||||
VERIFY_IS_APPROX(identity, m1*m2);
|
||||
VERIFY_IS_APPROX(det, m1.determinant());
|
||||
|
||||
m2.setZero();
|
||||
m1.computeInverseWithCheck(m2, invertible);
|
||||
VERIFY(invertible);
|
||||
VERIFY_IS_APPROX(identity, m1*m2);
|
||||
|
||||
//Second: a rank one matrix (not invertible, except for 1x1 matrices)
|
||||
VectorType v3 = VectorType::Random(rows);
|
||||
MatrixType m3 = v3*v3.transpose(), m4(rows,cols);
|
||||
m3.computeInverseAndDetWithCheck(m4, det, invertible);
|
||||
VERIFY( rows==1 ? invertible : !invertible );
|
||||
VERIFY_IS_MUCH_SMALLER_THAN(abs(det-m3.determinant()), RealScalar(1));
|
||||
m3.computeInverseWithCheck(m4, invertible);
|
||||
VERIFY( rows==1 ? invertible : !invertible );
|
||||
|
||||
// check with submatrices
|
||||
{
|
||||
Matrix<Scalar, MatrixType::RowsAtCompileTime+1, MatrixType::RowsAtCompileTime+1, MatrixType::Options> m5;
|
||||
m5.setRandom();
|
||||
m5.topLeftCorner(rows,rows) = m1;
|
||||
m2 = m5.template topLeftCorner<MatrixType::RowsAtCompileTime,MatrixType::ColsAtCompileTime>().inverse();
|
||||
VERIFY_IS_APPROX( (m5.template topLeftCorner<MatrixType::RowsAtCompileTime,MatrixType::ColsAtCompileTime>()), m2.inverse() );
|
||||
}
|
||||
#endif
|
||||
inverse_for_fixed_size(m1);
|
||||
|
||||
// check in-place inversion
|
||||
if(MatrixType::RowsAtCompileTime>=2 && MatrixType::RowsAtCompileTime<=4)
|
||||
|
||||
@ -110,6 +110,19 @@ template<typename MatrixType> void real_complex(DenseIndex rows = MatrixType::Ro
|
||||
VERIFY(g_called && "matrix<complex> - real not properly optimized");
|
||||
}
|
||||
|
||||
template<int>
|
||||
void linearstructure_overflow()
|
||||
{
|
||||
// make sure that /=scalar and /scalar do not overflow
|
||||
// rational: 1.0/4.94e-320 overflow, but m/4.94e-320 should not
|
||||
Matrix4d m2, m3;
|
||||
m3 = m2 = Matrix4d::Random()*1e-20;
|
||||
m2 = m2 / 4.9e-320;
|
||||
VERIFY_IS_APPROX(m2.cwiseQuotient(m2), Matrix4d::Ones());
|
||||
m3 /= 4.9e-320;
|
||||
VERIFY_IS_APPROX(m3.cwiseQuotient(m3), Matrix4d::Ones());
|
||||
}
|
||||
|
||||
EIGEN_DECLARE_TEST(linearstructure)
|
||||
{
|
||||
g_called = true;
|
||||
@ -130,19 +143,5 @@ EIGEN_DECLARE_TEST(linearstructure)
|
||||
CALL_SUBTEST_11( real_complex<MatrixXcf>(10,10) );
|
||||
CALL_SUBTEST_11( real_complex<ArrayXXcf>(10,10) );
|
||||
}
|
||||
|
||||
#ifdef EIGEN_TEST_PART_4
|
||||
{
|
||||
// make sure that /=scalar and /scalar do not overflow
|
||||
// rational: 1.0/4.94e-320 overflow, but m/4.94e-320 should not
|
||||
Matrix4d m2, m3;
|
||||
m3 = m2 = Matrix4d::Random()*1e-20;
|
||||
m2 = m2 / 4.9e-320;
|
||||
VERIFY_IS_APPROX(m2.cwiseQuotient(m2), Matrix4d::Ones());
|
||||
m3 /= 4.9e-320;
|
||||
VERIFY_IS_APPROX(m3.cwiseQuotient(m3), Matrix4d::Ones());
|
||||
|
||||
|
||||
}
|
||||
#endif
|
||||
CALL_SUBTEST_4( linearstructure_overflow<0>() );
|
||||
}
|
||||
|
||||
@ -239,45 +239,28 @@ void testMatrixType(const MatrixType& m)
|
||||
VERIFY_IS_APPROX( A(i,j), s1 );
|
||||
}
|
||||
|
||||
EIGEN_DECLARE_TEST(nullary)
|
||||
template<int>
|
||||
void bug79()
|
||||
{
|
||||
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*10; i++) {
|
||||
CALL_SUBTEST_4( testVectorType(VectorXd(internal::random<int>(1,30000))) );
|
||||
CALL_SUBTEST_5( testVectorType(Vector4d()) ); // regression test for bug 232
|
||||
CALL_SUBTEST_6( testVectorType(Vector3d()) );
|
||||
CALL_SUBTEST_7( testVectorType(VectorXf(internal::random<int>(1,30000))) );
|
||||
CALL_SUBTEST_8( testVectorType(Vector3f()) );
|
||||
CALL_SUBTEST_8( testVectorType(Vector4f()) );
|
||||
CALL_SUBTEST_8( testVectorType(Matrix<float,8,1>()) );
|
||||
CALL_SUBTEST_8( testVectorType(Matrix<float,1,1>()) );
|
||||
|
||||
CALL_SUBTEST_9( testVectorType(VectorXi(internal::random<int>(1,10))) );
|
||||
CALL_SUBTEST_9( testVectorType(VectorXi(internal::random<int>(9,300))) );
|
||||
CALL_SUBTEST_9( testVectorType(Matrix<int,1,1>()) );
|
||||
}
|
||||
|
||||
#ifdef EIGEN_TEST_PART_6
|
||||
// Assignment of a RowVectorXd to a MatrixXd (regression test for bug #79).
|
||||
VERIFY( (MatrixXd(RowVectorXd::LinSpaced(3, 0, 1)) - RowVector3d(0, 0.5, 1)).norm() < std::numeric_limits<double>::epsilon() );
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef EIGEN_TEST_PART_9
|
||||
template<int>
|
||||
void nullary_overflow()
|
||||
{
|
||||
// Check possible overflow issue
|
||||
{
|
||||
int n = 60000;
|
||||
ArrayXi a1(n), a2(n);
|
||||
a1.setLinSpaced(n, 0, n-1);
|
||||
for(int i=0; i<n; ++i)
|
||||
a2(i) = i;
|
||||
VERIFY_IS_APPROX(a1,a2);
|
||||
}
|
||||
#endif
|
||||
int n = 60000;
|
||||
ArrayXi a1(n), a2(n);
|
||||
a1.setLinSpaced(n, 0, n-1);
|
||||
for(int i=0; i<n; ++i)
|
||||
a2(i) = i;
|
||||
VERIFY_IS_APPROX(a1,a2);
|
||||
}
|
||||
|
||||
#ifdef EIGEN_TEST_PART_10
|
||||
template<int>
|
||||
void nullary_internal_logic()
|
||||
{
|
||||
// check some internal logic
|
||||
VERIFY(( internal::has_nullary_operator<internal::scalar_constant_op<double> >::value ));
|
||||
VERIFY(( !internal::has_unary_operator<internal::scalar_constant_op<double> >::value ));
|
||||
@ -318,5 +301,30 @@ EIGEN_DECLARE_TEST(nullary)
|
||||
VERIFY(( !internal::has_binary_operator<internal::linspaced_op<int,int> >::value ));
|
||||
VERIFY(( internal::functor_has_linear_access<internal::linspaced_op<int,int> >::ret ));
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
EIGEN_DECLARE_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*10; i++) {
|
||||
CALL_SUBTEST_4( testVectorType(VectorXd(internal::random<int>(1,30000))) );
|
||||
CALL_SUBTEST_5( testVectorType(Vector4d()) ); // regression test for bug 232
|
||||
CALL_SUBTEST_6( testVectorType(Vector3d()) );
|
||||
CALL_SUBTEST_7( testVectorType(VectorXf(internal::random<int>(1,30000))) );
|
||||
CALL_SUBTEST_8( testVectorType(Vector3f()) );
|
||||
CALL_SUBTEST_8( testVectorType(Vector4f()) );
|
||||
CALL_SUBTEST_8( testVectorType(Matrix<float,8,1>()) );
|
||||
CALL_SUBTEST_8( testVectorType(Matrix<float,1,1>()) );
|
||||
|
||||
CALL_SUBTEST_9( testVectorType(VectorXi(internal::random<int>(1,10))) );
|
||||
CALL_SUBTEST_9( testVectorType(VectorXi(internal::random<int>(9,300))) );
|
||||
CALL_SUBTEST_9( testVectorType(Matrix<int,1,1>()) );
|
||||
}
|
||||
|
||||
CALL_SUBTEST_6( bug79<0>() );
|
||||
CALL_SUBTEST_9( nullary_overflow<0>() );
|
||||
CALL_SUBTEST_10( nullary_internal_logic<0>() );
|
||||
}
|
||||
|
||||
@ -30,21 +30,9 @@ void test_aliasing()
|
||||
x = z;
|
||||
}
|
||||
|
||||
EIGEN_DECLARE_TEST(product_large)
|
||||
template<int>
|
||||
void product_large_regressions()
|
||||
{
|
||||
for(int i = 0; i < g_repeat; i++) {
|
||||
CALL_SUBTEST_1( product(MatrixXf(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );
|
||||
CALL_SUBTEST_2( product(MatrixXd(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );
|
||||
CALL_SUBTEST_2( product(MatrixXd(internal::random<int>(1,10), internal::random<int>(1,10))) );
|
||||
|
||||
CALL_SUBTEST_3( product(MatrixXi(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );
|
||||
CALL_SUBTEST_4( product(MatrixXcf(internal::random<int>(1,EIGEN_TEST_MAX_SIZE/2), internal::random<int>(1,EIGEN_TEST_MAX_SIZE/2))) );
|
||||
CALL_SUBTEST_5( product(Matrix<float,Dynamic,Dynamic,RowMajor>(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );
|
||||
|
||||
CALL_SUBTEST_1( test_aliasing<float>() );
|
||||
}
|
||||
|
||||
#if defined EIGEN_TEST_PART_6
|
||||
{
|
||||
// test a specific issue in DiagonalProduct
|
||||
int N = 1000000;
|
||||
@ -97,7 +85,23 @@ EIGEN_DECLARE_TEST(product_large)
|
||||
* (((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A)) * ((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A)));
|
||||
VERIFY_IS_APPROX(B,C);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
EIGEN_DECLARE_TEST(product_large)
|
||||
{
|
||||
for(int i = 0; i < g_repeat; i++) {
|
||||
CALL_SUBTEST_1( product(MatrixXf(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );
|
||||
CALL_SUBTEST_2( product(MatrixXd(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );
|
||||
CALL_SUBTEST_2( product(MatrixXd(internal::random<int>(1,10), internal::random<int>(1,10))) );
|
||||
|
||||
CALL_SUBTEST_3( product(MatrixXi(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );
|
||||
CALL_SUBTEST_4( product(MatrixXcf(internal::random<int>(1,EIGEN_TEST_MAX_SIZE/2), internal::random<int>(1,EIGEN_TEST_MAX_SIZE/2))) );
|
||||
CALL_SUBTEST_5( product(Matrix<float,Dynamic,Dynamic,RowMajor>(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );
|
||||
|
||||
CALL_SUBTEST_1( test_aliasing<float>() );
|
||||
}
|
||||
|
||||
CALL_SUBTEST_6( product_large_regressions<0>() );
|
||||
|
||||
// Regression test for bug 714:
|
||||
#if defined EIGEN_HAS_OPENMP
|
||||
|
||||
@ -228,6 +228,36 @@ void bug_1311()
|
||||
VERIFY_IS_APPROX(res, A*b);
|
||||
}
|
||||
|
||||
template<int>
|
||||
void product_small_regressions()
|
||||
{
|
||||
{
|
||||
// test compilation of (outer_product) * vector
|
||||
Vector3f v = Vector3f::Random();
|
||||
VERIFY_IS_APPROX( (v * v.transpose()) * v, (v * v.transpose()).eval() * v);
|
||||
}
|
||||
|
||||
{
|
||||
// regression test for pull-request #93
|
||||
Eigen::Matrix<double, 1, 1> A; A.setRandom();
|
||||
Eigen::Matrix<double, 18, 1> B; B.setRandom();
|
||||
Eigen::Matrix<double, 1, 18> C; C.setRandom();
|
||||
VERIFY_IS_APPROX(B * A.inverse(), B * A.inverse()[0]);
|
||||
VERIFY_IS_APPROX(A.inverse() * C, A.inverse()[0] * C);
|
||||
}
|
||||
|
||||
{
|
||||
Eigen::Matrix<double, 10, 10> A, B, C;
|
||||
A.setRandom();
|
||||
C = A;
|
||||
for(int k=0; k<79; ++k)
|
||||
C = C * A;
|
||||
B.noalias() = (((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A)) * ((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A)))
|
||||
* (((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A)) * ((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A)));
|
||||
VERIFY_IS_APPROX(B,C);
|
||||
}
|
||||
}
|
||||
|
||||
EIGEN_DECLARE_TEST(product_small)
|
||||
{
|
||||
for(int i = 0; i < g_repeat; i++) {
|
||||
@ -263,31 +293,5 @@ EIGEN_DECLARE_TEST(product_small)
|
||||
CALL_SUBTEST_6( bug_1311<5>() );
|
||||
}
|
||||
|
||||
#ifdef EIGEN_TEST_PART_6
|
||||
{
|
||||
// test compilation of (outer_product) * vector
|
||||
Vector3f v = Vector3f::Random();
|
||||
VERIFY_IS_APPROX( (v * v.transpose()) * v, (v * v.transpose()).eval() * v);
|
||||
}
|
||||
|
||||
{
|
||||
// regression test for pull-request #93
|
||||
Eigen::Matrix<double, 1, 1> A; A.setRandom();
|
||||
Eigen::Matrix<double, 18, 1> B; B.setRandom();
|
||||
Eigen::Matrix<double, 1, 18> C; C.setRandom();
|
||||
VERIFY_IS_APPROX(B * A.inverse(), B * A.inverse()[0]);
|
||||
VERIFY_IS_APPROX(A.inverse() * C, A.inverse()[0] * C);
|
||||
}
|
||||
|
||||
{
|
||||
Eigen::Matrix<double, 10, 10> A, B, C;
|
||||
A.setRandom();
|
||||
C = A;
|
||||
for(int k=0; k<79; ++k)
|
||||
C = C * A;
|
||||
B.noalias() = (((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A)) * ((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A)))
|
||||
* (((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A)) * ((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A))*((A*A)*(A*A)));
|
||||
VERIFY_IS_APPROX(B,C);
|
||||
}
|
||||
#endif
|
||||
CALL_SUBTEST_6( product_small_regressions<0>() );
|
||||
}
|
||||
|
||||
@ -640,6 +640,20 @@ void big_sparse_triplet(Index rows, Index cols, double density) {
|
||||
VERIFY_IS_APPROX(sum, m.sum());
|
||||
}
|
||||
|
||||
template<int>
|
||||
void bug1105()
|
||||
{
|
||||
// Regression test for bug 1105
|
||||
int n = Eigen::internal::random<int>(200,600);
|
||||
SparseMatrix<std::complex<double>,0, long> mat(n, n);
|
||||
std::complex<double> val;
|
||||
|
||||
for(int i=0; i<n; ++i)
|
||||
{
|
||||
mat.coeffRef(i, i%(n/10)) = val;
|
||||
VERIFY(mat.data().allocatedSize()<20*n);
|
||||
}
|
||||
}
|
||||
|
||||
EIGEN_DECLARE_TEST(sparse_basic)
|
||||
{
|
||||
@ -671,18 +685,5 @@ EIGEN_DECLARE_TEST(sparse_basic)
|
||||
CALL_SUBTEST_3((big_sparse_triplet<SparseMatrix<float, RowMajor, int> >(10000, 10000, 0.125)));
|
||||
CALL_SUBTEST_4((big_sparse_triplet<SparseMatrix<double, ColMajor, long int> >(10000, 10000, 0.125)));
|
||||
|
||||
// Regression test for bug 1105
|
||||
#ifdef EIGEN_TEST_PART_7
|
||||
{
|
||||
int n = Eigen::internal::random<int>(200,600);
|
||||
SparseMatrix<std::complex<double>,0, long> mat(n, n);
|
||||
std::complex<double> val;
|
||||
|
||||
for(int i=0; i<n; ++i)
|
||||
{
|
||||
mat.coeffRef(i, i%(n/10)) = val;
|
||||
VERIFY(mat.data().allocatedSize()<20*n);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
CALL_SUBTEST_7( bug1105<0>() );
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user