devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

bug #86 : use internal:: namespace instead of ei_ prefix

Browse Source
This commit is contained in:
Benoit Jacob
2010-10-25 10:15:22 -04:00
parent ca85a1f6c5
commit 4716040703
330 changed files with 7615 additions and 7032 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
test/adjoint.cpp
View File

@@ -41,7 +41,7 @@ template<typename MatrixType> void adjoint(const MatrixType& m)
Index cols = m.cols();
RealScalar largerEps = test_precision<RealScalar>();
if (ei_is_same_type<RealScalar,float>::ret)
if (internal::is_same_type<RealScalar,float>::ret)
largerEps = RealScalar(1e-3f);
MatrixType m1 = MatrixType::Random(rows, cols),
@@ -55,8 +55,8 @@ template<typename MatrixType> void adjoint(const MatrixType& m)
v3 = VectorType::Random(rows),
vzero = VectorType::Zero(rows);
Scalar s1 = ei_random<Scalar>(),
s2 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>(),
s2 = internal::random<Scalar>();
// check basic compatibility of adjoint, transpose, conjugate
VERIFY_IS_APPROX(m1.transpose().conjugate().adjoint(), m1);
@@ -64,26 +64,26 @@ template<typename MatrixType> void adjoint(const MatrixType& m)
// check multiplicative behavior
VERIFY_IS_APPROX((m1.adjoint() * m2).adjoint(), m2.adjoint() * m1);
VERIFY_IS_APPROX((s1 * m1).adjoint(), ei_conj(s1) * m1.adjoint());
VERIFY_IS_APPROX((s1 * m1).adjoint(), internal::conj(s1) * m1.adjoint());
// check basic properties of dot, norm, norm2
typedef typename NumTraits<Scalar>::Real RealScalar;
VERIFY(ei_isApprox((s1 * v1 + s2 * v2).dot(v3), ei_conj(s1) * v1.dot(v3) + ei_conj(s2) * v2.dot(v3), largerEps));
VERIFY(ei_isApprox(v3.dot(s1 * v1 + s2 * v2), s1*v3.dot(v1)+s2*v3.dot(v2), largerEps));
VERIFY_IS_APPROX(ei_conj(v1.dot(v2)), v2.dot(v1));
VERIFY_IS_APPROX(ei_abs(v1.dot(v1)), v1.squaredNorm());
VERIFY(internal::isApprox((s1 * v1 + s2 * v2).dot(v3), internal::conj(s1) * v1.dot(v3) + internal::conj(s2) * v2.dot(v3), largerEps));
VERIFY(internal::isApprox(v3.dot(s1 * v1 + s2 * v2), s1*v3.dot(v1)+s2*v3.dot(v2), largerEps));
VERIFY_IS_APPROX(internal::conj(v1.dot(v2)), v2.dot(v1));
VERIFY_IS_APPROX(internal::abs(v1.dot(v1)), v1.squaredNorm());
if(!NumTraits<Scalar>::IsInteger)
VERIFY_IS_APPROX(v1.squaredNorm(), v1.norm() * v1.norm());
VERIFY_IS_MUCH_SMALLER_THAN(ei_abs(vzero.dot(v1)), static_cast<RealScalar>(1));
VERIFY_IS_MUCH_SMALLER_THAN(internal::abs(vzero.dot(v1)), static_cast<RealScalar>(1));
// check compatibility of dot and adjoint
VERIFY(ei_isApprox(v1.dot(square * v2), (square.adjoint() * v1).dot(v2), largerEps));
VERIFY(internal::isApprox(v1.dot(square * v2), (square.adjoint() * v1).dot(v2), largerEps));
// like in testBasicStuff, test operator() to check const-qualification
Index r = ei_random<Index>(0, rows-1),
c = ei_random<Index>(0, cols-1);
VERIFY_IS_APPROX(m1.conjugate()(r,c), ei_conj(m1(r,c)));
VERIFY_IS_APPROX(m1.adjoint()(c,r), ei_conj(m1(r,c)));
Index r = internal::random<Index>(0, rows-1),
c = internal::random<Index>(0, cols-1);
VERIFY_IS_APPROX(m1.conjugate()(r,c), internal::conj(m1(r,c)));
VERIFY_IS_APPROX(m1.adjoint()(c,r), internal::conj(m1(r,c)));
if(!NumTraits<Scalar>::IsInteger)
{

44
test/array.cpp
View File

@@ -42,8 +42,8 @@ template<typename ArrayType> void array(const ArrayType& m)
ColVectorType cv1 = ColVectorType::Random(rows);
RowVectorType rv1 = RowVectorType::Random(cols);
Scalar s1 = ei_random<Scalar>(),
s2 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>(),
s2 = internal::random<Scalar>();
// scalar addition
VERIFY_IS_APPROX(m1 + s1, s1 + m1);
@@ -62,9 +62,9 @@ template<typename ArrayType> void array(const ArrayType& m)
// reductions
VERIFY_IS_APPROX(m1.colwise().sum().sum(), m1.sum());
VERIFY_IS_APPROX(m1.rowwise().sum().sum(), m1.sum());
if (!ei_isApprox(m1.sum(), (m1+m2).sum()))
if (!internal::isApprox(m1.sum(), (m1+m2).sum()))
VERIFY_IS_NOT_APPROX(((m1+m2).rowwise().sum()).sum(), m1.sum());
VERIFY_IS_APPROX(m1.colwise().sum(), m1.colwise().redux(ei_scalar_sum_op<Scalar>()));
VERIFY_IS_APPROX(m1.colwise().sum(), m1.colwise().redux(internal::scalar_sum_op<Scalar>()));
// vector-wise ops
m3 = m1;
@@ -87,8 +87,8 @@ template<typename ArrayType> void comparisons(const ArrayType& m)
Index rows = m.rows();
Index cols = m.cols();
Index r = ei_random<Index>(0, rows-1),
c = ei_random<Index>(0, cols-1);
Index r = internal::random<Index>(0, rows-1),
c = internal::random<Index>(0, cols-1);
ArrayType m1 = ArrayType::Random(rows, cols),
m2 = ArrayType::Random(rows, cols),
@@ -116,7 +116,7 @@ template<typename ArrayType> void comparisons(const ArrayType& m)
Scalar mid = (m1.cwiseAbs().minCoeff() + m1.cwiseAbs().maxCoeff())/Scalar(2);
for (int j=0; j<cols; ++j)
for (int i=0; i<rows; ++i)
m3(i,j) = ei_abs(m1(i,j))<mid ? 0 : m1(i,j);
m3(i,j) = internal::abs(m1(i,j))<mid ? 0 : m1(i,j);
VERIFY_IS_APPROX( (m1.abs()<ArrayType::Constant(rows,cols,mid))
.select(ArrayType::Zero(rows,cols),m1), m3);
// shorter versions:
@@ -151,28 +151,28 @@ template<typename ArrayType> void array_real(const ArrayType& m)
m3(rows, cols);
VERIFY_IS_APPROX(m1.sin(), std::sin(m1));
VERIFY_IS_APPROX(m1.sin(), ei_sin(m1));
VERIFY_IS_APPROX(m1.sin(), internal::sin(m1));
VERIFY_IS_APPROX(m1.cos(), std::cos(m1));
VERIFY_IS_APPROX(m1.cos(), ei_cos(m1));
VERIFY_IS_APPROX(m1.cos(), internal::cos(m1));
VERIFY_IS_APPROX(ei_cos(m1+RealScalar(3)*m2), ei_cos((m1+RealScalar(3)*m2).eval()));
VERIFY_IS_APPROX(internal::cos(m1+RealScalar(3)*m2), internal::cos((m1+RealScalar(3)*m2).eval()));
VERIFY_IS_APPROX(std::cos(m1+RealScalar(3)*m2), std::cos((m1+RealScalar(3)*m2).eval()));
VERIFY_IS_APPROX(m1.abs().sqrt(), std::sqrt(std::abs(m1)));
VERIFY_IS_APPROX(m1.abs().sqrt(), ei_sqrt(ei_abs(m1)));
VERIFY_IS_APPROX(m1.abs(), ei_sqrt(ei_abs2(m1)));
VERIFY_IS_APPROX(m1.abs().sqrt(), internal::sqrt(internal::abs(m1)));
VERIFY_IS_APPROX(m1.abs(), internal::sqrt(internal::abs2(m1)));
VERIFY_IS_APPROX(ei_abs2(ei_real(m1)) + ei_abs2(ei_imag(m1)), ei_abs2(m1));
VERIFY_IS_APPROX(ei_abs2(std::real(m1)) + ei_abs2(std::imag(m1)), ei_abs2(m1));
VERIFY_IS_APPROX(internal::abs2(internal::real(m1)) + internal::abs2(internal::imag(m1)), internal::abs2(m1));
VERIFY_IS_APPROX(internal::abs2(std::real(m1)) + internal::abs2(std::imag(m1)), internal::abs2(m1));
if(!NumTraits<Scalar>::IsComplex)
VERIFY_IS_APPROX(ei_real(m1), m1);
VERIFY_IS_APPROX(internal::real(m1), m1);
VERIFY_IS_APPROX(m1.abs().log(), std::log(std::abs(m1)));
VERIFY_IS_APPROX(m1.abs().log(), ei_log(ei_abs(m1)));
VERIFY_IS_APPROX(m1.abs().log(), internal::log(internal::abs(m1)));
VERIFY_IS_APPROX(m1.exp(), std::exp(m1));
VERIFY_IS_APPROX(m1.exp() * m2.exp(), std::exp(m1+m2));
VERIFY_IS_APPROX(m1.exp(), ei_exp(m1));
VERIFY_IS_APPROX(m1.exp(), internal::exp(m1));
VERIFY_IS_APPROX(m1.exp() / m2.exp(), std::exp(m1-m2));
VERIFY_IS_APPROX(m1.pow(2), m1.square());
@@ -206,11 +206,11 @@ void test_array()
CALL_SUBTEST_5( array_real(ArrayXXf(8, 12)) );
}
VERIFY((ei_is_same_type< ei_global_math_functions_filtering_base<int>::type, int >::ret));
VERIFY((ei_is_same_type< ei_global_math_functions_filtering_base<float>::type, float >::ret));
VERIFY((ei_is_same_type< ei_global_math_functions_filtering_base<Array2i>::type, ArrayBase<Array2i> >::ret));
typedef CwiseUnaryOp<ei_scalar_sum_op<double>, ArrayXd > Xpr;
VERIFY((ei_is_same_type< ei_global_math_functions_filtering_base<Xpr>::type,
VERIFY((internal::is_same_type< internal::global_math_functions_filtering_base<int>::type, int >::ret));
VERIFY((internal::is_same_type< internal::global_math_functions_filtering_base<float>::type, float >::ret));
VERIFY((internal::is_same_type< internal::global_math_functions_filtering_base<Array2i>::type, ArrayBase<Array2i> >::ret));
typedef CwiseUnaryOp<internal::scalar_sum_op<double>, ArrayXd > Xpr;
VERIFY((internal::is_same_type< internal::global_math_functions_filtering_base<Xpr>::type,
ArrayBase<Xpr>
>::ret));
}

18
test/array_for_matrix.cpp
View File

@@ -42,8 +42,8 @@ template<typename MatrixType> void array_for_matrix(const MatrixType& m)
ColVectorType cv1 = ColVectorType::Random(rows);
RowVectorType rv1 = RowVectorType::Random(cols);
Scalar s1 = ei_random<Scalar>(),
s2 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>(),
s2 = internal::random<Scalar>();
// scalar addition
VERIFY_IS_APPROX(m1.array() + s1, s1 + m1.array());
@@ -59,9 +59,9 @@ template<typename MatrixType> void array_for_matrix(const MatrixType& m)
// reductions
VERIFY_IS_APPROX(m1.colwise().sum().sum(), m1.sum());
VERIFY_IS_APPROX(m1.rowwise().sum().sum(), m1.sum());
if (!ei_isApprox(m1.sum(), (m1+m2).sum()))
if (!internal::isApprox(m1.sum(), (m1+m2).sum()))
VERIFY_IS_NOT_APPROX(((m1+m2).rowwise().sum()).sum(), m1.sum());
VERIFY_IS_APPROX(m1.colwise().sum(), m1.colwise().redux(ei_scalar_sum_op<Scalar>()));
VERIFY_IS_APPROX(m1.colwise().sum(), m1.colwise().redux(internal::scalar_sum_op<Scalar>()));
// vector-wise ops
m3 = m1;
@@ -88,8 +88,8 @@ template<typename MatrixType> void comparisons(const MatrixType& m)
Index rows = m.rows();
Index cols = m.cols();
Index r = ei_random<Index>(0, rows-1),
c = ei_random<Index>(0, cols-1);
Index r = internal::random<Index>(0, rows-1),
c = internal::random<Index>(0, cols-1);
MatrixType m1 = MatrixType::Random(rows, cols),
m2 = MatrixType::Random(rows, cols),
@@ -117,7 +117,7 @@ template<typename MatrixType> void comparisons(const MatrixType& m)
Scalar mid = (m1.cwiseAbs().minCoeff() + m1.cwiseAbs().maxCoeff())/Scalar(2);
for (int j=0; j<cols; ++j)
for (int i=0; i<rows; ++i)
m3(i,j) = ei_abs(m1(i,j))<mid ? 0 : m1(i,j);
m3(i,j) = internal::abs(m1(i,j))<mid ? 0 : m1(i,j);
VERIFY_IS_APPROX( (m1.array().abs()<MatrixType::Constant(rows,cols,mid).array())
.select(MatrixType::Zero(rows,cols),m1), m3);
// shorter versions:
@@ -144,8 +144,8 @@ template<typename VectorType> void lpNorm(const VectorType& v)
VERIFY_IS_APPROX(u.template lpNorm<Infinity>(), u.cwiseAbs().maxCoeff());
VERIFY_IS_APPROX(u.template lpNorm<1>(), u.cwiseAbs().sum());
VERIFY_IS_APPROX(u.template lpNorm<2>(), ei_sqrt(u.array().abs().square().sum()));
VERIFY_IS_APPROX(ei_pow(u.template lpNorm<5>(), typename VectorType::RealScalar(5)), u.array().abs().pow(5).sum());
VERIFY_IS_APPROX(u.template lpNorm<2>(), internal::sqrt(u.array().abs().square().sum()));
VERIFY_IS_APPROX(internal::pow(u.template lpNorm<5>(), typename VectorType::RealScalar(5)), u.array().abs().pow(5).sum());
}
void test_array_for_matrix()

4
test/array_replicate.cpp
View File

@@ -47,8 +47,8 @@ template<typename MatrixType> void replicate(const MatrixType& m)
MatrixX x1, x2;
VectorX vx1;
int f1 = ei_random<int>(1,10),
f2 = ei_random<int>(1,10);
int f1 = internal::random<int>(1,10),
f2 = internal::random<int>(1,10);
x1.resize(rows*f1,cols*f2);
for(int j=0; j<f2; j++)

6
test/array_reverse.cpp
View File

@@ -104,10 +104,10 @@ template<typename MatrixType> void reverse(const MatrixType& m)
}
}
Scalar x = ei_random<Scalar>();
Scalar x = internal::random<Scalar>();
Index r = ei_random<Index>(0, rows-1),
c = ei_random<Index>(0, cols-1);
Index r = internal::random<Index>(0, rows-1),
c = internal::random<Index>(0, cols-1);
m1.reverse()(r, c) = x;
VERIFY_IS_APPROX(x, m1(rows - 1 - r, cols - 1 - c));

8
test/bandmatrix.cpp
View File

@@ -78,10 +78,10 @@ void test_bandmatrix()
typedef BandMatrix<float>::Index Index;
for(int i = 0; i < 10*g_repeat ; i++) {
Index rows = ei_random<Index>(1,10);
Index cols = ei_random<Index>(1,10);
Index sups = ei_random<Index>(0,cols-1);
Index subs = ei_random<Index>(0,rows-1);
Index rows = internal::random<Index>(1,10);
Index cols = internal::random<Index>(1,10);
Index sups = internal::random<Index>(0,cols-1);
Index subs = internal::random<Index>(0,rows-1);
CALL_SUBTEST(bandmatrix(BandMatrix<float>(rows,cols,sups,subs)) );
}
}

32
test/basicstuff.cpp
View File

@@ -50,10 +50,10 @@ template<typename MatrixType> void basicStuff(const MatrixType& m)
vzero = VectorType::Zero(rows);
SquareMatrixType sm1 = SquareMatrixType::Random(rows,rows), sm2(rows,rows);
Scalar x = ei_random<Scalar>();
Scalar x = internal::random<Scalar>();
Index r = ei_random<Index>(0, rows-1),
c = ei_random<Index>(0, cols-1);
Index r = internal::random<Index>(0, rows-1),
c = internal::random<Index>(0, cols-1);
m1.coeffRef(r,c) = x;
VERIFY_IS_APPROX(x, m1.coeff(r,c));
@@ -156,14 +156,14 @@ template<typename MatrixType> void basicStuffComplex(const MatrixType& m)
Index rows = m.rows();
Index cols = m.cols();
Scalar s1 = ei_random<Scalar>(),
s2 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>(),
s2 = internal::random<Scalar>();
VERIFY(ei_real(s1)==ei_real_ref(s1));
VERIFY(ei_imag(s1)==ei_imag_ref(s1));
ei_real_ref(s1) = ei_real(s2);
ei_imag_ref(s1) = ei_imag(s2);
VERIFY(ei_isApprox(s1, s2, NumTraits<RealScalar>::epsilon()));
VERIFY(internal::real(s1)==internal::real_ref(s1));
VERIFY(internal::imag(s1)==internal::imag_ref(s1));
internal::real_ref(s1) = internal::real(s2);
internal::imag_ref(s1) = internal::imag(s2);
VERIFY(internal::isApprox(s1, s2, NumTraits<RealScalar>::epsilon()));
// extended precision in Intel FPUs means that s1 == s2 in the line above is not guaranteed.
RealMatrixType rm1 = RealMatrixType::Random(rows,cols),
@@ -200,14 +200,14 @@ void test_basicstuff()
for(int i = 0; i < g_repeat; i++) {
CALL_SUBTEST_1( basicStuff(Matrix<float, 1, 1>()) );
CALL_SUBTEST_2( basicStuff(Matrix4d()) );
CALL_SUBTEST_3( basicStuff(MatrixXcf(ei_random<int>(1,100), ei_random<int>(1,100))) );
CALL_SUBTEST_4( basicStuff(MatrixXi(ei_random<int>(1,100), ei_random<int>(1,100))) );
CALL_SUBTEST_5( basicStuff(MatrixXcd(ei_random<int>(1,100), ei_random<int>(1,100))) );
CALL_SUBTEST_3( basicStuff(MatrixXcf(internal::random<int>(1,100), internal::random<int>(1,100))) );
CALL_SUBTEST_4( basicStuff(MatrixXi(internal::random<int>(1,100), internal::random<int>(1,100))) );
CALL_SUBTEST_5( basicStuff(MatrixXcd(internal::random<int>(1,100), internal::random<int>(1,100))) );
CALL_SUBTEST_6( basicStuff(Matrix<float, 100, 100>()) );
CALL_SUBTEST_7( basicStuff(Matrix<long double,Dynamic,Dynamic>(ei_random<int>(1,100),ei_random<int>(1,100))) );
CALL_SUBTEST_7( basicStuff(Matrix<long double,Dynamic,Dynamic>(internal::random<int>(1,100),internal::random<int>(1,100))) );
CALL_SUBTEST_3( basicStuffComplex(MatrixXcf(ei_random<int>(1,100), ei_random<int>(1,100))) );
CALL_SUBTEST_5( basicStuffComplex(MatrixXcd(ei_random<int>(1,100), ei_random<int>(1,100))) );
CALL_SUBTEST_3( basicStuffComplex(MatrixXcf(internal::random<int>(1,100), internal::random<int>(1,100))) );
CALL_SUBTEST_5( basicStuffComplex(MatrixXcd(internal::random<int>(1,100), internal::random<int>(1,100))) );
}
CALL_SUBTEST_2(casting());

32
test/block.cpp
View File

