diff options
| author |  Benoit Jacob <jacob.benoit.1@gmail.com> | 2010-10-25 10:15:22 -0400 |
|---|---|---|
| committer | Benoit Jacob <jacob.benoit.1@gmail.com> | 2010-10-25 10:15:22 -0400 |
| commit | 4716040703be1ee906439385d20475dcddad5ce3 (patch) | |
| tree | 8efd3cf3007d8360e66f38e2d280127cbb70daa6 /test | |
| parent | ca85a1f6c5fc33ac382aa2d7ba2da63d55d3223e (diff) | |
bug #86 : use internal:: namespace instead of ei_ prefix
Diffstat (limited to 'test')
74 files changed, 624 insertions, 620 deletions
diff --git a/test/adjoint.cpp b/test/adjoint.cpp index 2cf9ef380..f37bad787 100644 --- a/test/adjoint.cpp +++ b/test/adjoint.cpp @@ -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) { diff --git a/test/array.cpp b/test/array.cpp index 332861168..70473bd1d 100644 --- a/test/array.cpp +++ b/test/array.cpp @@ -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)); } diff --git a/test/array_for_matrix.cpp b/test/array_for_matrix.cpp index 3699b861a..b7671ccda 100644 --- a/test/array_for_matrix.cpp +++ b/test/array_for_matrix.cpp @@ -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() diff --git a/test/array_replicate.cpp b/test/array_replicate.cpp index cafdafef5..b3520b58c 100644 --- a/test/array_replicate.cpp +++ b/test/array_replicate.cpp @@ -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++) diff --git a/test/array_reverse.cpp b/test/array_reverse.cpp index 1461900c3..fdede3760 100644 --- a/test/array_reverse.cpp +++ b/test/array_reverse.cpp @@ -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)); diff --git a/test/bandmatrix.cpp b/test/bandmatrix.cpp index 2f228cdd2..6dfaa1879 100644 --- a/test/bandmatrix.cpp +++ b/test/bandmatrix.cpp @@ -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)) ); } } diff --git a/test/basicstuff.cpp b/test/basicstuff.cpp index 4ff4a24fa..175f54009 100644 --- a/test/basicstuff.cpp +++ b/test/basicstuff.cpp @@ -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()); diff --git a/test/block.cpp b/test/block.cpp index 1c2e080ad..6c5681683 100644 --- a/test/block.cpp +++ b/test/block.cpp @@ -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 } } diff --git a/test/cholesky.cpp b/test/cholesky.cpp index 46140bb11..0a0424aa1 100644 --- a/test/cholesky.cpp +++ b/test/cholesky.cpp @@ -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)) ); } diff --git a/test/conservative_resize.cpp b/test/conservative_resize.cpp index f428021dd..781cf5aad 100644 --- a/test/conservative_resize.cpp +++ b/test/conservative_resize.cpp @@ -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); diff --git a/test/corners.cpp b/test/corners.cpp index fe2b205d7..8d12c6146 100644 --- a/test/corners.cpp +++ b/test/corners.cpp @@ -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)); diff --git a/test/cwiseop.cpp b/test/cwiseop.cpp index 7533b7566..c63ace1cc 100644 --- a/test/cwiseop.cpp +++ b/test/cwiseop.cpp @@ -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); diff --git a/test/determinant.cpp b/test/determinant.cpp index 8112131b7..dcf64387d 100644 --- a/test/determinant.cpp +++ b/test/determinant.cpp @@ -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()); diff --git a/test/diagonalmatrices.cpp b/test/diagonalmatrices.cpp index 8408dda44..9d6f069c6 100644 --- a/test/diagonalmatrices.cpp +++ b/test/diagonalmatrices.cpp @@ -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) ); diff --git a/test/dynalloc.cpp b/test/dynalloc.cpp index 26813ba0b..cd0062aac 100644 --- a/test/dynalloc.cpp +++ b/test/dynalloc.cpp @@ -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); } } diff --git a/test/eigen2support.cpp b/test/eigen2support.cpp index 6684d1b9a..1c3686013 100644 --- a/test/eigen2support.cpp +++ b/test/eigen2support.cpp @@ -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()); diff --git a/test/eigensolver_selfadjoint.cpp b/test/eigensolver_selfadjoint.cpp index 3215d2184..9a40ed529 100644 --- a/test/eigensolver_selfadjoint.cpp +++ b/test/eigensolver_selfadjoint.cpp @@ -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>()); diff --git a/test/first_aligned.cpp b/test/first_aligned.cpp index 687f4a5dc..b4ccb22cd 100644 --- a/test/first_aligned.cpp +++ b/test/first_aligned.cpp @@ -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; }; diff --git a/test/geo_alignedbox.cpp b/test/geo_alignedbox.cpp index 65c232b96..738ca3150 100644 --- a/test/geo_alignedbox.cpp +++ b/test/geo_alignedbox.cpp @@ -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 ) ); diff --git a/test/geo_eulerangles.cpp b/test/geo_eulerangles.cpp index bbc9ebb81..f82cb8fbe 100644 --- a/test/geo_eulerangles.cpp +++ b/test/geo_eulerangles.cpp @@ -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; diff --git a/test/geo_homogeneous.cpp b/test/geo_homogeneous.cpp index a0fee2f0c..7e93d843e 100644 --- a/test/geo_homogeneous.cpp +++ b/test/geo_homogeneous.cpp @@ -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(), diff --git a/test/geo_hyperplane.cpp b/test/geo_hyperplane.cpp index bed6f5b40..23027f38e 100644 --- a/test/geo_hyperplane.cpp +++ b/test/geo_hyperplane.cpp @@ -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(); diff --git a/test/geo_orthomethods.cpp b/test/geo_orthomethods.cpp index 8ed7195ec..9152d99c8 100644 --- a/test/geo_orthomethods.cpp +++ b/test/geo_orthomethods.cpp @@ -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(); diff --git a/test/geo_parametrizedline.cpp b/test/geo_parametrizedline.cpp index 3ffc378a6..36b38b979 100644 --- a/test/geo_parametrizedline.cpp +++ b/test/geo_parametrizedline.cpp @@ -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) ); diff --git a/test/geo_quaternion.cpp b/test/geo_quaternion.cpp index bfe15320a..6ad9a099d 100644 --- a/test/geo_quaternion.cpp +++ b/test/geo_quaternion.cpp @@ -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()); diff --git a/test/geo_transformations.cpp b/test/geo_transformations.cpp index b9ea6bb91..bc850e8dc 100644 --- a/test/geo_transformations.cpp +++ b/test/geo_transformations.cpp @@ -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>(); diff --git a/test/hessenberg.cpp b/test/hessenberg.cpp index 35df3d58d..51e758bb3 100644 --- a/test/hessenberg.cpp +++ b/test/hessenberg.cpp @@ -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)); diff --git a/test/householder.cpp b/test/householder.cpp index 1f22c6c53..244ae8e5f 100644 --- a/test/householder.cpp +++ b/test/householder.cpp @@ -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); diff --git a/test/integer_types.cpp b/test/integer_types.cpp index 14f8eaa6e..b27bb0a2a 100644 --- a/test/integer_types.cpp +++ b/test/integer_types.cpp @@ -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); diff --git a/test/inverse.cpp b/test/inverse.cpp index df11c0a4a..f0c69e78c 100644 --- a/test/inverse.cpp +++ b/test/inverse.cpp @@ -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>()) ); diff --git a/test/jacobi.cpp b/test/jacobi.cpp index 623a5ac6c..6464c63c5 100644 --- a/test/jacobi.cpp +++ b/test/jacobi.cpp @@ -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)) )); diff --git a/test/jacobisvd.cpp b/test/jacobisvd.cpp index 79a05b368..681852ffa 100644 --- a/test/jacobisvd.cpp +++ b/test/jacobisvd.cpp @@ -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>() )); diff --git a/test/linearstructure.cpp b/test/linearstructure.cpp index b5c58bdaa..312102701 100644 --- a/test/linearstructure.cpp +++ b/test/linearstructure.cpp @@ -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); diff --git a/test/lu.cpp b/test/lu.cpp index 8cb3cbbee..eac7c1ee6 100644 --- a/test/lu.cpp +++ b/test/lu.cpp @@ -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); diff --git a/test/main.h b/test/main.h index 8fa4ca8b5..e03838714 100644 --- a/test/main.h +++ b/test/main.h @@ -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_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_ei_isApprox(const double& a, const double& b) +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_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_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; diff --git a/test/map.cpp b/test/map.cpp index 9b0301ec0..aa954167a 100644 --- a/test/map.cpp +++ b/test/map.cpp @@ -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()) ); diff --git a/test/mapstride.cpp b/test/mapstride.cpp index 072b2134c..8ccd758f8 100644 --- a/test/mapstride.cpp +++ b/test/mapstride.cpp @@ -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))) ); } } diff --git a/test/meta.cpp b/test/meta.cpp index 88d549a8a..ba2167677 100644 --- a/test/meta.cpp +++ b/test/meta.cpp @@ -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); diff --git a/test/miscmatrices.cpp b/test/miscmatrices.cpp index b14bca61c..327ceaedb 100644 --- a/test/miscmatrices.cpp +++ b/test/miscmatrices.cpp @@ -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)); diff --git a/test/mixingtypes.cpp b/test/mixingtypes.cpp index 7673348b4..0ebd00d1d 100644 --- a/test/mixingtypes.cpp +++ b/test/mixingtypes.cpp @@ -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))); } diff --git a/test/nomalloc.cpp b/test/nomalloc.cpp index b4c0ff741..0e3caa4ae 100644 --- a/test/nomalloc.cpp +++ b/test/nomalloc.cpp @@ -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))); diff --git a/test/nullary.cpp b/test/nullary.cpp index b0a416b25..cc842203e 100644 --- a/test/nullary.cpp +++ b/test/nullary.cpp @@ -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); diff --git a/test/packetmath.cpp b/test/packetmath.cpp index 0eb3d7f51..3d1fc2850 100644 --- a/test/packetmath.cpp +++ b/test/packetmath.cpp @@ -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"); } diff --git a/test/permutationmatrices.cpp b/test/permutationmatrices.cpp index 880cd87a9..b9b3bbbca 100644 --- a/test/permutationmatrices.cpp +++ b/test/permutationmatrices.cpp @@ -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)); diff --git a/test/prec_inverse_4x4.cpp b/test/prec_inverse_4x4.cpp index 8b1aa8869..c40cf7399 100644 --- a/test/prec_inverse_4x4.cpp +++ b/test/prec_inverse_4x4.cpp @@ -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() ); diff --git a/test/product.h b/test/product.h index 804ce131d..101766b18 100644 --- a/test/product.h +++ b/test/product.h @@ -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) diff --git a/test/product_extra.cpp b/test/product_extra.cpp index de105946e..fcedacb2c 100644 --- a/test/product_extra.cpp +++ b/test/product_extra.cpp @@ -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))) ); } } diff --git a/test/product_large.cpp b/test/product_large.cpp index 2c5523913..8ed937068 100644 --- a/test/product_large.cpp +++ b/test/product_large.cpp @@ -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); } { diff --git a/test/product_notemporary.cpp b/test/product_notemporary.cpp index 9175694ba..e5dd964c0 100644 --- a/test/product_notemporary.cpp +++ b/test/product_notemporary.cpp @@ -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)) ); } } diff --git a/test/product_selfadjoint.cpp b/test/product_selfadjoint.cpp index c84582484..2e1fc7ec0 100644 --- a/test/product_selfadjoint.cpp +++ b/test/product_selfadjoint.cpp @@ -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)) ); } } diff --git a/test/product_symm.cpp b/test/product_symm.cpp index 5ddae30c0..21c2f605b 100644 --- a/test/product_symm.cpp +++ b/test/product_symm.cpp @@ -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_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_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>(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)) )); } } diff --git a/test/product_syrk.cpp b/test/product_syrk.cpp index 575b21cac..951a254ed 100644 --- a/test/product_syrk.cpp +++ b/test/product_syrk.cpp @@ -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)) ); } } diff --git a/test/product_trmm.cpp b/test/product_trmm.cpp index e4790fb66..e117f6931 100644 --- a/test/product_trmm.cpp +++ b/test/product_trmm.cpp @@ -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)))); } } diff --git a/test/product_trmv.cpp b/test/product_trmv.cpp index d32e96c55..cfb7355ff 100644 --- a/test/product_trmv.cpp +++ b/test/product_trmv.cpp @@ -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)) ); } } diff --git a/test/product_trsolve.cpp b/test/product_trsolve.cpp index 352f54751..e7ada23a5 100644 --- a/test/product_trsolve.cpp +++ b/test/product_trsolve.cpp @@ -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>())); diff --git a/test/qr.cpp b/test/qr.cpp index 09fb81dde..85707a06d 100644 --- a/test/qr.cpp +++ b/test/qr.cpp @@ -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 >() )); diff --git a/test/qr_colpivoting.cpp b/test/qr_colpivoting.cpp index a499412cd..13495594b 100644 --- a/test/qr_colpivoting.cpp +++ b/test/qr_colpivoting.cpp @@ -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() diff --git a/test/qr_fullpivoting.cpp b/test/qr_fullpivoting.cpp index 340b73037..f77ac86a9 100644 --- a/test/qr_fullpivoting.cpp +++ b/test/qr_fullpivoting.cpp @@ -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() diff --git a/test/redux.cpp b/test/redux.cpp index 9a1df71a8..b9004fbd2 100644 --- a/test/redux.cpp +++ b/test/redux.cpp @@ -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()); diff --git a/test/schur_complex.cpp b/test/schur_complex.cpp index 7c4dcb21a..a2a89fd67 100644 --- a/test/schur_complex.cpp +++ b/test/schur_complex.cpp @@ -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> >() )); diff --git a/test/schur_real.cpp b/test/schur_real.cpp index ab1dd1b85..b61c698c2 100644 --- a/test/schur_real.cpp +++ b/test/schur_real.cpp @@ -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> >() )); diff --git a/test/selfadjoint.cpp b/test/selfadjoint.cpp index b1a910b0b..a92ad96b5 100644 --- a/test/selfadjoint.cpp +++ b/test/selfadjoint.cpp @@ -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>()) ); diff --git a/test/smallvectors.cpp b/test/smallvectors.cpp index d6dc8e97c..144944162 100644 --- a/test/smallvectors.cpp +++ b/test/smallvectors.cpp @@ -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); diff --git a/test/sparse.h b/test/sparse.h index 4733e4d10..1489f2a0e 100644 --- a/test/sparse.h +++ b/test/sparse.h @@ -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; diff --git a/test/sparse_basic.cpp b/test/sparse_basic.cpp index 8c93909c6..8dfa0baff 100644 --- a/test/sparse_basic.cpp +++ b/test/sparse_basic.cpp @@ -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 diff --git a/test/sparse_product.cpp b/test/sparse_product.cpp index d4809711c..ce42c5f52 100644 --- a/test/sparse_product.cpp +++ b/test/sparse_product.cpp @@ -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); diff --git a/test/sparse_solvers.cpp b/test/sparse_solvers.cpp index ed54feddc..aba61e6c0 100644 --- a/test/sparse_solvers.cpp +++ b/test/sparse_solvers.cpp @@ -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) ); } diff --git a/test/sparse_vector.cpp b/test/sparse_vector.cpp index a5101398c..be85740c0 100644 --- a/test/sparse_vector.cpp +++ b/test/sparse_vector.cpp @@ -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) diff --git a/test/stable_norm.cpp b/test/stable_norm.cpp index f3e671c3b..69e4a1b12 100644 --- a/test/stable_norm.cpp +++ b/test/stable_norm.cpp @@ -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))) ); } } diff --git a/test/swap.cpp b/test/swap.cpp index 74543a662..4a575e7d7 100644 --- a/test/swap.cpp +++ b/test/swap.cpp @@ -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(); diff --git a/test/triangular.cpp b/test/triangular.cpp index bf5db4e27..0c69749e0 100644 --- a/test/triangular.cpp +++ b/test/triangular.cpp @@ -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>()) ); diff --git a/test/umeyama.cpp b/test/umeyama.cpp index 6c710bc88..abbb1fc7f 100644 --- a/test/umeyama.cpp +++ b/test/umeyama.cpp @@ -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) diff --git a/test/vectorization_logic.cpp b/test/vectorization_logic.cpp index 2b23d4082..1a00af840 100644 --- a/test/vectorization_logic.cpp +++ b/test/vectorization_logic.cpp @@ -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)); diff --git a/test/visitor.cpp b/test/visitor.cpp index 1ddabc63d..2552c6c26 100644 --- a/test/visitor.cpp +++ b/test/visitor.cpp @@ -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; |