@@ -48,12 +48,12 @@ template<typename MatrixType> void block(const MatrixType& m)
v3 = VectorType::Random(rows),
vzero = VectorType::Zero(rows);
Scalar s1 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>();
Index r1 = ei_random<Index>(0,rows-1);
Index r2 = ei_random<Index>(r1,rows-1);
Index c1 = ei_random<Index>(0,cols-1);
Index c2 = ei_random<Index>(c1,cols-1);
Index r1 = internal::random<Index>(0,rows-1);
Index r2 = internal::random<Index>(r1,rows-1);
Index c1 = internal::random<Index>(0,cols-1);
Index c2 = internal::random<Index>(c1,cols-1);
//check row() and col()
VERIFY_IS_EQUAL(m1.col(c1).transpose(), m1.transpose().row(c1));
@@ -100,16 +100,16 @@ template<typename MatrixType> void block(const MatrixType& m)
VERIFY_IS_EQUAL(v1.template tail<2>(), v1.tail(2));
VERIFY_IS_EQUAL(v1.template tail<2>(), v1.segment(i,2));
VERIFY_IS_EQUAL(v1.template tail<2>(), v1.template segment<2>(i));
i = ei_random<Index>(0,rows-2);
i = internal::random<Index>(0,rows-2);
VERIFY_IS_EQUAL(v1.segment(i,2), v1.template segment<2>(i));
}
// stress some basic stuffs with block matrices
VERIFY(ei_real(ones.col(c1).sum()) == RealScalar(rows));
VERIFY(ei_real(ones.row(r1).sum()) == RealScalar(cols));
VERIFY(internal::real(ones.col(c1).sum()) == RealScalar(rows));
VERIFY(internal::real(ones.row(r1).sum()) == RealScalar(cols));
VERIFY(ei_real(ones.col(c1).dot(ones.col(c2))) == RealScalar(rows));
VERIFY(ei_real(ones.row(r1).dot(ones.row(r2))) == RealScalar(cols));
VERIFY(internal::real(ones.col(c1).dot(ones.col(c2))) == RealScalar(rows));
VERIFY(internal::real(ones.row(r1).dot(ones.row(r2))) == RealScalar(cols));
// now test some block-inside-of-block.
@@ -197,10 +197,10 @@ void data_and_stride(const MatrixType& m)
Index rows = m.rows();
Index cols = m.cols();
Index r1 = ei_random<Index>(0,rows-1);
Index r2 = ei_random<Index>(r1,rows-1);
Index c1 = ei_random<Index>(0,cols-1);
Index c2 = ei_random<Index>(c1,cols-1);
Index r1 = internal::random<Index>(0,rows-1);
Index r2 = internal::random<Index>(r1,rows-1);
Index c1 = internal::random<Index>(0,cols-1);
Index c2 = internal::random<Index>(c1,cols-1);
MatrixType m1 = MatrixType::Random(rows, cols);
compare_using_data_and_stride(m1.block(r1, c1, r2-r1+1, c2-c1+1));
@@ -224,8 +224,8 @@ void test_block()
CALL_SUBTEST_8( block(Matrix<float,Dynamic,4>(3, 4)) );
#ifndef EIGEN_DEFAULT_TO_ROW_MAJOR
CALL_SUBTEST_6( data_and_stride(MatrixXf(ei_random(5,50), ei_random(5,50))) );
CALL_SUBTEST_7( data_and_stride(Matrix<int,Dynamic,Dynamic,RowMajor>(ei_random(5,50), ei_random(5,50))) );
CALL_SUBTEST_6( data_and_stride(MatrixXf(internal::random(5,50), internal::random(5,50))) );
CALL_SUBTEST_7( data_and_stride(Matrix<int,Dynamic,Dynamic,RowMajor>(internal::random(5,50), internal::random(5,50))) );
#endif
}
}

10
test/cholesky.cpp
View File

@@ -78,7 +78,7 @@ template<typename MatrixType> void cholesky(const MatrixType& m)
//symm.template part<StrictlyLower>().setZero();
#ifdef HAS_GSL
// if (ei_is_same_type<RealScalar,double>::ret)
// if (internal::is_same_type<RealScalar,double>::ret)
// {
// typedef GslTraits<Scalar> Gsl;
// typename Gsl::Matrix gMatA=0, gSymm=0;
@@ -128,7 +128,7 @@ template<typename MatrixType> void cholesky(const MatrixType& m)
// LDLT
{
int sign = ei_random<int>()%2 ? 1 : -1;
int sign = internal::random<int>()%2 ? 1 : -1;
if(sign == -1)
{
@@ -226,7 +226,7 @@ template<typename MatrixType> void cholesky_cplx(const MatrixType& m)
// LDLT
{
int sign = ei_random<int>()%2 ? 1 : -1;
int sign = internal::random<int>()%2 ? 1 : -1;
if(sign == -1)
{
@@ -273,9 +273,9 @@ void test_cholesky()
CALL_SUBTEST_3( cholesky(Matrix2d()) );
CALL_SUBTEST_4( cholesky(Matrix3f()) );
CALL_SUBTEST_5( cholesky(Matrix4d()) );
s = ei_random<int>(1,200);
s = internal::random<int>(1,200);
CALL_SUBTEST_2( cholesky(MatrixXd(s,s)) );
s = ei_random<int>(1,100);
s = internal::random<int>(1,100);
CALL_SUBTEST_6( cholesky_cplx(MatrixXcd(s,s)) );
}

12
test/conservative_resize.cpp
View File

@@ -52,8 +52,8 @@ void run_matrix_tests()
// random shrinking ...
for (int i=0; i<25; ++i)
{
const Index rows = ei_random<Index>(1,50);
const Index cols = ei_random<Index>(1,50);
const Index rows = internal::random<Index>(1,50);
const Index cols = internal::random<Index>(1,50);
m = n = MatrixType::Random(50,50);
m.conservativeResize(rows,cols);
VERIFY_IS_APPROX(m, n.block(0,0,rows,cols));
@@ -62,8 +62,8 @@ void run_matrix_tests()
// random growing with zeroing ...
for (int i=0; i<25; ++i)
{
const Index rows = ei_random<Index>(50,75);
const Index cols = ei_random<Index>(50,75);
const Index rows = internal::random<Index>(50,75);
const Index cols = internal::random<Index>(50,75);
m = n = MatrixType::Random(50,50);
m.conservativeResizeLike(MatrixType::Zero(rows,cols));
VERIFY_IS_APPROX(m.block(0,0,n.rows(),n.cols()), n);
@@ -91,7 +91,7 @@ void run_vector_tests()
// random shrinking ...
for (int i=0; i<50; ++i)
{
const int size = ei_random<int>(1,50);
const int size = internal::random<int>(1,50);
m = n = MatrixType::Random(50);
m.conservativeResize(size);
VERIFY_IS_APPROX(m, n.segment(0,size));
@@ -100,7 +100,7 @@ void run_vector_tests()
// random growing with zeroing ...
for (int i=0; i<50; ++i)
{
const int size = ei_random<int>(50,100);
const int size = internal::random<int>(50,100);
m = n = MatrixType::Random(50);
m.conservativeResizeLike(MatrixType::Zero(size));
VERIFY_IS_APPROX(m.segment(0,50), n);

12
test/corners.cpp
View File

@@ -34,8 +34,8 @@ template<typename MatrixType> void corners(const MatrixType& m)
Index rows = m.rows();
Index cols = m.cols();
Index r = ei_random<Index>(1,rows);
Index c = ei_random<Index>(1,cols);
Index r = internal::random<Index>(1,rows);
Index c = internal::random<Index>(1,cols);
MatrixType matrix = MatrixType::Random(rows,cols);
const MatrixType const_matrix = MatrixType::Random(rows,cols);
@@ -45,10 +45,10 @@ template<typename MatrixType> void corners(const MatrixType& m)
COMPARE_CORNER(bottomLeftCorner(r,c), block(rows-r,0,r,c));
COMPARE_CORNER(bottomRightCorner(r,c), block(rows-r,cols-c,r,c));
Index sr = ei_random<Index>(1,rows) - 1;
Index nr = ei_random<Index>(1,rows-sr);
Index sc = ei_random<Index>(1,cols) - 1;
Index nc = ei_random<Index>(1,cols-sc);
Index sr = internal::random<Index>(1,rows) - 1;
Index nr = internal::random<Index>(1,rows-sr);
Index sc = internal::random<Index>(1,cols) - 1;
Index nc = internal::random<Index>(1,cols-sc);
COMPARE_CORNER(topRows(r), block(0,0,r,cols));
COMPARE_CORNER(middleRows(sr,nr), block(sr,0,nr,cols));

6
test/cwiseop.cpp
View File

@@ -60,10 +60,10 @@ template<typename MatrixType> void cwiseops(const MatrixType& m)
vones = VectorType::Ones(rows),
v3(rows);
Index r = ei_random<Index>(0, rows-1),
c = ei_random<Index>(0, cols-1);
Index r = internal::random<Index>(0, rows-1),
c = internal::random<Index>(0, cols-1);
Scalar s1 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>();
// test Zero, Ones, Constant, and the set* variants
m3 = MatrixType::Constant(rows, cols, s1);

8
test/determinant.cpp
View File

@@ -38,14 +38,14 @@ template<typename MatrixType> void determinant(const MatrixType& m)
m1.setRandom();
m2.setRandom();
typedef typename MatrixType::Scalar Scalar;
Scalar x = ei_random<Scalar>();
Scalar x = internal::random<Scalar>();
VERIFY_IS_APPROX(MatrixType::Identity(size, size).determinant(), Scalar(1));
VERIFY_IS_APPROX((m1*m2).eval().determinant(), m1.determinant() * m2.determinant());
if(size==1) return;
Index i = ei_random<Index>(0, size-1);
Index i = internal::random<Index>(0, size-1);
Index j;
do {
j = ei_random<Index>(0, size-1);
j = internal::random<Index>(0, size-1);
} while(j==i);
m2 = m1;
m2.row(i).swap(m2.row(j));
@@ -54,7 +54,7 @@ template<typename MatrixType> void determinant(const MatrixType& m)
m2.col(i).swap(m2.col(j));
VERIFY_IS_APPROX(m2.determinant(), -m1.determinant());
VERIFY_IS_APPROX(m2.determinant(), m2.transpose().determinant());
VERIFY_IS_APPROX(ei_conj(m2.determinant()), m2.adjoint().determinant());
VERIFY_IS_APPROX(internal::conj(m2.determinant()), m2.adjoint().determinant());
m2 = m1;
m2.row(i) += x*m2.row(j);
VERIFY_IS_APPROX(m2.determinant(), m1.determinant());

4
test/diagonalmatrices.cpp
View File

@@ -66,8 +66,8 @@ template<typename MatrixType> void diagonalmatrices(const MatrixType& m)
sq_m1.transpose() = ldm1;
VERIFY_IS_APPROX(sq_m1, ldm1.toDenseMatrix());
Index i = ei_random<Index>(0, rows-1);
Index j = ei_random<Index>(0, cols-1);
Index i = internal::random<Index>(0, rows-1);
Index j = internal::random<Index>(0, cols-1);
VERIFY_IS_APPROX( ((ldm1 * m1)(i,j)) , ldm1.diagonal()(i) * m1(i,j) );
VERIFY_IS_APPROX( ((ldm1 * (m1+m2))(i,j)) , ldm1.diagonal()(i) * (m1+m2)(i,j) );

12
test/dynalloc.cpp
View File

@@ -34,11 +34,11 @@ void check_handmade_aligned_malloc()
{
for(int i = 1; i < 1000; i++)
{
char *p = (char*)ei_handmade_aligned_malloc(i);
char *p = (char*)internal::handmade_aligned_malloc(i);
VERIFY(size_t(p)%ALIGNMENT==0);
// if the buffer is wrongly allocated this will give a bad write --> check with valgrind
for(int j = 0; j < i; j++) p[j]=0;
ei_handmade_aligned_free(p);
internal::handmade_aligned_free(p);
}
}
@@ -46,11 +46,11 @@ void check_aligned_malloc()
{
for(int i = 1; i < 1000; i++)
{
char *p = (char*)ei_aligned_malloc(i);
char *p = (char*)internal::aligned_malloc(i);
VERIFY(size_t(p)%ALIGNMENT==0);
// if the buffer is wrongly allocated this will give a bad write --> check with valgrind
for(int j = 0; j < i; j++) p[j]=0;
ei_aligned_free(p);
internal::aligned_free(p);
}
}
@@ -58,11 +58,11 @@ void check_aligned_new()
{
for(int i = 1; i < 1000; i++)
{
float *p = ei_aligned_new<float>(i);
float *p = internal::aligned_new<float>(i);
VERIFY(size_t(p)%ALIGNMENT==0);
// if the buffer is wrongly allocated this will give a bad write --> check with valgrind
for(int j = 0; j < i; j++) p[j]=0;
ei_aligned_delete(p,i);
internal::aligned_delete(p,i);
}
}

4
test/eigen2support.cpp
View File

@@ -38,8 +38,8 @@ template<typename MatrixType> void eigen2support(const MatrixType& m)
m2 = MatrixType::Random(rows, cols),
m3(rows, cols);
Scalar s1 = ei_random<Scalar>(),
s2 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>(),
s2 = internal::random<Scalar>();
// scalar addition
VERIFY_IS_APPROX(m1.cwise() + s1, s1 + m1.cwise());

2
test/eigensolver_selfadjoint.cpp
View File

@@ -63,7 +63,7 @@ template<typename MatrixType> void selfadjointeigensolver(const MatrixType& m)
GeneralizedSelfAdjointEigenSolver<MatrixType> eiSymmGen(symmA, symmB);
#ifdef HAS_GSL
if (ei_is_same_type<RealScalar,double>::ret)
if (internal::is_same_type<RealScalar,double>::ret)
{
// restore symmA and symmB.
symmA = MatrixType(symmA.template selfadjointView<Lower>());

6
test/first_aligned.cpp
View File

@@ -27,8 +27,8 @@
template<typename Scalar>
void test_first_aligned_helper(Scalar *array, int size)
{
const int packet_size = sizeof(Scalar) * ei_packet_traits<Scalar>::size;
VERIFY(((size_t(array) + sizeof(Scalar) * ei_first_aligned(array, size)) % packet_size) == 0);
const int packet_size = sizeof(Scalar) * internal::packet_traits<Scalar>::size;
VERIFY(((size_t(array) + sizeof(Scalar) * internal::first_aligned(array, size)) % packet_size) == 0);
}
template<typename Scalar>
@@ -36,7 +36,7 @@ void test_none_aligned_helper(Scalar *array, int size)
{
EIGEN_UNUSED_VARIABLE(array);
EIGEN_UNUSED_VARIABLE(size);
VERIFY(ei_packet_traits<Scalar>::size == 1 || ei_first_aligned(array, size) == size);
VERIFY(internal::packet_traits<Scalar>::size == 1 || internal::first_aligned(array, size) == size);
}
struct some_non_vectorizable_type { float x; };

4
test/geo_alignedbox.cpp
View File

@@ -46,7 +46,7 @@ template<typename BoxType> void alignedbox(const BoxType& _box)
VectorType p1 = VectorType::Random(dim);
while( p1 == p0 ){
p1 = VectorType::Random(dim); }
RealScalar s1 = ei_random<RealScalar>(0,1);
RealScalar s1 = internal::random<RealScalar>(0,1);
BoxType b0(dim);
BoxType b1(VectorType::Random(dim),VectorType::Random(dim));
@@ -124,7 +124,7 @@ void specificTest1()
VERIFY_IS_APPROX( 14.0f, box.volume() );
VERIFY_IS_APPROX( 53.0f, box.diagonal().squaredNorm() );
VERIFY_IS_APPROX( ei_sqrt( 53.0f ), box.diagonal().norm() );
VERIFY_IS_APPROX( internal::sqrt( 53.0f ), box.diagonal().norm() );
VERIFY_IS_APPROX( m, box.corner( BoxType::BottomLeft ) );
VERIFY_IS_APPROX( M, box.corner( BoxType::TopRight ) );

2
test/geo_eulerangles.cpp
View File

@@ -34,7 +34,7 @@ template<typename Scalar> void eulerangles(void)
typedef Quaternion<Scalar> Quaternionx;
typedef AngleAxis<Scalar> AngleAxisx;
Scalar a = ei_random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
Scalar a = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
Quaternionx q1;
q1 = AngleAxisx(a, Vector3::Random().normalized());
Matrix3 m;

2
test/geo_homogeneous.cpp
View File

@@ -42,7 +42,7 @@ template<typename Scalar,int Size> void homogeneous(void)
typedef Matrix<Scalar,Size+1,Size> T3MatrixType;
Scalar largeEps = test_precision<Scalar>();
if (ei_is_same_type<Scalar,float>::ret)
if (internal::is_same_type<Scalar,float>::ret)
largeEps = 1e-3f;
VectorType v0 = VectorType::Random(),

8
test/geo_hyperplane.cpp
View File

@@ -51,8 +51,8 @@ template<typename HyperplaneType> void hyperplane(const HyperplaneType& _plane)
HyperplaneType pl1(n1, p1);
HyperplaneType pl2 = pl1;
Scalar s0 = ei_random<Scalar>();
Scalar s1 = ei_random<Scalar>();
Scalar s0 = internal::random<Scalar>();
Scalar s1 = internal::random<Scalar>();
VERIFY_IS_APPROX( n1.dot(n1), Scalar(1) );
@@ -103,8 +103,8 @@ template<typename Scalar> void lines()
Vector center = Vector::Random();
Vector u = Vector::Random();
Vector v = Vector::Random();
Scalar a = ei_random<Scalar>();
while (ei_abs(a-1) < 1e-4) a = ei_random<Scalar>();
Scalar a = internal::random<Scalar>();
while (internal::abs(a-1) < 1e-4) a = internal::random<Scalar>();
while (u.norm() < 1e-4) u = Vector::Random();
while (v.norm() < 1e-4) v = Vector::Random();

4
test/geo_orthomethods.cpp
View File

@@ -55,7 +55,7 @@ template<typename Scalar> void orthomethods_3()
mat3.setRandom();
Vector3 vec3 = Vector3::Random();
Matrix3 mcross;
int i = ei_random<int>(0,2);
int i = internal::random<int>(0,2);
mcross = mat3.colwise().cross(vec3);
VERIFY_IS_APPROX(mcross.col(i), mat3.col(i).cross(vec3));
mcross = mat3.rowwise().cross(vec3);
@@ -97,7 +97,7 @@ template<typename Scalar, int Size> void orthomethods(int size=Size)
// colwise/rowwise cross product
Vector3 vec3 = Vector3::Random();
int i = ei_random<int>(0,size-1);
int i = internal::random<int>(0,size-1);
Matrix3N mat3N(3,size), mcross3N(3,size);
mat3N.setRandom();

4
test/geo_parametrizedline.cpp
View File

@@ -48,8 +48,8 @@ template<typename LineType> void parametrizedline(const LineType& _line)
LineType l0(p0, d0);
Scalar s0 = ei_random<Scalar>();
Scalar s1 = ei_abs(ei_random<Scalar>());
Scalar s0 = internal::random<Scalar>();
Scalar s1 = internal::abs(internal::random<Scalar>());
VERIFY_IS_MUCH_SMALLER_THAN( l0.distance(p0), RealScalar(1) );
VERIFY_IS_MUCH_SMALLER_THAN( l0.distance(p0+s0*d0), RealScalar(1) );

12
test/geo_quaternion.cpp
View File

@@ -40,17 +40,17 @@ template<typename Scalar> void quaternion(void)
typedef AngleAxis<Scalar> AngleAxisx;
Scalar largeEps = test_precision<Scalar>();
if (ei_is_same_type<Scalar,float>::ret)
if (internal::is_same_type<Scalar,float>::ret)
largeEps = 1e-3f;
Scalar eps = ei_random<Scalar>() * Scalar(1e-2);
Scalar eps = internal::random<Scalar>() * Scalar(1e-2);
Vector3 v0 = Vector3::Random(),
v1 = Vector3::Random(),
v2 = Vector3::Random(),
v3 = Vector3::Random();
Scalar a = ei_random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
Scalar a = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
// Quaternion: Identity(), setIdentity();
Quaternionx q1, q2;
@@ -66,13 +66,13 @@ template<typename Scalar> void quaternion(void)
q2 = AngleAxisx(a, v1.normalized());
// angular distance
Scalar refangle = ei_abs(AngleAxisx(q1.inverse()*q2).angle());
Scalar refangle = internal::abs(AngleAxisx(q1.inverse()*q2).angle());
if (refangle>Scalar(M_PI))
refangle = Scalar(2)*Scalar(M_PI) - refangle;
if((q1.coeffs()-q2.coeffs()).norm() > 10*largeEps)
{
VERIFY(ei_isApprox(q1.angularDistance(q2), refangle, largeEps));
VERIFY(internal::isApprox(q1.angularDistance(q2), refangle, largeEps));
}
// rotation matrix conversion
@@ -96,7 +96,7 @@ template<typename Scalar> void quaternion(void)
VERIFY_IS_APPROX( v2.normalized(),(q2.setFromTwoVectors(v1, v2)*v1).normalized());
VERIFY_IS_APPROX( v1.normalized(),(q2.setFromTwoVectors(v1, v1)*v1).normalized());
VERIFY_IS_APPROX(-v1.normalized(),(q2.setFromTwoVectors(v1,-v1)*v1).normalized());
if (ei_is_same_type<Scalar,double>::ret)
if (internal::is_same_type<Scalar,double>::ret)
{
v3 = (v1.array()+eps).matrix();
VERIFY_IS_APPROX( v3.normalized(),(q2.setFromTwoVectors(v1, v3)*v1).normalized());

22
test/geo_transformations.cpp
View File

@@ -51,7 +51,7 @@ template<typename Scalar, int Mode> void non_projective_only(void)
typedef Translation<Scalar,3> Translation3;
Scalar largeEps = test_precision<Scalar>();
if (ei_is_same_type<Scalar,float>::ret)
if (internal::is_same_type<Scalar,float>::ret)
largeEps = 1e-2f;
Vector3 v0 = Vector3::Random(),
@@ -59,7 +59,7 @@ template<typename Scalar, int Mode> void non_projective_only(void)
Transform3 t0, t1, t2;
Scalar a = ei_random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
Scalar a = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
Quaternionx q1, q2;
@@ -126,7 +126,7 @@ template<typename Scalar, int Mode> void transformations(void)
typedef Translation<Scalar,3> Translation3;
Scalar largeEps = test_precision<Scalar>();
if (ei_is_same_type<Scalar,float>::ret)
if (internal::is_same_type<Scalar,float>::ret)
largeEps = 1e-2f;
Vector3 v0 = Vector3::Random(),
@@ -135,12 +135,12 @@ template<typename Scalar, int Mode> void transformations(void)
Vector2 u0 = Vector2::Random();
Matrix3 matrot1, m;
Scalar a = ei_random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
Scalar s0 = ei_random<Scalar>();
Scalar a = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
Scalar s0 = internal::random<Scalar>();
VERIFY_IS_APPROX(v0, AngleAxisx(a, v0.normalized()) * v0);
VERIFY_IS_APPROX(-v0, AngleAxisx(Scalar(M_PI), v0.unitOrthogonal()) * v0);
VERIFY_IS_APPROX(ei_cos(a)*v0.squaredNorm(), v0.dot(AngleAxisx(a, v0.unitOrthogonal()) * v0));
VERIFY_IS_APPROX(internal::cos(a)*v0.squaredNorm(), v0.dot(AngleAxisx(a, v0.unitOrthogonal()) * v0));
m = AngleAxisx(a, v0.normalized()).toRotationMatrix().adjoint();
VERIFY_IS_APPROX(Matrix3::Identity(), m * AngleAxisx(a, v0.normalized()));
VERIFY_IS_APPROX(Matrix3::Identity(), AngleAxisx(a, v0.normalized()) * m);
@@ -180,8 +180,8 @@ template<typename Scalar, int Mode> void transformations(void)
// Transform
// TODO complete the tests !
a = 0;
while (ei_abs(a)<Scalar(0.1))
a = ei_random<Scalar>(-Scalar(0.4)*Scalar(M_PI), Scalar(0.4)*Scalar(M_PI));
while (internal::abs(a)<Scalar(0.1))
a = internal::random<Scalar>(-Scalar(0.4)*Scalar(M_PI), Scalar(0.4)*Scalar(M_PI));
q1 = AngleAxisx(a, v0.normalized());
Transform3 t0, t1, t2;
@@ -227,7 +227,7 @@ template<typename Scalar, int Mode> void transformations(void)
tmat4.matrix()(3,3) = Scalar(1);
VERIFY_IS_APPROX(tmat3.matrix(), tmat4.matrix());
Scalar a3 = ei_random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
Scalar a3 = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
Vector3 v3 = Vector3::Random().normalized();
AngleAxisx aa3(a3, v3);
Transform3 t3(aa3);
@@ -274,7 +274,7 @@ template<typename Scalar, int Mode> void transformations(void)
Vector2 v20 = Vector2::Random();
Vector2 v21 = Vector2::Random();
for (int k=0; k<2; ++k)
if (ei_abs(v21[k])<Scalar(1e-3)) v21[k] = Scalar(1e-3);
if (internal::abs(v21[k])<Scalar(1e-3)) v21[k] = Scalar(1e-3);
t21.setIdentity();
t21.linear() = Rotation2D<Scalar>(a).toRotationMatrix();
VERIFY_IS_APPROX(t20.fromPositionOrientationScale(v20,a,v21).matrix(),
@@ -411,7 +411,7 @@ template<typename Scalar, int Mode> void transformations(void)
AngleAxis<double> aa1d = aa1.template cast<double>();
VERIFY_IS_APPROX(aa1d.template cast<Scalar>(),aa1);
Rotation2D<Scalar> r2d1(ei_random<Scalar>());
Rotation2D<Scalar> r2d1(internal::random<Scalar>());
Rotation2D<float> r2d1f = r2d1.template cast<float>();
VERIFY_IS_APPROX(r2d1f.template cast<Scalar>(),r2d1);
Rotation2D<double> r2d1d = r2d1.template cast<double>();

4
test/hessenberg.cpp
View File

@@ -69,8 +69,8 @@ void test_hessenberg()
CALL_SUBTEST_1(( hessenberg<std::complex<double>,1>() ));
CALL_SUBTEST_2(( hessenberg<std::complex<double>,2>() ));
CALL_SUBTEST_3(( hessenberg<std::complex<float>,4>() ));
CALL_SUBTEST_4(( hessenberg<float,Dynamic>(ei_random<int>(1,320)) ));
CALL_SUBTEST_5(( hessenberg<std::complex<double>,Dynamic>(ei_random<int>(1,320)) ));
CALL_SUBTEST_4(( hessenberg<float,Dynamic>(internal::random<int>(1,320)) ));
CALL_SUBTEST_5(( hessenberg<std::complex<double>,Dynamic>(internal::random<int>(1,320)) ));
// Test problem size constructors
CALL_SUBTEST_6(HessenbergDecomposition<MatrixXf>(10));

12
test/householder.cpp
View File

@@ -39,7 +39,7 @@ template<typename MatrixType> void householder(const MatrixType& m)
typedef typename MatrixType::Scalar Scalar;
typedef typename NumTraits<Scalar>::Real RealScalar;
typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
typedef Matrix<Scalar, ei_decrement_size<MatrixType::RowsAtCompileTime>::ret, 1> EssentialVectorType;
typedef Matrix<Scalar, internal::decrement_size<MatrixType::RowsAtCompileTime>::ret, 1> EssentialVectorType;
typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> SquareMatrixType;
typedef Matrix<Scalar, Dynamic, MatrixType::ColsAtCompileTime> HBlockMatrixType;
typedef Matrix<Scalar, Dynamic, 1> HCoeffsVectorType;
@@ -77,8 +77,8 @@ template<typename MatrixType> void householder(const MatrixType& m)
m1.applyHouseholderOnTheLeft(essential,beta,tmp);
VERIFY_IS_APPROX(m1.norm(), m2.norm());
if(rows>=2) VERIFY_IS_MUCH_SMALLER_THAN(m1.block(1,0,rows-1,cols).norm(), m1.norm());
VERIFY_IS_MUCH_SMALLER_THAN(ei_imag(m1(0,0)), ei_real(m1(0,0)));
VERIFY_IS_APPROX(ei_real(m1(0,0)), alpha);
VERIFY_IS_MUCH_SMALLER_THAN(internal::imag(m1(0,0)), internal::real(m1(0,0)));
VERIFY_IS_APPROX(internal::real(m1(0,0)), alpha);
v1 = VectorType::Random(rows);
if(even) v1.tail(rows-1).setZero();
@@ -89,12 +89,12 @@ template<typename MatrixType> void householder(const MatrixType& m)
m3.applyHouseholderOnTheRight(essential,beta,tmp);
VERIFY_IS_APPROX(m3.norm(), m4.norm());
if(rows>=2) VERIFY_IS_MUCH_SMALLER_THAN(m3.block(0,1,rows,rows-1).norm(), m3.norm());
VERIFY_IS_MUCH_SMALLER_THAN(ei_imag(m3(0,0)), ei_real(m3(0,0)));
VERIFY_IS_APPROX(ei_real(m3(0,0)), alpha);
VERIFY_IS_MUCH_SMALLER_THAN(internal::imag(m3(0,0)), internal::real(m3(0,0)));
VERIFY_IS_APPROX(internal::real(m3(0,0)), alpha);
// test householder sequence on the left with a shift
Index shift = ei_random<Index>(0, std::max<Index>(rows-2,0));
Index shift = internal::random<Index>(0, std::max<Index>(rows-2,0));
Index brows = rows - shift;
m1.setRandom(rows, cols);
HBlockMatrixType hbm = m1.block(shift,0,brows,cols);

4
test/integer_types.cpp
View File

@@ -54,7 +54,7 @@ template<typename MatrixType> void signed_integer_type_tests(const MatrixType& m
Scalar s1;
do {
s1 = ei_random<Scalar>();
s1 = internal::random<Scalar>();
} while(s1 == 0);
VERIFY_IS_EQUAL(-(-m1), m1);
@@ -126,7 +126,7 @@ template<typename MatrixType> void integer_type_tests(const MatrixType& m)
Scalar s1;
do {
s1 = ei_random<Scalar>();
s1 = internal::random<Scalar>();
} while(s1 == 0);
VERIFY_IS_EQUAL(m1+m1, 2*m1);

6
test/inverse.cpp
View File

@@ -79,7 +79,7 @@ template<typename MatrixType> void inverse(const MatrixType& m)
MatrixType m3 = v3*v3.transpose(), m4(rows,cols);
m3.computeInverseAndDetWithCheck(m4, det, invertible);
VERIFY( rows==1 ? invertible : !invertible );
VERIFY_IS_MUCH_SMALLER_THAN(ei_abs(det-m3.determinant()), RealScalar(1));
VERIFY_IS_MUCH_SMALLER_THAN(internal::abs(det-m3.determinant()), RealScalar(1));
m3.computeInverseWithCheck(m4, invertible);
VERIFY( rows==1 ? invertible : !invertible );
#endif
@@ -107,9 +107,9 @@ void test_inverse()
CALL_SUBTEST_3( inverse(Matrix3f()) );
CALL_SUBTEST_4( inverse(Matrix4f()) );
CALL_SUBTEST_4( inverse(Matrix<float,4,4,DontAlign>()) );
s = ei_random<int>(50,320);
s = internal::random<int>(50,320);
CALL_SUBTEST_5( inverse(MatrixXf(s,s)) );
s = ei_random<int>(25,100);
s = internal::random<int>(25,100);
CALL_SUBTEST_6( inverse(MatrixXcd(s,s)) );
CALL_SUBTEST_7( inverse(Matrix4d()) );
CALL_SUBTEST_7( inverse(Matrix<double,4,4,DontAlign>()) );

18
test/jacobi.cpp
View File

@@ -48,29 +48,29 @@ void jacobi(const MatrixType& m = MatrixType())
JacobiRotation<JacobiScalar> rot(c, s);
{
Index p = ei_random<Index>(0, rows-1);
Index p = internal::random<Index>(0, rows-1);
Index q;
do {
q = ei_random<Index>(0, rows-1);
q = internal::random<Index>(0, rows-1);
} while (q == p);
MatrixType b = a;
b.applyOnTheLeft(p, q, rot);
VERIFY_IS_APPROX(b.row(p), c * a.row(p) + ei_conj(s) * a.row(q));
VERIFY_IS_APPROX(b.row(q), -s * a.row(p) + ei_conj(c) * a.row(q));
VERIFY_IS_APPROX(b.row(p), c * a.row(p) + internal::conj(s) * a.row(q));
VERIFY_IS_APPROX(b.row(q), -s * a.row(p) + internal::conj(c) * a.row(q));
}
{
Index p = ei_random<Index>(0, cols-1);
Index p = internal::random<Index>(0, cols-1);
Index q;
do {
q = ei_random<Index>(0, cols-1);
q = internal::random<Index>(0, cols-1);
} while (q == p);
MatrixType b = a;
b.applyOnTheRight(p, q, rot);
VERIFY_IS_APPROX(b.col(p), c * a.col(p) - s * a.col(q));
VERIFY_IS_APPROX(b.col(q), ei_conj(s) * a.col(p) + ei_conj(c) * a.col(q));
VERIFY_IS_APPROX(b.col(q), internal::conj(s) * a.col(p) + internal::conj(c) * a.col(q));
}
}
@@ -82,8 +82,8 @@ void test_jacobi()
CALL_SUBTEST_3(( jacobi<Matrix4cf, float>() ));
CALL_SUBTEST_3(( jacobi<Matrix4cf, std::complex<float> >() ));
int r = ei_random<int>(2, 20),
c = ei_random<int>(2, 20);
int r = internal::random<int>(2, 20),
c = internal::random<int>(2, 20);
CALL_SUBTEST_4(( jacobi<MatrixXf, float>(MatrixXf(r,c)) ));
CALL_SUBTEST_5(( jacobi<MatrixXcd, double>(MatrixXcd(r,c)) ));
CALL_SUBTEST_5(( jacobi<MatrixXcd, std::complex<double> >(MatrixXcd(r,c)) ));

14
test/jacobisvd.cpp
View File

@@ -94,7 +94,7 @@ void jacobisvd_solve(const MatrixType& m, unsigned int computationOptions)
typedef Matrix<Scalar, RowsAtCompileTime, Dynamic> RhsType;
typedef Matrix<Scalar, ColsAtCompileTime, Dynamic> SolutionType;
RhsType rhs = RhsType::Random(rows, ei_random<Index>(1, cols));
RhsType rhs = RhsType::Random(rows, internal::random<Index>(1, cols));
JacobiSVD<MatrixType, QRPreconditioner> svd(m, computationOptions);
SolutionType x = svd.solve(rhs);
// evaluate normal equation which works also for least-squares solutions
@@ -230,11 +230,11 @@ void jacobisvd_inf_nan()
svd.compute(MatrixType::Constant(10,10,some_nan), ComputeFullU | ComputeFullV);
MatrixType m = MatrixType::Zero(10,10);
m(ei_random<int>(0,9), ei_random<int>(0,9)) = some_inf;
m(internal::random<int>(0,9), internal::random<int>(0,9)) = some_inf;
svd.compute(m, ComputeFullU | ComputeFullV);
m = MatrixType::Zero(10,10);
m(ei_random<int>(0,9), ei_random<int>(0,9)) = some_nan;
m(internal::random<int>(0,9), internal::random<int>(0,9)) = some_nan;
svd.compute(m, ComputeFullU | ComputeFullV);
}
@@ -267,8 +267,8 @@ void test_jacobisvd()
CALL_SUBTEST_5(( jacobisvd<Matrix<float,3,5> >() ));
CALL_SUBTEST_6(( jacobisvd<Matrix<double,Dynamic,2> >(Matrix<double,Dynamic,2>(10,2)) ));
int r = ei_random<int>(1, 30),
c = ei_random<int>(1, 30);
int r = internal::random<int>(1, 30),
c = internal::random<int>(1, 30);
CALL_SUBTEST_7(( jacobisvd<MatrixXf>(MatrixXf(r,c)) ));
CALL_SUBTEST_8(( jacobisvd<MatrixXcd>(MatrixXcd(r,c)) ));
(void) r;
@@ -278,8 +278,8 @@ void test_jacobisvd()
CALL_SUBTEST_7( jacobisvd_inf_nan<MatrixXf>() );
}
CALL_SUBTEST_7(( jacobisvd<MatrixXf>(MatrixXf(ei_random<int>(100, 150), ei_random<int>(100, 150))) ));
CALL_SUBTEST_8(( jacobisvd<MatrixXcd>(MatrixXcd(ei_random<int>(80, 100), ei_random<int>(80, 100))) ));
CALL_SUBTEST_7(( jacobisvd<MatrixXf>(MatrixXf(internal::random<int>(100, 150), internal::random<int>(100, 150))) ));
CALL_SUBTEST_8(( jacobisvd<MatrixXcd>(MatrixXcd(internal::random<int>(80, 100), internal::random<int>(80, 100))) ));
// test matrixbase method
CALL_SUBTEST_1(( jacobisvd_method<Matrix2cd>() ));

8
test/linearstructure.cpp
View File

@@ -42,11 +42,11 @@ template<typename MatrixType> void linearStructure(const MatrixType& m)
m3(rows, cols),
mzero = MatrixType::Zero(rows, cols);
Scalar s1 = ei_random<Scalar>();
while (ei_abs(s1)<1e-3) s1 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>();
while (internal::abs(s1)<1e-3) s1 = internal::random<Scalar>();
Index r = ei_random<Index>(0, rows-1),
c = ei_random<Index>(0, cols-1);
Index r = internal::random<Index>(0, rows-1),
c = internal::random<Index>(0, cols-1);
VERIFY_IS_APPROX(-(-m1), m1);
VERIFY_IS_APPROX(m1+m1, 2*m1);

16
test/lu.cpp
View File

@@ -37,7 +37,7 @@ template<typename MatrixType> void lu_non_invertible()
Index rows, cols, cols2;
if(MatrixType::RowsAtCompileTime==Dynamic)
{
rows = ei_random<Index>(2,200);
rows = internal::random<Index>(2,200);
}
else
{
@@ -45,8 +45,8 @@ template<typename MatrixType> void lu_non_invertible()
}
if(MatrixType::ColsAtCompileTime==Dynamic)
{
cols = ei_random<Index>(2,200);
cols2 = ei_random<int>(2,200);
cols = internal::random<Index>(2,200);
cols2 = internal::random<int>(2,200);
}
else
{
@@ -57,14 +57,14 @@ template<typename MatrixType> void lu_non_invertible()
RowsAtCompileTime = MatrixType::RowsAtCompileTime,
ColsAtCompileTime = MatrixType::ColsAtCompileTime
};
typedef typename ei_kernel_retval_base<FullPivLU<MatrixType> >::ReturnType KernelMatrixType;
typedef typename ei_image_retval_base<FullPivLU<MatrixType> >::ReturnType ImageMatrixType;
typedef typename internal::kernel_retval_base<FullPivLU<MatrixType> >::ReturnType KernelMatrixType;
typedef typename internal::image_retval_base<FullPivLU<MatrixType> >::ReturnType ImageMatrixType;
typedef Matrix<typename MatrixType::Scalar, ColsAtCompileTime, ColsAtCompileTime>
CMatrixType;
typedef Matrix<typename MatrixType::Scalar, RowsAtCompileTime, RowsAtCompileTime>
RMatrixType;
Index rank = ei_random<Index>(1, std::min(rows, cols)-1);
Index rank = internal::random<Index>(1, std::min(rows, cols)-1);
// The image of the zero matrix should consist of a single (zero) column vector
VERIFY((MatrixType::Zero(rows,cols).fullPivLu().image(MatrixType::Zero(rows,cols)).cols() == 1));
@@ -117,7 +117,7 @@ template<typename MatrixType> void lu_invertible()
*/
typedef typename MatrixType::Scalar Scalar;
typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
int size = ei_random<int>(1,200);
int size = internal::random<int>(1,200);
MatrixType m1(size, size), m2(size, size), m3(size, size);
FullPivLU<MatrixType> lu;
@@ -149,7 +149,7 @@ template<typename MatrixType> void lu_partial_piv()
typedef typename MatrixType::Index Index;
typedef typename MatrixType::Scalar Scalar;
typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
Index rows = ei_random<Index>(1,4);
Index rows = internal::random<Index>(1,4);
Index cols = rows;
MatrixType m1(cols, rows);

132
test/main.h
View File

@@ -71,10 +71,10 @@ namespace Eigen
static bool no_more_assert = false;
static bool report_on_cerr_on_assert_failure = true;
struct ei_assert_exception
struct eigen_assert_exception
{
ei_assert_exception(void) {}
~ei_assert_exception() { Eigen::no_more_assert = false; }
eigen_assert_exception(void) {}
~eigen_assert_exception() { Eigen::no_more_assert = false; }
};
}
@@ -89,52 +89,52 @@ namespace Eigen
namespace Eigen
{
static bool ei_push_assert = false;
static std::vector<std::string> ei_assert_list;
static bool internal::push_assert = false;
static std::vector<std::string> eigen_assert_list;
}
#define ei_assert(a) \
#define eigen_assert(a) \
if( (!(a)) && (!no_more_assert) ) \
{ \
if(report_on_cerr_on_assert_failure) \
std::cerr << #a << " " __FILE__ << "(" << __LINE__ << ")\n"; \
Eigen::no_more_assert = true; \
throw Eigen::ei_assert_exception(); \
throw Eigen::eigen_assert_exception(); \
} \
else if (Eigen::ei_push_assert) \
else if (Eigen::internal::push_assert) \
{ \
ei_assert_list.push_back(std::string(EI_PP_MAKE_STRING(__FILE__)" ("EI_PP_MAKE_STRING(__LINE__)") : "#a) ); \
eigen_assert_list.push_back(std::string(EI_PP_MAKE_STRING(__FILE__)" ("EI_PP_MAKE_STRING(__LINE__)") : "#a) ); \
}
#define VERIFY_RAISES_ASSERT(a) \
{ \
Eigen::no_more_assert = false; \
Eigen::ei_assert_list.clear(); \
Eigen::ei_push_assert = true; \
Eigen::eigen_assert_list.clear(); \
Eigen::internal::push_assert = true; \
Eigen::report_on_cerr_on_assert_failure = false; \
try { \
a; \
std::cerr << "One of the following asserts should have been triggered:\n"; \
for (uint ai=0 ; ai<ei_assert_list.size() ; ++ai) \
std::cerr << " " << ei_assert_list[ai] << "\n"; \
for (uint ai=0 ; ai<eigen_assert_list.size() ; ++ai) \
std::cerr << " " << eigen_assert_list[ai] << "\n"; \
VERIFY(Eigen::should_raise_an_assert && # a); \
} catch (Eigen::ei_assert_exception) { \
Eigen::ei_push_assert = false; VERIFY(true); \
} catch (Eigen::eigen_assert_exception) { \
Eigen::internal::push_assert = false; VERIFY(true); \
} \
Eigen::report_on_cerr_on_assert_failure = true; \
Eigen::ei_push_assert = false; \
Eigen::internal::push_assert = false; \
}
#else // EIGEN_DEBUG_ASSERTS
#define ei_assert(a) \
#define eigen_assert(a) \
if( (!(a)) && (!no_more_assert) ) \
{ \
Eigen::no_more_assert = true; \
if(report_on_cerr_on_assert_failure) \
assert(a); \
else \
throw Eigen::ei_assert_exception(); \
throw Eigen::eigen_assert_exception(); \
}
#define VERIFY_RAISES_ASSERT(a) { \
@@ -144,7 +144,7 @@ namespace Eigen
a; \
VERIFY(Eigen::should_raise_an_assert && # a); \
} \
catch (Eigen::ei_assert_exception&) { VERIFY(true); } \
catch (Eigen::eigen_assert_exception&) { VERIFY(true); } \
Eigen::report_on_cerr_on_assert_failure = true; \
}
@@ -170,12 +170,12 @@ namespace Eigen
} } while (0)
#define VERIFY_IS_EQUAL(a, b) VERIFY(test_is_equal(a, b))
#define VERIFY_IS_APPROX(a, b) VERIFY(test_ei_isApprox(a, b))
#define VERIFY_IS_NOT_APPROX(a, b) VERIFY(!test_ei_isApprox(a, b))
#define VERIFY_IS_MUCH_SMALLER_THAN(a, b) VERIFY(test_ei_isMuchSmallerThan(a, b))
#define VERIFY_IS_NOT_MUCH_SMALLER_THAN(a, b) VERIFY(!test_ei_isMuchSmallerThan(a, b))
#define VERIFY_IS_APPROX_OR_LESS_THAN(a, b) VERIFY(test_ei_isApproxOrLessThan(a, b))
#define VERIFY_IS_NOT_APPROX_OR_LESS_THAN(a, b) VERIFY(!test_ei_isApproxOrLessThan(a, b))
#define VERIFY_IS_APPROX(a, b) VERIFY(test_isApprox(a, b))
#define VERIFY_IS_NOT_APPROX(a, b) VERIFY(!test_isApprox(a, b))
#define VERIFY_IS_MUCH_SMALLER_THAN(a, b) VERIFY(test_isMuchSmallerThan(a, b))
#define VERIFY_IS_NOT_MUCH_SMALLER_THAN(a, b) VERIFY(!test_isMuchSmallerThan(a, b))
#define VERIFY_IS_APPROX_OR_LESS_THAN(a, b) VERIFY(test_isApproxOrLessThan(a, b))
#define VERIFY_IS_NOT_APPROX_OR_LESS_THAN(a, b) VERIFY(!test_isApproxOrLessThan(a, b))
#define VERIFY_IS_UNITARY(a) VERIFY(test_isUnitary(a))
@@ -290,82 +290,82 @@ template<> inline float test_precision<std::complex<float> >() { return test_pre
template<> inline double test_precision<std::complex<double> >() { return test_precision<double>(); }
template<> inline long double test_precision<long double>() { return 1e-6; }
inline bool test_ei_isApprox(const int& a, const int& b)
{ return ei_isApprox(a, b, test_precision<int>()); }
inline bool test_ei_isMuchSmallerThan(const int& a, const int& b)
{ return ei_isMuchSmallerThan(a, b, test_precision<int>()); }
inline bool test_ei_isApproxOrLessThan(const int& a, const int& b)
{ return ei_isApproxOrLessThan(a, b, test_precision<int>()); }
inline bool test_isApprox(const int& a, const int& b)
{ return internal::isApprox(a, b, test_precision<int>()); }
inline bool test_isMuchSmallerThan(const int& a, const int& b)
{ return internal::isMuchSmallerThan(a, b, test_precision<int>()); }
inline bool test_isApproxOrLessThan(const int& a, const int& b)
{ return internal::isApproxOrLessThan(a, b, test_precision<int>()); }
inline bool test_ei_isApprox(const float& a, const float& b)
{ return ei_isApprox(a, b, test_precision<float>()); }
inline bool test_ei_isMuchSmallerThan(const float& a, const float& b)
{ return ei_isMuchSmallerThan(a, b, test_precision<float>()); }
inline bool test_ei_isApproxOrLessThan(const float& a, const float& b)
{ return ei_isApproxOrLessThan(a, b, test_precision<float>()); }
inline bool test_isApprox(const float& a, const float& b)
{ return internal::isApprox(a, b, test_precision<float>()); }
inline bool test_isMuchSmallerThan(const float& a, const float& b)
{ return internal::isMuchSmallerThan(a, b, test_precision<float>()); }
inline bool test_isApproxOrLessThan(const float& a, const float& b)
{ return internal::isApproxOrLessThan(a, b, test_precision<float>()); }
inline bool test_ei_isApprox(const double& a, const double& b)
inline bool test_isApprox(const double& a, const double& b)
{
bool ret = ei_isApprox(a, b, test_precision<double>());
bool ret = internal::isApprox(a, b, test_precision<double>());
if (!ret) std::cerr
<< std::endl << " actual = " << a
<< std::endl << " expected = " << b << std::endl << std::endl;
return ret;
}
inline bool test_ei_isMuchSmallerThan(const double& a, const double& b)
{ return ei_isMuchSmallerThan(a, b, test_precision<double>()); }
inline bool test_ei_isApproxOrLessThan(const double& a, const double& b)
{ return ei_isApproxOrLessThan(a, b, test_precision<double>()); }
inline bool test_isMuchSmallerThan(const double& a, const double& b)
{ return internal::isMuchSmallerThan(a, b, test_precision<double>()); }
inline bool test_isApproxOrLessThan(const double& a, const double& b)
{ return internal::isApproxOrLessThan(a, b, test_precision<double>()); }
inline bool test_ei_isApprox(const std::complex<float>& a, const std::complex<float>& b)
{ return ei_isApprox(a, b, test_precision<std::complex<float> >()); }
inline bool test_ei_isMuchSmallerThan(const std::complex<float>& a, const std::complex<float>& b)
{ return ei_isMuchSmallerThan(a, b, test_precision<std::complex<float> >()); }
inline bool test_isApprox(const std::complex<float>& a, const std::complex<float>& b)
{ return internal::isApprox(a, b, test_precision<std::complex<float> >()); }
inline bool test_isMuchSmallerThan(const std::complex<float>& a, const std::complex<float>& b)
{ return internal::isMuchSmallerThan(a, b, test_precision<std::complex<float> >()); }
inline bool test_ei_isApprox(const std::complex<double>& a, const std::complex<double>& b)
{ return ei_isApprox(a, b, test_precision<std::complex<double> >()); }
inline bool test_ei_isMuchSmallerThan(const std::complex<double>& a, const std::complex<double>& b)
{ return ei_isMuchSmallerThan(a, b, test_precision<std::complex<double> >()); }
inline bool test_isApprox(const std::complex<double>& a, const std::complex<double>& b)
{ return internal::isApprox(a, b, test_precision<std::complex<double> >()); }
inline bool test_isMuchSmallerThan(const std::complex<double>& a, const std::complex<double>& b)
{ return internal::isMuchSmallerThan(a, b, test_precision<std::complex<double> >()); }
inline bool test_ei_isApprox(const long double& a, const long double& b)
inline bool test_isApprox(const long double& a, const long double& b)
{
bool ret = ei_isApprox(a, b, test_precision<long double>());
bool ret = internal::isApprox(a, b, test_precision<long double>());
if (!ret) std::cerr
<< std::endl << " actual = " << a
<< std::endl << " expected = " << b << std::endl << std::endl;
return ret;
}
inline bool test_ei_isMuchSmallerThan(const long double& a, const long double& b)
{ return ei_isMuchSmallerThan(a, b, test_precision<long double>()); }
inline bool test_ei_isApproxOrLessThan(const long double& a, const long double& b)
{ return ei_isApproxOrLessThan(a, b, test_precision<long double>()); }
inline bool test_isMuchSmallerThan(const long double& a, const long double& b)
{ return internal::isMuchSmallerThan(a, b, test_precision<long double>()); }
inline bool test_isApproxOrLessThan(const long double& a, const long double& b)
{ return internal::isApproxOrLessThan(a, b, test_precision<long double>()); }
template<typename Type1, typename Type2>
inline bool test_ei_isApprox(const Type1& a, const Type2& b)
inline bool test_isApprox(const Type1& a, const Type2& b)
{
return a.isApprox(b, test_precision<typename Type1::Scalar>());
}
template<typename Derived1, typename Derived2>
inline bool test_ei_isMuchSmallerThan(const MatrixBase<Derived1>& m1,
inline bool test_isMuchSmallerThan(const MatrixBase<Derived1>& m1,
const MatrixBase<Derived2>& m2)
{
return m1.isMuchSmallerThan(m2, test_precision<typename ei_traits<Derived1>::Scalar>());
return m1.isMuchSmallerThan(m2, test_precision<typename internal::traits<Derived1>::Scalar>());
}
template<typename Derived>
inline bool test_ei_isMuchSmallerThan(const MatrixBase<Derived>& m,
const typename NumTraits<typename ei_traits<Derived>::Scalar>::Real& s)
inline bool test_isMuchSmallerThan(const MatrixBase<Derived>& m,
const typename NumTraits<typename internal::traits<Derived>::Scalar>::Real& s)
{
return m.isMuchSmallerThan(s, test_precision<typename ei_traits<Derived>::Scalar>());
return m.isMuchSmallerThan(s, test_precision<typename internal::traits<Derived>::Scalar>());
}
template<typename Derived>
inline bool test_isUnitary(const MatrixBase<Derived>& m)
{
return m.isUnitary(test_precision<typename ei_traits<Derived>::Scalar>());
return m.isUnitary(test_precision<typename internal::traits<Derived>::Scalar>());
}
template<typename T, typename U>
@@ -388,8 +388,8 @@ bool test_is_equal(const T& actual, const U& expected)
template<typename MatrixType>
void createRandomPIMatrixOfRank(typename MatrixType::Index desired_rank, typename MatrixType::Index rows, typename MatrixType::Index cols, MatrixType& m)
{
typedef typename ei_traits<MatrixType>::Index Index;
typedef typename ei_traits<MatrixType>::Scalar Scalar;
typedef typename internal::traits<MatrixType>::Index Index;
typedef typename internal::traits<MatrixType>::Scalar Scalar;
enum { Rows = MatrixType::RowsAtCompileTime, Cols = MatrixType::ColsAtCompileTime };
typedef Matrix<Scalar, Dynamic, 1> VectorType;

28
test/map.cpp
View File

@@ -32,8 +32,8 @@ template<typename VectorType> void map_class_vector(const VectorType& m)
Index size = m.size();
// test Map.h
Scalar* array1 = ei_aligned_new<Scalar>(size);
Scalar* array2 = ei_aligned_new<Scalar>(size);
Scalar* array1 = internal::aligned_new<Scalar>(size);
Scalar* array2 = internal::aligned_new<Scalar>(size);
Scalar* array3 = new Scalar[size+1];
Scalar* array3unaligned = size_t(array3)%16 == 0 ? array3+1 : array3;
@@ -49,8 +49,8 @@ template<typename VectorType> void map_class_vector(const VectorType& m)
VERIFY_RAISES_ASSERT((Map<VectorType,Aligned>(array3unaligned, size)))
#endif
ei_aligned_delete(array1, size);
ei_aligned_delete(array2, size);
internal::aligned_delete(array1, size);
internal::aligned_delete(array2, size);
delete[] array3;
}
@@ -62,9 +62,9 @@ template<typename MatrixType> void map_class_matrix(const MatrixType& m)
Index rows = m.rows(), cols = m.cols(), size = rows*cols;
// test Map.h
Scalar* array1 = ei_aligned_new<Scalar>(size);
Scalar* array1 = internal::aligned_new<Scalar>(size);
for(int i = 0; i < size; i++) array1[i] = Scalar(1);
Scalar* array2 = ei_aligned_new<Scalar>(size);
Scalar* array2 = internal::aligned_new<Scalar>(size);
for(int i = 0; i < size; i++) array2[i] = Scalar(1);
Scalar* array3 = new Scalar[size+1];
for(int i = 0; i < size+1; i++) array3[i] = Scalar(1);
@@ -78,8 +78,8 @@ template<typename MatrixType> void map_class_matrix(const MatrixType& m)
MatrixType ma3 = Map<MatrixType>(array3unaligned, rows, cols);
VERIFY_IS_EQUAL(ma1, ma3);
ei_aligned_delete(array1, size);
ei_aligned_delete(array2, size);
internal::aligned_delete(array1, size);
internal::aligned_delete(array2, size);
delete[] array3;
}
@@ -91,8 +91,8 @@ template<typename VectorType> void map_static_methods(const VectorType& m)
Index size = m.size();
// test Map.h
Scalar* array1 = ei_aligned_new<Scalar>(size);
Scalar* array2 = ei_aligned_new<Scalar>(size);
Scalar* array1 = internal::aligned_new<Scalar>(size);
Scalar* array2 = internal::aligned_new<Scalar>(size);
Scalar* array3 = new Scalar[size+1];
Scalar* array3unaligned = size_t(array3)%16 == 0 ? array3+1 : array3;
@@ -105,8 +105,8 @@ template<typename VectorType> void map_static_methods(const VectorType& m)
VERIFY_IS_EQUAL(ma1, ma2);
VERIFY_IS_EQUAL(ma1, ma3);
ei_aligned_delete(array1, size);
ei_aligned_delete(array2, size);
internal::aligned_delete(array1, size);
internal::aligned_delete(array2, size);
delete[] array3;
}
@@ -123,8 +123,8 @@ void test_map()
CALL_SUBTEST_1( map_class_matrix(Matrix<float, 1, 1>()) );
CALL_SUBTEST_2( map_class_matrix(Matrix4d()) );
CALL_SUBTEST_11( map_class_matrix(Matrix<float,3,5>()) );
CALL_SUBTEST_4( map_class_matrix(MatrixXcf(ei_random<int>(1,10),ei_random<int>(1,10))) );
CALL_SUBTEST_5( map_class_matrix(MatrixXi(ei_random<int>(1,10),ei_random<int>(1,10))) );
CALL_SUBTEST_4( map_class_matrix(MatrixXcf(internal::random<int>(1,10),internal::random<int>(1,10))) );
CALL_SUBTEST_5( map_class_matrix(MatrixXi(internal::random<int>(1,10),internal::random<int>(1,10))) );
CALL_SUBTEST_6( map_static_methods(Matrix<double, 1, 1>()) );
CALL_SUBTEST_7( map_static_methods(Vector3f()) );

12
test/mapstride.cpp
View File

@@ -35,7 +35,7 @@ template<typename VectorType> void map_class_vector(const VectorType& m)
Index arraysize = 3*size;
Scalar* array = ei_aligned_new<Scalar>(arraysize);
Scalar* array = internal::aligned_new<Scalar>(arraysize);
{
Map<VectorType, Aligned, InnerStride<3> > map(array, size);
@@ -57,7 +57,7 @@ template<typename VectorType> void map_class_vector(const VectorType& m)
}
}
ei_aligned_delete(array, arraysize);
internal::aligned_delete(array, arraysize);
}
template<typename MatrixType> void map_class_matrix(const MatrixType& _m)
@@ -71,7 +71,7 @@ template<typename MatrixType> void map_class_matrix(const MatrixType& _m)
Index arraysize = 2*(rows+4)*(cols+4);
Scalar* array = ei_aligned_new<Scalar>(arraysize);
Scalar* array = internal::aligned_new<Scalar>(arraysize);
// test no inner stride and some dynamic outer stride
{
@@ -119,7 +119,7 @@ template<typename MatrixType> void map_class_matrix(const MatrixType& _m)
}
}
ei_aligned_delete(array, arraysize);
internal::aligned_delete(array, arraysize);
}
void test_mapstride()
@@ -135,7 +135,7 @@ void test_mapstride()
CALL_SUBTEST_2( map_class_matrix(Matrix4d()) );
CALL_SUBTEST_3( map_class_matrix(Matrix<float,3,5>()) );
CALL_SUBTEST_3( map_class_matrix(Matrix<float,4,8>()) );
CALL_SUBTEST_4( map_class_matrix(MatrixXcf(ei_random<int>(1,10),ei_random<int>(1,10))) );
CALL_SUBTEST_5( map_class_matrix(MatrixXi(5,5)));//ei_random<int>(1,10),ei_random<int>(1,10))) );
CALL_SUBTEST_4( map_class_matrix(MatrixXcf(internal::random<int>(1,10),internal::random<int>(1,10))) );
CALL_SUBTEST_5( map_class_matrix(MatrixXi(5,5)));//internal::random<int>(1,10),internal::random<int>(1,10))) );
}
}

46
test/meta.cpp
View File

@@ -29,33 +29,33 @@ void test_meta()
typedef float & FloatRef;
typedef const float & ConstFloatRef;
VERIFY((ei_meta_if<(3<4),ei_meta_true, ei_meta_false>::ret::ret));
VERIFY(( ei_is_same_type<float,float>::ret));
VERIFY((!ei_is_same_type<float,double>::ret));
VERIFY((!ei_is_same_type<float,float&>::ret));
VERIFY((!ei_is_same_type<float,const float&>::ret));
VERIFY((internal::meta_if<(3<4),internal::meta_true, internal::meta_false>::ret::ret));
VERIFY(( internal::is_same_type<float,float>::ret));
VERIFY((!internal::is_same_type<float,double>::ret));
VERIFY((!internal::is_same_type<float,float&>::ret));
VERIFY((!internal::is_same_type<float,const float&>::ret));
VERIFY(( ei_is_same_type<float,ei_cleantype<const float&>::type >::ret));
VERIFY(( ei_is_same_type<float,ei_cleantype<const float*>::type >::ret));
VERIFY(( ei_is_same_type<float,ei_cleantype<const float*&>::type >::ret));
VERIFY(( ei_is_same_type<float,ei_cleantype<float**>::type >::ret));
VERIFY(( ei_is_same_type<float,ei_cleantype<float**&>::type >::ret));
VERIFY(( ei_is_same_type<float,ei_cleantype<float* const *&>::type >::ret));
VERIFY(( ei_is_same_type<float,ei_cleantype<float* const>::type >::ret));
VERIFY(( internal::is_same_type<float,internal::cleantype<const float&>::type >::ret));
VERIFY(( internal::is_same_type<float,internal::cleantype<const float*>::type >::ret));
VERIFY(( internal::is_same_type<float,internal::cleantype<const float*&>::type >::ret));
VERIFY(( internal::is_same_type<float,internal::cleantype<float**>::type >::ret));
VERIFY(( internal::is_same_type<float,internal::cleantype<float**&>::type >::ret));
VERIFY(( internal::is_same_type<float,internal::cleantype<float* const *&>::type >::ret));
VERIFY(( internal::is_same_type<float,internal::cleantype<float* const>::type >::ret));
VERIFY(( ei_is_same_type<float*,ei_unconst<const float*>::type >::ret));
VERIFY(( ei_is_same_type<float&,ei_unconst<const float&>::type >::ret));
VERIFY(( ei_is_same_type<float&,ei_unconst<ConstFloatRef>::type >::ret));
VERIFY(( internal::is_same_type<float*,internal::unconst<const float*>::type >::ret));
VERIFY(( internal::is_same_type<float&,internal::unconst<const float&>::type >::ret));
VERIFY(( internal::is_same_type<float&,internal::unconst<ConstFloatRef>::type >::ret));
VERIFY(( ei_is_same_type<float&,ei_unconst<float&>::type >::ret));
VERIFY(( ei_is_same_type<float,ei_unref<float&>::type >::ret));
VERIFY(( ei_is_same_type<const float,ei_unref<const float&>::type >::ret));
VERIFY(( ei_is_same_type<float,ei_unpointer<float*>::type >::ret));
VERIFY(( ei_is_same_type<const float,ei_unpointer<const float*>::type >::ret));
VERIFY(( ei_is_same_type<float,ei_unpointer<float* const >::type >::ret));
VERIFY(( internal::is_same_type<float&,internal::unconst<float&>::type >::ret));
VERIFY(( internal::is_same_type<float,internal::unref<float&>::type >::ret));
VERIFY(( internal::is_same_type<const float,internal::unref<const float&>::type >::ret));
VERIFY(( internal::is_same_type<float,internal::unpointer<float*>::type >::ret));
VERIFY(( internal::is_same_type<const float,internal::unpointer<const float*>::type >::ret));
VERIFY(( internal::is_same_type<float,internal::unpointer<float* const >::type >::ret));
VERIFY(ei_meta_sqrt<1>::ret == 1);
#define VERIFY_META_SQRT(X) VERIFY(ei_meta_sqrt<X>::ret == int(ei_sqrt(double(X))))
VERIFY(internal::meta_sqrt<1>::ret == 1);
#define VERIFY_META_SQRT(X) VERIFY(internal::meta_sqrt<X>::ret == int(internal::sqrt(double(X))))
VERIFY_META_SQRT(2);
VERIFY_META_SQRT(3);
VERIFY_META_SQRT(4);

2
test/miscmatrices.cpp
View File

@@ -36,7 +36,7 @@ template<typename MatrixType> void miscMatrices(const MatrixType& m)
Index rows = m.rows();
Index cols = m.cols();
Index r = ei_random<Index>(0, rows-1), r2 = ei_random<Index>(0, rows-1), c = ei_random<Index>(0, cols-1);
Index r = internal::random<Index>(0, rows-1), r2 = internal::random<Index>(0, rows-1), c = internal::random<Index>(0, cols-1);
VERIFY_IS_APPROX(MatrixType::Ones(rows,cols)(r,c), static_cast<Scalar>(1));
MatrixType m1 = MatrixType::Ones(rows,cols);
VERIFY_IS_APPROX(m1(r,c), static_cast<Scalar>(1));

10
test/mixingtypes.cpp
View File

@@ -59,10 +59,10 @@ template<int SizeAtCompileType> void mixingtypes(int size = SizeAtCompileType)
Vec_d vd = vf.template cast<double>();
Vec_cf vcf = Vec_cf::Random(size,1);
Vec_cd vcd = vcf.template cast<complex<double> >();
float sf = ei_random<float>();
double sd = ei_random<double>();
complex<float> scf = ei_random<complex<float> >();
complex<double> scd = ei_random<complex<double> >();
float sf = internal::random<float>();
double sd = internal::random<double>();
complex<float> scf = internal::random<complex<float> >();
complex<double> scd = internal::random<complex<double> >();
mf+mf;
@@ -144,5 +144,5 @@ void test_mixingtypes()
{
CALL_SUBTEST_1(mixingtypes<3>());
CALL_SUBTEST_2(mixingtypes<4>());
CALL_SUBTEST_3(mixingtypes<Dynamic>(ei_random<int>(1,310)));
CALL_SUBTEST_3(mixingtypes<Dynamic>(internal::random<int>(1,310)));
}

6
test/nomalloc.cpp
View File

@@ -62,10 +62,10 @@ template<typename MatrixType> void nomalloc(const MatrixType& m)
v2 = VectorType::Random(rows),
vzero = VectorType::Zero(rows);
Scalar s1 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>();
Index r = ei_random<Index>(0, rows-1),
c = ei_random<Index>(0, cols-1);
Index r = internal::random<Index>(0, rows-1),
c = internal::random<Index>(0, cols-1);
VERIFY_IS_APPROX((m1+m2)*s1, s1*m1+s1*m2);
VERIFY_IS_APPROX((m1+m2)(r,c), (m1(r,c))+(m2(r,c)));

8
test/nullary.cpp
View File

@@ -49,10 +49,10 @@ bool equalsIdentity(const MatrixType& A)
template<typename VectorType>
void testVectorType(const VectorType& base)
{
typedef typename ei_traits<VectorType>::Index Index;
typedef typename ei_traits<VectorType>::Scalar Scalar;
Scalar low = ei_random<Scalar>(-500,500);
Scalar high = ei_random<Scalar>(-500,500);
typedef typename internal::traits<VectorType>::Index Index;
typedef typename internal::traits<VectorType>::Scalar Scalar;
Scalar low = internal::random<Scalar>(-500,500);
Scalar high = internal::random<Scalar>(-500,500);
if (low>high) std::swap(low,high);
const Index size = base.size();
const Scalar step = (high-low)/(size-1);

182
test/packetmath.cpp
View File

@@ -27,11 +27,15 @@
// using namespace Eigen;
template<typename T> T ei_negate(const T& x) { return -x; }
namespace Eigen {
namespace internal {
template<typename T> T negate(const T& x) { return -x; }
}
}
template<typename Scalar> bool isApproxAbs(const Scalar& a, const Scalar& b, const typename NumTraits<Scalar>::Real& refvalue)
{
return ei_isMuchSmallerThan(a-b, refvalue);
return internal::isMuchSmallerThan(a-b, refvalue);
}
template<typename Scalar> bool areApproxAbs(const Scalar* a, const Scalar* b, int size, const typename NumTraits<Scalar>::Real& refvalue)
@@ -51,7 +55,7 @@ template<typename Scalar> bool areApprox(const Scalar* a, const Scalar* b, int s
{
for (int i=0; i<size; ++i)
{
if (!ei_isApprox(a[i],b[i]))
if (!internal::isApprox(a[i],b[i]))
{
std::cout << "a[" << i << "]: " << a[i] << " != b[" << i << "]: " << b[i] << std::endl;
return false;
@@ -64,14 +68,14 @@ template<typename Scalar> bool areApprox(const Scalar* a, const Scalar* b, int s
#define CHECK_CWISE2(REFOP, POP) { \
for (int i=0; i<PacketSize; ++i) \
ref[i] = REFOP(data1[i], data1[i+PacketSize]); \
ei_pstore(data2, POP(ei_pload<Packet>(data1), ei_pload<Packet>(data1+PacketSize))); \
internal::pstore(data2, POP(internal::pload<Packet>(data1), internal::pload<Packet>(data1+PacketSize))); \
VERIFY(areApprox(ref, data2, PacketSize) && #POP); \
}
#define CHECK_CWISE1(REFOP, POP) { \
for (int i=0; i<PacketSize; ++i) \
ref[i] = REFOP(data1[i]); \
ei_pstore(data2, POP(ei_pload<Packet>(data1))); \
internal::pstore(data2, POP(internal::pload<Packet>(data1))); \
VERIFY(areApprox(ref, data2, PacketSize) && #POP); \
}
@@ -79,10 +83,10 @@ template<bool Cond,typename Packet>
struct packet_helper
{
template<typename T>
inline Packet load(const T* from) const { return ei_pload<Packet>(from); }
inline Packet load(const T* from) const { return internal::pload<Packet>(from); }
template<typename T>
inline void store(T* to, const Packet& x) const { ei_pstore(to,x); }
inline void store(T* to, const Packet& x) const { internal::pstore(to,x); }
};
template<typename Packet>
@@ -110,150 +114,150 @@ struct packet_helper<false,Packet>
template<typename Scalar> void packetmath()
{
typedef typename ei_packet_traits<Scalar>::type Packet;
const int PacketSize = ei_packet_traits<Scalar>::size;
typedef typename internal::packet_traits<Scalar>::type Packet;
const int PacketSize = internal::packet_traits<Scalar>::size;
typedef typename NumTraits<Scalar>::Real RealScalar;
const int size = PacketSize*4;
EIGEN_ALIGN16 Scalar data1[ei_packet_traits<Scalar>::size*4];
EIGEN_ALIGN16 Scalar data2[ei_packet_traits<Scalar>::size*4];
EIGEN_ALIGN16 Scalar data1[internal::packet_traits<Scalar>::size*4];
EIGEN_ALIGN16 Scalar data2[internal::packet_traits<Scalar>::size*4];
EIGEN_ALIGN16 Packet packets[PacketSize*2];
EIGEN_ALIGN16 Scalar ref[ei_packet_traits<Scalar>::size*4];
EIGEN_ALIGN16 Scalar ref[internal::packet_traits<Scalar>::size*4];
RealScalar refvalue = 0;
for (int i=0; i<size; ++i)
{
data1[i] = ei_random<Scalar>();
data2[i] = ei_random<Scalar>();
refvalue = std::max(refvalue,ei_abs(data1[i]));
data1[i] = internal::random<Scalar>();
data2[i] = internal::random<Scalar>();
refvalue = std::max(refvalue,internal::abs(data1[i]));
}
ei_pstore(data2, ei_pload<Packet>(data1));
internal::pstore(data2, internal::pload<Packet>(data1));
VERIFY(areApprox(data1, data2, PacketSize) && "aligned load/store");
for (int offset=0; offset<PacketSize; ++offset)
{
ei_pstore(data2, ei_ploadu<Packet>(data1+offset));
VERIFY(areApprox(data1+offset, data2, PacketSize) && "ei_ploadu");
internal::pstore(data2, internal::ploadu<Packet>(data1+offset));
VERIFY(areApprox(data1+offset, data2, PacketSize) && "internal::ploadu");
}
for (int offset=0; offset<PacketSize; ++offset)
{
ei_pstoreu(data2+offset, ei_pload<Packet>(data1));
VERIFY(areApprox(data1, data2+offset, PacketSize) && "ei_pstoreu");
internal::pstoreu(data2+offset, internal::pload<Packet>(data1));
VERIFY(areApprox(data1, data2+offset, PacketSize) && "internal::pstoreu");
}
for (int offset=0; offset<PacketSize; ++offset)
{
packets[0] = ei_pload<Packet>(data1);
packets[1] = ei_pload<Packet>(data1+PacketSize);
if (offset==0) ei_palign<0>(packets[0], packets[1]);
else if (offset==1) ei_palign<1>(packets[0], packets[1]);
else if (offset==2) ei_palign<2>(packets[0], packets[1]);
else if (offset==3) ei_palign<3>(packets[0], packets[1]);
ei_pstore(data2, packets[0]);
packets[0] = internal::pload<Packet>(data1);
packets[1] = internal::pload<Packet>(data1+PacketSize);
if (offset==0) internal::palign<0>(packets[0], packets[1]);
else if (offset==1) internal::palign<1>(packets[0], packets[1]);
else if (offset==2) internal::palign<2>(packets[0], packets[1]);
else if (offset==3) internal::palign<3>(packets[0], packets[1]);
internal::pstore(data2, packets[0]);
for (int i=0; i<PacketSize; ++i)
ref[i] = data1[i+offset];
typedef Matrix<Scalar, PacketSize, 1> Vector;
VERIFY(areApprox(ref, data2, PacketSize) && "ei_palign");
VERIFY(areApprox(ref, data2, PacketSize) && "internal::palign");
}
CHECK_CWISE2(REF_ADD, ei_padd);
CHECK_CWISE2(REF_SUB, ei_psub);
CHECK_CWISE2(REF_MUL, ei_pmul);
CHECK_CWISE2(REF_ADD, internal::padd);
CHECK_CWISE2(REF_SUB, internal::psub);
CHECK_CWISE2(REF_MUL, internal::pmul);
#ifndef EIGEN_VECTORIZE_ALTIVEC
if (!ei_is_same_type<Scalar,int>::ret)
CHECK_CWISE2(REF_DIV, ei_pdiv);
if (!internal::is_same_type<Scalar,int>::ret)
CHECK_CWISE2(REF_DIV, internal::pdiv);
#endif
CHECK_CWISE1(ei_negate, ei_pnegate);
CHECK_CWISE1(ei_conj, ei_pconj);
CHECK_CWISE1(internal::negate, internal::pnegate);
CHECK_CWISE1(internal::conj, internal::pconj);
for (int i=0; i<PacketSize; ++i)
ref[i] = data1[0];
ei_pstore(data2, ei_pset1<Packet>(data1[0]));
VERIFY(areApprox(ref, data2, PacketSize) && "ei_pset1");
internal::pstore(data2, internal::pset1<Packet>(data1[0]));
VERIFY(areApprox(ref, data2, PacketSize) && "internal::pset1");
VERIFY(ei_isApprox(data1[0], ei_pfirst(ei_pload<Packet>(data1))) && "ei_pfirst");
VERIFY(internal::isApprox(data1[0], internal::pfirst(internal::pload<Packet>(data1))) && "internal::pfirst");
ref[0] = 0;
for (int i=0; i<PacketSize; ++i)
ref[0] += data1[i];
VERIFY(isApproxAbs(ref[0], ei_predux(ei_pload<Packet>(data1)), refvalue) && "ei_predux");
VERIFY(isApproxAbs(ref[0], internal::predux(internal::pload<Packet>(data1)), refvalue) && "internal::predux");
ref[0] = 1;
for (int i=0; i<PacketSize; ++i)
ref[0] *= data1[i];
VERIFY(ei_isApprox(ref[0], ei_predux_mul(ei_pload<Packet>(data1))) && "ei_predux_mul");
VERIFY(internal::isApprox(ref[0], internal::predux_mul(internal::pload<Packet>(data1))) && "internal::predux_mul");
for (int j=0; j<PacketSize; ++j)
{
ref[j] = 0;
for (int i=0; i<PacketSize; ++i)
ref[j] += data1[i+j*PacketSize];
packets[j] = ei_pload<Packet>(data1+j*PacketSize);
packets[j] = internal::pload<Packet>(data1+j*PacketSize);
}
ei_pstore(data2, ei_preduxp(packets));
VERIFY(areApproxAbs(ref, data2, PacketSize, refvalue) && "ei_preduxp");
internal::pstore(data2, internal::preduxp(packets));
VERIFY(areApproxAbs(ref, data2, PacketSize, refvalue) && "internal::preduxp");
for (int i=0; i<PacketSize; ++i)
ref[i] = data1[PacketSize-i-1];
ei_pstore(data2, ei_preverse(ei_pload<Packet>(data1)));
VERIFY(areApprox(ref, data2, PacketSize) && "ei_preverse");
internal::pstore(data2, internal::preverse(internal::pload<Packet>(data1)));
VERIFY(areApprox(ref, data2, PacketSize) && "internal::preverse");
}
template<typename Scalar> void packetmath_real()
{
typedef typename ei_packet_traits<Scalar>::type Packet;
const int PacketSize = ei_packet_traits<Scalar>::size;
typedef typename internal::packet_traits<Scalar>::type Packet;
const int PacketSize = internal::packet_traits<Scalar>::size;
const int size = PacketSize*4;
EIGEN_ALIGN16 Scalar data1[ei_packet_traits<Scalar>::size*4];
EIGEN_ALIGN16 Scalar data2[ei_packet_traits<Scalar>::size*4];
EIGEN_ALIGN16 Scalar ref[ei_packet_traits<Scalar>::size*4];
EIGEN_ALIGN16 Scalar data1[internal::packet_traits<Scalar>::size*4];
EIGEN_ALIGN16 Scalar data2[internal::packet_traits<Scalar>::size*4];
EIGEN_ALIGN16 Scalar ref[internal::packet_traits<Scalar>::size*4];
for (int i=0; i<size; ++i)
{
data1[i] = ei_random<Scalar>(-1e3,1e3);
data2[i] = ei_random<Scalar>(-1e3,1e3);
data1[i] = internal::random<Scalar>(-1e3,1e3);
data2[i] = internal::random<Scalar>(-1e3,1e3);
}
CHECK_CWISE1_IF(ei_packet_traits<Scalar>::HasSin, ei_sin, ei_psin);
CHECK_CWISE1_IF(ei_packet_traits<Scalar>::HasCos, ei_cos, ei_pcos);
CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasSin, internal::sin, internal::psin);
CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasCos, internal::cos, internal::pcos);
for (int i=0; i<size; ++i)
{
data1[i] = ei_random<Scalar>(-87,88);
data2[i] = ei_random<Scalar>(-87,88);
data1[i] = internal::random<Scalar>(-87,88);
data2[i] = internal::random<Scalar>(-87,88);
}
CHECK_CWISE1_IF(ei_packet_traits<Scalar>::HasExp, ei_exp, ei_pexp);
CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasExp, internal::exp, internal::pexp);
for (int i=0; i<size; ++i)
{
data1[i] = ei_random<Scalar>(0,1e6);
data2[i] = ei_random<Scalar>(0,1e6);
data1[i] = internal::random<Scalar>(0,1e6);
data2[i] = internal::random<Scalar>(0,1e6);
}
CHECK_CWISE1_IF(ei_packet_traits<Scalar>::HasLog, ei_log, ei_plog);
CHECK_CWISE1_IF(ei_packet_traits<Scalar>::HasSqrt, ei_sqrt, ei_psqrt);
CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasLog, internal::log, internal::plog);
CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasSqrt, internal::sqrt, internal::psqrt);
ref[0] = data1[0];
for (int i=0; i<PacketSize; ++i)
ref[0] = std::min(ref[0],data1[i]);
VERIFY(ei_isApprox(ref[0], ei_predux_min(ei_pload<Packet>(data1))) && "ei_predux_min");
VERIFY(internal::isApprox(ref[0], internal::predux_min(internal::pload<Packet>(data1))) && "internal::predux_min");
CHECK_CWISE2(std::min, ei_pmin);
CHECK_CWISE2(std::max, ei_pmax);
CHECK_CWISE1(ei_abs, ei_pabs);
CHECK_CWISE2(std::min, internal::pmin);
CHECK_CWISE2(std::max, internal::pmax);
CHECK_CWISE1(internal::abs, internal::pabs);
ref[0] = data1[0];
for (int i=0; i<PacketSize; ++i)
ref[0] = std::max(ref[0],data1[i]);
VERIFY(ei_isApprox(ref[0], ei_predux_max(ei_pload<Packet>(data1))) && "ei_predux_max");
VERIFY(internal::isApprox(ref[0], internal::predux_max(internal::pload<Packet>(data1))) && "internal::predux_max");
}
template<typename Scalar> void packetmath_complex()
{
typedef typename ei_packet_traits<Scalar>::type Packet;
const int PacketSize = ei_packet_traits<Scalar>::size;
typedef typename internal::packet_traits<Scalar>::type Packet;
const int PacketSize = internal::packet_traits<Scalar>::size;
const int size = PacketSize*4;
EIGEN_ALIGN16 Scalar data1[PacketSize*4];
@@ -263,52 +267,52 @@ template<typename Scalar> void packetmath_complex()
for (int i=0; i<size; ++i)
{
data1[i] = ei_random<Scalar>() * Scalar(1e2);
data2[i] = ei_random<Scalar>() * Scalar(1e2);
data1[i] = internal::random<Scalar>() * Scalar(1e2);
data2[i] = internal::random<Scalar>() * Scalar(1e2);
}
{
ei_conj_helper<Scalar,Scalar,false,false> cj;
ei_conj_helper<Packet,Packet,false,false> pcj;
internal::conj_helper<Scalar,Scalar,false,false> cj;
internal::conj_helper<Packet,Packet,false,false> pcj;
for(int i=0;i<PacketSize;++i)
{
ref[i] = data1[i] * data2[i];
VERIFY(ei_isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper");
VERIFY(internal::isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper");
}
ei_pstore(pval,pcj.pmul(ei_pload<Packet>(data1),ei_pload<Packet>(data2)));
internal::pstore(pval,pcj.pmul(internal::pload<Packet>(data1),internal::pload<Packet>(data2)));
VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper");
}
{
ei_conj_helper<Scalar,Scalar,true,false> cj;
ei_conj_helper<Packet,Packet,true,false> pcj;
internal::conj_helper<Scalar,Scalar,true,false> cj;
internal::conj_helper<Packet,Packet,true,false> pcj;
for(int i=0;i<PacketSize;++i)
{
ref[i] = ei_conj(data1[i]) * data2[i];
VERIFY(ei_isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper");
ref[i] = internal::conj(data1[i]) * data2[i];
VERIFY(internal::isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper");
}
ei_pstore(pval,pcj.pmul(ei_pload<Packet>(data1),ei_pload<Packet>(data2)));
internal::pstore(pval,pcj.pmul(internal::pload<Packet>(data1),internal::pload<Packet>(data2)));
VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper");
}
{
ei_conj_helper<Scalar,Scalar,false,true> cj;
ei_conj_helper<Packet,Packet,false,true> pcj;
internal::conj_helper<Scalar,Scalar,false,true> cj;
internal::conj_helper<Packet,Packet,false,true> pcj;
for(int i=0;i<PacketSize;++i)
{
ref[i] = data1[i] * ei_conj(data2[i]);
VERIFY(ei_isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper");
ref[i] = data1[i] * internal::conj(data2[i]);
VERIFY(internal::isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper");
}
ei_pstore(pval,pcj.pmul(ei_pload<Packet>(data1),ei_pload<Packet>(data2)));
internal::pstore(pval,pcj.pmul(internal::pload<Packet>(data1),internal::pload<Packet>(data2)));
VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper");
}
{
ei_conj_helper<Scalar,Scalar,true,true> cj;
ei_conj_helper<Packet,Packet,true,true> pcj;
internal::conj_helper<Scalar,Scalar,true,true> cj;
internal::conj_helper<Packet,Packet,true,true> pcj;
for(int i=0;i<PacketSize;++i)
{
ref[i] = ei_conj(data1[i]) * ei_conj(data2[i]);
VERIFY(ei_isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper");
ref[i] = internal::conj(data1[i]) * internal::conj(data2[i]);
VERIFY(internal::isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper");
}
ei_pstore(pval,pcj.pmul(ei_pload<Packet>(data1),ei_pload<Packet>(data2)));
internal::pstore(pval,pcj.pmul(internal::pload<Packet>(data1),internal::pload<Packet>(data2)));
VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper");
}

12
test/permutationmatrices.cpp
View File

@@ -34,9 +34,9 @@ void randomPermutationVector(PermutationVectorType& v, typename PermutationVecto
if(size == 1) return;
for(Index n = 0; n < 3 * size; ++n)
{
Index i = ei_random<Index>(0, size-1);
Index i = internal::random<Index>(0, size-1);
Index j;
do j = ei_random<Index>(0, size-1); while(j==i);
do j = internal::random<Index>(0, size-1); while(j==i);
std::swap(v(i), v(j));
}
}
@@ -108,17 +108,17 @@ template<typename MatrixType> void permutationmatrices(const MatrixType& m)
if(rows>1 && cols>1)
{
lp2 = lp;
Index i = ei_random<Index>(0, rows-1);
Index i = internal::random<Index>(0, rows-1);
Index j;
do j = ei_random<Index>(0, rows-1); while(j==i);
do j = internal::random<Index>(0, rows-1); while(j==i);
lp2.applyTranspositionOnTheLeft(i, j);
lm = lp;
lm.row(i).swap(lm.row(j));
VERIFY_IS_APPROX(lm, lp2.toDenseMatrix().template cast<Scalar>());
RightPermutationType rp2 = rp;
i = ei_random<Index>(0, cols-1);
do j = ei_random<Index>(0, cols-1); while(j==i);
i = internal::random<Index>(0, cols-1);
do j = internal::random<Index>(0, cols-1); while(j==i);
rp2.applyTranspositionOnTheRight(i, j);
rm = rp;
rm.col(i).swap(rm.col(j));

2
test/prec_inverse_4x4.cpp
View File

@@ -53,7 +53,7 @@ template<typename MatrixType> void inverse_general_4x4(int repeat)
RealScalar absdet;
do {
m = MatrixType::Random();
absdet = ei_abs(m.determinant());
absdet = internal::abs(m.determinant());
} while(absdet < NumTraits<Scalar>::epsilon());
MatrixType inv = m.inverse();
double error = double( (m*inv-MatrixType::Identity()).norm() * absdet / NumTraits<Scalar>::epsilon() );

8
test/product.h
View File

@@ -69,11 +69,11 @@ template<typename MatrixType> void product(const MatrixType& m)
ColVectorType vc2 = ColVectorType::Random(cols), vcres(cols);
OtherMajorMatrixType tm1 = m1;
Scalar s1 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>();
Index r = ei_random<Index>(0, rows-1),
c = ei_random<Index>(0, cols-1),
c2 = ei_random<Index>(0, cols-1);
Index r = internal::random<Index>(0, rows-1),
c = internal::random<Index>(0, cols-1),
c2 = internal::random<Index>(0, cols-1);
// begin testing Product.h: only associativity for now
// (we use Transpose.h but this doesn't count as a test for it)

28
test/product_extra.cpp
View File

@@ -50,15 +50,15 @@ template<typename MatrixType> void product_extra(const MatrixType& m)
ColVectorType vc2 = ColVectorType::Random(cols), vcres(cols);
OtherMajorMatrixType tm1 = m1;
Scalar s1 = ei_random<Scalar>(),
s2 = ei_random<Scalar>(),
s3 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>(),
s2 = internal::random<Scalar>(),
s3 = internal::random<Scalar>();
VERIFY_IS_APPROX(m3.noalias() = m1 * m2.adjoint(), m1 * m2.adjoint().eval());
VERIFY_IS_APPROX(m3.noalias() = m1.adjoint() * square.adjoint(), m1.adjoint().eval() * square.adjoint().eval());
VERIFY_IS_APPROX(m3.noalias() = m1.adjoint() * m2, m1.adjoint().eval() * m2);
VERIFY_IS_APPROX(m3.noalias() = (s1 * m1.adjoint()) * m2, (s1 * m1.adjoint()).eval() * m2);
VERIFY_IS_APPROX(m3.noalias() = ((s1 * m1).adjoint()) * m2, (ei_conj(s1) * m1.adjoint()).eval() * m2);
VERIFY_IS_APPROX(m3.noalias() = ((s1 * m1).adjoint()) * m2, (internal::conj(s1) * m1.adjoint()).eval() * m2);
VERIFY_IS_APPROX(m3.noalias() = (- m1.adjoint() * s1) * (s3 * m2), (- m1.adjoint() * s1).eval() * (s3 * m2).eval());
VERIFY_IS_APPROX(m3.noalias() = (s2 * m1.adjoint() * s1) * m2, (s2 * m1.adjoint() * s1).eval() * m2);
VERIFY_IS_APPROX(m3.noalias() = (-m1*s2) * s1*m2.adjoint(), (-m1*s2).eval() * (s1*m2.adjoint()).eval());
@@ -101,12 +101,12 @@ template<typename MatrixType> void product_extra(const MatrixType& m)
(-m1.adjoint()*s2).eval() * (s1 * v1.adjoint()).eval());
// test the vector-matrix product with non aligned starts
Index i = ei_random<Index>(0,m1.rows()-2);
Index j = ei_random<Index>(0,m1.cols()-2);
Index r = ei_random<Index>(1,m1.rows()-i);
Index c = ei_random<Index>(1,m1.cols()-j);
Index i2 = ei_random<Index>(0,m1.rows()-1);
Index j2 = ei_random<Index>(0,m1.cols()-1);
Index i = internal::random<Index>(0,m1.rows()-2);
Index j = internal::random<Index>(0,m1.cols()-2);
Index r = internal::random<Index>(1,m1.rows()-i);
Index c = internal::random<Index>(1,m1.cols()-j);
Index i2 = internal::random<Index>(0,m1.rows()-1);
Index j2 = internal::random<Index>(0,m1.cols()-1);
VERIFY_IS_APPROX(m1.col(j2).adjoint() * m1.block(0,j,m1.rows(),c), m1.col(j2).adjoint().eval() * m1.block(0,j,m1.rows(),c).eval());
VERIFY_IS_APPROX(m1.block(i,0,r,m1.cols()) * m1.row(i2).adjoint(), m1.block(i,0,r,m1.cols()).eval() * m1.row(i2).adjoint().eval());
@@ -119,9 +119,9 @@ template<typename MatrixType> void product_extra(const MatrixType& m)
void test_product_extra()
{
for(int i = 0; i < g_repeat; i++) {
CALL_SUBTEST_1( product_extra(MatrixXf(ei_random<int>(1,320), ei_random<int>(1,320))) );
CALL_SUBTEST_2( product_extra(MatrixXd(ei_random<int>(1,320), ei_random<int>(1,320))) );
CALL_SUBTEST_3( product_extra(MatrixXcf(ei_random<int>(1,150), ei_random<int>(1,150))) );
CALL_SUBTEST_4( product_extra(MatrixXcd(ei_random<int>(1,150), ei_random<int>(1,150))) );
CALL_SUBTEST_1( product_extra(MatrixXf(internal::random<int>(1,320), internal::random<int>(1,320))) );
CALL_SUBTEST_2( product_extra(MatrixXd(internal::random<int>(1,320), internal::random<int>(1,320))) );
CALL_SUBTEST_3( product_extra(MatrixXcf(internal::random<int>(1,150), internal::random<int>(1,150))) );
CALL_SUBTEST_4( product_extra(MatrixXcd(internal::random<int>(1,150), internal::random<int>(1,150))) );
}
}

22
test/product_large.cpp
View File

@@ -27,11 +27,11 @@
void test_product_large()
{
for(int i = 0; i < g_repeat; i++) {
CALL_SUBTEST_1( product(MatrixXf(ei_random<int>(1,320), ei_random<int>(1,320))) );
CALL_SUBTEST_2( product(MatrixXd(ei_random<int>(1,320), ei_random<int>(1,320))) );
CALL_SUBTEST_3( product(MatrixXi(ei_random<int>(1,320), ei_random<int>(1,320))) );
CALL_SUBTEST_4( product(MatrixXcf(ei_random<int>(1,150), ei_random<int>(1,150))) );
CALL_SUBTEST_5( product(Matrix<float,Dynamic,Dynamic,RowMajor>(ei_random<int>(1,320), ei_random<int>(1,320))) );
CALL_SUBTEST_1( product(MatrixXf(internal::random<int>(1,320), internal::random<int>(1,320))) );
CALL_SUBTEST_2( product(MatrixXd(internal::random<int>(1,320), internal::random<int>(1,320))) );
CALL_SUBTEST_3( product(MatrixXi(internal::random<int>(1,320), internal::random<int>(1,320))) );
CALL_SUBTEST_4( product(MatrixXcf(internal::random<int>(1,150), internal::random<int>(1,150))) );
CALL_SUBTEST_5( product(Matrix<float,Dynamic,Dynamic,RowMajor>(internal::random<int>(1,320), internal::random<int>(1,320))) );
}
#if defined EIGEN_TEST_PART_6
@@ -53,16 +53,16 @@ void test_product_large()
{
// check the functions to setup blocking sizes compile and do not segfault
// FIXME check they do what they are supposed to do !!
std::ptrdiff_t l1 = ei_random<int>(10000,20000);
std::ptrdiff_t l2 = ei_random<int>(1000000,2000000);
std::ptrdiff_t l1 = internal::random<int>(10000,20000);
std::ptrdiff_t l2 = internal::random<int>(1000000,2000000);
setCpuCacheSizes(l1,l2);
VERIFY(l1==l1CacheSize());
VERIFY(l2==l2CacheSize());
std::ptrdiff_t k1 = ei_random<int>(10,100)*16;
std::ptrdiff_t m1 = ei_random<int>(10,100)*16;
std::ptrdiff_t n1 = ei_random<int>(10,100)*16;
std::ptrdiff_t k1 = internal::random<int>(10,100)*16;
std::ptrdiff_t m1 = internal::random<int>(10,100)*16;
std::ptrdiff_t n1 = internal::random<int>(10,100)*16;
// only makes sure it compiles fine
computeProductBlockingSizes<float,float>(k1,m1,n1);
internal::computeProductBlockingSizes<float,float>(k1,m1,n1);
}
{

22
test/product_notemporary.cpp
View File

@@ -57,14 +57,14 @@ template<typename MatrixType> void product_notemporary(const MatrixType& m)
ColVectorType vc2 = ColVectorType::Random(cols), cvres(cols);
RowMajorMatrixType rm3(rows, cols);
Scalar s1 = ei_random<Scalar>(),
s2 = ei_random<Scalar>(),
s3 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>(),
s2 = internal::random<Scalar>(),
s3 = internal::random<Scalar>();
Index c0 = ei_random<Index>(4,cols-8),
c1 = ei_random<Index>(8,cols-c0),
r0 = ei_random<Index>(4,cols-8),
r1 = ei_random<Index>(8,rows-r0);
Index c0 = internal::random<Index>(4,cols-8),
c1 = internal::random<Index>(8,cols-c0),
r0 = internal::random<Index>(4,cols-8),
r1 = internal::random<Index>(8,rows-r0);
VERIFY_EVALUATION_COUNT( m3 = (m1 * m2.adjoint()), 1);
VERIFY_EVALUATION_COUNT( m3.noalias() = m1 * m2.adjoint(), 0);
@@ -128,13 +128,13 @@ void test_product_notemporary()
{
int s;
for(int i = 0; i < g_repeat; i++) {
s = ei_random<int>(16,320);
s = internal::random<int>(16,320);
CALL_SUBTEST_1( product_notemporary(MatrixXf(s, s)) );
s = ei_random<int>(16,320);
s = internal::random<int>(16,320);
CALL_SUBTEST_2( product_notemporary(MatrixXd(s, s)) );
s = ei_random<int>(16,120);
s = internal::random<int>(16,120);
CALL_SUBTEST_3( product_notemporary(MatrixXcf(s,s)) );
s = ei_random<int>(16,120);
s = internal::random<int>(16,120);
CALL_SUBTEST_4( product_notemporary(MatrixXcd(s,s)) );
}
}

14
test/product_selfadjoint.cpp
View File

@@ -47,9 +47,9 @@ template<typename MatrixType> void product_selfadjoint(const MatrixType& m)
r2 = RowVectorType::Random(rows);
RhsMatrixType m4 = RhsMatrixType::Random(rows,10);
Scalar s1 = ei_random<Scalar>(),
s2 = ei_random<Scalar>(),
s3 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>(),
s2 = internal::random<Scalar>(),
s3 = internal::random<Scalar>();
m1 = (m1.adjoint() + m1).eval();
@@ -83,13 +83,13 @@ void test_product_selfadjoint()
CALL_SUBTEST_1( product_selfadjoint(Matrix<float, 1, 1>()) );
CALL_SUBTEST_2( product_selfadjoint(Matrix<float, 2, 2>()) );
CALL_SUBTEST_3( product_selfadjoint(Matrix3d()) );
s = ei_random<int>(1,150);
s = internal::random<int>(1,150);
CALL_SUBTEST_4( product_selfadjoint(MatrixXcf(s, s)) );
s = ei_random<int>(1,150);
s = internal::random<int>(1,150);
CALL_SUBTEST_5( product_selfadjoint(MatrixXcd(s,s)) );
s = ei_random<int>(1,320);
s = internal::random<int>(1,320);
CALL_SUBTEST_6( product_selfadjoint(MatrixXd(s,s)) );
s = ei_random<int>(1,320);
s = internal::random<int>(1,320);
CALL_SUBTEST_7( product_selfadjoint(Matrix<float,Dynamic,Dynamic,RowMajor>(s,s)) );
}
}

20
test/product_symm.cpp
View File

@@ -47,8 +47,8 @@ template<typename Scalar, int Size, int OtherSize> void symm(int size = Size, in
Rhs2 rhs2 = Rhs2::Random(othersize, rows), rhs22(othersize, rows), rhs23(othersize, rows);
Rhs3 rhs3 = Rhs3::Random(cols, othersize), rhs32(cols, othersize), rhs33(cols, othersize);
Scalar s1 = ei_random<Scalar>(),
s2 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>(),
s2 = internal::random<Scalar>();
m2 = m1.template triangularView<Lower>();
m3 = m2.template selfadjointView<Lower>();
@@ -98,14 +98,14 @@ void test_product_symm()
{
for(int i = 0; i < g_repeat ; i++)
{
CALL_SUBTEST_1(( symm<float,Dynamic,Dynamic>(ei_random<int>(1,320),ei_random<int>(1,320)) ));
CALL_SUBTEST_2(( symm<double,Dynamic,Dynamic>(ei_random<int>(1,320),ei_random<int>(1,320)) ));
CALL_SUBTEST_3(( symm<std::complex<float>,Dynamic,Dynamic>(ei_random<int>(1,200),ei_random<int>(1,200)) ));
CALL_SUBTEST_4(( symm<std::complex<double>,Dynamic,Dynamic>(ei_random<int>(1,200),ei_random<int>(1,200)) ));
CALL_SUBTEST_1(( symm<float,Dynamic,Dynamic>(internal::random<int>(1,320),internal::random<int>(1,320)) ));
CALL_SUBTEST_2(( symm<double,Dynamic,Dynamic>(internal::random<int>(1,320),internal::random<int>(1,320)) ));
CALL_SUBTEST_3(( symm<std::complex<float>,Dynamic,Dynamic>(internal::random<int>(1,200),internal::random<int>(1,200)) ));
CALL_SUBTEST_4(( symm<std::complex<double>,Dynamic,Dynamic>(internal::random<int>(1,200),internal::random<int>(1,200)) ));
CALL_SUBTEST_5(( symm<float,Dynamic,1>(ei_random<int>(1,320)) ));
CALL_SUBTEST_6(( symm<double,Dynamic,1>(ei_random<int>(1,320)) ));
CALL_SUBTEST_7(( symm<std::complex<float>,Dynamic,1>(ei_random<int>(1,320)) ));
CALL_SUBTEST_8(( symm<std::complex<double>,Dynamic,1>(ei_random<int>(1,320)) ));
CALL_SUBTEST_5(( symm<float,Dynamic,1>(internal::random<int>(1,320)) ));
CALL_SUBTEST_6(( symm<double,Dynamic,1>(internal::random<int>(1,320)) ));
CALL_SUBTEST_7(( symm<std::complex<float>,Dynamic,1>(internal::random<int>(1,320)) ));
CALL_SUBTEST_8(( symm<std::complex<double>,Dynamic,1>(internal::random<int>(1,320)) ));
}
}

16
test/product_syrk.cpp
View File

@@ -39,11 +39,11 @@ template<typename MatrixType> void syrk(const MatrixType& m)
MatrixType m1 = MatrixType::Random(rows, cols),
m2 = MatrixType::Random(rows, cols);
Rhs1 rhs1 = Rhs1::Random(ei_random<int>(1,320), cols);
Rhs2 rhs2 = Rhs2::Random(rows, ei_random<int>(1,320));
Rhs3 rhs3 = Rhs3::Random(ei_random<int>(1,320), rows);
Rhs1 rhs1 = Rhs1::Random(internal::random<int>(1,320), cols);
Rhs2 rhs2 = Rhs2::Random(rows, internal::random<int>(1,320));
Rhs3 rhs3 = Rhs3::Random(internal::random<int>(1,320), rows);
Scalar s1 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>();
m2.setZero();
VERIFY_IS_APPROX((m2.template selfadjointView<Lower>().rankUpdate(rhs2,s1)._expression()),
@@ -75,13 +75,13 @@ void test_product_syrk()
for(int i = 0; i < g_repeat ; i++)
{
int s;
s = ei_random<int>(1,320);
s = internal::random<int>(1,320);
CALL_SUBTEST_1( syrk(MatrixXf(s, s)) );
s = ei_random<int>(1,320);
s = internal::random<int>(1,320);
CALL_SUBTEST_2( syrk(MatrixXd(s, s)) );
s = ei_random<int>(1,200);
s = internal::random<int>(1,200);
CALL_SUBTEST_3( syrk(MatrixXcf(s, s)) );
s = ei_random<int>(1,200);
s = internal::random<int>(1,200);
CALL_SUBTEST_4( syrk(MatrixXcd(s, s)) );
}
}

20
test/product_trmm.cpp
View File

@@ -32,15 +32,15 @@ template<typename Scalar> void trmm(int size,int /*othersize*/)
typedef Matrix<Scalar,Dynamic,Dynamic,RowMajor> MatrixRowMaj;
DenseIndex rows = size;
DenseIndex cols = ei_random<DenseIndex>(1,size);
DenseIndex cols = internal::random<DenseIndex>(1,size);
MatrixColMaj triV(rows,cols), triH(cols,rows), upTri(cols,rows), loTri(rows,cols),
unitUpTri(cols,rows), unitLoTri(rows,cols), strictlyUpTri(cols,rows), strictlyLoTri(rows,cols);
MatrixColMaj ge1(rows,cols), ge2(cols,rows), ge3;
MatrixRowMaj rge3;
Scalar s1 = ei_random<Scalar>(),
s2 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>(),
s2 = internal::random<Scalar>();
triV.setRandom();
triH.setRandom();
@@ -65,7 +65,7 @@ template<typename Scalar> void trmm(int size,int /*othersize*/)
VERIFY_IS_APPROX( ge3 = ge1.adjoint() * triV.template triangularView<Lower>(), ge1.adjoint() * loTri);
VERIFY_IS_APPROX( ge3 = triH.template triangularView<Upper>() * ge2.adjoint(), upTri * ge2.adjoint());
VERIFY_IS_APPROX(rge3.noalias() = triH.template triangularView<Upper>() * ge2.adjoint(), upTri * ge2.adjoint());
VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView<Upper>() * ge2.adjoint(), ei_conj(s1) * loTri.adjoint() * ge2.adjoint());
VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView<Upper>() * ge2.adjoint(), internal::conj(s1) * loTri.adjoint() * ge2.adjoint());
VERIFY_IS_APPROX(rge3.noalias() = triV.adjoint().template triangularView<Upper>() * ge2.adjoint(), loTri.adjoint() * ge2.adjoint());
VERIFY_IS_APPROX( ge3 = triH.adjoint().template triangularView<Lower>() * ge1.adjoint(), upTri.adjoint() * ge1.adjoint());
VERIFY_IS_APPROX(rge3.noalias() = triH.adjoint().template triangularView<Lower>() * ge1.adjoint(), upTri.adjoint() * ge1.adjoint());
@@ -73,21 +73,21 @@ template<typename Scalar> void trmm(int size,int /*othersize*/)
VERIFY_IS_APPROX( ge3 = triV.template triangularView<UnitLower>() * ge2, unitLoTri * ge2);
VERIFY_IS_APPROX( rge3.noalias() = ge2 * triV.template triangularView<UnitLower>(), ge2 * unitLoTri);
VERIFY_IS_APPROX( ge3 = ge2 * triV.template triangularView<UnitLower>(), ge2 * unitLoTri);
VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView<UnitUpper>() * ge2.adjoint(), ei_conj(s1) * unitLoTri.adjoint() * ge2.adjoint());
VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView<UnitUpper>() * ge2.adjoint(), internal::conj(s1) * unitLoTri.adjoint() * ge2.adjoint());
VERIFY_IS_APPROX( ge3 = triV.template triangularView<StrictlyLower>() * ge2, strictlyLoTri * ge2);
VERIFY_IS_APPROX( rge3.noalias() = ge2 * triV.template triangularView<StrictlyLower>(), ge2 * strictlyLoTri);
VERIFY_IS_APPROX( ge3 = ge2 * triV.template triangularView<StrictlyLower>(), ge2 * strictlyLoTri);
VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView<StrictlyUpper>() * ge2.adjoint(), ei_conj(s1) * strictlyLoTri.adjoint() * ge2.adjoint());
VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView<StrictlyUpper>() * ge2.adjoint(), internal::conj(s1) * strictlyLoTri.adjoint() * ge2.adjoint());
}
void test_product_trmm()
{
for(int i = 0; i < g_repeat ; i++)
{
CALL_SUBTEST_1((trmm<float>(ei_random<int>(1,320),ei_random<int>(1,320))));
CALL_SUBTEST_2((trmm<double>(ei_random<int>(1,320),ei_random<int>(1,320))));
CALL_SUBTEST_3((trmm<std::complex<float> >(ei_random<int>(1,200),ei_random<int>(1,200))));
CALL_SUBTEST_4((trmm<std::complex<double> >(ei_random<int>(1,200),ei_random<int>(1,200))));
CALL_SUBTEST_1((trmm<float>(internal::random<int>(1,320),internal::random<int>(1,320))));
CALL_SUBTEST_2((trmm<double>(internal::random<int>(1,320),internal::random<int>(1,320))));
CALL_SUBTEST_3((trmm<std::complex<float> >(internal::random<int>(1,200),internal::random<int>(1,200))));
CALL_SUBTEST_4((trmm<std::complex<double> >(internal::random<int>(1,200),internal::random<int>(1,200))));
}
}

8
test/product_trmv.cpp
View File

@@ -40,7 +40,7 @@ template<typename MatrixType> void trmv(const MatrixType& m)
m3(rows, cols);
VectorType v1 = VectorType::Random(rows);
Scalar s1 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>();
m1 = MatrixType::Random(rows, cols);
@@ -93,11 +93,11 @@ void test_product_trmv()
CALL_SUBTEST_1( trmv(Matrix<float, 1, 1>()) );
CALL_SUBTEST_2( trmv(Matrix<float, 2, 2>()) );
CALL_SUBTEST_3( trmv(Matrix3d()) );
s = ei_random<int>(1,200);
s = internal::random<int>(1,200);
CALL_SUBTEST_4( trmv(MatrixXcf(s,s)) );
s = ei_random<int>(1,200);
s = internal::random<int>(1,200);
CALL_SUBTEST_5( trmv(MatrixXcd(s,s)) );
s = ei_random<int>(1,320);
s = internal::random<int>(1,320);
CALL_SUBTEST_6( trmv(Matrix<float,Dynamic,Dynamic,RowMajor>(s, s)) );
}
}

10
test/product_trsolve.cpp
View File

@@ -80,13 +80,13 @@ void test_product_trsolve()
for(int i = 0; i < g_repeat ; i++)
{
// matrices
CALL_SUBTEST_1((trsolve<float,Dynamic,Dynamic>(ei_random<int>(1,320),ei_random<int>(1,320))));
CALL_SUBTEST_2((trsolve<double,Dynamic,Dynamic>(ei_random<int>(1,320),ei_random<int>(1,320))));
CALL_SUBTEST_3((trsolve<std::complex<float>,Dynamic,Dynamic>(ei_random<int>(1,200),ei_random<int>(1,200))));
CALL_SUBTEST_4((trsolve<std::complex<double>,Dynamic,Dynamic>(ei_random<int>(1,200),ei_random<int>(1,200))));
CALL_SUBTEST_1((trsolve<float,Dynamic,Dynamic>(internal::random<int>(1,320),internal::random<int>(1,320))));
CALL_SUBTEST_2((trsolve<double,Dynamic,Dynamic>(internal::random<int>(1,320),internal::random<int>(1,320))));
CALL_SUBTEST_3((trsolve<std::complex<float>,Dynamic,Dynamic>(internal::random<int>(1,200),internal::random<int>(1,200))));
CALL_SUBTEST_4((trsolve<std::complex<double>,Dynamic,Dynamic>(internal::random<int>(1,200),internal::random<int>(1,200))));
// vectors
CALL_SUBTEST_5((trsolve<std::complex<double>,Dynamic,1>(ei_random<int>(1,320))));
CALL_SUBTEST_5((trsolve<std::complex<double>,Dynamic,1>(internal::random<int>(1,320))));
CALL_SUBTEST_6((trsolve<float,1,1>()));
CALL_SUBTEST_7((trsolve<float,1,2>()));
CALL_SUBTEST_8((trsolve<std::complex<float>,4,1>()));

14
test/qr.cpp
View File

@@ -71,12 +71,12 @@ template<typename MatrixType> void qr_invertible()
typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
typedef typename MatrixType::Scalar Scalar;
int size = ei_random<int>(10,50);
int size = internal::random<int>(10,50);
MatrixType m1(size, size), m2(size, size), m3(size, size);
m1 = MatrixType::Random(size,size);
if (ei_is_same_type<RealScalar,float>::ret)
if (internal::is_same_type<RealScalar,float>::ret)
{
// let's build a matrix more stable to inverse
MatrixType a = MatrixType::Random(size,size*2);
@@ -90,13 +90,13 @@ template<typename MatrixType> void qr_invertible()
// now construct a matrix with prescribed determinant
m1.setZero();
for(int i = 0; i < size; i++) m1(i,i) = ei_random<Scalar>();
RealScalar absdet = ei_abs(m1.diagonal().prod());
for(int i = 0; i < size; i++) m1(i,i) = internal::random<Scalar>();
RealScalar absdet = internal::abs(m1.diagonal().prod());
m3 = qr.householderQ(); // get a unitary
m1 = m3 * m1 * m3;
qr.compute(m1);
VERIFY_IS_APPROX(absdet, qr.absDeterminant());
VERIFY_IS_APPROX(ei_log(absdet), qr.logAbsDeterminant());
VERIFY_IS_APPROX(internal::log(absdet), qr.logAbsDeterminant());
}
template<typename MatrixType> void qr_verify_assert()
@@ -114,8 +114,8 @@ template<typename MatrixType> void qr_verify_assert()
void test_qr()
{
for(int i = 0; i < g_repeat; i++) {
CALL_SUBTEST_1( qr(MatrixXf(ei_random<int>(1,200),ei_random<int>(1,200))) );
CALL_SUBTEST_2( qr(MatrixXcd(ei_random<int>(1,200),ei_random<int>(1,200))) );
CALL_SUBTEST_1( qr(MatrixXf(internal::random<int>(1,200),internal::random<int>(1,200))) );
CALL_SUBTEST_2( qr(MatrixXcd(internal::random<int>(1,200),internal::random<int>(1,200))) );
CALL_SUBTEST_3(( qr_fixedsize<Matrix<float,3,4>, 2 >() ));
CALL_SUBTEST_4(( qr_fixedsize<Matrix<double,6,2>, 4 >() ));
CALL_SUBTEST_5(( qr_fixedsize<Matrix<double,2,5>, 7 >() ));

16
test/qr_colpivoting.cpp
View File

@@ -30,8 +30,8 @@ template<typename MatrixType> void qr()
{
typedef typename MatrixType::Index Index;
Index rows = ei_random<Index>(2,200), cols = ei_random<Index>(2,200), cols2 = ei_random<Index>(2,200);
Index rank = ei_random<Index>(1, std::min(rows, cols)-1);
Index rows = internal::random<Index>(2,200), cols = internal::random<Index>(2,200), cols2 = internal::random<Index>(2,200);
Index rank = internal::random<Index>(1, std::min(rows, cols)-1);
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::RealScalar RealScalar;
@@ -64,7 +64,7 @@ template<typename MatrixType, int Cols2> void qr_fixedsize()
{
enum { Rows = MatrixType::RowsAtCompileTime, Cols = MatrixType::ColsAtCompileTime };
typedef typename MatrixType::Scalar Scalar;
int rank = ei_random<int>(1, std::min(int(Rows), int(Cols))-1);
int rank = internal::random<int>(1, std::min(int(Rows), int(Cols))-1);
Matrix<Scalar,Rows,Cols> m1;
createRandomPIMatrixOfRank(rank,Rows,Cols,m1);
ColPivHouseholderQR<Matrix<Scalar,Rows,Cols> > qr(m1);
@@ -90,12 +90,12 @@ template<typename MatrixType> void qr_invertible()
typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
typedef typename MatrixType::Scalar Scalar;
int size = ei_random<int>(10,50);
int size = internal::random<int>(10,50);
MatrixType m1(size, size), m2(size, size), m3(size, size);
m1 = MatrixType::Random(size,size);
if (ei_is_same_type<RealScalar,float>::ret)
if (internal::is_same_type<RealScalar,float>::ret)
{
// let's build a matrix more stable to inverse
MatrixType a = MatrixType::Random(size,size*2);
@@ -109,13 +109,13 @@ template<typename MatrixType> void qr_invertible()
// now construct a matrix with prescribed determinant
m1.setZero();
for(int i = 0; i < size; i++) m1(i,i) = ei_random<Scalar>();
RealScalar absdet = ei_abs(m1.diagonal().prod());
for(int i = 0; i < size; i++) m1(i,i) = internal::random<Scalar>();
RealScalar absdet = internal::abs(m1.diagonal().prod());
m3 = qr.householderQ(); // get a unitary
m1 = m3 * m1 * m3;
qr.compute(m1);
VERIFY_IS_APPROX(absdet, qr.absDeterminant());
VERIFY_IS_APPROX(ei_log(absdet), qr.logAbsDeterminant());
VERIFY_IS_APPROX(internal::log(absdet), qr.logAbsDeterminant());
}
template<typename MatrixType> void qr_verify_assert()

14
test/qr_fullpivoting.cpp
View File

@@ -30,8 +30,8 @@ template<typename MatrixType> void qr()
{
typedef typename MatrixType::Index Index;
Index rows = ei_random<Index>(20,200), cols = ei_random<int>(20,200), cols2 = ei_random<int>(20,200);
Index rank = ei_random<Index>(1, std::min(rows, cols)-1);
Index rows = internal::random<Index>(20,200), cols = internal::random<int>(20,200), cols2 = internal::random<int>(20,200);
Index rank = internal::random<Index>(1, std::min(rows, cols)-1);
typedef typename MatrixType::Scalar Scalar;
typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> MatrixQType;
@@ -69,12 +69,12 @@ template<typename MatrixType> void qr_invertible()
typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
typedef typename MatrixType::Scalar Scalar;
int size = ei_random<int>(10,50);
int size = internal::random<int>(10,50);
MatrixType m1(size, size), m2(size, size), m3(size, size);
m1 = MatrixType::Random(size,size);
if (ei_is_same_type<RealScalar,float>::ret)
if (internal::is_same_type<RealScalar,float>::ret)
{
// let's build a matrix more stable to inverse
MatrixType a = MatrixType::Random(size,size*2);
@@ -92,13 +92,13 @@ template<typename MatrixType> void qr_invertible()
// now construct a matrix with prescribed determinant
m1.setZero();
for(int i = 0; i < size; i++) m1(i,i) = ei_random<Scalar>();
RealScalar absdet = ei_abs(m1.diagonal().prod());
for(int i = 0; i < size; i++) m1(i,i) = internal::random<Scalar>();
RealScalar absdet = internal::abs(m1.diagonal().prod());
m3 = qr.matrixQ(); // get a unitary
m1 = m3 * m1 * m3;
qr.compute(m1);
VERIFY_IS_APPROX(absdet, qr.absDeterminant());
VERIFY_IS_APPROX(ei_log(absdet), qr.logAbsDeterminant());
VERIFY_IS_APPROX(internal::log(absdet), qr.logAbsDeterminant());
}
template<typename MatrixType> void qr_verify_assert()

38
test/redux.cpp
View File

@@ -37,28 +37,28 @@ template<typename MatrixType> void matrixRedux(const MatrixType& m)
VERIFY_IS_MUCH_SMALLER_THAN(MatrixType::Zero(rows, cols).sum(), Scalar(1));
VERIFY_IS_APPROX(MatrixType::Ones(rows, cols).sum(), Scalar(float(rows*cols))); // the float() here to shut up excessive MSVC warning about int->complex conversion being lossy
Scalar s(0), p(1), minc(ei_real(m1.coeff(0))), maxc(ei_real(m1.coeff(0)));
Scalar s(0), p(1), minc(internal::real(m1.coeff(0))), maxc(internal::real(m1.coeff(0)));
for(int j = 0; j < cols; j++)
for(int i = 0; i < rows; i++)
{
s += m1(i,j);
p *= m1(i,j);
minc = std::min(ei_real(minc), ei_real(m1(i,j)));
maxc = std::max(ei_real(maxc), ei_real(m1(i,j)));
minc = std::min(internal::real(minc), internal::real(m1(i,j)));
maxc = std::max(internal::real(maxc), internal::real(m1(i,j)));
}
const Scalar mean = s/Scalar(RealScalar(rows*cols));
VERIFY_IS_APPROX(m1.sum(), s);
VERIFY_IS_APPROX(m1.mean(), mean);
VERIFY_IS_APPROX(m1.prod(), p);
VERIFY_IS_APPROX(m1.real().minCoeff(), ei_real(minc));
VERIFY_IS_APPROX(m1.real().maxCoeff(), ei_real(maxc));
VERIFY_IS_APPROX(m1.real().minCoeff(), internal::real(minc));
VERIFY_IS_APPROX(m1.real().maxCoeff(), internal::real(maxc));
// test slice vectorization assuming assign is ok
Index r0 = ei_random<Index>(0,rows-1);
Index c0 = ei_random<Index>(0,cols-1);
Index r1 = ei_random<Index>(r0+1,rows)-r0;
Index c1 = ei_random<Index>(c0+1,cols)-c0;
Index r0 = internal::random<Index>(0,rows-1);
Index c0 = internal::random<Index>(0,cols-1);
Index r1 = internal::random<Index>(r0+1,rows)-r0;
Index c1 = internal::random<Index>(c0+1,cols)-c0;
VERIFY_IS_APPROX(m1.block(r0,c0,r1,c1).sum(), m1.block(r0,c0,r1,c1).eval().sum());
VERIFY_IS_APPROX(m1.block(r0,c0,r1,c1).mean(), m1.block(r0,c0,r1,c1).eval().mean());
VERIFY_IS_APPROX(m1.block(r0,c0,r1,c1).prod(), m1.block(r0,c0,r1,c1).eval().prod());
@@ -81,13 +81,13 @@ template<typename VectorType> void vectorRedux(const VectorType& w)
for(int i = 1; i < size; i++)
{
Scalar s(0), p(1);
RealScalar minc(ei_real(v.coeff(0))), maxc(ei_real(v.coeff(0)));
RealScalar minc(internal::real(v.coeff(0))), maxc(internal::real(v.coeff(0)));
for(int j = 0; j < i; j++)
{
s += v[j];
p *= v[j];
minc = std::min(minc, ei_real(v[j]));
maxc = std::max(maxc, ei_real(v[j]));
minc = std::min(minc, internal::real(v[j]));
maxc = std::max(maxc, internal::real(v[j]));
}
VERIFY_IS_APPROX(s, v.head(i).sum());
VERIFY_IS_APPROX(p, v.head(i).prod());
@@ -98,15 +98,15 @@ template<typename VectorType> void vectorRedux(const VectorType& w)
for(int i = 0; i < size-1; i++)
{
Scalar s(0), p(1);
RealScalar minc(ei_real(v.coeff(i))), maxc(ei_real(v.coeff(i)));
RealScalar minc(internal::real(v.coeff(i))), maxc(internal::real(v.coeff(i)));
for(int j = i; j < size; j++)
{
s += v[j];
p *= v[j];
minc = std::min(minc, ei_real(v[j]));
maxc = std::max(maxc, ei_real(v[j]));
minc = std::min(minc, internal::real(v[j]));
maxc = std::max(maxc, internal::real(v[j]));
}
VERIFY_IS_MUCH_SMALLER_THAN(ei_abs(s - v.tail(size-i).sum()), Scalar(1));
VERIFY_IS_MUCH_SMALLER_THAN(internal::abs(s - v.tail(size-i).sum()), Scalar(1));
VERIFY_IS_APPROX(p, v.tail(size-i).prod());
VERIFY_IS_APPROX(minc, v.real().tail(size-i).minCoeff());
VERIFY_IS_APPROX(maxc, v.real().tail(size-i).maxCoeff());
@@ -115,13 +115,13 @@ template<typename VectorType> void vectorRedux(const VectorType& w)
for(int i = 0; i < size/2; i++)
{
Scalar s(0), p(1);
RealScalar minc(ei_real(v.coeff(i))), maxc(ei_real(v.coeff(i)));
RealScalar minc(internal::real(v.coeff(i))), maxc(internal::real(v.coeff(i)));
for(int j = i; j < size-i; j++)
{
s += v[j];
p *= v[j];
minc = std::min(minc, ei_real(v[j]));
maxc = std::max(maxc, ei_real(v[j]));
minc = std::min(minc, internal::real(v[j]));
maxc = std::max(maxc, internal::real(v[j]));
}
VERIFY_IS_APPROX(s, v.segment(i, size-2*i).sum());
VERIFY_IS_APPROX(p, v.segment(i, size-2*i).prod());

2
test/schur_complex.cpp
View File

@@ -80,7 +80,7 @@ template<typename MatrixType> void schur(int size = MatrixType::ColsAtCompileTim
void test_schur_complex()
{
CALL_SUBTEST_1(( schur<Matrix4cd>() ));
CALL_SUBTEST_2(( schur<MatrixXcf>(ei_random<int>(1,50)) ));
CALL_SUBTEST_2(( schur<MatrixXcf>(internal::random<int>(1,50)) ));
CALL_SUBTEST_3(( schur<Matrix<std::complex<float>, 1, 1> >() ));
CALL_SUBTEST_4(( schur<Matrix<float, 3, 3, Eigen::RowMajor> >() ));

2
test/schur_real.cpp
View File

@@ -99,7 +99,7 @@ template<typename MatrixType> void schur(int size = MatrixType::ColsAtCompileTim
void test_schur_real()
{
CALL_SUBTEST_1(( schur<Matrix4f>() ));
CALL_SUBTEST_2(( schur<MatrixXd>(ei_random<int>(1,50)) ));
CALL_SUBTEST_2(( schur<MatrixXd>(internal::random<int>(1,50)) ));
CALL_SUBTEST_3(( schur<Matrix<float, 1, 1> >() ));
CALL_SUBTEST_4(( schur<Matrix<double, 3, 3, Eigen::RowMajor> >() ));

2
test/selfadjoint.cpp
View File

@@ -56,7 +56,7 @@ void test_selfadjoint()
{
for(int i = 0; i < g_repeat ; i++)
{
int s = ei_random<int>(1,20); EIGEN_UNUSED_VARIABLE(s);
int s = internal::random<int>(1,20); EIGEN_UNUSED_VARIABLE(s);
CALL_SUBTEST_1( selfadjoint(Matrix<float, 1, 1>()) );
CALL_SUBTEST_2( selfadjoint(Matrix<float, 2, 2>()) );

8
test/smallvectors.cpp
View File

@@ -29,10 +29,10 @@ template<typename Scalar> void smallVectors()
typedef Matrix<Scalar, 1, 2> V2;
typedef Matrix<Scalar, 3, 1> V3;
typedef Matrix<Scalar, 1, 4> V4;
Scalar x1 = ei_random<Scalar>(),
x2 = ei_random<Scalar>(),
x3 = ei_random<Scalar>(),
x4 = ei_random<Scalar>();
Scalar x1 = internal::random<Scalar>(),
x2 = internal::random<Scalar>(),
x3 = internal::random<Scalar>(),
x4 = internal::random<Scalar>();
V2 v2(x1, x2);
V3 v3(x1, x2, x3);
V4 v4(x1, x2, x3, x4);

14
test/sparse.h
View File

@@ -71,10 +71,10 @@ initSparse(double density,
sparseMat.startVec(j);
for(int i=0; i<refMat.rows(); i++)
{
Scalar v = (ei_random<double>(0,1) < density) ? ei_random<Scalar>() : Scalar(0);
Scalar v = (internal::random<double>(0,1) < density) ? internal::random<Scalar>() : Scalar(0);
if ((flags&ForceNonZeroDiag) && (i==j))
{
v = ei_random<Scalar>()*Scalar(3.);
v = internal::random<Scalar>()*Scalar(3.);
v = v*v + Scalar(5.);
}
if ((flags & MakeLowerTriangular) && j>i)
@@ -83,7 +83,7 @@ initSparse(double density,
v = Scalar(0);
if ((flags&ForceRealDiag) && (i==j))
v = ei_real(v);
v = internal::real(v);
if (v!=Scalar(0))
{
@@ -116,10 +116,10 @@ initSparse(double density,
sparseMat.startVec(j); // not needed for DynamicSparseMatrix
for(int i=0; i<refMat.rows(); i++)
{
Scalar v = (ei_random<double>(0,1) < density) ? ei_random<Scalar>() : Scalar(0);
Scalar v = (internal::random<double>(0,1) < density) ? internal::random<Scalar>() : Scalar(0);
if ((flags&ForceNonZeroDiag) && (i==j))
{
v = ei_random<Scalar>()*Scalar(3.);
v = internal::random<Scalar>()*Scalar(3.);
v = v*v + Scalar(5.);
}
if ((flags & MakeLowerTriangular) && j>i)
@@ -128,7 +128,7 @@ initSparse(double density,
v = Scalar(0);
if ((flags&ForceRealDiag) && (i==j))
v = ei_real(v);
v = internal::real(v);
if (v!=Scalar(0))
{
@@ -157,7 +157,7 @@ initSparse(double density,
sparseVec.setZero();
for(int i=0; i<refVec.size(); i++)
{
Scalar v = (ei_random<double>(0,1) < density) ? ei_random<Scalar>() : Scalar(0);
Scalar v = (internal::random<double>(0,1) < density) ? internal::random<Scalar>() : Scalar(0);
if (v!=Scalar(0))
{
sparseVec.insertBack(i) = v;

34
test/sparse_basic.cpp
View File

@@ -41,7 +41,7 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
SparseMatrixType m(rows, cols);
DenseMatrix refMat = DenseMatrix::Zero(rows, cols);
DenseVector vec1 = DenseVector::Random(rows);
Scalar s1 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>();
std::vector<Vector2i> zeroCoords;
std::vector<Vector2i> nonzeroCoords;
@@ -54,7 +54,7 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
for (int i=0; i<(int)zeroCoords.size(); ++i)
{
VERIFY_IS_MUCH_SMALLER_THAN( m.coeff(zeroCoords[i].x(),zeroCoords[i].y()), eps );
if(ei_is_same_type<SparseMatrixType,SparseMatrix<Scalar,Flags> >::ret)
if(internal::is_same_type<SparseMatrixType,SparseMatrix<Scalar,Flags> >::ret)
VERIFY_RAISES_ASSERT( m.coeffRef(zeroCoords[0].x(),zeroCoords[0].y()) = 5 );
}
VERIFY_IS_APPROX(m, refMat);
@@ -67,10 +67,10 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
// test InnerIterators and Block expressions
for (int t=0; t<10; ++t)
{
int j = ei_random<int>(0,cols-1);
int i = ei_random<int>(0,rows-1);
int w = ei_random<int>(1,cols-j-1);
int h = ei_random<int>(1,rows-i-1);
int j = internal::random<int>(0,cols-1);
int i = internal::random<int>(0,rows-1);
int w = internal::random<int>(1,cols-j-1);
int h = internal::random<int>(1,rows-i-1);
// VERIFY_IS_APPROX(m.block(i,j,h,w), refMat.block(i,j,h,w));
for(int c=0; c<w; c++)
@@ -114,9 +114,9 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
{
for (int k=0; k<rows/2; ++k)
{
int i = ei_random<int>(0,rows-1);
int i = internal::random<int>(0,rows-1);
if (m1.coeff(i,j)==Scalar(0))
m2.insert(i,j) = m1(i,j) = ei_random<Scalar>();
m2.insert(i,j) = m1(i,j) = internal::random<Scalar>();
}
}
m2.finalize();
@@ -131,10 +131,10 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
m2.reserve(10);
for (int k=0; k<rows*cols; ++k)
{
int i = ei_random<int>(0,rows-1);
int j = ei_random<int>(0,cols-1);
int i = internal::random<int>(0,rows-1);
int j = internal::random<int>(0,cols-1);
if (m1.coeff(i,j)==Scalar(0))
m2.insert(i,j) = m1(i,j) = ei_random<Scalar>();
m2.insert(i,j) = m1(i,j) = internal::random<Scalar>();
}
m2.finalize();
VERIFY_IS_APPROX(m2,m1);
@@ -190,8 +190,8 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
DenseMatrix refMat2 = DenseMatrix::Zero(rows, rows);
SparseMatrixType m2(rows, rows);
initSparse<Scalar>(density, refMat2, m2);
int j0 = ei_random(0,rows-1);
int j1 = ei_random(0,rows-1);
int j0 = internal::random(0,rows-1);
int j1 = internal::random(0,rows-1);
VERIFY_IS_APPROX(m2.innerVector(j0), refMat2.col(j0));
VERIFY_IS_APPROX(m2.innerVector(j0)+m2.innerVector(j1), refMat2.col(j0)+refMat2.col(j1));
//m2.innerVector(j0) = 2*m2.innerVector(j1);
@@ -204,9 +204,9 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
DenseMatrix refMat2 = DenseMatrix::Zero(rows, rows);
SparseMatrixType m2(rows, rows);
initSparse<Scalar>(density, refMat2, m2);
int j0 = ei_random(0,rows-2);
int j1 = ei_random(0,rows-2);
int n0 = ei_random<int>(1,rows-std::max(j0,j1));
int j0 = internal::random(0,rows-2);
int j1 = internal::random(0,rows-2);
int n0 = internal::random<int>(1,rows-std::max(j0,j1));
VERIFY_IS_APPROX(m2.innerVectors(j0,n0), refMat2.block(0,j0,rows,n0));
VERIFY_IS_APPROX(m2.innerVectors(j0,n0)+m2.innerVectors(j1,n0),
refMat2.block(0,j0,rows,n0)+refMat2.block(0,j1,rows,n0));
@@ -226,7 +226,7 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
m2.startVec(j);
for (int i=0; i<m2.innerSize(); ++i)
{
float x = ei_random<float>(0,1);
float x = internal::random<float>(0,1);
if (x<0.1)
{
// do nothing

6
test/sparse_product.cpp
View File

@@ -36,8 +36,8 @@ template<typename SparseMatrixType> void sparse_product(const SparseMatrixType&
typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix;
typedef Matrix<Scalar,Dynamic,1> DenseVector;
Scalar s1 = ei_random<Scalar>();
Scalar s2 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>();
Scalar s2 = internal::random<Scalar>();
// test matrix-matrix product
{
@@ -54,7 +54,7 @@ template<typename SparseMatrixType> void sparse_product(const SparseMatrixType&
initSparse<Scalar>(density, refMat3, m3);
initSparse<Scalar>(density, refMat4, m4);
int c = ei_random<int>(0,rows-1);
int c = internal::random<int>(0,rows-1);
VERIFY_IS_APPROX(m4=m2*m3, refMat4=refMat2*refMat3);
VERIFY_IS_APPROX(m4=m2.transpose()*m3, refMat4=refMat2.transpose()*refMat3);

2
test/sparse_solvers.cpp
View File

@@ -111,7 +111,7 @@ void test_sparse_solvers()
{
for(int i = 0; i < g_repeat; i++) {
CALL_SUBTEST_1(sparse_solvers<double>(8, 8) );
int s = ei_random<int>(1,300);
int s = internal::random<int>(1,300);
CALL_SUBTEST_2(sparse_solvers<std::complex<double> >(s,s) );
CALL_SUBTEST_1(sparse_solvers<double>(s,s) );
}

2
test/sparse_vector.cpp
View File

@@ -48,7 +48,7 @@ template<typename Scalar> void sparse_vector(int rows, int cols)
initSparse<Scalar>(densityVec, refV2, v2);
initSparse<Scalar>(densityVec, refV3, v3);
Scalar s1 = ei_random<Scalar>();
Scalar s1 = internal::random<Scalar>();
// test coeff and coeffRef
for (unsigned int i=0; i<zerocoords.size(); ++i)

34
test/stable_norm.cpp
View File

@@ -55,7 +55,7 @@ template<typename MatrixType> void stable_norm(const MatrixType& m)
Index rows = m.rows();
Index cols = m.cols();
Scalar big = ei_random<Scalar>() * (std::numeric_limits<RealScalar>::max() * RealScalar(1e-4));
Scalar big = internal::random<Scalar>() * (std::numeric_limits<RealScalar>::max() * RealScalar(1e-4));
Scalar small = static_cast<RealScalar>(1)/big;
MatrixType vzero = MatrixType::Zero(rows, cols),
@@ -75,33 +75,33 @@ template<typename MatrixType> void stable_norm(const MatrixType& m)
// test isFinite
VERIFY(!isFinite( std::numeric_limits<RealScalar>::infinity()));
VERIFY(!isFinite(ei_sqrt(-ei_abs(big))));
VERIFY(!isFinite(internal::sqrt(-internal::abs(big))));
// test overflow
VERIFY(isFinite(ei_sqrt(size)*ei_abs(big)));
VERIFY(isFinite(internal::sqrt(size)*internal::abs(big)));
#ifdef EIGEN_VECTORIZE_SSE
// since x87 FPU uses 80bits of precision overflow is not detected
if(ei_packet_traits<Scalar>::size>1)
if(internal::packet_traits<Scalar>::size>1)
{
VERIFY_IS_NOT_APPROX(static_cast<Scalar>(vbig.norm()), ei_sqrt(size)*big); // here the default norm must fail
VERIFY_IS_NOT_APPROX(static_cast<Scalar>(vbig.norm()), internal::sqrt(size)*big); // here the default norm must fail
}
#endif
VERIFY_IS_APPROX(vbig.stableNorm(), ei_sqrt(size)*ei_abs(big));
VERIFY_IS_APPROX(vbig.blueNorm(), ei_sqrt(size)*ei_abs(big));
VERIFY_IS_APPROX(vbig.hypotNorm(), ei_sqrt(size)*ei_abs(big));
VERIFY_IS_APPROX(vbig.stableNorm(), internal::sqrt(size)*internal::abs(big));
VERIFY_IS_APPROX(vbig.blueNorm(), internal::sqrt(size)*internal::abs(big));
VERIFY_IS_APPROX(vbig.hypotNorm(), internal::sqrt(size)*internal::abs(big));
// test underflow
VERIFY(isFinite(ei_sqrt(size)*ei_abs(small)));
VERIFY(isFinite(internal::sqrt(size)*internal::abs(small)));
#ifdef EIGEN_VECTORIZE_SSE
// since x87 FPU uses 80bits of precision underflow is not detected
if(ei_packet_traits<Scalar>::size>1)
if(internal::packet_traits<Scalar>::size>1)
{
VERIFY_IS_NOT_APPROX(static_cast<Scalar>(vsmall.norm()), ei_sqrt(size)*small); // here the default norm must fail
VERIFY_IS_NOT_APPROX(static_cast<Scalar>(vsmall.norm()), internal::sqrt(size)*small); // here the default norm must fail
}
#endif
VERIFY_IS_APPROX(vsmall.stableNorm(), ei_sqrt(size)*ei_abs(small));
VERIFY_IS_APPROX(vsmall.blueNorm(), ei_sqrt(size)*ei_abs(small));
VERIFY_IS_APPROX(vsmall.hypotNorm(), ei_sqrt(size)*ei_abs(small));
VERIFY_IS_APPROX(vsmall.stableNorm(), internal::sqrt(size)*internal::abs(small));
VERIFY_IS_APPROX(vsmall.blueNorm(), internal::sqrt(size)*internal::abs(small));
VERIFY_IS_APPROX(vsmall.hypotNorm(), internal::sqrt(size)*internal::abs(small));
// Test compilation of cwise() version
VERIFY_IS_APPROX(vrand.colwise().stableNorm(), vrand.colwise().norm());
@@ -117,8 +117,8 @@ void test_stable_norm()
for(int i = 0; i < g_repeat; i++) {
CALL_SUBTEST_1( stable_norm(Matrix<float, 1, 1>()) );
CALL_SUBTEST_2( stable_norm(Vector4d()) );
CALL_SUBTEST_3( stable_norm(VectorXd(ei_random<int>(10,2000))) );
CALL_SUBTEST_4( stable_norm(VectorXf(ei_random<int>(10,2000))) );
CALL_SUBTEST_5( stable_norm(VectorXcd(ei_random<int>(10,2000))) );
CALL_SUBTEST_3( stable_norm(VectorXd(internal::random<int>(10,2000))) );
CALL_SUBTEST_4( stable_norm(VectorXf(internal::random<int>(10,2000))) );
CALL_SUBTEST_5( stable_norm(VectorXcd(internal::random<int>(10,2000))) );
}
}

2
test/swap.cpp
View File

@@ -42,7 +42,7 @@ template<typename MatrixType> void swap(const MatrixType& m)
typedef typename other_matrix_type<MatrixType>::type OtherMatrixType;
typedef typename MatrixType::Scalar Scalar;
ei_assert((!ei_is_same_type<MatrixType,OtherMatrixType>::ret));
eigen_assert((!internal::is_same_type<MatrixType,OtherMatrixType>::ret));
typename MatrixType::Index rows = m.rows();
typename MatrixType::Index cols = m.cols();

6
test/triangular.cpp
View File

@@ -88,7 +88,7 @@ template<typename MatrixType> void triangular_square(const MatrixType& m)
m1 = MatrixType::Random(rows, cols);
for (int i=0; i<rows; ++i)
while (ei_abs2(m1(i,i))<1e-1) m1(i,i) = ei_random<Scalar>();
while (internal::abs2(m1(i,i))<1e-1) m1(i,i) = internal::random<Scalar>();
Transpose<MatrixType> trm4(m4);
// test back and forward subsitution with a vector as the rhs
@@ -239,8 +239,8 @@ void test_triangular()
{
for(int i = 0; i < g_repeat ; i++)
{
int r = ei_random<int>(2,20); EIGEN_UNUSED_VARIABLE(r);
int c = ei_random<int>(2,20); EIGEN_UNUSED_VARIABLE(c);
int r = internal::random<int>(2,20); EIGEN_UNUSED_VARIABLE(r);
int c = internal::random<int>(2,20); EIGEN_UNUSED_VARIABLE(c);
CALL_SUBTEST_1( triangular_square(Matrix<float, 1, 1>()) );
CALL_SUBTEST_2( triangular_square(Matrix<float, 2, 2>()) );

12
test/umeyama.cpp
View File

@@ -82,7 +82,7 @@ Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> randMatrixUnitary(int size)
}
if (max_tries == 0)
ei_assert(false && "randMatrixUnitary: Could not construct unitary matrix!");
eigen_assert(false && "randMatrixUnitary: Could not construct unitary matrix!");
return Q;
}
@@ -100,7 +100,7 @@ Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> randMatrixSpecialUnitary(int si
MatrixType Q = randMatrixUnitary<Scalar>(size);
// tweak the first column to make the determinant be 1
Q.col(0) *= ei_conj(Q.determinant());
Q.col(0) *= internal::conj(Q.determinant());
return Q;
}
@@ -108,13 +108,13 @@ Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> randMatrixSpecialUnitary(int si
template <typename MatrixType>
void run_test(int dim, int num_elements)
{
typedef typename ei_traits<MatrixType>::Scalar Scalar;
typedef typename internal::traits<MatrixType>::Scalar Scalar;
typedef Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> MatrixX;
typedef Matrix<Scalar, Eigen::Dynamic, 1> VectorX;
// MUST be positive because in any other case det(cR_t) may become negative for
// odd dimensions!
const Scalar c = ei_abs(ei_random<Scalar>());
const Scalar c = internal::abs(internal::random<Scalar>());
MatrixX R = randMatrixSpecialUnitary<Scalar>(dim);
VectorX t = Scalar(50)*VectorX::Random(dim,1);
@@ -147,7 +147,7 @@ void run_fixed_size_test(int num_elements)
// MUST be positive because in any other case det(cR_t) may become negative for
// odd dimensions!
const Scalar c = ei_abs(ei_random<Scalar>());
const Scalar c = internal::abs(internal::random<Scalar>());
FixedMatrix R = randMatrixSpecialUnitary<Scalar>(dim);
FixedVector t = Scalar(50)*FixedVector::Random(dim,1);
@@ -175,7 +175,7 @@ void test_umeyama()
{
for (int i=0; i<g_repeat; ++i)
{
const int num_elements = ei_random<int>(40,500);
const int num_elements = internal::random<int>(40,500);
// works also for dimensions bigger than 3...
for (int dim=2; dim<8; ++dim)

30
test/vectorization_logic.cpp
View File

@@ -46,15 +46,15 @@ std::string demangle_unrolling(int t)
template<typename Dst, typename Src>
bool test_assign(const Dst&, const Src&, int traversal, int unrolling)
{
ei_assign_traits<Dst,Src>::debug();
bool res = ei_assign_traits<Dst,Src>::Traversal==traversal
&& ei_assign_traits<Dst,Src>::Unrolling==unrolling;
internal::assign_traits<Dst,Src>::debug();
bool res = internal::assign_traits<Dst,Src>::Traversal==traversal
&& internal::assign_traits<Dst,Src>::Unrolling==unrolling;
if(!res)
{
std::cerr << " Expected Traversal == " << demangle_traversal(traversal)
<< " got " << demangle_traversal(ei_assign_traits<Dst,Src>::Traversal) << "\n";
<< " got " << demangle_traversal(internal::assign_traits<Dst,Src>::Traversal) << "\n";
std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling)
<< " got " << demangle_unrolling(ei_assign_traits<Dst,Src>::Unrolling) << "\n";
<< " got " << demangle_unrolling(internal::assign_traits<Dst,Src>::Unrolling) << "\n";
}
return res;
}
@@ -62,15 +62,15 @@ bool test_assign(const Dst&, const Src&, int traversal, int unrolling)
template<typename Dst, typename Src>
bool test_assign(int traversal, int unrolling)
{
ei_assign_traits<Dst,Src>::debug();
bool res = ei_assign_traits<Dst,Src>::Traversal==traversal
&& ei_assign_traits<Dst,Src>::Unrolling==unrolling;
internal::assign_traits<Dst,Src>::debug();
bool res = internal::assign_traits<Dst,Src>::Traversal==traversal
&& internal::assign_traits<Dst,Src>::Unrolling==unrolling;
if(!res)
{
std::cerr << " Expected Traversal == " << demangle_traversal(traversal)
<< " got " << demangle_traversal(ei_assign_traits<Dst,Src>::Traversal) << "\n";
<< " got " << demangle_traversal(internal::assign_traits<Dst,Src>::Traversal) << "\n";
std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling)
<< " got " << demangle_unrolling(ei_assign_traits<Dst,Src>::Unrolling) << "\n";
<< " got " << demangle_unrolling(internal::assign_traits<Dst,Src>::Unrolling) << "\n";
}
return res;
}
@@ -78,7 +78,7 @@ bool test_assign(int traversal, int unrolling)
template<typename Xpr>
bool test_redux(const Xpr&, int traversal, int unrolling)
{
typedef ei_redux_traits<ei_scalar_sum_op<typename Xpr::Scalar>,Xpr> traits;
typedef internal::redux_traits<internal::scalar_sum_op<typename Xpr::Scalar>,Xpr> traits;
bool res = traits::Traversal==traversal && traits::Unrolling==unrolling;
if(!res)
{
@@ -90,10 +90,10 @@ bool test_redux(const Xpr&, int traversal, int unrolling)
return res;
}
template<typename Scalar, bool Enable = ei_packet_traits<Scalar>::Vectorizable> struct vectorization_logic
template<typename Scalar, bool Enable = internal::packet_traits<Scalar>::Vectorizable> struct vectorization_logic
{
enum {
PacketSize = ei_packet_traits<Scalar>::size
PacketSize = internal::packet_traits<Scalar>::size
};
static void run()
{
@@ -221,7 +221,7 @@ void test_vectorization_logic()
vectorization_logic<std::complex<float> >::run();
vectorization_logic<std::complex<double> >::run();
if(ei_packet_traits<float>::Vectorizable)
if(internal::packet_traits<float>::Vectorizable)
{
VERIFY(test_assign(Matrix<float,3,3>(),Matrix<float,3,3>()+Matrix<float,3,3>(),
LinearTraversal,CompleteUnrolling));
@@ -230,7 +230,7 @@ void test_vectorization_logic()
DefaultTraversal,CompleteUnrolling));
}
if(ei_packet_traits<double>::Vectorizable)
if(internal::packet_traits<double>::Vectorizable)
{
VERIFY(test_assign(Matrix<double,3,3>(),Matrix<double,3,3>()+Matrix<double,3,3>(),
LinearTraversal,CompleteUnrolling));

4
test/visitor.cpp
View File

@@ -38,7 +38,7 @@ template<typename MatrixType> void matrixVisitor(const MatrixType& p)
for(Index i = 0; i < m.size(); i++)
for(Index i2 = 0; i2 < i; i2++)
while(m(i) == m(i2)) // yes, ==
m(i) = ei_random<Scalar>();
m(i) = internal::random<Scalar>();
Scalar minc = Scalar(1000), maxc = Scalar(-1000);
Index minrow=0,mincol=0,maxrow=0,maxcol=0;
@@ -85,7 +85,7 @@ template<typename VectorType> void vectorVisitor(const VectorType& w)
for(Index i = 0; i < size; i++)
for(Index i2 = 0; i2 < i; i2++)
while(v(i) == v(i2)) // yes, ==
v(i) = ei_random<Scalar>();
v(i) = internal::random<Scalar>();
Scalar minc = Scalar(1000), maxc = Scalar(-1000);
Index minidx=0,maxidx=0;