From 4716040703be1ee906439385d20475dcddad5ce3 Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Mon, 25 Oct 2010 10:15:22 -0400 Subject: bug #86 : use internal:: namespace instead of ei_ prefix --- Eigen/Eigen2Support | 22 +- Eigen/QtAlignedMalloc | 8 +- Eigen/src/Cholesky/LDLT.h | 72 +-- Eigen/src/Cholesky/LLT.h | 60 ++- Eigen/src/Core/Array.h | 16 +- Eigen/src/Core/ArrayBase.h | 38 +- Eigen/src/Core/ArrayWrapper.h | 17 +- Eigen/src/Core/Assign.h | 154 +++--- Eigen/src/Core/BandMatrix.h | 33 +- Eigen/src/Core/Block.h | 71 +-- Eigen/src/Core/BooleanRedux.h | 24 +- Eigen/src/Core/CommaInitializer.h | 14 +- Eigen/src/Core/CwiseBinaryOp.h | 77 +-- Eigen/src/Core/CwiseNullaryOp.h | 65 +-- Eigen/src/Core/CwiseUnaryOp.h | 29 +- Eigen/src/Core/CwiseUnaryView.h | 41 +- Eigen/src/Core/DenseBase.h | 88 ++-- Eigen/src/Core/DenseCoeffsBase.h | 100 ++-- Eigen/src/Core/DenseStorage.h | 88 ++-- Eigen/src/Core/Diagonal.h | 19 +- Eigen/src/Core/DiagonalMatrix.h | 40 +- Eigen/src/Core/DiagonalProduct.h | 28 +- Eigen/src/Core/Dot.h | 72 +-- Eigen/src/Core/EigenBase.h | 6 +- Eigen/src/Core/Flagged.h | 7 +- Eigen/src/Core/ForceAlignedAccess.h | 13 +- Eigen/src/Core/Functors.h | 522 ++++++++++---------- Eigen/src/Core/Fuzzy.h | 147 +----- Eigen/src/Core/GenericPacketMath.h | 108 +++-- Eigen/src/Core/GlobalFunctions.h | 45 +- Eigen/src/Core/IO.h | 27 +- Eigen/src/Core/Map.h | 9 +- Eigen/src/Core/MapBase.h | 44 +- Eigen/src/Core/MathFunctions.h | 298 ++++++------ Eigen/src/Core/Matrix.h | 17 +- Eigen/src/Core/MatrixBase.h | 50 +- Eigen/src/Core/NestByValue.h | 9 +- Eigen/src/Core/NoAlias.h | 18 +- Eigen/src/Core/NumTraits.h | 6 +- Eigen/src/Core/PermutationMatrix.h | 57 ++- Eigen/src/Core/PlainObjectBase.h | 81 ++-- Eigen/src/Core/Product.h | 169 ++++--- Eigen/src/Core/ProductBase.h | 60 +-- Eigen/src/Core/Random.h | 25 +- Eigen/src/Core/Redux.h | 118 ++--- Eigen/src/Core/Replicate.h | 37 +- Eigen/src/Core/ReturnByValue.h | 25 +- Eigen/src/Core/Reverse.h | 40 +- Eigen/src/Core/Select.h | 26 +- Eigen/src/Core/SelfAdjointView.h | 53 +- Eigen/src/Core/SelfCwiseBinaryOp.h | 39 +- Eigen/src/Core/SolveTriangular.h | 70 +-- Eigen/src/Core/StableNorm.h | 48 +- Eigen/src/Core/Stride.h | 8 +- Eigen/src/Core/Swap.h | 18 +- Eigen/src/Core/Transpose.h | 96 ++-- Eigen/src/Core/Transpositions.h | 37 +- Eigen/src/Core/TriangularMatrix.h | 120 ++--- Eigen/src/Core/VectorBlock.h | 21 +- Eigen/src/Core/VectorwiseOp.h | 98 ++-- Eigen/src/Core/Visitor.h | 47 +- Eigen/src/Core/arch/AltiVec/Complex.h | 124 ++--- Eigen/src/Core/arch/AltiVec/PacketMath.h | 189 ++++---- Eigen/src/Core/arch/NEON/Complex.h | 92 ++-- Eigen/src/Core/arch/NEON/PacketMath.h | 141 +++--- Eigen/src/Core/arch/SSE/Complex.h | 248 +++++----- Eigen/src/Core/arch/SSE/MathFunctions.h | 226 ++++----- Eigen/src/Core/arch/SSE/PacketMath.h | 312 ++++++------ Eigen/src/Core/products/CoeffBasedProduct.h | 146 +++--- Eigen/src/Core/products/GeneralBlockPanelKernel.h | 406 ++++++++-------- Eigen/src/Core/products/GeneralMatrixMatrix.h | 108 +++-- Eigen/src/Core/products/GeneralMatrixVector.h | 222 ++++----- Eigen/src/Core/products/Parallelizer.h | 18 +- Eigen/src/Core/products/SelfadjointMatrixMatrix.h | 104 ++-- Eigen/src/Core/products/SelfadjointMatrixVector.h | 72 +-- Eigen/src/Core/products/SelfadjointProduct.h | 87 ++-- Eigen/src/Core/products/SelfadjointRank2Update.h | 39 +- Eigen/src/Core/products/TriangularMatrixMatrix.h | 63 +-- Eigen/src/Core/products/TriangularMatrixVector.h | 54 ++- Eigen/src/Core/products/TriangularSolverMatrix.h | 42 +- Eigen/src/Core/util/BlasUtil.h | 120 ++--- Eigen/src/Core/util/ForwardDeclarations.h | 117 +++-- Eigen/src/Core/util/Macros.h | 52 +- Eigen/src/Core/util/Memory.h | 215 +++++---- Eigen/src/Core/util/Meta.h | 188 ++++---- Eigen/src/Core/util/StaticAssert.h | 18 +- Eigen/src/Core/util/XprHelper.h | 248 +++++----- Eigen/src/Eigen2Support/Block.h | 8 +- Eigen/src/Eigen2Support/Cwise.h | 40 +- Eigen/src/Eigen2Support/CwiseOperators.h | 38 +- Eigen/src/Eigen2Support/Minor.h | 13 +- Eigen/src/Eigenvalues/ComplexEigenSolver.h | 10 +- Eigen/src/Eigenvalues/ComplexSchur.h | 61 ++- Eigen/src/Eigenvalues/EigenSolver.h | 58 +-- .../GeneralizedSelfAdjointEigenSolver.h | 4 +- Eigen/src/Eigenvalues/HessenbergDecomposition.h | 14 +- Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h | 14 +- Eigen/src/Eigenvalues/RealSchur.h | 24 +- Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h | 42 +- Eigen/src/Eigenvalues/Tridiagonalization.h | 64 +-- Eigen/src/Geometry/AlignedBox.h | 30 +- Eigen/src/Geometry/AngleAxis.h | 16 +- Eigen/src/Geometry/EulerAngles.h | 16 +- Eigen/src/Geometry/Homogeneous.h | 73 +-- Eigen/src/Geometry/Hyperplane.h | 12 +- Eigen/src/Geometry/OrthoMethods.h | 72 +-- Eigen/src/Geometry/ParametrizedLine.h | 6 +- Eigen/src/Geometry/Quaternion.h | 87 ++-- Eigen/src/Geometry/Rotation2D.h | 18 +- Eigen/src/Geometry/RotationBase.h | 32 +- Eigen/src/Geometry/Scaling.h | 4 +- Eigen/src/Geometry/Transform.h | 112 +++-- Eigen/src/Geometry/Translation.h | 8 +- Eigen/src/Geometry/Umeyama.h | 57 +-- Eigen/src/Geometry/arch/Geometry_SSE.h | 59 +-- Eigen/src/Householder/BlockHouseholder.h | 11 +- Eigen/src/Householder/Householder.h | 20 +- Eigen/src/Householder/HouseholderSequence.h | 60 +-- Eigen/src/Jacobi/Jacobi.h | 163 ++++--- Eigen/src/LU/Determinant.h | 54 ++- Eigen/src/LU/FullPivLU.h | 91 ++-- Eigen/src/LU/Inverse.h | 148 +++--- Eigen/src/LU/PartialPivLU.h | 56 ++- Eigen/src/LU/arch/Inverse_SSE.h | 8 +- Eigen/src/QR/ColPivHouseholderQR.h | 68 +-- Eigen/src/QR/FullPivHouseholderQR.h | 64 +-- Eigen/src/QR/HouseholderQR.h | 80 +-- Eigen/src/SVD/JacobiSVD.h | 246 +++++----- Eigen/src/SVD/UpperBidiagonalization.h | 10 +- Eigen/src/Sparse/AmbiVector.h | 16 +- Eigen/src/Sparse/CompressedStorage.h | 2 +- Eigen/src/Sparse/DynamicSparseMatrix.h | 11 +- Eigen/src/Sparse/MappedSparseMatrix.h | 10 +- Eigen/src/Sparse/SparseBlock.h | 48 +- Eigen/src/Sparse/SparseCwiseBinaryOp.h | 85 ++-- Eigen/src/Sparse/SparseCwiseUnaryOp.h | 16 +- Eigen/src/Sparse/SparseDenseProduct.h | 46 +- Eigen/src/Sparse/SparseDiagonalProduct.h | 71 +-- Eigen/src/Sparse/SparseDot.h | 26 +- Eigen/src/Sparse/SparseFuzzy.h | 4 +- Eigen/src/Sparse/SparseMatrix.h | 27 +- Eigen/src/Sparse/SparseMatrixBase.h | 92 ++-- Eigen/src/Sparse/SparseProduct.h | 35 +- Eigen/src/Sparse/SparseRedux.h | 12 +- Eigen/src/Sparse/SparseSelfAdjointView.h | 24 +- Eigen/src/Sparse/SparseSparseProduct.h | 118 ++--- Eigen/src/Sparse/SparseTranspose.h | 2 +- Eigen/src/Sparse/SparseTriangularView.h | 10 +- Eigen/src/Sparse/SparseUtil.h | 36 +- Eigen/src/Sparse/SparseVector.h | 33 +- Eigen/src/Sparse/SparseView.h | 12 +- Eigen/src/Sparse/TriangularSolver.h | 76 +-- Eigen/src/StlSupport/details.h | 88 ++-- Eigen/src/misc/Image.h | 22 +- Eigen/src/misc/Kernel.h | 22 +- Eigen/src/misc/Solve.h | 24 +- Eigen/src/plugins/ArrayCwiseBinaryOps.h | 18 +- Eigen/src/plugins/ArrayCwiseUnaryOps.h | 26 +- Eigen/src/plugins/BlockMethods.h | 12 +- Eigen/src/plugins/CommonCwiseBinaryOps.h | 4 +- Eigen/src/plugins/CommonCwiseUnaryOps.h | 42 +- Eigen/src/plugins/MatrixCwiseBinaryOps.h | 12 +- Eigen/src/plugins/MatrixCwiseUnaryOps.h | 8 +- bench/BenchSparseUtil.h | 8 +- bench/benchBlasGemm.cpp | 6 +- bench/benchCholesky.cpp | 4 +- bench/benchEigenSolver.cpp | 4 +- bench/benchVecAdd.cpp | 70 +-- bench/bench_gemm.cpp | 6 +- bench/bench_norm.cpp | 118 ++--- bench/bench_reverse.cpp | 4 +- bench/benchmarkSlice.cpp | 8 +- bench/btl/libs/eigen2/eigen2_interface.hh | 16 +- bench/btl/libs/hand_vec/hand_vec_interface.hh | 534 ++++++++++----------- bench/check_cache_queries.cpp | 12 +- bench/eig33.cpp | 10 +- bench/quat_slerp.cpp | 20 +- bench/quatmul.cpp | 2 +- bench/sparse_cholesky.cpp | 6 +- bench/sparse_randomsetter.cpp | 10 +- bench/sparse_setter.cpp | 10 +- bench/sparse_trisolver.cpp | 4 +- blas/level1_impl.h | 36 +- blas/level2_impl.h | 56 +-- blas/level3_impl.h | 162 +++---- demos/mandelbrot/mandelbrot.cpp | 6 +- demos/opengl/gpuhelper.h | 8 +- demos/opengl/quaternion_demo.cpp | 2 +- demos/opengl/trackball.cpp | 2 +- doc/D11_UnalignedArrayAssert.dox | 2 +- doc/I00_CustomizingEigen.dox | 36 +- doc/I03_InsideEigenExample.dox | 114 ++--- doc/I11_Aliasing.dox | 2 +- doc/I13_FunctionsTakingEigenTypes.dox | 8 +- .../Tridiagonalization_decomposeInPlace.cpp | 2 +- test/adjoint.cpp | 28 +- test/array.cpp | 44 +- test/array_for_matrix.cpp | 18 +- test/array_replicate.cpp | 4 +- test/array_reverse.cpp | 6 +- test/bandmatrix.cpp | 8 +- test/basicstuff.cpp | 32 +- test/block.cpp | 32 +- test/cholesky.cpp | 10 +- test/conservative_resize.cpp | 12 +- test/corners.cpp | 12 +- test/cwiseop.cpp | 6 +- test/determinant.cpp | 8 +- test/diagonalmatrices.cpp | 4 +- test/dynalloc.cpp | 12 +- test/eigen2support.cpp | 4 +- test/eigensolver_selfadjoint.cpp | 2 +- test/first_aligned.cpp | 6 +- test/geo_alignedbox.cpp | 4 +- test/geo_eulerangles.cpp | 2 +- test/geo_homogeneous.cpp | 2 +- test/geo_hyperplane.cpp | 8 +- test/geo_orthomethods.cpp | 4 +- test/geo_parametrizedline.cpp | 4 +- test/geo_quaternion.cpp | 12 +- test/geo_transformations.cpp | 22 +- test/hessenberg.cpp | 4 +- test/householder.cpp | 12 +- test/integer_types.cpp | 4 +- test/inverse.cpp | 6 +- test/jacobi.cpp | 18 +- test/jacobisvd.cpp | 14 +- test/linearstructure.cpp | 8 +- test/lu.cpp | 16 +- test/main.h | 136 +++--- test/map.cpp | 28 +- test/mapstride.cpp | 12 +- test/meta.cpp | 46 +- test/miscmatrices.cpp | 2 +- test/mixingtypes.cpp | 10 +- test/nomalloc.cpp | 6 +- test/nullary.cpp | 8 +- test/packetmath.cpp | 182 +++---- test/permutationmatrices.cpp | 12 +- test/prec_inverse_4x4.cpp | 2 +- test/product.h | 8 +- test/product_extra.cpp | 28 +- test/product_large.cpp | 22 +- test/product_notemporary.cpp | 22 +- test/product_selfadjoint.cpp | 14 +- test/product_symm.cpp | 22 +- test/product_syrk.cpp | 16 +- test/product_trmm.cpp | 20 +- test/product_trmv.cpp | 8 +- test/product_trsolve.cpp | 10 +- test/qr.cpp | 14 +- test/qr_colpivoting.cpp | 16 +- test/qr_fullpivoting.cpp | 14 +- test/redux.cpp | 38 +- test/schur_complex.cpp | 2 +- test/schur_real.cpp | 2 +- test/selfadjoint.cpp | 2 +- test/smallvectors.cpp | 8 +- test/sparse.h | 14 +- test/sparse_basic.cpp | 34 +- test/sparse_product.cpp | 6 +- test/sparse_solvers.cpp | 2 +- test/sparse_vector.cpp | 2 +- test/stable_norm.cpp | 34 +- test/swap.cpp | 2 +- test/triangular.cpp | 6 +- test/umeyama.cpp | 12 +- test/vectorization_logic.cpp | 30 +- test/visitor.cpp | 4 +- unsupported/Eigen/AdolcForward | 32 +- unsupported/Eigen/AlignedVector3 | 16 +- unsupported/Eigen/FFT | 20 +- unsupported/Eigen/MPRealSupport | 52 +- unsupported/Eigen/MatrixFunctions | 2 +- unsupported/Eigen/OpenGLSupport | 41 +- unsupported/Eigen/src/AutoDiff/AutoDiffJacobian.h | 2 +- unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h | 212 ++++---- unsupported/Eigen/src/AutoDiff/AutoDiffVector.h | 64 +-- unsupported/Eigen/src/BVH/BVAlgorithms.h | 100 ++-- unsupported/Eigen/src/BVH/KdBVH.h | 30 +- unsupported/Eigen/src/FFT/ei_fftw_impl.h | 50 +- unsupported/Eigen/src/FFT/ei_kissfft_impl.h | 10 +- .../src/IterativeSolvers/ConstrainedConjGrad.h | 14 +- .../src/IterativeSolvers/IterationController.h | 2 +- .../Eigen/src/MatrixFunctions/MatrixExponential.h | 10 +- .../Eigen/src/MatrixFunctions/MatrixFunction.h | 64 +-- .../src/MatrixFunctions/MatrixFunctionAtomic.h | 4 +- .../Eigen/src/MoreVectorization/MathFunctions.h | 47 +- .../NonLinearOptimization/HybridNonLinearSolver.h | 36 +- .../src/NonLinearOptimization/LevenbergMarquardt.h | 44 +- .../Eigen/src/NonLinearOptimization/chkder.h | 19 +- .../Eigen/src/NonLinearOptimization/covar.h | 10 +- .../Eigen/src/NonLinearOptimization/dogleg.h | 8 +- .../Eigen/src/NonLinearOptimization/fdjac1.h | 12 +- .../Eigen/src/NonLinearOptimization/lmpar.h | 18 +- .../Eigen/src/NonLinearOptimization/qrsolv.h | 6 +- .../Eigen/src/NonLinearOptimization/r1mpyq.h | 4 +- .../Eigen/src/NonLinearOptimization/r1updt.h | 6 +- .../Eigen/src/NonLinearOptimization/rwupdt.h | 4 +- .../Eigen/src/NumericalDiff/NumericalDiff.h | 4 +- unsupported/Eigen/src/Polynomials/Companion.h | 47 +- .../Eigen/src/Polynomials/PolynomialSolver.h | 20 +- .../Eigen/src/Polynomials/PolynomialUtils.h | 6 +- unsupported/Eigen/src/Skyline/SkylineInplaceLU.h | 8 +- unsupported/Eigen/src/Skyline/SkylineMatrix.h | 80 +-- unsupported/Eigen/src/Skyline/SkylineMatrixBase.h | 24 +- unsupported/Eigen/src/Skyline/SkylineProduct.h | 63 +-- unsupported/Eigen/src/Skyline/SkylineUtil.h | 21 +- unsupported/Eigen/src/SparseExtra/CholmodSupport.h | 75 +-- unsupported/Eigen/src/SparseExtra/RandomSetter.h | 4 +- unsupported/Eigen/src/SparseExtra/SparseLDLT.h | 30 +- unsupported/Eigen/src/SparseExtra/SparseLLT.h | 28 +- unsupported/Eigen/src/SparseExtra/SparseLU.h | 6 +- unsupported/Eigen/src/SparseExtra/SuperLUSupport.h | 36 +- unsupported/Eigen/src/SparseExtra/UmfPackSupport.h | 29 +- unsupported/doc/examples/BVH_Example.cpp | 2 +- unsupported/doc/examples/PolynomialSolver1.cpp | 2 +- unsupported/test/BVH.cpp | 16 +- unsupported/test/NonLinearOptimization.cpp | 8 +- unsupported/test/alignedvector3.cpp | 4 +- unsupported/test/matrix_exponential.cpp | 2 +- unsupported/test/matrix_function.cpp | 18 +- unsupported/test/mpreal_support.cpp | 2 +- unsupported/test/openglsupport.cpp | 8 +- unsupported/test/polynomialsolver.cpp | 38 +- unsupported/test/polynomialutils.cpp | 14 +- unsupported/test/sparse_extra.cpp | 8 +- unsupported/test/sparse_ldlt.cpp | 4 +- unsupported/test/sparse_llt.cpp | 4 +- unsupported/test/sparse_lu.cpp | 2 +- 330 files changed, 7637 insertions(+), 7054 deletions(-) diff --git a/Eigen/Eigen2Support b/Eigen/Eigen2Support index b612c2961..1503d5cec 100644 --- a/Eigen/Eigen2Support +++ b/Eigen/Eigen2Support @@ -63,16 +63,16 @@ namespace Eigen { EIGEN_USING_MATRIX_TYPEDEFS \ using Eigen::Matrix; \ using Eigen::MatrixBase; \ -using Eigen::ei_random; \ -using Eigen::ei_real; \ -using Eigen::ei_imag; \ -using Eigen::ei_conj; \ -using Eigen::ei_abs; \ -using Eigen::ei_abs2; \ -using Eigen::ei_sqrt; \ -using Eigen::ei_exp; \ -using Eigen::ei_log; \ -using Eigen::ei_sin; \ -using Eigen::ei_cos; +using Eigen::internal::random; \ +using Eigen::internal::real; \ +using Eigen::internal::imag; \ +using Eigen::internal::conj; \ +using Eigen::internal::abs; \ +using Eigen::internal::abs2; \ +using Eigen::internal::sqrt; \ +using Eigen::internal::exp; \ +using Eigen::internal::log; \ +using Eigen::internal::sin; \ +using Eigen::internal::cos; #endif // EIGEN2SUPPORT_H diff --git a/Eigen/QtAlignedMalloc b/Eigen/QtAlignedMalloc index 698607faa..5ae9f0cda 100644 --- a/Eigen/QtAlignedMalloc +++ b/Eigen/QtAlignedMalloc @@ -10,19 +10,19 @@ void *qMalloc(size_t size) { - return Eigen::ei_aligned_malloc(size); + return Eigen::internal::aligned_malloc(size); } void qFree(void *ptr) { - Eigen::ei_aligned_free(ptr); + Eigen::internal::aligned_free(ptr); } void *qRealloc(void *ptr, size_t size) { - void* newPtr = Eigen::ei_aligned_malloc(size); + void* newPtr = Eigen::internal::aligned_malloc(size); memcpy(newPtr, ptr, size); - Eigen::ei_aligned_free(ptr); + Eigen::internal::aligned_free(ptr); return newPtr; } diff --git a/Eigen/src/Cholesky/LDLT.h b/Eigen/src/Cholesky/LDLT.h index 15a92f8fe..15925ba5d 100644 --- a/Eigen/src/Cholesky/LDLT.h +++ b/Eigen/src/Cholesky/LDLT.h @@ -27,7 +27,9 @@ #ifndef EIGEN_LDLT_H #define EIGEN_LDLT_H +namespace internal { template struct LDLT_Traits; +} /** \ingroup cholesky_Module * @@ -74,7 +76,7 @@ template class LDLT typedef Transpositions TranspositionType; typedef PermutationMatrix PermutationType; - typedef LDLT_Traits Traits; + typedef internal::LDLT_Traits Traits; /** \brief Default Constructor. * @@ -108,14 +110,14 @@ template class LDLT /** \returns a view of the upper triangular matrix U */ inline typename Traits::MatrixU matrixU() const { - ei_assert(m_isInitialized && "LDLT is not initialized."); + eigen_assert(m_isInitialized && "LDLT is not initialized."); return Traits::getU(m_matrix); } /** \returns a view of the lower triangular matrix L */ inline typename Traits::MatrixL matrixL() const { - ei_assert(m_isInitialized && "LDLT is not initialized."); + eigen_assert(m_isInitialized && "LDLT is not initialized."); return Traits::getL(m_matrix); } @@ -123,28 +125,28 @@ template class LDLT */ inline const TranspositionType& transpositionsP() const { - ei_assert(m_isInitialized && "LDLT is not initialized."); + eigen_assert(m_isInitialized && "LDLT is not initialized."); return m_transpositions; } /** \returns the coefficients of the diagonal matrix D */ inline Diagonal vectorD(void) const { - ei_assert(m_isInitialized && "LDLT is not initialized."); + eigen_assert(m_isInitialized && "LDLT is not initialized."); return m_matrix.diagonal(); } /** \returns true if the matrix is positive (semidefinite) */ inline bool isPositive(void) const { - ei_assert(m_isInitialized && "LDLT is not initialized."); + eigen_assert(m_isInitialized && "LDLT is not initialized."); return m_sign == 1; } /** \returns true if the matrix is negative (semidefinite) */ inline bool isNegative(void) const { - ei_assert(m_isInitialized && "LDLT is not initialized."); + eigen_assert(m_isInitialized && "LDLT is not initialized."); return m_sign == -1; } @@ -155,13 +157,13 @@ template class LDLT * \sa solveInPlace(), MatrixBase::ldlt() */ template - inline const ei_solve_retval + inline const internal::solve_retval solve(const MatrixBase& b) const { - ei_assert(m_isInitialized && "LDLT is not initialized."); - ei_assert(m_matrix.rows()==b.rows() + eigen_assert(m_isInitialized && "LDLT is not initialized."); + eigen_assert(m_matrix.rows()==b.rows() && "LDLT::solve(): invalid number of rows of the right hand side matrix b"); - return ei_solve_retval(*this, b.derived()); + return internal::solve_retval(*this, b.derived()); } template @@ -175,7 +177,7 @@ template class LDLT */ inline const MatrixType& matrixLDLT() const { - ei_assert(m_isInitialized && "LDLT is not initialized."); + eigen_assert(m_isInitialized && "LDLT is not initialized."); return m_matrix; } @@ -199,9 +201,11 @@ template class LDLT bool m_isInitialized; }; -template struct ei_ldlt_inplace; +namespace internal { + +template struct ldlt_inplace; -template<> struct ei_ldlt_inplace +template<> struct ldlt_inplace { template static bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, int* sign=0) @@ -209,14 +213,14 @@ template<> struct ei_ldlt_inplace typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::RealScalar RealScalar; typedef typename MatrixType::Index Index; - ei_assert(mat.rows()==mat.cols()); + eigen_assert(mat.rows()==mat.cols()); const Index size = mat.rows(); if (size <= 1) { transpositions.setIdentity(); if(sign) - *sign = ei_real(mat.coeff(0,0))>0 ? 1:-1; + *sign = real(mat.coeff(0,0))>0 ? 1:-1; return true; } @@ -234,10 +238,10 @@ template<> struct ei_ldlt_inplace // The biggest overall is the point of reference to which further diagonals // are compared; if any diagonal is negligible compared // to the largest overall, the algorithm bails. - cutoff = ei_abs(NumTraits::epsilon() * biggest_in_corner); + cutoff = abs(NumTraits::epsilon() * biggest_in_corner); if(sign) - *sign = ei_real(mat.diagonal().coeff(index_of_biggest_in_corner)) > 0 ? 1 : -1; + *sign = real(mat.diagonal().coeff(index_of_biggest_in_corner)) > 0 ? 1 : -1; } // Finish early if the matrix is not full rank. @@ -259,11 +263,11 @@ template<> struct ei_ldlt_inplace for(int i=k+1;i::IsComplex) - mat.coeffRef(index_of_biggest_in_corner,k) = ei_conj(mat.coeff(index_of_biggest_in_corner,k)); + mat.coeffRef(index_of_biggest_in_corner,k) = conj(mat.coeff(index_of_biggest_in_corner,k)); } // partition the matrix: @@ -282,7 +286,7 @@ template<> struct ei_ldlt_inplace if(rs>0) A21.noalias() -= A20 * temp.head(k); } - if((rs>0) && (ei_abs(mat.coeffRef(k,k)) > cutoff)) + if((rs>0) && (abs(mat.coeffRef(k,k)) > cutoff)) A21 /= mat.coeffRef(k,k); } @@ -290,13 +294,13 @@ template<> struct ei_ldlt_inplace } }; -template<> struct ei_ldlt_inplace +template<> struct ldlt_inplace { template static EIGEN_STRONG_INLINE bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, int* sign=0) { Transpose matt(mat); - return ei_ldlt_inplace::unblocked(matt, transpositions, temp, sign); + return ldlt_inplace::unblocked(matt, transpositions, temp, sign); } }; @@ -316,12 +320,14 @@ template struct LDLT_Traits inline static MatrixU getU(const MatrixType& m) { return m; } }; +} // end namespace internal + /** Compute / recompute the LDLT decomposition A = L D L^* = U^* D U of \a matrix */ template LDLT& LDLT::compute(const MatrixType& a) { - ei_assert(a.rows()==a.cols()); + eigen_assert(a.rows()==a.cols()); const Index size = a.rows(); m_matrix = a; @@ -330,22 +336,23 @@ LDLT& LDLT::compute(const MatrixType& a) m_isInitialized = false; m_temporary.resize(size); - ei_ldlt_inplace::unblocked(m_matrix, m_transpositions, m_temporary, &m_sign); + internal::ldlt_inplace::unblocked(m_matrix, m_transpositions, m_temporary, &m_sign); m_isInitialized = true; return *this; } +namespace internal { template -struct ei_solve_retval, Rhs> - : ei_solve_retval_base, Rhs> +struct solve_retval, Rhs> + : solve_retval_base, Rhs> { typedef LDLT<_MatrixType,_UpLo> LDLTType; EIGEN_MAKE_SOLVE_HELPERS(LDLTType,Rhs) template void evalTo(Dest& dst) const { - ei_assert(rhs().rows() == dec().matrixLDLT().rows()); + eigen_assert(rhs().rows() == dec().matrixLDLT().rows()); // dst = P b dst = dec().transpositionsP() * rhs(); @@ -362,6 +369,7 @@ struct ei_solve_retval, Rhs> dst = dec().transpositionsP().transpose() * dst; } }; +} /** \internal use x = ldlt_object.solve(x); * @@ -380,9 +388,9 @@ template template bool LDLT::solveInPlace(MatrixBase &bAndX) const { - ei_assert(m_isInitialized && "LDLT is not initialized."); + eigen_assert(m_isInitialized && "LDLT is not initialized."); const Index size = m_matrix.rows(); - ei_assert(size == bAndX.rows()); + eigen_assert(size == bAndX.rows()); bAndX = this->solve(bAndX); @@ -395,7 +403,7 @@ bool LDLT::solveInPlace(MatrixBase &bAndX) const template MatrixType LDLT::reconstructedMatrix() const { - ei_assert(m_isInitialized && "LDLT is not initialized."); + eigen_assert(m_isInitialized && "LDLT is not initialized."); const Index size = m_matrix.rows(); MatrixType res(size,size); diff --git a/Eigen/src/Cholesky/LLT.h b/Eigen/src/Cholesky/LLT.h index df135fce3..80a248546 100644 --- a/Eigen/src/Cholesky/LLT.h +++ b/Eigen/src/Cholesky/LLT.h @@ -25,7 +25,9 @@ #ifndef EIGEN_LLT_H #define EIGEN_LLT_H +namespace internal{ template struct LLT_Traits; +} /** \ingroup cholesky_Module * @@ -68,12 +70,12 @@ template class LLT typedef typename MatrixType::Index Index; enum { - PacketSize = ei_packet_traits::size, + PacketSize = internal::packet_traits::size, AlignmentMask = int(PacketSize)-1, UpLo = _UpLo }; - typedef LLT_Traits Traits; + typedef internal::LLT_Traits Traits; /** * \brief Default Constructor. @@ -102,14 +104,14 @@ template class LLT /** \returns a view of the upper triangular matrix U */ inline typename Traits::MatrixU matrixU() const { - ei_assert(m_isInitialized && "LLT is not initialized."); + eigen_assert(m_isInitialized && "LLT is not initialized."); return Traits::getU(m_matrix); } /** \returns a view of the lower triangular matrix L */ inline typename Traits::MatrixL matrixL() const { - ei_assert(m_isInitialized && "LLT is not initialized."); + eigen_assert(m_isInitialized && "LLT is not initialized."); return Traits::getL(m_matrix); } @@ -124,13 +126,13 @@ template class LLT * \sa solveInPlace(), MatrixBase::llt() */ template - inline const ei_solve_retval + inline const internal::solve_retval solve(const MatrixBase& b) const { - ei_assert(m_isInitialized && "LLT is not initialized."); - ei_assert(m_matrix.rows()==b.rows() + eigen_assert(m_isInitialized && "LLT is not initialized."); + eigen_assert(m_matrix.rows()==b.rows() && "LLT::solve(): invalid number of rows of the right hand side matrix b"); - return ei_solve_retval(*this, b.derived()); + return internal::solve_retval(*this, b.derived()); } template @@ -144,7 +146,7 @@ template class LLT */ inline const MatrixType& matrixLLT() const { - ei_assert(m_isInitialized && "LLT is not initialized."); + eigen_assert(m_isInitialized && "LLT is not initialized."); return m_matrix; } @@ -158,7 +160,7 @@ template class LLT */ ComputationInfo info() const { - ei_assert(m_isInitialized && "LLT is not initialized."); + eigen_assert(m_isInitialized && "LLT is not initialized."); return m_info; } @@ -175,9 +177,11 @@ template class LLT ComputationInfo m_info; }; -template struct ei_llt_inplace; +namespace internal { + +template struct llt_inplace; -template<> struct ei_llt_inplace +template<> struct llt_inplace { template static bool unblocked(MatrixType& mat) @@ -185,7 +189,7 @@ template<> struct ei_llt_inplace typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::RealScalar RealScalar; typedef typename MatrixType::Index Index; - ei_assert(mat.rows()==mat.cols()); + eigen_assert(mat.rows()==mat.cols()); const Index size = mat.rows(); for(Index k = 0; k < size; ++k) { @@ -195,11 +199,11 @@ template<> struct ei_llt_inplace Block A10(mat,k,0,1,k); Block A20(mat,k+1,0,rs,k); - RealScalar x = ei_real(mat.coeff(k,k)); + RealScalar x = real(mat.coeff(k,k)); if (k>0) x -= mat.row(k).head(k).squaredNorm(); if (x<=RealScalar(0)) return false; - mat.coeffRef(k,k) = x = ei_sqrt(x); + mat.coeffRef(k,k) = x = sqrt(x); if (k>0 && rs>0) A21.noalias() -= A20 * A10.adjoint(); if (rs>0) A21 *= RealScalar(1)/x; } @@ -210,7 +214,7 @@ template<> struct ei_llt_inplace static bool blocked(MatrixType& m) { typedef typename MatrixType::Index Index; - ei_assert(m.rows()==m.cols()); + eigen_assert(m.rows()==m.cols()); Index size = m.rows(); if(size<32) return unblocked(m); @@ -239,19 +243,19 @@ template<> struct ei_llt_inplace } }; -template<> struct ei_llt_inplace +template<> struct llt_inplace { template static EIGEN_STRONG_INLINE bool unblocked(MatrixType& mat) { Transpose matt(mat); - return ei_llt_inplace::unblocked(matt); + return llt_inplace::unblocked(matt); } template static EIGEN_STRONG_INLINE bool blocked(MatrixType& mat) { Transpose matt(mat); - return ei_llt_inplace::blocked(matt); + return llt_inplace::blocked(matt); } }; @@ -262,7 +266,7 @@ template struct LLT_Traits inline static MatrixL getL(const MatrixType& m) { return m; } inline static MatrixU getU(const MatrixType& m) { return m.adjoint(); } static bool inplace_decomposition(MatrixType& m) - { return ei_llt_inplace::blocked(m); } + { return llt_inplace::blocked(m); } }; template struct LLT_Traits @@ -272,9 +276,11 @@ template struct LLT_Traits inline static MatrixL getL(const MatrixType& m) { return m.adjoint(); } inline static MatrixU getU(const MatrixType& m) { return m; } static bool inplace_decomposition(MatrixType& m) - { return ei_llt_inplace::blocked(m); } + { return llt_inplace::blocked(m); } }; +} // end namespace internal + /** Computes / recomputes the Cholesky decomposition A = LL^* = U^*U of \a matrix * * @@ -295,9 +301,10 @@ LLT& LLT::compute(const MatrixType& a) return *this; } +namespace internal { template -struct ei_solve_retval, Rhs> - : ei_solve_retval_base, Rhs> +struct solve_retval, Rhs> + : solve_retval_base, Rhs> { typedef LLT<_MatrixType,UpLo> LLTType; EIGEN_MAKE_SOLVE_HELPERS(LLTType,Rhs) @@ -308,6 +315,7 @@ struct ei_solve_retval, Rhs> dec().solveInPlace(dst); } }; +} /** \internal use x = llt_object.solve(x); * @@ -326,8 +334,8 @@ template template void LLT::solveInPlace(MatrixBase &bAndX) const { - ei_assert(m_isInitialized && "LLT is not initialized."); - ei_assert(m_matrix.rows()==bAndX.rows()); + eigen_assert(m_isInitialized && "LLT is not initialized."); + eigen_assert(m_matrix.rows()==bAndX.rows()); matrixL().solveInPlace(bAndX); matrixU().solveInPlace(bAndX); } @@ -338,7 +346,7 @@ void LLT::solveInPlace(MatrixBase &bAndX) const template MatrixType LLT::reconstructedMatrix() const { - ei_assert(m_isInitialized && "LLT is not initialized."); + eigen_assert(m_isInitialized && "LLT is not initialized."); return matrixL() * matrixL().adjoint().toDenseMatrix(); } diff --git a/Eigen/src/Core/Array.h b/Eigen/src/Core/Array.h index 03b70fa29..0861d7ab1 100644 --- a/Eigen/src/Core/Array.h +++ b/Eigen/src/Core/Array.h @@ -39,12 +39,14 @@ * * \sa \ref TutorialArrayClass, \ref TopicClassHierarchy */ +namespace internal { template -struct ei_traits > : ei_traits > +struct traits > : traits > { typedef ArrayXpr XprKind; typedef ArrayBase > XprBase; }; +} template class Array @@ -60,7 +62,7 @@ class Array protected: template - friend struct ei_conservative_resize_like_impl; + friend struct internal::conservative_resize_like_impl; using Base::m_storage; public: @@ -126,8 +128,8 @@ class Array #ifndef EIGEN_PARSED_BY_DOXYGEN // FIXME is it still needed ?? /** \internal */ - Array(ei_constructor_without_unaligned_array_assert) - : Base(ei_constructor_without_unaligned_array_assert()) + Array(internal::constructor_without_unaligned_array_assert) + : Base(internal::constructor_without_unaligned_array_assert()) { Base::_check_template_params(); EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED @@ -145,8 +147,8 @@ class Array { Base::_check_template_params(); EIGEN_STATIC_ASSERT_VECTOR_ONLY(Array) - ei_assert(dim > 0); - ei_assert(SizeAtCompileTime == Dynamic || SizeAtCompileTime == dim); + eigen_assert(dim > 0); + eigen_assert(SizeAtCompileTime == Dynamic || SizeAtCompileTime == dim); EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED } @@ -241,7 +243,7 @@ class Array private: template - friend struct ei_matrix_swap_impl; + friend struct internal::matrix_swap_impl; }; /** \defgroup arraytypedefs Global array typedefs diff --git a/Eigen/src/Core/ArrayBase.h b/Eigen/src/Core/ArrayBase.h index f0fbcd4ff..40a6fc8bb 100644 --- a/Eigen/src/Core/ArrayBase.h +++ b/Eigen/src/Core/ArrayBase.h @@ -53,16 +53,16 @@ template class ArrayBase #ifndef EIGEN_PARSED_BY_DOXYGEN /** The base class for a given storage type. */ typedef ArrayBase StorageBaseType; - + typedef ArrayBase Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl; - using ei_special_scalar_op_base::Scalar, - typename NumTraits::Scalar>::Real>::operator*; + using internal::special_scalar_op_base::Scalar, + typename NumTraits::Scalar>::Real>::operator*; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::Index Index; - typedef typename ei_traits::Scalar Scalar; - typedef typename ei_packet_traits::type PacketScalar; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Index Index; + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::packet_traits::type PacketScalar; typedef typename NumTraits::Real RealScalar; typedef DenseBase Base; @@ -99,17 +99,17 @@ template class ArrayBase * reference to a matrix, not a matrix! It is however guaranteed that the return type of eval() is either * PlainObject or const PlainObject&. */ - typedef Array::Scalar, - ei_traits::RowsAtCompileTime, - ei_traits::ColsAtCompileTime, - AutoAlign | (ei_traits::Flags&RowMajorBit ? RowMajor : ColMajor), - ei_traits::MaxRowsAtCompileTime, - ei_traits::MaxColsAtCompileTime + typedef Array::Scalar, + internal::traits::RowsAtCompileTime, + internal::traits::ColsAtCompileTime, + AutoAlign | (internal::traits::Flags&RowMajorBit ? RowMajor : ColMajor), + internal::traits::MaxRowsAtCompileTime, + internal::traits::MaxColsAtCompileTime > PlainObject; /** \internal Represents a matrix with all coefficients equal to one another*/ - typedef CwiseNullaryOp,Derived> ConstantReturnType; + typedef CwiseNullaryOp,Derived> ConstantReturnType; #endif // not EIGEN_PARSED_BY_DOXYGEN #define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::ArrayBase @@ -129,7 +129,7 @@ template class ArrayBase */ Derived& operator=(const ArrayBase& other) { - return ei_assign_selector::run(derived(), other.derived()); + return internal::assign_selector::run(derived(), other.derived()); } Derived& operator+=(const Scalar& scalar) @@ -185,7 +185,7 @@ template EIGEN_STRONG_INLINE Derived & ArrayBase::operator-=(const ArrayBase &other) { - SelfCwiseBinaryOp, Derived, OtherDerived> tmp(derived()); + SelfCwiseBinaryOp, Derived, OtherDerived> tmp(derived()); tmp = other; return derived(); } @@ -199,7 +199,7 @@ template EIGEN_STRONG_INLINE Derived & ArrayBase::operator+=(const ArrayBase& other) { - SelfCwiseBinaryOp, Derived, OtherDerived> tmp(derived()); + SelfCwiseBinaryOp, Derived, OtherDerived> tmp(derived()); tmp = other.derived(); return derived(); } @@ -213,7 +213,7 @@ template EIGEN_STRONG_INLINE Derived & ArrayBase::operator*=(const ArrayBase& other) { - SelfCwiseBinaryOp, Derived, OtherDerived> tmp(derived()); + SelfCwiseBinaryOp, Derived, OtherDerived> tmp(derived()); tmp = other.derived(); return derived(); } @@ -227,7 +227,7 @@ template EIGEN_STRONG_INLINE Derived & ArrayBase::operator/=(const ArrayBase& other) { - SelfCwiseBinaryOp, Derived, OtherDerived> tmp(derived()); + SelfCwiseBinaryOp, Derived, OtherDerived> tmp(derived()); tmp = other.derived(); return derived(); } diff --git a/Eigen/src/Core/ArrayWrapper.h b/Eigen/src/Core/ArrayWrapper.h index dc5bba443..814313f20 100644 --- a/Eigen/src/Core/ArrayWrapper.h +++ b/Eigen/src/Core/ArrayWrapper.h @@ -35,12 +35,15 @@ * * \sa MatrixBase::array(), class MatrixWrapper */ + +namespace internal { template -struct ei_traits > - : public ei_traits::type > +struct traits > + : public traits::type > { typedef ArrayXpr XprKind; }; +} template class ArrayWrapper : public ArrayBase > @@ -50,7 +53,7 @@ class ArrayWrapper : public ArrayBase > EIGEN_DENSE_PUBLIC_INTERFACE(ArrayWrapper) EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ArrayWrapper) - typedef typename ei_nested::type NestedExpressionType; + typedef typename internal::nested::type NestedExpressionType; inline ArrayWrapper(const ExpressionType& matrix) : m_expression(matrix) {} @@ -121,12 +124,14 @@ class ArrayWrapper : public ArrayBase > * \sa MatrixBase::matrix(), class ArrayWrapper */ +namespace internal { template -struct ei_traits > - : public ei_traits::type > +struct traits > + : public traits::type > { typedef MatrixXpr XprKind; }; +} template class MatrixWrapper : public MatrixBase > @@ -136,7 +141,7 @@ class MatrixWrapper : public MatrixBase > EIGEN_DENSE_PUBLIC_INTERFACE(MatrixWrapper) EIGEN_INHERIT_ASSIGNMENT_OPERATORS(MatrixWrapper) - typedef typename ei_nested::type NestedExpressionType; + typedef typename internal::nested::type NestedExpressionType; inline MatrixWrapper(const ExpressionType& matrix) : m_expression(matrix) {} diff --git a/Eigen/src/Core/Assign.h b/Eigen/src/Core/Assign.h index 335a888f6..37b0049a2 100644 --- a/Eigen/src/Core/Assign.h +++ b/Eigen/src/Core/Assign.h @@ -27,12 +27,14 @@ #ifndef EIGEN_ASSIGN_H #define EIGEN_ASSIGN_H +namespace internal { + /*************************************************************************** * Part 1 : the logic deciding a strategy for traversal and unrolling * ***************************************************************************/ template -struct ei_assign_traits +struct assign_traits { public: enum { @@ -51,7 +53,7 @@ private: : int(Derived::Flags)&RowMajorBit ? int(Derived::MaxColsAtCompileTime) : int(Derived::MaxRowsAtCompileTime), MaxSizeAtCompileTime = Derived::SizeAtCompileTime, - PacketSize = ei_packet_traits::size + PacketSize = packet_traits::size }; enum { @@ -143,7 +145,7 @@ public: ************************/ template -struct ei_assign_DefaultTraversal_CompleteUnrolling +struct assign_DefaultTraversal_CompleteUnrolling { enum { outer = Index / Derived1::InnerSizeAtCompileTime, @@ -153,28 +155,28 @@ struct ei_assign_DefaultTraversal_CompleteUnrolling EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { dst.copyCoeffByOuterInner(outer, inner, src); - ei_assign_DefaultTraversal_CompleteUnrolling::run(dst, src); + assign_DefaultTraversal_CompleteUnrolling::run(dst, src); } }; template -struct ei_assign_DefaultTraversal_CompleteUnrolling +struct assign_DefaultTraversal_CompleteUnrolling { EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &) {} }; template -struct ei_assign_DefaultTraversal_InnerUnrolling +struct assign_DefaultTraversal_InnerUnrolling { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src, int outer) { dst.copyCoeffByOuterInner(outer, Index, src); - ei_assign_DefaultTraversal_InnerUnrolling::run(dst, src, outer); + assign_DefaultTraversal_InnerUnrolling::run(dst, src, outer); } }; template -struct ei_assign_DefaultTraversal_InnerUnrolling +struct assign_DefaultTraversal_InnerUnrolling { EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &, int) {} }; @@ -184,17 +186,17 @@ struct ei_assign_DefaultTraversal_InnerUnrolling ***********************/ template -struct ei_assign_LinearTraversal_CompleteUnrolling +struct assign_LinearTraversal_CompleteUnrolling { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { dst.copyCoeff(Index, src); - ei_assign_LinearTraversal_CompleteUnrolling::run(dst, src); + assign_LinearTraversal_CompleteUnrolling::run(dst, src); } }; template -struct ei_assign_LinearTraversal_CompleteUnrolling +struct assign_LinearTraversal_CompleteUnrolling { EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &) {} }; @@ -204,41 +206,41 @@ struct ei_assign_LinearTraversal_CompleteUnrolling -struct ei_assign_innervec_CompleteUnrolling +struct assign_innervec_CompleteUnrolling { enum { outer = Index / Derived1::InnerSizeAtCompileTime, inner = Index % Derived1::InnerSizeAtCompileTime, - JointAlignment = ei_assign_traits::JointAlignment + JointAlignment = assign_traits::JointAlignment }; EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { dst.template copyPacketByOuterInner(outer, inner, src); - ei_assign_innervec_CompleteUnrolling::size, Stop>::run(dst, src); + assign_innervec_CompleteUnrolling::size, Stop>::run(dst, src); } }; template -struct ei_assign_innervec_CompleteUnrolling +struct assign_innervec_CompleteUnrolling { EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &) {} }; template -struct ei_assign_innervec_InnerUnrolling +struct assign_innervec_InnerUnrolling { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src, int outer) { dst.template copyPacketByOuterInner(outer, Index, src); - ei_assign_innervec_InnerUnrolling::size, Stop>::run(dst, src, outer); + assign_innervec_InnerUnrolling::size, Stop>::run(dst, src, outer); } }; template -struct ei_assign_innervec_InnerUnrolling +struct assign_innervec_InnerUnrolling { EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &, int) {} }; @@ -248,22 +250,22 @@ struct ei_assign_innervec_InnerUnrolling ***************************************************************************/ template::Traversal, - int Unrolling = ei_assign_traits::Unrolling> -struct ei_assign_impl; + int Traversal = assign_traits::Traversal, + int Unrolling = assign_traits::Unrolling> +struct assign_impl; /************************ *** Default traversal *** ************************/ template -struct ei_assign_impl +struct assign_impl { inline static void run(Derived1 &, const Derived2 &) { } }; template -struct ei_assign_impl +struct assign_impl { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -277,24 +279,24 @@ struct ei_assign_impl }; template -struct ei_assign_impl +struct assign_impl { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { - ei_assign_DefaultTraversal_CompleteUnrolling + assign_DefaultTraversal_CompleteUnrolling ::run(dst, src); } }; template -struct ei_assign_impl +struct assign_impl { typedef typename Derived1::Index Index; EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { const Index outerSize = dst.outerSize(); for(Index outer = 0; outer < outerSize; ++outer) - ei_assign_DefaultTraversal_InnerUnrolling + assign_DefaultTraversal_InnerUnrolling ::run(dst, src, outer); } }; @@ -304,7 +306,7 @@ struct ei_assign_impl ***********************/ template -struct ei_assign_impl +struct assign_impl { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -316,11 +318,11 @@ struct ei_assign_impl }; template -struct ei_assign_impl +struct assign_impl { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { - ei_assign_LinearTraversal_CompleteUnrolling + assign_LinearTraversal_CompleteUnrolling ::run(dst, src); } }; @@ -330,14 +332,14 @@ struct ei_assign_impl **************************/ template -struct ei_assign_impl +struct assign_impl { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) { const Index innerSize = dst.innerSize(); const Index outerSize = dst.outerSize(); - const Index packetSize = ei_packet_traits::size; + const Index packetSize = packet_traits::size; for(Index outer = 0; outer < outerSize; ++outer) for(Index inner = 0; inner < innerSize; inner+=packetSize) dst.template copyPacketByOuterInner(outer, inner, src); @@ -345,24 +347,24 @@ struct ei_assign_impl }; template -struct ei_assign_impl +struct assign_impl { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { - ei_assign_innervec_CompleteUnrolling + assign_innervec_CompleteUnrolling ::run(dst, src); } }; template -struct ei_assign_impl +struct assign_impl { typedef typename Derived1::Index Index; EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { const Index outerSize = dst.outerSize(); for(Index outer = 0; outer < outerSize; ++outer) - ei_assign_innervec_InnerUnrolling + assign_innervec_InnerUnrolling ::run(dst, src, outer); } }; @@ -372,14 +374,14 @@ struct ei_assign_impl -struct ei_unaligned_assign_impl +struct unaligned_assign_impl { template static EIGEN_STRONG_INLINE void run(const Derived&, OtherDerived&, typename Derived::Index, typename Derived::Index) {} }; template <> -struct ei_unaligned_assign_impl +struct unaligned_assign_impl { // MSVC must not inline this functions. If it does, it fails to optimize the // packet access path. @@ -397,45 +399,45 @@ struct ei_unaligned_assign_impl }; template -struct ei_assign_impl +struct assign_impl { typedef typename Derived1::Index Index; EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { const Index size = dst.size(); - typedef ei_packet_traits PacketTraits; + typedef packet_traits PacketTraits; enum { packetSize = PacketTraits::size, - dstAlignment = PacketTraits::AlignedOnScalar ? Aligned : int(ei_assign_traits::DstIsAligned) , - srcAlignment = ei_assign_traits::JointAlignment + dstAlignment = PacketTraits::AlignedOnScalar ? Aligned : int(assign_traits::DstIsAligned) , + srcAlignment = assign_traits::JointAlignment }; - const Index alignedStart = ei_assign_traits::DstIsAligned ? 0 - : ei_first_aligned(&dst.coeffRef(0), size); + const Index alignedStart = assign_traits::DstIsAligned ? 0 + : first_aligned(&dst.coeffRef(0), size); const Index alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize; - ei_unaligned_assign_impl::DstIsAligned!=0>::run(src,dst,0,alignedStart); + unaligned_assign_impl::DstIsAligned!=0>::run(src,dst,0,alignedStart); for(Index index = alignedStart; index < alignedEnd; index += packetSize) { dst.template copyPacket(index, src); } - ei_unaligned_assign_impl<>::run(src,dst,alignedEnd,size); + unaligned_assign_impl<>::run(src,dst,alignedEnd,size); } }; template -struct ei_assign_impl +struct assign_impl { typedef typename Derived1::Index Index; EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { enum { size = Derived1::SizeAtCompileTime, - packetSize = ei_packet_traits::size, + packetSize = packet_traits::size, alignedSize = (size/packetSize)*packetSize }; - ei_assign_innervec_CompleteUnrolling::run(dst, src); - ei_assign_DefaultTraversal_CompleteUnrolling::run(dst, src); + assign_innervec_CompleteUnrolling::run(dst, src); + assign_DefaultTraversal_CompleteUnrolling::run(dst, src); } }; @@ -444,24 +446,24 @@ struct ei_assign_impl -struct ei_assign_impl +struct assign_impl { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) { - typedef ei_packet_traits PacketTraits; + typedef packet_traits PacketTraits; enum { packetSize = PacketTraits::size, alignable = PacketTraits::AlignedOnScalar, - dstAlignment = alignable ? Aligned : int(ei_assign_traits::DstIsAligned) , - srcAlignment = ei_assign_traits::JointAlignment + dstAlignment = alignable ? Aligned : int(assign_traits::DstIsAligned) , + srcAlignment = assign_traits::JointAlignment }; const Index packetAlignedMask = packetSize - 1; const Index innerSize = dst.innerSize(); const Index outerSize = dst.outerSize(); const Index alignedStep = alignable ? (packetSize - dst.outerStride() % packetSize) & packetAlignedMask : 0; - Index alignedStart = ((!alignable) || ei_assign_traits::DstIsAligned) ? 0 - : ei_first_aligned(&dst.coeffRef(0,0), innerSize); + Index alignedStart = ((!alignable) || assign_traits::DstIsAligned) ? 0 + : first_aligned(&dst.coeffRef(0,0), innerSize); for(Index outer = 0; outer < outerSize; ++outer) { @@ -483,6 +485,8 @@ struct ei_assign_impl } }; +} // end namespace internal + /*************************************************************************** * Part 4 : implementation of DenseBase methods ***************************************************************************/ @@ -493,26 +497,26 @@ EIGEN_STRONG_INLINE Derived& DenseBase ::lazyAssign(const DenseBase& other) { enum{ - SameType = ei_is_same_type::ret + SameType = internal::is_same_type::ret }; EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived) EIGEN_STATIC_ASSERT(SameType,YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) - - #ifdef EIGEN_DEBUG_ASSIGN - ei_assign_traits::debug(); + internal::assign_traits::debug(); #endif - ei_assert(rows() == other.rows() && cols() == other.cols()); - ei_assign_impl::Traversal) - : int(InvalidTraversal)>::run(derived(),other.derived()); + eigen_assert(rows() == other.rows() && cols() == other.cols()); + internal::assign_impl::Traversal) + : int(InvalidTraversal)>::run(derived(),other.derived()); #ifndef EIGEN_NO_DEBUG checkTransposeAliasing(other.derived()); #endif return derived(); } +namespace internal { + template -struct ei_assign_selector; +struct assign_selector; template -struct ei_assign_selector { +struct assign_selector { EIGEN_STRONG_INLINE static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.derived()); } }; template -struct ei_assign_selector { +struct assign_selector { EIGEN_STRONG_INLINE static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.eval()); } }; template -struct ei_assign_selector { +struct assign_selector { EIGEN_STRONG_INLINE static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.transpose()); } }; template -struct ei_assign_selector { +struct assign_selector { EIGEN_STRONG_INLINE static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.transpose().eval()); } }; +} // end namespace internal + template template EIGEN_STRONG_INLINE Derived& DenseBase::operator=(const DenseBase& other) { - return ei_assign_selector::run(derived(), other.derived()); + return internal::assign_selector::run(derived(), other.derived()); } template EIGEN_STRONG_INLINE Derived& DenseBase::operator=(const DenseBase& other) { - return ei_assign_selector::run(derived(), other.derived()); + return internal::assign_selector::run(derived(), other.derived()); } template EIGEN_STRONG_INLINE Derived& MatrixBase::operator=(const MatrixBase& other) { - return ei_assign_selector::run(derived(), other.derived()); + return internal::assign_selector::run(derived(), other.derived()); } template template EIGEN_STRONG_INLINE Derived& MatrixBase::operator=(const DenseBase& other) { - return ei_assign_selector::run(derived(), other.derived()); + return internal::assign_selector::run(derived(), other.derived()); } template diff --git a/Eigen/src/Core/BandMatrix.h b/Eigen/src/Core/BandMatrix.h index 2f94d12dc..d5c0957ee 100644 --- a/Eigen/src/Core/BandMatrix.h +++ b/Eigen/src/Core/BandMatrix.h @@ -43,8 +43,10 @@ * * \sa class TridiagonalMatrix */ + +namespace internal { template -struct ei_traits > +struct traits > { typedef _Scalar Scalar; typedef Dense StorageKind; @@ -58,6 +60,7 @@ struct ei_traits > Flags = LvalueBit }; }; +} template class BandMatrix : public EigenBase > @@ -65,14 +68,14 @@ class BandMatrix : public EigenBase::Flags, - CoeffReadCost = ei_traits::CoeffReadCost, - RowsAtCompileTime = ei_traits::RowsAtCompileTime, - ColsAtCompileTime = ei_traits::ColsAtCompileTime, - MaxRowsAtCompileTime = ei_traits::MaxRowsAtCompileTime, - MaxColsAtCompileTime = ei_traits::MaxColsAtCompileTime + Flags = internal::traits::Flags, + CoeffReadCost = internal::traits::CoeffReadCost, + RowsAtCompileTime = internal::traits::RowsAtCompileTime, + ColsAtCompileTime = internal::traits::ColsAtCompileTime, + MaxRowsAtCompileTime = internal::traits::MaxRowsAtCompileTime, + MaxColsAtCompileTime = internal::traits::MaxColsAtCompileTime }; - typedef typename ei_traits::Scalar Scalar; + typedef typename internal::traits::Scalar Scalar; typedef Matrix DenseMatrixType; typedef typename DenseMatrixType::Index Index; @@ -144,8 +147,8 @@ class BandMatrix : public EigenBase BuildType; - typedef typename ei_meta_if,BuildType >, + typedef typename internal::meta_if,BuildType >, BuildType>::ret Type; }; @@ -164,14 +167,14 @@ class BandMatrix : public EigenBase diagonal(Index i) { - ei_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers())); + eigen_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers())); return Block(m_data, supers()-i, std::max(0,i), 1, diagonalLength(i)); } /** \returns a vector expression of the \a i -th sub or super diagonal */ inline const Block diagonal(Index i) const { - ei_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers())); + eigen_assert((i<0 && -i<=subs()) || (i>=0 && i<=supers())); return Block(m_data, supers()-i, std::max(0,i), 1, diagonalLength(i)); } @@ -199,9 +202,9 @@ class BandMatrix : public EigenBase m_rows; - ei_variable_if_dynamic m_supers; - ei_variable_if_dynamic m_subs; + internal::variable_if_dynamic m_rows; + internal::variable_if_dynamic m_supers; + internal::variable_if_dynamic m_subs; }; /** diff --git a/Eigen/src/Core/Block.h b/Eigen/src/Core/Block.h index a770b9721..76fb46e25 100644 --- a/Eigen/src/Core/Block.h +++ b/Eigen/src/Core/Block.h @@ -58,54 +58,57 @@ * * \sa DenseBase::block(Index,Index,Index,Index), DenseBase::block(Index,Index), class VectorBlock */ + +namespace internal { template -struct ei_traits > : ei_traits +struct traits > : traits { - typedef typename ei_traits::Scalar Scalar; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::XprKind XprKind; - typedef typename ei_nested::type XprTypeNested; - typedef typename ei_unref::type _XprTypeNested; + typedef typename traits::Scalar Scalar; + typedef typename traits::StorageKind StorageKind; + typedef typename traits::XprKind XprKind; + typedef typename nested::type XprTypeNested; + typedef typename unref::type _XprTypeNested; enum{ - MatrixRows = ei_traits::RowsAtCompileTime, - MatrixCols = ei_traits::ColsAtCompileTime, + MatrixRows = traits::RowsAtCompileTime, + MatrixCols = traits::ColsAtCompileTime, RowsAtCompileTime = MatrixRows == 0 ? 0 : BlockRows, ColsAtCompileTime = MatrixCols == 0 ? 0 : BlockCols, MaxRowsAtCompileTime = BlockRows==0 ? 0 : RowsAtCompileTime != Dynamic ? int(RowsAtCompileTime) - : int(ei_traits::MaxRowsAtCompileTime), + : int(traits::MaxRowsAtCompileTime), MaxColsAtCompileTime = BlockCols==0 ? 0 : ColsAtCompileTime != Dynamic ? int(ColsAtCompileTime) - : int(ei_traits::MaxColsAtCompileTime), - XprTypeIsRowMajor = (int(ei_traits::Flags)&RowMajorBit) != 0, + : int(traits::MaxColsAtCompileTime), + XprTypeIsRowMajor = (int(traits::Flags)&RowMajorBit) != 0, IsRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1 : (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0 : XprTypeIsRowMajor, HasSameStorageOrderAsXprType = (IsRowMajor == XprTypeIsRowMajor), InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime), InnerStrideAtCompileTime = HasSameStorageOrderAsXprType - ? int(ei_inner_stride_at_compile_time::ret) - : int(ei_outer_stride_at_compile_time::ret), + ? int(inner_stride_at_compile_time::ret) + : int(outer_stride_at_compile_time::ret), OuterStrideAtCompileTime = HasSameStorageOrderAsXprType - ? int(ei_outer_stride_at_compile_time::ret) - : int(ei_inner_stride_at_compile_time::ret), - MaskPacketAccessBit = (InnerSize == Dynamic || (InnerSize % ei_packet_traits::size) == 0) + ? int(outer_stride_at_compile_time::ret) + : int(inner_stride_at_compile_time::ret), + MaskPacketAccessBit = (InnerSize == Dynamic || (InnerSize % packet_traits::size) == 0) && (InnerStrideAtCompileTime == 1) ? PacketAccessBit : 0, - MaskAlignedBit = (InnerPanel && (OuterStrideAtCompileTime!=Dynamic) && ((OuterStrideAtCompileTime % ei_packet_traits::size) == 0)) ? AlignedBit : 0, + MaskAlignedBit = (InnerPanel && (OuterStrideAtCompileTime!=Dynamic) && ((OuterStrideAtCompileTime % packet_traits::size) == 0)) ? AlignedBit : 0, FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1) ? LinearAccessBit : 0, - Flags0 = ei_traits::Flags & (HereditaryBits | MaskPacketAccessBit | LvalueBit | DirectAccessBit | MaskAlignedBit), + Flags0 = traits::Flags & (HereditaryBits | MaskPacketAccessBit | LvalueBit | DirectAccessBit | MaskAlignedBit), Flags1 = Flags0 | FlagsLinearAccessBit, Flags = (Flags1 & ~RowMajorBit) | (IsRowMajor ? RowMajorBit : 0) }; }; +} template class Block - : public ei_dense_xpr_base >::type + : public internal::dense_xpr_base >::type { public: - typedef typename ei_dense_xpr_base::type Base; + typedef typename internal::dense_xpr_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(Block) class InnerIterator; @@ -123,7 +126,7 @@ template=0) && ( + eigen_assert( (i>=0) && ( ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && i= 0 && BlockRows >= 1 && startRow + BlockRows <= xpr.rows() + eigen_assert(startRow >= 0 && BlockRows >= 1 && startRow + BlockRows <= xpr.rows() && startCol >= 0 && BlockCols >= 1 && startCol + BlockCols <= xpr.cols()); } @@ -147,9 +150,9 @@ template= 0 && blockRows >= 0 && startRow + blockRows <= xpr.rows() + eigen_assert(startRow >= 0 && blockRows >= 0 && startRow + blockRows <= xpr.rows() && startCol >= 0 && blockCols >= 0 && startCol + blockCols <= xpr.cols()); } @@ -223,10 +226,10 @@ template m_startRow; - const ei_variable_if_dynamic m_startCol; - const ei_variable_if_dynamic m_blockRows; - const ei_variable_if_dynamic m_blockCols; + const internal::variable_if_dynamic m_startRow; + const internal::variable_if_dynamic m_startCol; + const internal::variable_if_dynamic m_blockRows; + const internal::variable_if_dynamic m_blockCols; }; /** \internal */ @@ -251,7 +254,7 @@ class Block BlockCols==1 ? 1 : xpr.cols()), m_xpr(xpr) { - ei_assert( (i>=0) && ( + eigen_assert( (i>=0) && ( ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && i inline Block(const XprType& xpr, Index startRow, Index startCol) : Base(&xpr.const_cast_derived().coeffRef(startRow,startCol)), m_xpr(xpr) { - ei_assert(startRow >= 0 && BlockRows >= 1 && startRow + BlockRows <= xpr.rows() + eigen_assert(startRow >= 0 && BlockRows >= 1 && startRow + BlockRows <= xpr.rows() && startCol >= 0 && BlockCols >= 1 && startCol + BlockCols <= xpr.cols()); init(); } @@ -275,9 +278,9 @@ class Block : Base(&xpr.const_cast_derived().coeffRef(startRow,startCol), blockRows, blockCols), m_xpr(xpr) { - ei_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows) + eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows) && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols)); - ei_assert(startRow >= 0 && blockRows >= 0 && startRow + blockRows <= xpr.rows() + eigen_assert(startRow >= 0 && blockRows >= 0 && startRow + blockRows <= xpr.rows() && startCol >= 0 && blockCols >= 0 && startCol + blockCols <= xpr.cols()); init(); } @@ -285,7 +288,7 @@ class Block /** \sa MapBase::innerStride() */ inline Index innerStride() const { - return ei_traits::HasSameStorageOrderAsXprType + return internal::traits::HasSameStorageOrderAsXprType ? m_xpr.innerStride() : m_xpr.outerStride(); } @@ -314,7 +317,7 @@ class Block protected: void init() { - m_outerStride = ei_traits::HasSameStorageOrderAsXprType + m_outerStride = internal::traits::HasSameStorageOrderAsXprType ? m_xpr.outerStride() : m_xpr.innerStride(); } diff --git a/Eigen/src/Core/BooleanRedux.h b/Eigen/src/Core/BooleanRedux.h index 9f9d1b594..5c3444a57 100644 --- a/Eigen/src/Core/BooleanRedux.h +++ b/Eigen/src/Core/BooleanRedux.h @@ -25,8 +25,10 @@ #ifndef EIGEN_ALLANDANY_H #define EIGEN_ALLANDANY_H +namespace internal { + template -struct ei_all_unroller +struct all_unroller { enum { col = (UnrollCount-1) / Derived::RowsAtCompileTime, @@ -35,24 +37,24 @@ struct ei_all_unroller inline static bool run(const Derived &mat) { - return ei_all_unroller::run(mat) && mat.coeff(row, col); + return all_unroller::run(mat) && mat.coeff(row, col); } }; template -struct ei_all_unroller +struct all_unroller { inline static bool run(const Derived &mat) { return mat.coeff(0, 0); } }; template -struct ei_all_unroller +struct all_unroller { inline static bool run(const Derived &) { return false; } }; template -struct ei_any_unroller +struct any_unroller { enum { col = (UnrollCount-1) / Derived::RowsAtCompileTime, @@ -61,22 +63,24 @@ struct ei_any_unroller inline static bool run(const Derived &mat) { - return ei_any_unroller::run(mat) || mat.coeff(row, col); + return any_unroller::run(mat) || mat.coeff(row, col); } }; template -struct ei_any_unroller +struct any_unroller { inline static bool run(const Derived &mat) { return mat.coeff(0, 0); } }; template -struct ei_any_unroller +struct any_unroller { inline static bool run(const Derived &) { return false; } }; +} // end namespace internal + /** \returns true if all coefficients are true * * Example: \include MatrixBase_all.cpp @@ -94,7 +98,7 @@ inline bool DenseBase::all() const && SizeAtCompileTime * (CoeffReadCost + NumTraits::AddCost) <= EIGEN_UNROLLING_LIMIT }; if(unroll) - return ei_all_unroller::run(derived()); else @@ -120,7 +124,7 @@ inline bool DenseBase::any() const && SizeAtCompileTime * (CoeffReadCost + NumTraits::AddCost) <= EIGEN_UNROLLING_LIMIT }; if(unroll) - return ei_any_unroller::run(derived()); else diff --git a/Eigen/src/Core/CommaInitializer.h b/Eigen/src/Core/CommaInitializer.h index da8df5592..92422bf2f 100644 --- a/Eigen/src/Core/CommaInitializer.h +++ b/Eigen/src/Core/CommaInitializer.h @@ -64,12 +64,12 @@ struct CommaInitializer m_row+=m_currentBlockRows; m_col = 0; m_currentBlockRows = 1; - ei_assert(m_row @@ -101,7 +101,7 @@ struct CommaInitializer inline ~CommaInitializer() { - ei_assert((m_row+m_currentBlockRows) == m_xpr.rows() + eigen_assert((m_row+m_currentBlockRows) == m_xpr.rows() && m_col == m_xpr.cols() && "Too few coefficients passed to comma initializer (operator<<)"); } diff --git a/Eigen/src/Core/CwiseBinaryOp.h b/Eigen/src/Core/CwiseBinaryOp.h index 5def0db2a..8e9761640 100644 --- a/Eigen/src/Core/CwiseBinaryOp.h +++ b/Eigen/src/Core/CwiseBinaryOp.h @@ -45,56 +45,59 @@ * * \sa MatrixBase::binaryExpr(const MatrixBase &,const CustomBinaryOp &) const, class CwiseUnaryOp, class CwiseNullaryOp */ + +namespace internal { template -struct ei_traits > +struct traits > { - // we must not inherit from ei_traits since it has + // we must not inherit from traits since it has // the potential to cause problems with MSVC - typedef typename ei_cleantype::type Ancestor; - typedef typename ei_traits::XprKind XprKind; + typedef typename cleantype::type Ancestor; + typedef typename traits::XprKind XprKind; enum { - RowsAtCompileTime = ei_traits::RowsAtCompileTime, - ColsAtCompileTime = ei_traits::ColsAtCompileTime, - MaxRowsAtCompileTime = ei_traits::MaxRowsAtCompileTime, - MaxColsAtCompileTime = ei_traits::MaxColsAtCompileTime + RowsAtCompileTime = traits::RowsAtCompileTime, + ColsAtCompileTime = traits::ColsAtCompileTime, + MaxRowsAtCompileTime = traits::MaxRowsAtCompileTime, + MaxColsAtCompileTime = traits::MaxColsAtCompileTime }; // even though we require Lhs and Rhs to have the same scalar type (see CwiseBinaryOp constructor), // we still want to handle the case when the result type is different. - typedef typename ei_result_of< + typedef typename result_of< BinaryOp( typename Lhs::Scalar, typename Rhs::Scalar ) >::type Scalar; - typedef typename ei_promote_storage_type::StorageKind, - typename ei_traits::StorageKind>::ret StorageKind; - typedef typename ei_promote_index_type::Index, - typename ei_traits::Index>::type Index; + typedef typename promote_storage_type::StorageKind, + typename traits::StorageKind>::ret StorageKind; + typedef typename promote_index_type::Index, + typename traits::Index>::type Index; typedef typename Lhs::Nested LhsNested; typedef typename Rhs::Nested RhsNested; - typedef typename ei_unref::type _LhsNested; - typedef typename ei_unref::type _RhsNested; + typedef typename unref::type _LhsNested; + typedef typename unref::type _RhsNested; enum { LhsCoeffReadCost = _LhsNested::CoeffReadCost, RhsCoeffReadCost = _RhsNested::CoeffReadCost, LhsFlags = _LhsNested::Flags, RhsFlags = _RhsNested::Flags, - SameType = ei_is_same_type::ret, + SameType = is_same_type::ret, StorageOrdersAgree = (int(Lhs::Flags)&RowMajorBit)==(int(Rhs::Flags)&RowMajorBit), Flags0 = (int(LhsFlags) | int(RhsFlags)) & ( HereditaryBits | (int(LhsFlags) & int(RhsFlags) & ( AlignedBit | (StorageOrdersAgree ? LinearAccessBit : 0) - | (ei_functor_traits::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0) + | (functor_traits::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0) ) ) ), Flags = (Flags0 & ~RowMajorBit) | (LhsFlags & RowMajorBit), - CoeffReadCost = LhsCoeffReadCost + RhsCoeffReadCost + ei_functor_traits::Cost + CoeffReadCost = LhsCoeffReadCost + RhsCoeffReadCost + functor_traits::Cost }; }; +} // end namespace internal // we require Lhs and Rhs to have the same scalar type. Currently there is no example of a binary functor // that would take two operands of different types. If there were such an example, then this check should be @@ -104,33 +107,33 @@ struct ei_traits > // So allowing mixing different types gives very unexpected errors when enabling vectorization, when the user tries to // add together a float matrix and a double matrix. #define EIGEN_CHECK_BINARY_COMPATIBILIY(BINOP,LHS,RHS) \ - EIGEN_STATIC_ASSERT((ei_functor_allows_mixing_real_and_complex::ret \ - ? int(ei_is_same_type::Real, typename NumTraits::Real>::ret) \ - : int(ei_is_same_type::ret)), \ + EIGEN_STATIC_ASSERT((internal::functor_allows_mixing_real_and_complex::ret \ + ? int(internal::is_same_type::Real, typename NumTraits::Real>::ret) \ + : int(internal::is_same_type::ret)), \ YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) template class CwiseBinaryOpImpl; template -class CwiseBinaryOp : ei_no_assignment_operator, +class CwiseBinaryOp : internal::no_assignment_operator, public CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, - typename ei_promote_storage_type::StorageKind, - typename ei_traits::StorageKind>::ret> + typename internal::promote_storage_type::StorageKind, + typename internal::traits::StorageKind>::ret> { public: typedef typename CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, - typename ei_promote_storage_type::StorageKind, - typename ei_traits::StorageKind>::ret>::Base Base; + typename internal::promote_storage_type::StorageKind, + typename internal::traits::StorageKind>::ret>::Base Base; EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseBinaryOp) - typedef typename ei_nested::type LhsNested; - typedef typename ei_nested::type RhsNested; - typedef typename ei_unref::type _LhsNested; - typedef typename ei_unref::type _RhsNested; + typedef typename internal::nested::type LhsNested; + typedef typename internal::nested::type RhsNested; + typedef typename internal::unref::type _LhsNested; + typedef typename internal::unref::type _RhsNested; EIGEN_STRONG_INLINE CwiseBinaryOp(const Lhs& lhs, const Rhs& rhs, const BinaryOp& func = BinaryOp()) : m_lhs(lhs), m_rhs(rhs), m_functor(func) @@ -138,19 +141,19 @@ class CwiseBinaryOp : ei_no_assignment_operator, EIGEN_CHECK_BINARY_COMPATIBILIY(BinaryOp,typename Lhs::Scalar,typename Rhs::Scalar); // require the sizes to match EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Lhs, Rhs) - ei_assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols()); + eigen_assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols()); } EIGEN_STRONG_INLINE Index rows() const { // return the fixed size type if available to enable compile time optimizations - if (ei_traits::type>::RowsAtCompileTime==Dynamic) + if (internal::traits::type>::RowsAtCompileTime==Dynamic) return m_rhs.rows(); else return m_lhs.rows(); } EIGEN_STRONG_INLINE Index cols() const { // return the fixed size type if available to enable compile time optimizations - if (ei_traits::type>::ColsAtCompileTime==Dynamic) + if (internal::traits::type>::ColsAtCompileTime==Dynamic) return m_rhs.cols(); else return m_lhs.cols(); @@ -171,12 +174,12 @@ class CwiseBinaryOp : ei_no_assignment_operator, template class CwiseBinaryOpImpl - : public ei_dense_xpr_base >::type + : public internal::dense_xpr_base >::type { typedef CwiseBinaryOp Derived; public: - typedef typename ei_dense_xpr_base >::type Base; + typedef typename internal::dense_xpr_base >::type Base; EIGEN_DENSE_PUBLIC_INTERFACE( Derived ) EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const @@ -215,7 +218,7 @@ template EIGEN_STRONG_INLINE Derived & MatrixBase::operator-=(const MatrixBase &other) { - SelfCwiseBinaryOp, Derived, OtherDerived> tmp(derived()); + SelfCwiseBinaryOp, Derived, OtherDerived> tmp(derived()); tmp = other.derived(); return derived(); } @@ -229,7 +232,7 @@ template EIGEN_STRONG_INLINE Derived & MatrixBase::operator+=(const MatrixBase& other) { - SelfCwiseBinaryOp, Derived, OtherDerived> tmp(derived()); + SelfCwiseBinaryOp, Derived, OtherDerived> tmp(derived()); tmp = other.derived(); return derived(); } diff --git a/Eigen/src/Core/CwiseNullaryOp.h b/Eigen/src/Core/CwiseNullaryOp.h index 0b8e7c0c1..a2f504985 100644 --- a/Eigen/src/Core/CwiseNullaryOp.h +++ b/Eigen/src/Core/CwiseNullaryOp.h @@ -42,32 +42,35 @@ * * \sa class CwiseUnaryOp, class CwiseBinaryOp, DenseBase::NullaryExpr() */ + +namespace internal { template -struct ei_traits > : ei_traits +struct traits > : traits { enum { - Flags = (ei_traits::Flags + Flags = (traits::Flags & ( HereditaryBits - | (ei_functor_has_linear_access::ret ? LinearAccessBit : 0) - | (ei_functor_traits::PacketAccess ? PacketAccessBit : 0))) - | (ei_functor_traits::IsRepeatable ? 0 : EvalBeforeNestingBit), - CoeffReadCost = ei_functor_traits::Cost + | (functor_has_linear_access::ret ? LinearAccessBit : 0) + | (functor_traits::PacketAccess ? PacketAccessBit : 0))) + | (functor_traits::IsRepeatable ? 0 : EvalBeforeNestingBit), + CoeffReadCost = functor_traits::Cost }; }; +} template -class CwiseNullaryOp : ei_no_assignment_operator, - public ei_dense_xpr_base< CwiseNullaryOp >::type +class CwiseNullaryOp : internal::no_assignment_operator, + public internal::dense_xpr_base< CwiseNullaryOp >::type { public: - typedef typename ei_dense_xpr_base::type Base; + typedef typename internal::dense_xpr_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(CwiseNullaryOp) CwiseNullaryOp(Index rows, Index cols, const NullaryOp& func = NullaryOp()) : m_rows(rows), m_cols(cols), m_functor(func) { - ei_assert(rows >= 0 + eigen_assert(rows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows) && cols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)); @@ -99,8 +102,8 @@ class CwiseNullaryOp : ei_no_assignment_operator, } protected: - const ei_variable_if_dynamic m_rows; - const ei_variable_if_dynamic m_cols; + const internal::variable_if_dynamic m_rows; + const internal::variable_if_dynamic m_cols; const NullaryOp m_functor; }; @@ -185,7 +188,7 @@ template EIGEN_STRONG_INLINE const typename DenseBase::ConstantReturnType DenseBase::Constant(Index rows, Index cols, const Scalar& value) { - return DenseBase::NullaryExpr(rows, cols, ei_scalar_constant_op(value)); + return DenseBase::NullaryExpr(rows, cols, internal::scalar_constant_op(value)); } /** \returns an expression of a constant matrix of value \a value @@ -207,7 +210,7 @@ template EIGEN_STRONG_INLINE const typename DenseBase::ConstantReturnType DenseBase::Constant(Index size, const Scalar& value) { - return DenseBase::NullaryExpr(size, ei_scalar_constant_op(value)); + return DenseBase::NullaryExpr(size, internal::scalar_constant_op(value)); } /** \returns an expression of a constant matrix of value \a value @@ -224,7 +227,7 @@ EIGEN_STRONG_INLINE const typename DenseBase::ConstantReturnType DenseBase::Constant(const Scalar& value) { EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) - return DenseBase::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, ei_scalar_constant_op(value)); + return DenseBase::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_constant_op(value)); } /** @@ -247,7 +250,7 @@ EIGEN_STRONG_INLINE const typename DenseBase::SequentialLinSpacedReturn DenseBase::LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high) { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) - return DenseBase::NullaryExpr(size, ei_linspaced_op(low,high,size)); + return DenseBase::NullaryExpr(size, internal::linspaced_op(low,high,size)); } /** @@ -260,7 +263,7 @@ DenseBase::LinSpaced(Sequential_t, const Scalar& low, const Scalar& hig { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) - return DenseBase::NullaryExpr(Derived::SizeAtCompileTime, ei_linspaced_op(low,high,Derived::SizeAtCompileTime)); + return DenseBase::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op(low,high,Derived::SizeAtCompileTime)); } /** @@ -280,7 +283,7 @@ EIGEN_STRONG_INLINE const typename DenseBase::RandomAccessLinSpacedRetu DenseBase::LinSpaced(Index size, const Scalar& low, const Scalar& high) { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) - return DenseBase::NullaryExpr(size, ei_linspaced_op(low,high,size)); + return DenseBase::NullaryExpr(size, internal::linspaced_op(low,high,size)); } /** @@ -293,7 +296,7 @@ DenseBase::LinSpaced(const Scalar& low, const Scalar& high) { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) - return DenseBase::NullaryExpr(Derived::SizeAtCompileTime, ei_linspaced_op(low,high,Derived::SizeAtCompileTime)); + return DenseBase::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op(low,high,Derived::SizeAtCompileTime)); } /** \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */ @@ -303,7 +306,7 @@ bool DenseBase::isApproxToConstant { for(Index j = 0; j < cols(); ++j) for(Index i = 0; i < rows(); ++i) - if(!ei_isApprox(this->coeff(i, j), value, prec)) + if(!internal::isApprox(this->coeff(i, j), value, prec)) return false; return true; } @@ -390,7 +393,7 @@ template EIGEN_STRONG_INLINE Derived& DenseBase::setLinSpaced(Index size, const Scalar& low, const Scalar& high) { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) - return derived() = Derived::NullaryExpr(size, ei_linspaced_op(low,high,size)); + return derived() = Derived::NullaryExpr(size, internal::linspaced_op(low,high,size)); } // zero: @@ -469,7 +472,7 @@ bool DenseBase::isZero(RealScalar prec) const { for(Index j = 0; j < cols(); ++j) for(Index i = 0; i < rows(); ++i) - if(!ei_isMuchSmallerThan(this->coeff(i, j), static_cast(1), prec)) + if(!internal::isMuchSmallerThan(this->coeff(i, j), static_cast(1), prec)) return false; return true; } @@ -668,7 +671,7 @@ template EIGEN_STRONG_INLINE const typename MatrixBase::IdentityReturnType MatrixBase::Identity(Index rows, Index cols) { - return DenseBase::NullaryExpr(rows, cols, ei_scalar_identity_op()); + return DenseBase::NullaryExpr(rows, cols, internal::scalar_identity_op()); } /** \returns an expression of the identity matrix (not necessarily square). @@ -686,7 +689,7 @@ EIGEN_STRONG_INLINE const typename MatrixBase::IdentityReturnType MatrixBase::Identity() { EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) - return MatrixBase::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, ei_scalar_identity_op()); + return MatrixBase::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_identity_op()); } /** \returns true if *this is approximately equal to the identity matrix @@ -708,12 +711,12 @@ bool MatrixBase::isIdentity { if(i == j) { - if(!ei_isApprox(this->coeff(i, j), static_cast(1), prec)) + if(!internal::isApprox(this->coeff(i, j), static_cast(1), prec)) return false; } else { - if(!ei_isMuchSmallerThan(this->coeff(i, j), static_cast(1), prec)) + if(!internal::isMuchSmallerThan(this->coeff(i, j), static_cast(1), prec)) return false; } } @@ -721,8 +724,10 @@ bool MatrixBase::isIdentity return true; } +namespace internal { + template=16)> -struct ei_setIdentity_impl +struct setIdentity_impl { static EIGEN_STRONG_INLINE Derived& run(Derived& m) { @@ -731,7 +736,7 @@ struct ei_setIdentity_impl }; template -struct ei_setIdentity_impl +struct setIdentity_impl { typedef typename Derived::Index Index; static EIGEN_STRONG_INLINE Derived& run(Derived& m) @@ -743,6 +748,8 @@ struct ei_setIdentity_impl } }; +} // end namespace internal + /** Writes the identity expression (not necessarily square) into *this. * * Example: \include MatrixBase_setIdentity.cpp @@ -753,7 +760,7 @@ struct ei_setIdentity_impl template EIGEN_STRONG_INLINE Derived& MatrixBase::setIdentity() { - return ei_setIdentity_impl::run(derived()); + return internal::setIdentity_impl::run(derived()); } /** \brief Resizes to the given size, and writes the identity expression (not necessarily square) into *this. diff --git a/Eigen/src/Core/CwiseUnaryOp.h b/Eigen/src/Core/CwiseUnaryOp.h index 4c92f36bb..284eb39b0 100644 --- a/Eigen/src/Core/CwiseUnaryOp.h +++ b/Eigen/src/Core/CwiseUnaryOp.h @@ -45,33 +45,36 @@ * * \sa MatrixBase::unaryExpr(const CustomUnaryOp &) const, class CwiseBinaryOp, class CwiseNullaryOp */ + +namespace internal { template -struct ei_traits > - : ei_traits +struct traits > + : traits { - typedef typename ei_result_of< + typedef typename result_of< UnaryOp(typename XprType::Scalar) >::type Scalar; typedef typename XprType::Nested XprTypeNested; - typedef typename ei_unref::type _XprTypeNested; + typedef typename unref::type _XprTypeNested; enum { Flags = _XprTypeNested::Flags & ( HereditaryBits | LinearAccessBit | AlignedBit - | (ei_functor_traits::PacketAccess ? PacketAccessBit : 0)), - CoeffReadCost = _XprTypeNested::CoeffReadCost + ei_functor_traits::Cost + | (functor_traits::PacketAccess ? PacketAccessBit : 0)), + CoeffReadCost = _XprTypeNested::CoeffReadCost + functor_traits::Cost }; }; +} template class CwiseUnaryOpImpl; template -class CwiseUnaryOp : ei_no_assignment_operator, - public CwiseUnaryOpImpl::StorageKind> +class CwiseUnaryOp : internal::no_assignment_operator, + public CwiseUnaryOpImpl::StorageKind> { public: - typedef typename CwiseUnaryOpImpl::StorageKind>::Base Base; + typedef typename CwiseUnaryOpImpl::StorageKind>::Base Base; EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp) inline CwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp()) @@ -84,11 +87,11 @@ class CwiseUnaryOp : ei_no_assignment_operator, const UnaryOp& functor() const { return m_functor; } /** \returns the nested expression */ - const typename ei_cleantype::type& + const typename internal::cleantype::type& nestedExpression() const { return m_xpr; } /** \returns the nested expression */ - typename ei_cleantype::type& + typename internal::cleantype::type& nestedExpression() { return m_xpr.const_cast_derived(); } protected: @@ -100,12 +103,12 @@ class CwiseUnaryOp : ei_no_assignment_operator, // It can be used for any expression types implementing the dense concept. template class CwiseUnaryOpImpl - : public ei_dense_xpr_base >::type + : public internal::dense_xpr_base >::type { public: typedef CwiseUnaryOp Derived; - typedef typename ei_dense_xpr_base >::type Base; + typedef typename internal::dense_xpr_base >::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(Derived) EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const diff --git a/Eigen/src/Core/CwiseUnaryView.h b/Eigen/src/Core/CwiseUnaryView.h index 37c58223e..8b5a69513 100644 --- a/Eigen/src/Core/CwiseUnaryView.h +++ b/Eigen/src/Core/CwiseUnaryView.h @@ -38,39 +38,42 @@ * * \sa MatrixBase::unaryViewExpr(const CustomUnaryOp &) const, class CwiseUnaryOp */ + +namespace internal { template -struct ei_traits > - : ei_traits +struct traits > + : traits { - typedef typename ei_result_of< - ViewOp(typename ei_traits::Scalar) + typedef typename result_of< + ViewOp(typename traits::Scalar) >::type Scalar; typedef typename MatrixType::Nested MatrixTypeNested; - typedef typename ei_cleantype::type _MatrixTypeNested; + typedef typename cleantype::type _MatrixTypeNested; enum { - Flags = (ei_traits<_MatrixTypeNested>::Flags & (HereditaryBits | LvalueBit | LinearAccessBit | DirectAccessBit)), - CoeffReadCost = ei_traits<_MatrixTypeNested>::CoeffReadCost + ei_functor_traits::Cost, - MatrixTypeInnerStride = ei_inner_stride_at_compile_time::ret, + Flags = (traits<_MatrixTypeNested>::Flags & (HereditaryBits | LvalueBit | LinearAccessBit | DirectAccessBit)), + CoeffReadCost = traits<_MatrixTypeNested>::CoeffReadCost + functor_traits::Cost, + MatrixTypeInnerStride = inner_stride_at_compile_time::ret, // need to cast the sizeof's from size_t to int explicitly, otherwise: // "error: no integral type can represent all of the enumerator values InnerStrideAtCompileTime = MatrixTypeInnerStride == Dynamic ? int(Dynamic) : int(MatrixTypeInnerStride) - * int(sizeof(typename ei_traits::Scalar) / sizeof(Scalar)), - OuterStrideAtCompileTime = ei_outer_stride_at_compile_time::ret + * int(sizeof(typename traits::Scalar) / sizeof(Scalar)), + OuterStrideAtCompileTime = outer_stride_at_compile_time::ret }; }; +} template class CwiseUnaryViewImpl; template -class CwiseUnaryView : ei_no_assignment_operator, - public CwiseUnaryViewImpl::StorageKind> +class CwiseUnaryView : internal::no_assignment_operator, + public CwiseUnaryViewImpl::StorageKind> { public: - typedef typename CwiseUnaryViewImpl::StorageKind>::Base Base; + typedef typename CwiseUnaryViewImpl::StorageKind>::Base Base; EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryView) inline CwiseUnaryView(const MatrixType& mat, const ViewOp& func = ViewOp()) @@ -85,33 +88,33 @@ class CwiseUnaryView : ei_no_assignment_operator, const ViewOp& functor() const { return m_functor; } /** \returns the nested expression */ - const typename ei_cleantype::type& + const typename internal::cleantype::type& nestedExpression() const { return m_matrix; } /** \returns the nested expression */ - typename ei_cleantype::type& + typename internal::cleantype::type& nestedExpression() { return m_matrix.const_cast_derived(); } protected: // FIXME changed from MatrixType::Nested because of a weird compilation error with sun CC - const typename ei_nested::type m_matrix; + const typename internal::nested::type m_matrix; ViewOp m_functor; }; template class CwiseUnaryViewImpl - : public ei_dense_xpr_base< CwiseUnaryView >::type + : public internal::dense_xpr_base< CwiseUnaryView >::type { public: typedef CwiseUnaryView Derived; - typedef typename ei_dense_xpr_base< CwiseUnaryView >::type Base; + typedef typename internal::dense_xpr_base< CwiseUnaryView >::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(Derived) inline Index innerStride() const { - return derived().nestedExpression().innerStride() * sizeof(typename ei_traits::Scalar) / sizeof(Scalar); + return derived().nestedExpression().innerStride() * sizeof(typename internal::traits::Scalar) / sizeof(Scalar); } inline Index outerStride() const diff --git a/Eigen/src/Core/DenseBase.h b/Eigen/src/Core/DenseBase.h index 3ef58ab03..f8ad160bf 100644 --- a/Eigen/src/Core/DenseBase.h +++ b/Eigen/src/Core/DenseBase.h @@ -40,22 +40,22 @@ */ template class DenseBase #ifndef EIGEN_PARSED_BY_DOXYGEN - : public ei_special_scalar_op_base::Scalar, - typename NumTraits::Scalar>::Real> + : public internal::special_scalar_op_base::Scalar, + typename NumTraits::Scalar>::Real> #else : public DenseCoeffsBase #endif // not EIGEN_PARSED_BY_DOXYGEN { public: - using ei_special_scalar_op_base::Scalar, - typename NumTraits::Scalar>::Real>::operator*; + using internal::special_scalar_op_base::Scalar, + typename NumTraits::Scalar>::Real>::operator*; class InnerIterator; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::Index Index; /**< The type of indices */ - typedef typename ei_traits::Scalar Scalar; - typedef typename ei_packet_traits::type PacketScalar; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Index Index; /**< The type of indices */ + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::packet_traits::type PacketScalar; typedef typename NumTraits::Real RealScalar; typedef DenseCoeffsBase Base; @@ -93,26 +93,26 @@ template class DenseBase enum { - RowsAtCompileTime = ei_traits::RowsAtCompileTime, + RowsAtCompileTime = internal::traits::RowsAtCompileTime, /**< The number of rows at compile-time. This is just a copy of the value provided * by the \a Derived type. If a value is not known at compile-time, * it is set to the \a Dynamic constant. * \sa MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */ - ColsAtCompileTime = ei_traits::ColsAtCompileTime, + ColsAtCompileTime = internal::traits::ColsAtCompileTime, /**< The number of columns at compile-time. This is just a copy of the value provided * by the \a Derived type. If a value is not known at compile-time, * it is set to the \a Dynamic constant. * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */ - SizeAtCompileTime = (ei_size_at_compile_time::RowsAtCompileTime, - ei_traits::ColsAtCompileTime>::ret), + SizeAtCompileTime = (internal::size_at_compile_time::RowsAtCompileTime, + internal::traits::ColsAtCompileTime>::ret), /**< This is equal to the number of coefficients, i.e. the number of * rows times the number of columns, or to \a Dynamic if this is not * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */ - MaxRowsAtCompileTime = ei_traits::MaxRowsAtCompileTime, + MaxRowsAtCompileTime = internal::traits::MaxRowsAtCompileTime, /**< This value is equal to the maximum possible number of rows that this expression * might have. If this expression might have an arbitrarily high number of rows, * this value is set to \a Dynamic. @@ -123,7 +123,7 @@ template class DenseBase * \sa RowsAtCompileTime, MaxColsAtCompileTime, MaxSizeAtCompileTime */ - MaxColsAtCompileTime = ei_traits::MaxColsAtCompileTime, + MaxColsAtCompileTime = internal::traits::MaxColsAtCompileTime, /**< This value is equal to the maximum possible number of columns that this expression * might have. If this expression might have an arbitrarily high number of columns, * this value is set to \a Dynamic. @@ -134,8 +134,8 @@ template class DenseBase * \sa ColsAtCompileTime, MaxRowsAtCompileTime, MaxSizeAtCompileTime */ - MaxSizeAtCompileTime = (ei_size_at_compile_time::MaxRowsAtCompileTime, - ei_traits::MaxColsAtCompileTime>::ret), + MaxSizeAtCompileTime = (internal::size_at_compile_time::MaxRowsAtCompileTime, + internal::traits::MaxColsAtCompileTime>::ret), /**< This value is equal to the maximum possible number of coefficients that this expression * might have. If this expression might have an arbitrarily high number of coefficients, * this value is set to \a Dynamic. @@ -146,14 +146,14 @@ template class DenseBase * \sa SizeAtCompileTime, MaxRowsAtCompileTime, MaxColsAtCompileTime */ - IsVectorAtCompileTime = ei_traits::MaxRowsAtCompileTime == 1 - || ei_traits::MaxColsAtCompileTime == 1, + IsVectorAtCompileTime = internal::traits::MaxRowsAtCompileTime == 1 + || internal::traits::MaxColsAtCompileTime == 1, /**< This is set to true if either the number of rows or the number of * columns is known at compile-time to be equal to 1. Indeed, in that case, * we are dealing with a column-vector (if there is only one column) or with * a row-vector (if there is only one row). */ - Flags = ei_traits::Flags, + Flags = internal::traits::Flags, /**< This stores expression \ref flags flags which may or may not be inherited by new expressions * constructed from this one. See the \ref flags "list of flags". */ @@ -163,13 +163,13 @@ template class DenseBase InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? SizeAtCompileTime : int(IsRowMajor) ? ColsAtCompileTime : RowsAtCompileTime, - CoeffReadCost = ei_traits::CoeffReadCost, + CoeffReadCost = internal::traits::CoeffReadCost, /**< This is a rough measure of how expensive it is to read one coefficient from * this expression. */ - InnerStrideAtCompileTime = ei_inner_stride_at_compile_time::ret, - OuterStrideAtCompileTime = ei_outer_stride_at_compile_time::ret + InnerStrideAtCompileTime = internal::inner_stride_at_compile_time::ret, + OuterStrideAtCompileTime = internal::outer_stride_at_compile_time::ret }; /** \returns the number of nonzero coefficients which is in practice the number @@ -209,7 +209,7 @@ template class DenseBase void resize(Index size) { EIGEN_ONLY_USED_FOR_DEBUG(size); - ei_assert(size == this->size() + eigen_assert(size == this->size() && "DenseBase::resize() does not actually allow to resize."); } /** Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are @@ -220,20 +220,20 @@ template class DenseBase { EIGEN_ONLY_USED_FOR_DEBUG(rows); EIGEN_ONLY_USED_FOR_DEBUG(cols); - ei_assert(rows == this->rows() && cols == this->cols() + eigen_assert(rows == this->rows() && cols == this->cols() && "DenseBase::resize() does not actually allow to resize."); } #ifndef EIGEN_PARSED_BY_DOXYGEN /** \internal Represents a matrix with all coefficients equal to one another*/ - typedef CwiseNullaryOp,Derived> ConstantReturnType; + typedef CwiseNullaryOp,Derived> ConstantReturnType; /** \internal Represents a vector with linearly spaced coefficients that allows sequential access only. */ - typedef CwiseNullaryOp,Derived> SequentialLinSpacedReturnType; + typedef CwiseNullaryOp,Derived> SequentialLinSpacedReturnType; /** \internal Represents a vector with linearly spaced coefficients that allows random access. */ - typedef CwiseNullaryOp,Derived> RandomAccessLinSpacedReturnType; + typedef CwiseNullaryOp,Derived> RandomAccessLinSpacedReturnType; /** \internal the return type of MatrixBase::eigenvalues() */ - typedef Matrix::Scalar>::Real, ei_traits::ColsAtCompileTime, 1> EigenvaluesReturnType; + typedef Matrix::Scalar>::Real, internal::traits::ColsAtCompileTime, 1> EigenvaluesReturnType; #endif // not EIGEN_PARSED_BY_DOXYGEN @@ -381,12 +381,12 @@ template class DenseBase * Notice that in the case of a plain matrix or vector (not an expression) this function just returns * a const reference, in order to avoid a useless copy. */ - EIGEN_STRONG_INLINE const typename ei_eval::type eval() const + EIGEN_STRONG_INLINE const typename internal::eval::type eval() const { // Even though MSVC does not honor strong inlining when the return type // is a dynamic matrix, we desperately need strong inlining for fixed // size types on MSVC. - return typename ei_eval::type(derived()); + return typename internal::eval::type(derived()); } template @@ -395,8 +395,8 @@ template class DenseBase inline const NestByValue nestByValue() const; inline const ForceAlignedAccess forceAlignedAccess() const; inline ForceAlignedAccess forceAlignedAccess(); - template inline const typename ei_meta_if,Derived&>::ret forceAlignedAccessIf() const; - template inline typename ei_meta_if,Derived&>::ret forceAlignedAccessIf(); + template inline const typename internal::meta_if,Derived&>::ret forceAlignedAccessIf() const; + template inline typename internal::meta_if,Derived&>::ret forceAlignedAccessIf(); Scalar sum() const; Scalar mean() const; @@ -404,17 +404,17 @@ template class DenseBase Scalar prod() const; - typename ei_traits::Scalar minCoeff() const; - typename ei_traits::Scalar maxCoeff() const; + typename internal::traits::Scalar minCoeff() const; + typename internal::traits::Scalar maxCoeff() const; - typename ei_traits::Scalar minCoeff(Index* row, Index* col) const; - typename ei_traits::Scalar maxCoeff(Index* row, Index* col) const; + typename internal::traits::Scalar minCoeff(Index* row, Index* col) const; + typename internal::traits::Scalar maxCoeff(Index* row, Index* col) const; - typename ei_traits::Scalar minCoeff(Index* index) const; - typename ei_traits::Scalar maxCoeff(Index* index) const; + typename internal::traits::Scalar minCoeff(Index* index) const; + typename internal::traits::Scalar maxCoeff(Index* index) const; template - typename ei_result_of::Scalar)>::type + typename internal::result_of::Scalar)>::type redux(const BinaryOp& func) const; template @@ -433,9 +433,9 @@ template class DenseBase const VectorwiseOp colwise() const; VectorwiseOp colwise(); - static const CwiseNullaryOp,Derived> Random(Index rows, Index cols); - static const CwiseNullaryOp,Derived> Random(Index size); - static const CwiseNullaryOp,Derived> Random(); + static const CwiseNullaryOp,Derived> Random(Index rows, Index cols); + static const CwiseNullaryOp,Derived> Random(Index size); + static const CwiseNullaryOp,Derived> Random(); template const Select @@ -482,7 +482,7 @@ template class DenseBase // disable the use of evalTo for dense objects with a nice compilation error template inline void evalTo(Dest& ) const { - EIGEN_STATIC_ASSERT((ei_is_same_type::ret),THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS); + EIGEN_STATIC_ASSERT((internal::is_same_type::ret),THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS); } protected: @@ -493,7 +493,7 @@ template class DenseBase * Only do it when debugging Eigen, as this borders on paranoiac and could slow compilation down */ #ifdef EIGEN_INTERNAL_DEBUGGING - EIGEN_STATIC_ASSERT(ei_are_flags_consistent::ret, + EIGEN_STATIC_ASSERT(internal::are_flags_consistent::ret, INVALID_MATRIXBASE_TEMPLATE_PARAMETERS) EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, int(IsRowMajor)) && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, int(!IsRowMajor))), diff --git a/Eigen/src/Core/DenseCoeffsBase.h b/Eigen/src/Core/DenseCoeffsBase.h index 918b246a8..d39aafc08 100644 --- a/Eigen/src/Core/DenseCoeffsBase.h +++ b/Eigen/src/Core/DenseCoeffsBase.h @@ -40,15 +40,15 @@ template class DenseCoeffsBase : public EigenBase { public: - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::Index Index; - typedef typename ei_traits::Scalar Scalar; - typedef typename ei_packet_traits::type PacketScalar; - typedef typename ei_meta_if::Flags&LvalueBit), + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Index Index; + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::packet_traits::type PacketScalar; + typedef typename internal::meta_if::Flags&LvalueBit), const Scalar&, - typename ei_meta_if::ret, Scalar, const Scalar>::ret + typename internal::meta_if::ret, Scalar, const Scalar>::ret >::ret CoeffReturnType; - typedef typename ei_makeconst_return_type::type>::type PacketReturnType; + typedef typename internal::makeconst_return_type::type>::type PacketReturnType; typedef EigenBase Base; using Base::rows; @@ -88,7 +88,7 @@ class DenseCoeffsBase : public EigenBase */ EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const { - ei_internal_assert(row >= 0 && row < rows() + eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); return derived().coeff(row, col); } @@ -105,7 +105,7 @@ class DenseCoeffsBase : public EigenBase */ EIGEN_STRONG_INLINE CoeffReturnType operator()(Index row, Index col) const { - ei_assert(row >= 0 && row < rows() + eigen_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); return derived().coeff(row, col); } @@ -128,7 +128,7 @@ class DenseCoeffsBase : public EigenBase EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { - ei_internal_assert(index >= 0 && index < size()); + eigen_internal_assert(index >= 0 && index < size()); return derived().coeff(index); } @@ -146,7 +146,7 @@ class DenseCoeffsBase : public EigenBase { EIGEN_STATIC_ASSERT(Derived::IsVectorAtCompileTime, THE_BRACKET_OPERATOR_IS_ONLY_FOR_VECTORS__USE_THE_PARENTHESIS_OPERATOR_INSTEAD) - ei_assert(index >= 0 && index < size()); + eigen_assert(index >= 0 && index < size()); return derived().coeff(index); } @@ -163,7 +163,7 @@ class DenseCoeffsBase : public EigenBase EIGEN_STRONG_INLINE CoeffReturnType operator()(Index index) const { - ei_assert(index >= 0 && index < size()); + eigen_assert(index >= 0 && index < size()); return derived().coeff(index); } @@ -199,7 +199,7 @@ class DenseCoeffsBase : public EigenBase template EIGEN_STRONG_INLINE PacketReturnType packet(Index row, Index col) const { - ei_internal_assert(row >= 0 && row < rows() + eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); return derived().template packet(row,col); } @@ -224,7 +224,7 @@ class DenseCoeffsBase : public EigenBase template EIGEN_STRONG_INLINE PacketReturnType packet(Index index) const { - ei_internal_assert(index >= 0 && index < size()); + eigen_internal_assert(index >= 0 && index < size()); return derived().template packet(index); } @@ -267,10 +267,10 @@ class DenseCoeffsBase : public DenseCoeffsBase Base; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::Index Index; - typedef typename ei_traits::Scalar Scalar; - typedef typename ei_packet_traits::type PacketScalar; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Index Index; + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::packet_traits::type PacketScalar; typedef typename NumTraits::Real RealScalar; using Base::coeff; @@ -303,7 +303,7 @@ class DenseCoeffsBase : public DenseCoeffsBase= 0 && row < rows() + eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); return derived().coeffRef(row, col); } @@ -323,7 +323,7 @@ class DenseCoeffsBase : public DenseCoeffsBase= 0 && row < rows() + eigen_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); return derived().coeffRef(row, col); } @@ -347,7 +347,7 @@ class DenseCoeffsBase : public DenseCoeffsBase= 0 && index < size()); + eigen_internal_assert(index >= 0 && index < size()); return derived().coeffRef(index); } @@ -363,7 +363,7 @@ class DenseCoeffsBase : public DenseCoeffsBase= 0 && index < size()); + eigen_assert(index >= 0 && index < size()); return derived().coeffRef(index); } @@ -379,7 +379,7 @@ class DenseCoeffsBase : public DenseCoeffsBase= 0 && index < size()); + eigen_assert(index >= 0 && index < size()); return derived().coeffRef(index); } @@ -414,9 +414,9 @@ class DenseCoeffsBase : public DenseCoeffsBase EIGEN_STRONG_INLINE void writePacket - (Index row, Index col, const typename ei_packet_traits::type& x) + (Index row, Index col, const typename internal::packet_traits::type& x) { - ei_internal_assert(row >= 0 && row < rows() + eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); derived().template writePacket(row,col,x); } @@ -424,7 +424,7 @@ class DenseCoeffsBase : public DenseCoeffsBase EIGEN_STRONG_INLINE void writePacketByOuterInner - (Index outer, Index inner, const typename ei_packet_traits::type& x) + (Index outer, Index inner, const typename internal::packet_traits::type& x) { writePacket(rowIndexByOuterInner(outer, inner), colIndexByOuterInner(outer, inner), @@ -442,9 +442,9 @@ class DenseCoeffsBase : public DenseCoeffsBase EIGEN_STRONG_INLINE void writePacket - (Index index, const typename ei_packet_traits::type& x) + (Index index, const typename internal::packet_traits::type& x) { - ei_internal_assert(index >= 0 && index < size()); + eigen_internal_assert(index >= 0 && index < size()); derived().template writePacket(index,x); } @@ -461,7 +461,7 @@ class DenseCoeffsBase : public DenseCoeffsBase EIGEN_STRONG_INLINE void copyCoeff(Index row, Index col, const DenseBase& other) { - ei_internal_assert(row >= 0 && row < rows() + eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); derived().coeffRef(row, col) = other.derived().coeff(row, col); } @@ -477,7 +477,7 @@ class DenseCoeffsBase : public DenseCoeffsBase EIGEN_STRONG_INLINE void copyCoeff(Index index, const DenseBase& other) { - ei_internal_assert(index >= 0 && index < size()); + eigen_internal_assert(index >= 0 && index < size()); derived().coeffRef(index) = other.derived().coeff(index); } @@ -502,7 +502,7 @@ class DenseCoeffsBase : public DenseCoeffsBase EIGEN_STRONG_INLINE void copyPacket(Index row, Index col, const DenseBase& other) { - ei_internal_assert(row >= 0 && row < rows() + eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); derived().template writePacket(row, col, other.derived().template packet(row, col)); @@ -519,7 +519,7 @@ class DenseCoeffsBase : public DenseCoeffsBase EIGEN_STRONG_INLINE void copyPacket(Index index, const DenseBase& other) { - ei_internal_assert(index >= 0 && index < size()); + eigen_internal_assert(index >= 0 && index < size()); derived().template writePacket(index, other.derived().template packet(index)); } @@ -553,8 +553,8 @@ class DenseCoeffsBase : public DenseCoeffsBase Base; - typedef typename ei_traits::Index Index; - typedef typename ei_traits::Scalar Scalar; + typedef typename internal::traits::Index Index; + typedef typename internal::traits::Scalar Scalar; typedef typename NumTraits::Real RealScalar; using Base::rows; @@ -606,57 +606,61 @@ class DenseCoeffsBase : public DenseCoeffsBase -struct ei_first_aligned_impl +struct first_aligned_impl { inline static typename Derived::Index run(const Derived&) { return 0; } }; template -struct ei_first_aligned_impl +struct first_aligned_impl { inline static typename Derived::Index run(const Derived& m) { - return ei_first_aligned(&m.const_cast_derived().coeffRef(0,0), m.size()); + return first_aligned(&m.const_cast_derived().coeffRef(0,0), m.size()); } }; /** \internal \returns the index of the first element of the array that is well aligned for vectorization. * - * There is also the variant ei_first_aligned(const Scalar*, Integer) defined in Memory.h. See it for more + * There is also the variant first_aligned(const Scalar*, Integer) defined in Memory.h. See it for more * documentation. */ template -inline static typename Derived::Index ei_first_aligned(const Derived& m) +inline static typename Derived::Index first_aligned(const Derived& m) { - return ei_first_aligned_impl + return first_aligned_impl ::run(m); } -template::ret> -struct ei_inner_stride_at_compile_time +template::ret> +struct inner_stride_at_compile_time { - enum { ret = ei_traits::InnerStrideAtCompileTime }; + enum { ret = traits::InnerStrideAtCompileTime }; }; template -struct ei_inner_stride_at_compile_time +struct inner_stride_at_compile_time { enum { ret = 0 }; }; -template::ret> -struct ei_outer_stride_at_compile_time +template::ret> +struct outer_stride_at_compile_time { - enum { ret = ei_traits::OuterStrideAtCompileTime }; + enum { ret = traits::OuterStrideAtCompileTime }; }; template -struct ei_outer_stride_at_compile_time +struct outer_stride_at_compile_time { enum { ret = 0 }; }; +} // end namespace internal + #endif // EIGEN_DENSECOEFFSBASE_H diff --git a/Eigen/src/Core/DenseStorage.h b/Eigen/src/Core/DenseStorage.h index da6c3754f..446335568 100644 --- a/Eigen/src/Core/DenseStorage.h +++ b/Eigen/src/Core/DenseStorage.h @@ -33,7 +33,9 @@ #define EIGEN_INT_DEBUG_MATRIX_CTOR #endif -struct ei_constructor_without_unaligned_array_assert {}; +namespace internal { + +struct constructor_without_unaligned_array_assert {}; /** \internal * Static array. If the MatrixOptions require auto-alignment, the array will be automatically aligned: @@ -43,39 +45,41 @@ template -struct ei_matrix_array +struct matrix_array { T array[Size]; - ei_matrix_array() {} - ei_matrix_array(ei_constructor_without_unaligned_array_assert) {} + matrix_array() {} + matrix_array(constructor_without_unaligned_array_assert) {} }; #ifdef EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) #else #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) \ - ei_assert((reinterpret_cast(array) & sizemask) == 0 \ + eigen_assert((reinterpret_cast(array) & sizemask) == 0 \ && "this assertion is explained here: " \ "http://eigen.tuxfamily.org/dox/UnalignedArrayAssert.html" \ " **** READ THIS WEB PAGE !!! ****"); #endif template -struct ei_matrix_array +struct matrix_array { EIGEN_ALIGN16 T array[Size]; - ei_matrix_array() { EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(0xf) } - ei_matrix_array(ei_constructor_without_unaligned_array_assert) {} + matrix_array() { EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(0xf) } + matrix_array(constructor_without_unaligned_array_assert) {} }; template -struct ei_matrix_array +struct matrix_array { EIGEN_ALIGN16 T array[1]; - ei_matrix_array() {} - ei_matrix_array(ei_constructor_without_unaligned_array_assert) {} + matrix_array() {} + matrix_array(constructor_without_unaligned_array_assert) {} }; +} // end namespace internal + /** \internal * * \class DenseStorage @@ -93,11 +97,11 @@ template class DenseSt // purely fixed-size matrix template class DenseStorage { - ei_matrix_array m_data; + internal::matrix_array m_data; public: inline explicit DenseStorage() {} - inline DenseStorage(ei_constructor_without_unaligned_array_assert) - : m_data(ei_constructor_without_unaligned_array_assert()) {} + inline DenseStorage(internal::constructor_without_unaligned_array_assert) + : m_data(internal::constructor_without_unaligned_array_assert()) {} inline DenseStorage(DenseIndex,DenseIndex,DenseIndex) {} inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); } inline static DenseIndex rows(void) {return _Rows;} @@ -113,7 +117,7 @@ template class DenseStorage class DenseStorage class DenseStorage { - ei_matrix_array m_data; + internal::matrix_array m_data; DenseIndex m_rows; DenseIndex m_cols; public: inline explicit DenseStorage() : m_rows(0), m_cols(0) {} - inline DenseStorage(ei_constructor_without_unaligned_array_assert) - : m_data(ei_constructor_without_unaligned_array_assert()), m_rows(0), m_cols(0) {} + inline DenseStorage(internal::constructor_without_unaligned_array_assert) + : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0), m_cols(0) {} inline DenseStorage(DenseIndex, DenseIndex rows, DenseIndex cols) : m_rows(rows), m_cols(cols) {} inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); } @@ -148,12 +152,12 @@ template class DenseStorage class DenseStorage { - ei_matrix_array m_data; + internal::matrix_array m_data; DenseIndex m_rows; public: inline explicit DenseStorage() : m_rows(0) {} - inline DenseStorage(ei_constructor_without_unaligned_array_assert) - : m_data(ei_constructor_without_unaligned_array_assert()), m_rows(0) {} + inline DenseStorage(internal::constructor_without_unaligned_array_assert) + : m_data(internal::constructor_without_unaligned_array_assert()), m_rows(0) {} inline DenseStorage(DenseIndex, DenseIndex rows, DenseIndex) : m_rows(rows) {} inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); } inline DenseIndex rows(void) const {return m_rows;} @@ -167,12 +171,12 @@ template class DenseStorage class DenseStorage { - ei_matrix_array m_data; + internal::matrix_array m_data; DenseIndex m_cols; public: inline explicit DenseStorage() : m_cols(0) {} - inline DenseStorage(ei_constructor_without_unaligned_array_assert) - : m_data(ei_constructor_without_unaligned_array_assert()), m_cols(0) {} + inline DenseStorage(internal::constructor_without_unaligned_array_assert) + : m_data(internal::constructor_without_unaligned_array_assert()), m_cols(0) {} inline DenseStorage(DenseIndex, DenseIndex, DenseIndex cols) : m_cols(cols) {} inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); } inline DenseIndex rows(void) const {return _Rows;} @@ -191,19 +195,19 @@ template class DenseStorage(size)), m_rows(rows), m_cols(cols) + : m_data(internal::conditional_aligned_new(size)), m_rows(rows), m_cols(cols) { EIGEN_INT_DEBUG_MATRIX_CTOR } - inline ~DenseStorage() { ei_conditional_aligned_delete(m_data, m_rows*m_cols); } + inline ~DenseStorage() { internal::conditional_aligned_delete(m_data, m_rows*m_cols); } inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); } inline DenseIndex rows(void) const {return m_rows;} inline DenseIndex cols(void) const {return m_cols;} inline void conservativeResize(DenseIndex size, DenseIndex rows, DenseIndex cols) { - m_data = ei_conditional_aligned_realloc_new(m_data, size, m_rows*m_cols); + m_data = internal::conditional_aligned_realloc_new(m_data, size, m_rows*m_cols); m_rows = rows; m_cols = cols; } @@ -211,9 +215,9 @@ template class DenseStorage(m_data, m_rows*m_cols); + internal::conditional_aligned_delete(m_data, m_rows*m_cols); if (size) - m_data = ei_conditional_aligned_new(size); + m_data = internal::conditional_aligned_new(size); else m_data = 0; EIGEN_INT_DEBUG_MATRIX_CTOR @@ -232,25 +236,25 @@ template class DenseStorage(size)), m_cols(cols) + inline DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_cols(0) {} + inline DenseStorage(DenseIndex size, DenseIndex, DenseIndex cols) : m_data(internal::conditional_aligned_new(size)), m_cols(cols) { EIGEN_INT_DEBUG_MATRIX_CTOR } - inline ~DenseStorage() { ei_conditional_aligned_delete(m_data, _Rows*m_cols); } + inline ~DenseStorage() { internal::conditional_aligned_delete(m_data, _Rows*m_cols); } inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); } inline static DenseIndex rows(void) {return _Rows;} inline DenseIndex cols(void) const {return m_cols;} inline void conservativeResize(DenseIndex size, DenseIndex, DenseIndex cols) { - m_data = ei_conditional_aligned_realloc_new(m_data, size, _Rows*m_cols); + m_data = internal::conditional_aligned_realloc_new(m_data, size, _Rows*m_cols); m_cols = cols; } EIGEN_STRONG_INLINE void resize(DenseIndex size, DenseIndex, DenseIndex cols) { if(size != _Rows*m_cols) { - ei_conditional_aligned_delete(m_data, _Rows*m_cols); + internal::conditional_aligned_delete(m_data, _Rows*m_cols); if (size) - m_data = ei_conditional_aligned_new(size); + m_data = internal::conditional_aligned_new(size); else m_data = 0; EIGEN_INT_DEBUG_MATRIX_CTOR @@ -268,25 +272,25 @@ template class DenseStorage(size)), m_rows(rows) + inline DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_rows(0) {} + inline DenseStorage(DenseIndex size, DenseIndex rows, DenseIndex) : m_data(internal::conditional_aligned_new(size)), m_rows(rows) { EIGEN_INT_DEBUG_MATRIX_CTOR } - inline ~DenseStorage() { ei_conditional_aligned_delete(m_data, _Cols*m_rows); } + inline ~DenseStorage() { internal::conditional_aligned_delete(m_data, _Cols*m_rows); } inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); } inline DenseIndex rows(void) const {return m_rows;} inline static DenseIndex cols(void) {return _Cols;} inline void conservativeResize(DenseIndex size, DenseIndex rows, DenseIndex) { - m_data = ei_conditional_aligned_realloc_new(m_data, size, m_rows*_Cols); + m_data = internal::conditional_aligned_realloc_new(m_data, size, m_rows*_Cols); m_rows = rows; } EIGEN_STRONG_INLINE void resize(DenseIndex size, DenseIndex rows, DenseIndex) { if(size != m_rows*_Cols) { - ei_conditional_aligned_delete(m_data, _Cols*m_rows); + internal::conditional_aligned_delete(m_data, _Cols*m_rows); if (size) - m_data = ei_conditional_aligned_new(size); + m_data = internal::conditional_aligned_new(size); else m_data = 0; EIGEN_INT_DEBUG_MATRIX_CTOR diff --git a/Eigen/src/Core/Diagonal.h b/Eigen/src/Core/Diagonal.h index 0b7d14179..1a86b4e39 100644 --- a/Eigen/src/Core/Diagonal.h +++ b/Eigen/src/Core/Diagonal.h @@ -43,12 +43,14 @@ * * \sa MatrixBase::diagonal(), MatrixBase::diagonal(Index) */ + +namespace internal { template -struct ei_traits > - : ei_traits +struct traits > + : traits { - typedef typename ei_nested::type MatrixTypeNested; - typedef typename ei_unref::type _MatrixTypeNested; + typedef typename nested::type MatrixTypeNested; + typedef typename unref::type _MatrixTypeNested; typedef typename MatrixType::StorageKind StorageKind; enum { AbsDiagIndex = DiagIndex<0 ? -DiagIndex : DiagIndex, // only used if DiagIndex != Dynamic @@ -64,18 +66,19 @@ struct ei_traits > MaxColsAtCompileTime = 1, Flags = (unsigned int)_MatrixTypeNested::Flags & (HereditaryBits | LinearAccessBit | LvalueBit | DirectAccessBit) & ~RowMajorBit, CoeffReadCost = _MatrixTypeNested::CoeffReadCost, - MatrixTypeOuterStride = ei_outer_stride_at_compile_time::ret, + MatrixTypeOuterStride = outer_stride_at_compile_time::ret, InnerStrideAtCompileTime = MatrixTypeOuterStride == Dynamic ? Dynamic : MatrixTypeOuterStride+1, OuterStrideAtCompileTime = 0 }; }; +} template class Diagonal - : public ei_dense_xpr_base< Diagonal >::type + : public internal::dense_xpr_base< Diagonal >::type { public: - typedef typename ei_dense_xpr_base::type Base; + typedef typename internal::dense_xpr_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(Diagonal) inline Diagonal(const MatrixType& matrix, Index index = DiagIndex) : m_matrix(matrix), m_index(index) {} @@ -119,7 +122,7 @@ template class Diagonal protected: const typename MatrixType::Nested m_matrix; - const ei_variable_if_dynamic m_index; + const internal::variable_if_dynamic m_index; private: // some compilers may fail to optimize std::max etc in case of compile-time constants... diff --git a/Eigen/src/Core/DiagonalMatrix.h b/Eigen/src/Core/DiagonalMatrix.h index 630c172ed..af16cf563 100644 --- a/Eigen/src/Core/DiagonalMatrix.h +++ b/Eigen/src/Core/DiagonalMatrix.h @@ -31,10 +31,10 @@ template class DiagonalBase : public EigenBase { public: - typedef typename ei_traits::DiagonalVectorType DiagonalVectorType; + typedef typename internal::traits::DiagonalVectorType DiagonalVectorType; typedef typename DiagonalVectorType::Scalar Scalar; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::Index Index; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Index Index; enum { RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime, @@ -70,7 +70,7 @@ class DiagonalBase : public EigenBase const DiagonalProduct operator*(const MatrixBase &matrix) const; - inline const DiagonalWrapper, DiagonalVectorType> > + inline const DiagonalWrapper, DiagonalVectorType> > inverse() const { return diagonal().cwiseInverse(); @@ -98,9 +98,11 @@ void DiagonalBase::evalTo(MatrixBase &other) const * * \sa class DiagonalWrapper */ + +namespace internal { template -struct ei_traits > - : ei_traits > +struct traits > + : traits > { typedef Matrix<_Scalar,SizeAtCompileTime,1,0,MaxSizeAtCompileTime,1> DiagonalVectorType; typedef Dense StorageKind; @@ -109,18 +111,18 @@ struct ei_traits Flags = LvalueBit }; }; - +} template class DiagonalMatrix : public DiagonalBase > { public: #ifndef EIGEN_PARSED_BY_DOXYGEN - typedef typename ei_traits::DiagonalVectorType DiagonalVectorType; + typedef typename internal::traits::DiagonalVectorType DiagonalVectorType; typedef const DiagonalMatrix& Nested; typedef _Scalar Scalar; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::Index Index; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Index Index; #endif protected: @@ -204,8 +206,10 @@ class DiagonalMatrix * * \sa class DiagonalMatrix, class DiagonalBase, MatrixBase::asDiagonal() */ + +namespace internal { template -struct ei_traits > +struct traits > { typedef _DiagonalVectorType DiagonalVectorType; typedef typename DiagonalVectorType::Scalar Scalar; @@ -216,13 +220,14 @@ struct ei_traits > ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime, MaxRowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime, MaxColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime, - Flags = ei_traits::Flags & LvalueBit + Flags = traits::Flags & LvalueBit }; }; +} template class DiagonalWrapper - : public DiagonalBase >, ei_no_assignment_operator + : public DiagonalBase >, internal::no_assignment_operator { public: #ifndef EIGEN_PARSED_BY_DOXYGEN @@ -265,21 +270,20 @@ MatrixBase::asDiagonal() const * \sa asDiagonal() */ template -bool MatrixBase::isDiagonal -(RealScalar prec) const +bool MatrixBase::isDiagonal(RealScalar prec) const { if(cols() != rows()) return false; RealScalar maxAbsOnDiagonal = static_cast(-1); for(Index j = 0; j < cols(); ++j) { - RealScalar absOnDiagonal = ei_abs(coeff(j,j)); + RealScalar absOnDiagonal = internal::abs(coeff(j,j)); if(absOnDiagonal > maxAbsOnDiagonal) maxAbsOnDiagonal = absOnDiagonal; } for(Index j = 0; j < cols(); ++j) for(Index i = 0; i < j; ++i) { - if(!ei_isMuchSmallerThan(coeff(i, j), maxAbsOnDiagonal, prec)) return false; - if(!ei_isMuchSmallerThan(coeff(j, i), maxAbsOnDiagonal, prec)) return false; + if(!internal::isMuchSmallerThan(coeff(i, j), maxAbsOnDiagonal, prec)) return false; + if(!internal::isMuchSmallerThan(coeff(j, i), maxAbsOnDiagonal, prec)) return false; } return true; } diff --git a/Eigen/src/Core/DiagonalProduct.h b/Eigen/src/Core/DiagonalProduct.h index 14c49e828..6c9b62920 100644 --- a/Eigen/src/Core/DiagonalProduct.h +++ b/Eigen/src/Core/DiagonalProduct.h @@ -26,11 +26,12 @@ #ifndef EIGEN_DIAGONALPRODUCT_H #define EIGEN_DIAGONALPRODUCT_H +namespace internal { template -struct ei_traits > - : ei_traits +struct traits > + : traits { - typedef typename ei_scalar_product_traits::ReturnType Scalar; + typedef typename scalar_product_traits::ReturnType Scalar; enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime, @@ -40,7 +41,7 @@ struct ei_traits > _StorageOrder = MatrixType::Flags & RowMajorBit ? RowMajor : ColMajor, _PacketOnDiag = !((int(_StorageOrder) == RowMajor && int(ProductOrder) == OnTheLeft) ||(int(_StorageOrder) == ColMajor && int(ProductOrder) == OnTheRight)), - _SameTypes = ei_is_same_type::ret, + _SameTypes = is_same_type::ret, // FIXME currently we need same types, but in the future the next rule should be the one //_Vectorizable = bool(int(MatrixType::Flags)&PacketAccessBit) && ((!_PacketOnDiag) || (_SameTypes && bool(int(DiagonalType::Flags)&PacketAccessBit))), _Vectorizable = bool(int(MatrixType::Flags)&PacketAccessBit) && _SameTypes && ((!_PacketOnDiag) || (bool(int(DiagonalType::Flags)&PacketAccessBit))), @@ -49,9 +50,10 @@ struct ei_traits > CoeffReadCost = NumTraits::MulCost + MatrixType::CoeffReadCost + DiagonalType::DiagonalVectorType::CoeffReadCost }; }; +} template -class DiagonalProduct : ei_no_assignment_operator, +class DiagonalProduct : internal::no_assignment_operator, public MatrixBase > { public: @@ -62,7 +64,7 @@ class DiagonalProduct : ei_no_assignment_operator, inline DiagonalProduct(const MatrixType& matrix, const DiagonalType& diagonal) : m_matrix(matrix), m_diagonal(diagonal) { - ei_assert(diagonal.diagonal().size() == (ProductOrder == OnTheLeft ? matrix.rows() : matrix.cols())); + eigen_assert(diagonal.diagonal().size() == (ProductOrder == OnTheLeft ? matrix.rows() : matrix.cols())); } inline Index rows() const { return m_matrix.rows(); } @@ -81,27 +83,27 @@ class DiagonalProduct : ei_no_assignment_operator, }; const Index indexInDiagonalVector = ProductOrder == OnTheLeft ? row : col; - return packet_impl(row,col,indexInDiagonalVector,typename ei_meta_if< + return packet_impl(row,col,indexInDiagonalVector,typename internal::meta_if< ((int(StorageOrder) == RowMajor && int(ProductOrder) == OnTheLeft) - ||(int(StorageOrder) == ColMajor && int(ProductOrder) == OnTheRight)), ei_meta_true, ei_meta_false>::ret()); + ||(int(StorageOrder) == ColMajor && int(ProductOrder) == OnTheRight)), internal::meta_true, internal::meta_false>::ret()); } protected: template - EIGEN_STRONG_INLINE PacketScalar packet_impl(Index row, Index col, Index id, ei_meta_true) const + EIGEN_STRONG_INLINE PacketScalar packet_impl(Index row, Index col, Index id, internal::meta_true) const { - return ei_pmul(m_matrix.template packet(row, col), - ei_pset1(m_diagonal.diagonal().coeff(id))); + return internal::pmul(m_matrix.template packet(row, col), + internal::pset1(m_diagonal.diagonal().coeff(id))); } template - EIGEN_STRONG_INLINE PacketScalar packet_impl(Index row, Index col, Index id, ei_meta_false) const + EIGEN_STRONG_INLINE PacketScalar packet_impl(Index row, Index col, Index id, internal::meta_false) const { enum { InnerSize = (MatrixType::Flags & RowMajorBit) ? MatrixType::ColsAtCompileTime : MatrixType::RowsAtCompileTime, DiagonalVectorPacketLoadMode = (LoadMode == Aligned && ((InnerSize%16) == 0)) ? Aligned : Unaligned }; - return ei_pmul(m_matrix.template packet(row, col), + return internal::pmul(m_matrix.template packet(row, col), m_diagonal.diagonal().template packet(id)); } diff --git a/Eigen/src/Core/Dot.h b/Eigen/src/Core/Dot.h index 7fb7f0de6..9e02f1bf3 100644 --- a/Eigen/src/Core/Dot.h +++ b/Eigen/src/Core/Dot.h @@ -25,6 +25,8 @@ #ifndef EIGEN_DOT_H #define EIGEN_DOT_H +namespace internal { + // helper function for dot(). The problem is that if we put that in the body of dot(), then upon calling dot // with mismatched types, the compiler emits errors about failing to instantiate cwiseProduct BEFORE // looking at the static assertions. Thus this is a trick to get better compile errors. @@ -37,23 +39,25 @@ template -struct ei_dot_nocheck +struct dot_nocheck { - static inline typename ei_traits::Scalar run(const MatrixBase& a, const MatrixBase& b) + static inline typename traits::Scalar run(const MatrixBase& a, const MatrixBase& b) { - return a.template binaryExpr::Scalar> >(b).sum(); + return a.template binaryExpr::Scalar> >(b).sum(); } }; template -struct ei_dot_nocheck +struct dot_nocheck { - static inline typename ei_traits::Scalar run(const MatrixBase& a, const MatrixBase& b) + static inline typename traits::Scalar run(const MatrixBase& a, const MatrixBase& b) { - return a.transpose().template binaryExpr::Scalar> >(b).sum(); + return a.transpose().template binaryExpr::Scalar> >(b).sum(); } }; +} // end namespace internal + /** \returns the dot product of *this with other. * * \only_for_vectors @@ -66,18 +70,18 @@ struct ei_dot_nocheck */ template template -typename ei_traits::Scalar +typename internal::traits::Scalar MatrixBase::dot(const MatrixBase& other) const { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived) EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived) - EIGEN_STATIC_ASSERT((ei_is_same_type::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type::ret), YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) - ei_assert(size() == other.size()); + eigen_assert(size() == other.size()); - return ei_dot_nocheck::run(*this, other); + return internal::dot_nocheck::run(*this, other); } //---------- implementation of L2 norm and related functions ---------- @@ -87,9 +91,9 @@ MatrixBase::dot(const MatrixBase& other) const * \sa dot(), norm() */ template -EIGEN_STRONG_INLINE typename NumTraits::Scalar>::Real MatrixBase::squaredNorm() const +EIGEN_STRONG_INLINE typename NumTraits::Scalar>::Real MatrixBase::squaredNorm() const { - return ei_real((*this).cwiseAbs2().sum()); + return internal::real((*this).cwiseAbs2().sum()); } /** \returns the \em l2 norm of *this, i.e., for vectors, the square root of the dot product of *this with itself. @@ -97,9 +101,9 @@ EIGEN_STRONG_INLINE typename NumTraits::Scalar>::Rea * \sa dot(), squaredNorm() */ template -inline typename NumTraits::Scalar>::Real MatrixBase::norm() const +inline typename NumTraits::Scalar>::Real MatrixBase::norm() const { - return ei_sqrt(squaredNorm()); + return internal::sqrt(squaredNorm()); } /** \returns an expression of the quotient of *this by its own norm. @@ -112,8 +116,8 @@ template inline const typename MatrixBase::PlainObject MatrixBase::normalized() const { - typedef typename ei_nested::type Nested; - typedef typename ei_unref::type _Nested; + typedef typename internal::nested::type Nested; + typedef typename internal::unref::type _Nested; _Nested n(derived()); return n / n.norm(); } @@ -132,43 +136,47 @@ inline void MatrixBase::normalize() //---------- implementation of other norms ---------- +namespace internal { + template -struct ei_lpNorm_selector +struct lpNorm_selector { - typedef typename NumTraits::Scalar>::Real RealScalar; + typedef typename NumTraits::Scalar>::Real RealScalar; inline static RealScalar run(const MatrixBase& m) { - return ei_pow(m.cwiseAbs().array().pow(p).sum(), RealScalar(1)/p); + return pow(m.cwiseAbs().array().pow(p).sum(), RealScalar(1)/p); } }; template -struct ei_lpNorm_selector +struct lpNorm_selector { - inline static typename NumTraits::Scalar>::Real run(const MatrixBase& m) + inline static typename NumTraits::Scalar>::Real run(const MatrixBase& m) { return m.cwiseAbs().sum(); } }; template -struct ei_lpNorm_selector +struct lpNorm_selector { - inline static typename NumTraits::Scalar>::Real run(const MatrixBase& m) + inline static typename NumTraits::Scalar>::Real run(const MatrixBase& m) { return m.norm(); } }; template -struct ei_lpNorm_selector +struct lpNorm_selector { - inline static typename NumTraits::Scalar>::Real run(const MatrixBase& m) + inline static typename NumTraits::Scalar>::Real run(const MatrixBase& m) { return m.cwiseAbs().maxCoeff(); } }; +} // end namespace internal + /** \returns the \f$ \ell^p \f$ norm of *this, that is, returns the p-th root of the sum of the p-th powers of the absolute values * of the coefficients of *this. If \a p is the special value \a Eigen::Infinity, this function returns the \f$ \ell^\infty \f$ * norm, that is the maximum of the absolute values of the coefficients of *this. @@ -177,10 +185,10 @@ struct ei_lpNorm_selector */ template template -inline typename NumTraits::Scalar>::Real +inline typename NumTraits::Scalar>::Real MatrixBase::lpNorm() const { - return ei_lpNorm_selector::run(*this); + return internal::lpNorm_selector::run(*this); } //---------- implementation of isOrthogonal / isUnitary ---------- @@ -196,9 +204,9 @@ template bool MatrixBase::isOrthogonal (const MatrixBase& other, RealScalar prec) const { - typename ei_nested::type nested(derived()); - typename ei_nested::type otherNested(other.derived()); - return ei_abs2(nested.dot(otherNested)) <= prec * prec * nested.squaredNorm() * otherNested.squaredNorm(); + typename internal::nested::type nested(derived()); + typename internal::nested::type otherNested(other.derived()); + return internal::abs2(nested.dot(otherNested)) <= prec * prec * nested.squaredNorm() * otherNested.squaredNorm(); } /** \returns true if *this is approximately an unitary matrix, @@ -218,10 +226,10 @@ bool MatrixBase::isUnitary(RealScalar prec) const typename Derived::Nested nested(derived()); for(Index i = 0; i < cols(); ++i) { - if(!ei_isApprox(nested.col(i).squaredNorm(), static_cast(1), prec)) + if(!internal::isApprox(nested.col(i).squaredNorm(), static_cast(1), prec)) return false; for(Index j = 0; j < i; ++j) - if(!ei_isMuchSmallerThan(nested.col(i).dot(nested.col(j)), static_cast(1), prec)) + if(!internal::isMuchSmallerThan(nested.col(i).dot(nested.col(j)), static_cast(1), prec)) return false; } return true; diff --git a/Eigen/src/Core/EigenBase.h b/Eigen/src/Core/EigenBase.h index d07fea9a2..69e964350 100644 --- a/Eigen/src/Core/EigenBase.h +++ b/Eigen/src/Core/EigenBase.h @@ -39,10 +39,10 @@ */ template struct EigenBase { -// typedef typename ei_plain_matrix_type::type PlainObject; +// typedef typename internal::plain_matrix_type::type PlainObject; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::Index Index; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Index Index; /** \returns a reference to the derived object */ Derived& derived() { return *static_cast(this); } diff --git a/Eigen/src/Core/Flagged.h b/Eigen/src/Core/Flagged.h index 9211c50e8..8d2207a7f 100644 --- a/Eigen/src/Core/Flagged.h +++ b/Eigen/src/Core/Flagged.h @@ -40,11 +40,14 @@ * * \sa MatrixBase::flagged() */ + +namespace internal { template -struct ei_traits > : ei_traits +struct traits > : traits { enum { Flags = (ExpressionType::Flags | Added) & ~Removed }; }; +} template class Flagged : public MatrixBase > @@ -53,7 +56,7 @@ template clas typedef MatrixBase Base; EIGEN_DENSE_PUBLIC_INTERFACE(Flagged) - typedef typename ei_meta_if::ret, + typedef typename internal::meta_if::ret, ExpressionType, const ExpressionType&>::ret ExpressionTypeNested; typedef typename ExpressionType::InnerIterator InnerIterator; diff --git a/Eigen/src/Core/ForceAlignedAccess.h b/Eigen/src/Core/ForceAlignedAccess.h index 06d78fbe2..727b87e64 100644 --- a/Eigen/src/Core/ForceAlignedAccess.h +++ b/Eigen/src/Core/ForceAlignedAccess.h @@ -37,16 +37,19 @@ * * \sa MatrixBase::forceAlignedAccess() */ + +namespace internal { template -struct ei_traits > : public ei_traits +struct traits > : public traits {}; +} template class ForceAlignedAccess - : public ei_dense_xpr_base< ForceAlignedAccess >::type + : public internal::dense_xpr_base< ForceAlignedAccess >::type { public: - typedef typename ei_dense_xpr_base::type Base; + typedef typename internal::dense_xpr_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(ForceAlignedAccess) inline ForceAlignedAccess(const ExpressionType& matrix) : m_expression(matrix) {} @@ -134,7 +137,7 @@ MatrixBase::forceAlignedAccess() */ template template -inline typename ei_makeconst,Derived&>::ret>::type +inline typename internal::makeconst,Derived&>::ret>::type MatrixBase::forceAlignedAccessIf() const { return derived(); @@ -145,7 +148,7 @@ MatrixBase::forceAlignedAccessIf() const */ template template -inline typename ei_meta_if,Derived&>::ret +inline typename internal::meta_if,Derived&>::ret MatrixBase::forceAlignedAccessIf() { return derived(); diff --git a/Eigen/src/Core/Functors.h b/Eigen/src/Core/Functors.h index 052bcc35c..6716ccae8 100644 --- a/Eigen/src/Core/Functors.h +++ b/Eigen/src/Core/Functors.h @@ -25,6 +25,8 @@ #ifndef EIGEN_FUNCTORS_H #define EIGEN_FUNCTORS_H +namespace internal { + // associative functors: /** \internal @@ -32,21 +34,21 @@ * * \sa class CwiseBinaryOp, MatrixBase::operator+, class VectorwiseOp, MatrixBase::sum() */ -template struct ei_scalar_sum_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_sum_op) +template struct scalar_sum_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_sum_op) EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a + b; } template EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const - { return ei_padd(a,b); } + { return internal::padd(a,b); } template EIGEN_STRONG_INLINE const Scalar predux(const Packet& a) const - { return ei_predux(a); } + { return internal::predux(a); } }; template -struct ei_functor_traits > { +struct functor_traits > { enum { Cost = NumTraits::AddCost, - PacketAccess = ei_packet_traits::HasAdd + PacketAccess = packet_traits::HasAdd }; }; @@ -55,47 +57,47 @@ struct ei_functor_traits > { * * \sa class CwiseBinaryOp, Cwise::operator*(), class VectorwiseOp, MatrixBase::redux() */ -template struct ei_scalar_product_op { +template struct scalar_product_op { enum { - Vectorizable = ei_is_same_type::ret && ei_packet_traits::HasMul && ei_packet_traits::HasMul + Vectorizable = is_same_type::ret && packet_traits::HasMul && packet_traits::HasMul }; - typedef typename ei_scalar_product_traits::ReturnType result_type; - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_product_op) + typedef typename scalar_product_traits::ReturnType result_type; + EIGEN_EMPTY_STRUCT_CTOR(scalar_product_op) EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a * b; } template EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const - { return ei_pmul(a,b); } + { return internal::pmul(a,b); } template EIGEN_STRONG_INLINE const result_type predux(const Packet& a) const - { return ei_predux_mul(a); } + { return internal::predux_mul(a); } }; template -struct ei_functor_traits > { +struct functor_traits > { enum { Cost = (NumTraits::MulCost + NumTraits::MulCost)/2, // rough estimate! - PacketAccess = ei_scalar_product_op::Vectorizable + PacketAccess = scalar_product_op::Vectorizable }; }; /** \internal * \brief Template functor to compute the conjugate product of two scalars * - * This is a short cut for ei_conj(x) * y which is needed for optimization purpose + * This is a short cut for conj(x) * y which is needed for optimization purpose */ -template struct ei_scalar_conj_product_op { +template struct scalar_conj_product_op { enum { Conj = NumTraits::IsComplex }; - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_conj_product_op) + EIGEN_EMPTY_STRUCT_CTOR(scalar_conj_product_op) EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const - { return ei_conj_helper().pmul(a,b); } + { return conj_helper().pmul(a,b); } template EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const - { return ei_conj_helper().pmul(a,b); } + { return conj_helper().pmul(a,b); } }; template -struct ei_functor_traits > { +struct functor_traits > { enum { Cost = NumTraits::MulCost, - PacketAccess = ei_packet_traits::HasMul + PacketAccess = packet_traits::HasMul }; }; @@ -104,21 +106,21 @@ struct ei_functor_traits > { * * \sa class CwiseBinaryOp, MatrixBase::cwiseMin, class VectorwiseOp, MatrixBase::minCoeff() */ -template struct ei_scalar_min_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_min_op) +template struct scalar_min_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_min_op) EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return std::min(a, b); } template EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const - { return ei_pmin(a,b); } + { return internal::pmin(a,b); } template EIGEN_STRONG_INLINE const Scalar predux(const Packet& a) const - { return ei_predux_min(a); } + { return internal::predux_min(a); } }; template -struct ei_functor_traits > { +struct functor_traits > { enum { Cost = NumTraits::AddCost, - PacketAccess = ei_packet_traits::HasMin + PacketAccess = packet_traits::HasMin }; }; @@ -127,21 +129,21 @@ struct ei_functor_traits > { * * \sa class CwiseBinaryOp, MatrixBase::cwiseMax, class VectorwiseOp, MatrixBase::maxCoeff() */ -template struct ei_scalar_max_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_max_op) +template struct scalar_max_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_max_op) EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return std::max(a, b); } template EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const - { return ei_pmax(a,b); } + { return internal::pmax(a,b); } template EIGEN_STRONG_INLINE const Scalar predux(const Packet& a) const - { return ei_predux_max(a); } + { return internal::predux_max(a); } }; template -struct ei_functor_traits > { +struct functor_traits > { enum { Cost = NumTraits::AddCost, - PacketAccess = ei_packet_traits::HasMax + PacketAccess = packet_traits::HasMax }; }; @@ -150,19 +152,19 @@ struct ei_functor_traits > { * * \sa MatrixBase::stableNorm(), class Redux */ -template struct ei_scalar_hypot_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_hypot_op) +template struct scalar_hypot_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_hypot_op) // typedef typename NumTraits::Real result_type; EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& _x, const Scalar& _y) const { Scalar p = std::max(_x, _y); Scalar q = std::min(_x, _y); Scalar qp = q/p; - return p * ei_sqrt(Scalar(1) + qp*qp); + return p * sqrt(Scalar(1) + qp*qp); } }; template -struct ei_functor_traits > { +struct functor_traits > { enum { Cost = 5 * NumTraits::MulCost, PacketAccess=0 }; }; @@ -173,18 +175,18 @@ struct ei_functor_traits > { * * \sa class CwiseBinaryOp, MatrixBase::operator- */ -template struct ei_scalar_difference_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_difference_op) +template struct scalar_difference_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_difference_op) EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a - b; } template EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const - { return ei_psub(a,b); } + { return internal::psub(a,b); } }; template -struct ei_functor_traits > { +struct functor_traits > { enum { Cost = NumTraits::AddCost, - PacketAccess = ei_packet_traits::HasSub + PacketAccess = packet_traits::HasSub }; }; @@ -193,18 +195,18 @@ struct ei_functor_traits > { * * \sa class CwiseBinaryOp, Cwise::operator/() */ -template struct ei_scalar_quotient_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_quotient_op) +template struct scalar_quotient_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_quotient_op) EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a / b; } template EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const - { return ei_pdiv(a,b); } + { return internal::pdiv(a,b); } }; template -struct ei_functor_traits > { +struct functor_traits > { enum { Cost = 2 * NumTraits::MulCost, - PacketAccess = ei_packet_traits::HasDiv + PacketAccess = packet_traits::HasDiv }; }; @@ -215,18 +217,18 @@ struct ei_functor_traits > { * * \sa class CwiseUnaryOp, MatrixBase::operator- */ -template struct ei_scalar_opposite_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_opposite_op) +template struct scalar_opposite_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_opposite_op) EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return -a; } template EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const - { return ei_pnegate(a); } + { return internal::pnegate(a); } }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = NumTraits::AddCost, - PacketAccess = ei_packet_traits::HasNegate }; + PacketAccess = packet_traits::HasNegate }; }; /** \internal @@ -234,20 +236,20 @@ struct ei_functor_traits > * * \sa class CwiseUnaryOp, Cwise::abs */ -template struct ei_scalar_abs_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_abs_op) +template struct scalar_abs_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_abs_op) typedef typename NumTraits::Real result_type; - EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return ei_abs(a); } + EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return abs(a); } template EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const - { return ei_pabs(a); } + { return internal::pabs(a); } }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = NumTraits::AddCost, - PacketAccess = ei_packet_traits::HasAbs + PacketAccess = packet_traits::HasAbs }; }; @@ -256,35 +258,35 @@ struct ei_functor_traits > * * \sa class CwiseUnaryOp, Cwise::abs2 */ -template struct ei_scalar_abs2_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_abs2_op) +template struct scalar_abs2_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_abs2_op) typedef typename NumTraits::Real result_type; - EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return ei_abs2(a); } + EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return abs2(a); } template EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const - { return ei_pmul(a,a); } + { return internal::pmul(a,a); } }; template -struct ei_functor_traits > -{ enum { Cost = NumTraits::MulCost, PacketAccess = ei_packet_traits::HasAbs2 }; }; +struct functor_traits > +{ enum { Cost = NumTraits::MulCost, PacketAccess = packet_traits::HasAbs2 }; }; /** \internal * \brief Template functor to compute the conjugate of a complex value * * \sa class CwiseUnaryOp, MatrixBase::conjugate() */ -template struct ei_scalar_conjugate_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_conjugate_op) - EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return ei_conj(a); } +template struct scalar_conjugate_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_conjugate_op) + EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return conj(a); } template - EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const { return ei_pconj(a); } + EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const { return internal::pconj(a); } }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = NumTraits::IsComplex ? NumTraits::AddCost : 0, - PacketAccess = ei_packet_traits::HasConj + PacketAccess = packet_traits::HasConj }; }; @@ -294,14 +296,14 @@ struct ei_functor_traits > * \sa class CwiseUnaryOp, MatrixBase::cast() */ template -struct ei_scalar_cast_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_cast_op) +struct scalar_cast_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op) typedef NewType result_type; - EIGEN_STRONG_INLINE const NewType operator() (const Scalar& a) const { return ei_cast(a); } + EIGEN_STRONG_INLINE const NewType operator() (const Scalar& a) const { return cast(a); } }; template -struct ei_functor_traits > -{ enum { Cost = ei_is_same_type::ret ? 0 : NumTraits::AddCost, PacketAccess = false }; }; +struct functor_traits > +{ enum { Cost = is_same_type::ret ? 0 : NumTraits::AddCost, PacketAccess = false }; }; /** \internal * \brief Template functor to extract the real part of a complex @@ -309,13 +311,13 @@ struct ei_functor_traits > * \sa class CwiseUnaryOp, MatrixBase::real() */ template -struct ei_scalar_real_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_real_op) +struct scalar_real_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_real_op) typedef typename NumTraits::Real result_type; - EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return ei_real(a); } + EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return real(a); } }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 0, PacketAccess = false }; }; /** \internal @@ -324,13 +326,13 @@ struct ei_functor_traits > * \sa class CwiseUnaryOp, MatrixBase::imag() */ template -struct ei_scalar_imag_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_imag_op) +struct scalar_imag_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_op) typedef typename NumTraits::Real result_type; - EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return ei_imag(a); } + EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return imag(a); } }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 0, PacketAccess = false }; }; /** \internal @@ -339,13 +341,13 @@ struct ei_functor_traits > * \sa class CwiseUnaryOp, MatrixBase::real() */ template -struct ei_scalar_real_ref_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_real_ref_op) +struct scalar_real_ref_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_real_ref_op) typedef typename NumTraits::Real result_type; - EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return ei_real_ref(*const_cast(&a)); } + EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return real_ref(*const_cast(&a)); } }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 0, PacketAccess = false }; }; /** \internal @@ -354,13 +356,13 @@ struct ei_functor_traits > * \sa class CwiseUnaryOp, MatrixBase::imag() */ template -struct ei_scalar_imag_ref_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_imag_ref_op) +struct scalar_imag_ref_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_ref_op) typedef typename NumTraits::Real result_type; - EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return ei_imag_ref(*const_cast(&a)); } + EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return imag_ref(*const_cast(&a)); } }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 0, PacketAccess = false }; }; /** \internal @@ -369,15 +371,15 @@ struct ei_functor_traits > * * \sa class CwiseUnaryOp, Cwise::exp() */ -template struct ei_scalar_exp_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_exp_op) - inline const Scalar operator() (const Scalar& a) const { return ei_exp(a); } - typedef typename ei_packet_traits::type Packet; - inline Packet packetOp(const Packet& a) const { return ei_pexp(a); } +template struct scalar_exp_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_exp_op) + inline const Scalar operator() (const Scalar& a) const { return exp(a); } + typedef typename packet_traits::type Packet; + inline Packet packetOp(const Packet& a) const { return internal::pexp(a); } }; template -struct ei_functor_traits > -{ enum { Cost = 5 * NumTraits::MulCost, PacketAccess = ei_packet_traits::HasExp }; }; +struct functor_traits > +{ enum { Cost = 5 * NumTraits::MulCost, PacketAccess = packet_traits::HasExp }; }; /** \internal * @@ -385,81 +387,81 @@ struct ei_functor_traits > * * \sa class CwiseUnaryOp, Cwise::log() */ -template struct ei_scalar_log_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_log_op) - inline const Scalar operator() (const Scalar& a) const { return ei_log(a); } - typedef typename ei_packet_traits::type Packet; - inline Packet packetOp(const Packet& a) const { return ei_plog(a); } +template struct scalar_log_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_log_op) + inline const Scalar operator() (const Scalar& a) const { return log(a); } + typedef typename packet_traits::type Packet; + inline Packet packetOp(const Packet& a) const { return internal::plog(a); } }; template -struct ei_functor_traits > -{ enum { Cost = 5 * NumTraits::MulCost, PacketAccess = ei_packet_traits::HasLog }; }; +struct functor_traits > +{ enum { Cost = 5 * NumTraits::MulCost, PacketAccess = packet_traits::HasLog }; }; /** \internal * \brief Template functor to multiply a scalar by a fixed other one * * \sa class CwiseUnaryOp, MatrixBase::operator*, MatrixBase::operator/ */ -/* NOTE why doing the ei_pset1() in packetOp *is* an optimization ? - * indeed it seems better to declare m_other as a Packet and do the ei_pset1() once +/* NOTE why doing the pset1() in packetOp *is* an optimization ? + * indeed it seems better to declare m_other as a Packet and do the pset1() once * in the constructor. However, in practice: * - GCC does not like m_other as a Packet and generate a load every time it needs it - * - on the other hand GCC is able to moves the ei_pset1() away the loop :) + * - on the other hand GCC is able to moves the pset1() away the loop :) * - simpler code ;) * (ICC and gcc 4.4 seems to perform well in both cases, the issue is visible with y = a*x + b*y) */ template -struct ei_scalar_multiple_op { - typedef typename ei_packet_traits::type Packet; +struct scalar_multiple_op { + typedef typename packet_traits::type Packet; // FIXME default copy constructors seems bugged with std::complex<> - EIGEN_STRONG_INLINE ei_scalar_multiple_op(const ei_scalar_multiple_op& other) : m_other(other.m_other) { } - EIGEN_STRONG_INLINE ei_scalar_multiple_op(const Scalar& other) : m_other(other) { } + EIGEN_STRONG_INLINE scalar_multiple_op(const scalar_multiple_op& other) : m_other(other.m_other) { } + EIGEN_STRONG_INLINE scalar_multiple_op(const Scalar& other) : m_other(other) { } EIGEN_STRONG_INLINE Scalar operator() (const Scalar& a) const { return a * m_other; } EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const - { return ei_pmul(a, ei_pset1(m_other)); } - typename ei_makeconst::Nested>::type m_other; + { return internal::pmul(a, pset1(m_other)); } + typename makeconst::Nested>::type m_other; }; template -struct ei_functor_traits > -{ enum { Cost = NumTraits::MulCost, PacketAccess = ei_packet_traits::HasMul }; }; +struct functor_traits > +{ enum { Cost = NumTraits::MulCost, PacketAccess = packet_traits::HasMul }; }; template -struct ei_scalar_multiple2_op { - typedef typename ei_scalar_product_traits::ReturnType result_type; - EIGEN_STRONG_INLINE ei_scalar_multiple2_op(const ei_scalar_multiple2_op& other) : m_other(other.m_other) { } - EIGEN_STRONG_INLINE ei_scalar_multiple2_op(const Scalar2& other) : m_other(other) { } +struct scalar_multiple2_op { + typedef typename scalar_product_traits::ReturnType result_type; + EIGEN_STRONG_INLINE scalar_multiple2_op(const scalar_multiple2_op& other) : m_other(other.m_other) { } + EIGEN_STRONG_INLINE scalar_multiple2_op(const Scalar2& other) : m_other(other) { } EIGEN_STRONG_INLINE result_type operator() (const Scalar1& a) const { return a * m_other; } - typename ei_makeconst::Nested>::type m_other; + typename makeconst::Nested>::type m_other; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = NumTraits::MulCost, PacketAccess = false }; }; template -struct ei_scalar_quotient1_impl { - typedef typename ei_packet_traits::type Packet; +struct scalar_quotient1_impl { + typedef typename packet_traits::type Packet; // FIXME default copy constructors seems bugged with std::complex<> - EIGEN_STRONG_INLINE ei_scalar_quotient1_impl(const ei_scalar_quotient1_impl& other) : m_other(other.m_other) { } - EIGEN_STRONG_INLINE ei_scalar_quotient1_impl(const Scalar& other) : m_other(static_cast(1) / other) {} + EIGEN_STRONG_INLINE scalar_quotient1_impl(const scalar_quotient1_impl& other) : m_other(other.m_other) { } + EIGEN_STRONG_INLINE scalar_quotient1_impl(const Scalar& other) : m_other(static_cast(1) / other) {} EIGEN_STRONG_INLINE Scalar operator() (const Scalar& a) const { return a * m_other; } EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const - { return ei_pmul(a, ei_pset1(m_other)); } + { return internal::pmul(a, pset1(m_other)); } const Scalar m_other; }; template -struct ei_functor_traits > -{ enum { Cost = NumTraits::MulCost, PacketAccess = ei_packet_traits::HasMul }; }; +struct functor_traits > +{ enum { Cost = NumTraits::MulCost, PacketAccess = packet_traits::HasMul }; }; template -struct ei_scalar_quotient1_impl { +struct scalar_quotient1_impl { // FIXME default copy constructors seems bugged with std::complex<> - EIGEN_STRONG_INLINE ei_scalar_quotient1_impl(const ei_scalar_quotient1_impl& other) : m_other(other.m_other) { } - EIGEN_STRONG_INLINE ei_scalar_quotient1_impl(const Scalar& other) : m_other(other) {} + EIGEN_STRONG_INLINE scalar_quotient1_impl(const scalar_quotient1_impl& other) : m_other(other.m_other) { } + EIGEN_STRONG_INLINE scalar_quotient1_impl(const Scalar& other) : m_other(other) {} EIGEN_STRONG_INLINE Scalar operator() (const Scalar& a) const { return a / m_other; } - typename ei_makeconst::Nested>::type m_other; + typename makeconst::Nested>::type m_other; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 2 * NumTraits::MulCost, PacketAccess = false }; }; /** \internal @@ -471,43 +473,43 @@ struct ei_functor_traits > * \sa class CwiseUnaryOp, MatrixBase::operator/ */ template -struct ei_scalar_quotient1_op : ei_scalar_quotient1_impl::IsInteger > { - EIGEN_STRONG_INLINE ei_scalar_quotient1_op(const Scalar& other) - : ei_scalar_quotient1_impl::IsInteger >(other) {} +struct scalar_quotient1_op : scalar_quotient1_impl::IsInteger > { + EIGEN_STRONG_INLINE scalar_quotient1_op(const Scalar& other) + : scalar_quotient1_impl::IsInteger >(other) {} }; template -struct ei_functor_traits > -: ei_functor_traits::IsInteger> > +struct functor_traits > +: functor_traits::IsInteger> > {}; // nullary functors template -struct ei_scalar_constant_op { - typedef typename ei_packet_traits::type Packet; - EIGEN_STRONG_INLINE ei_scalar_constant_op(const ei_scalar_constant_op& other) : m_other(other.m_other) { } - EIGEN_STRONG_INLINE ei_scalar_constant_op(const Scalar& other) : m_other(other) { } +struct scalar_constant_op { + typedef typename packet_traits::type Packet; + EIGEN_STRONG_INLINE scalar_constant_op(const scalar_constant_op& other) : m_other(other.m_other) { } + EIGEN_STRONG_INLINE scalar_constant_op(const Scalar& other) : m_other(other) { } template EIGEN_STRONG_INLINE const Scalar operator() (Index, Index = 0) const { return m_other; } template - EIGEN_STRONG_INLINE const Packet packetOp(Index, Index = 0) const { return ei_pset1(m_other); } + EIGEN_STRONG_INLINE const Packet packetOp(Index, Index = 0) const { return internal::pset1(m_other); } const Scalar m_other; }; template -struct ei_functor_traits > +struct functor_traits > // FIXME replace this packet test by a safe one -{ enum { Cost = 1, PacketAccess = ei_packet_traits::Vectorizable, IsRepeatable = true }; }; +{ enum { Cost = 1, PacketAccess = packet_traits::Vectorizable, IsRepeatable = true }; }; -template struct ei_scalar_identity_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_identity_op) +template struct scalar_identity_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_identity_op) template EIGEN_STRONG_INLINE const Scalar operator() (Index row, Index col) const { return row==col ? Scalar(1) : Scalar(0); } }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = NumTraits::AddCost, PacketAccess = false, IsRepeatable = true }; }; -template struct ei_linspaced_op_impl; +template struct linspaced_op_impl; // linear access for packet ops: // 1) initialization @@ -515,19 +517,19 @@ template struct ei_linspaced_op_impl; // 2) each step // base += [size*step, ..., size*step] template -struct ei_linspaced_op_impl +struct linspaced_op_impl { - typedef typename ei_packet_traits::type Packet; + typedef typename packet_traits::type Packet; - ei_linspaced_op_impl(Scalar low, Scalar step) : + linspaced_op_impl(Scalar low, Scalar step) : m_low(low), m_step(step), - m_packetStep(ei_pset1(ei_packet_traits::size*step)), - m_base(ei_padd(ei_pset1(low),ei_pmul(ei_pset1(step),ei_plset(-ei_packet_traits::size)))) {} + m_packetStep(pset1(packet_traits::size*step)), + m_base(padd(pset1(low),pmul(pset1(step),plset(-packet_traits::size)))) {} template EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return m_low+i*m_step; } template - EIGEN_STRONG_INLINE const Packet packetOp(Index) const { return m_base = ei_padd(m_base,m_packetStep); } + EIGEN_STRONG_INLINE const Packet packetOp(Index) const { return m_base = padd(m_base,m_packetStep); } const Scalar m_low; const Scalar m_step; @@ -539,20 +541,20 @@ struct ei_linspaced_op_impl // 1) each step // [low, ..., low] + ( [step, ..., step] * ( [i, ..., i] + [0, ..., size] ) ) template -struct ei_linspaced_op_impl +struct linspaced_op_impl { - typedef typename ei_packet_traits::type Packet; + typedef typename packet_traits::type Packet; - ei_linspaced_op_impl(Scalar low, Scalar step) : + linspaced_op_impl(Scalar low, Scalar step) : m_low(low), m_step(step), - m_lowPacket(ei_pset1(m_low)), m_stepPacket(ei_pset1(m_step)), m_interPacket(ei_plset(0)) {} + m_lowPacket(pset1(m_low)), m_stepPacket(pset1(m_step)), m_interPacket(plset(0)) {} template EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return m_low+i*m_step; } template EIGEN_STRONG_INLINE const Packet packetOp(Index i) const - { return ei_padd(m_lowPacket, ei_pmul(m_stepPacket, ei_padd(ei_pset1(i),m_interPacket))); } + { return internal::padd(m_lowPacket, pmul(m_stepPacket, padd(pset1(i),m_interPacket))); } const Scalar m_low; const Scalar m_step; @@ -566,13 +568,13 @@ struct ei_linspaced_op_impl // Forward declaration (we default to random access which does not really give // us a speed gain when using packet access but it allows to use the functor in // nested expressions). -template struct ei_linspaced_op; -template struct ei_functor_traits< ei_linspaced_op > -{ enum { Cost = 1, PacketAccess = ei_packet_traits::HasSetLinear, IsRepeatable = true }; }; -template struct ei_linspaced_op +template struct linspaced_op; +template struct functor_traits< linspaced_op > +{ enum { Cost = 1, PacketAccess = packet_traits::HasSetLinear, IsRepeatable = true }; }; +template struct linspaced_op { - typedef typename ei_packet_traits::type Packet; - ei_linspaced_op(Scalar low, Scalar high, int num_steps) : impl(low, (high-low)/(num_steps-1)) {} + typedef typename packet_traits::type Packet; + linspaced_op(Scalar low, Scalar high, int num_steps) : impl(low, (high-low)/(num_steps-1)) {} template EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return impl(i); } @@ -582,7 +584,7 @@ template struct ei_linspaced_op template EIGEN_STRONG_INLINE const Scalar operator() (Index row, Index col) const { - ei_assert(col==0 || row==0); + eigen_assert(col==0 || row==0); return impl(col + row); } @@ -594,65 +596,65 @@ template struct ei_linspaced_op template EIGEN_STRONG_INLINE const Packet packetOp(Index row, Index col) const { - ei_assert(col==0 || row==0); + eigen_assert(col==0 || row==0); return impl(col + row); } // This proxy object handles the actual required temporaries, the different // implementations (random vs. sequential access) as well as the // correct piping to size 2/4 packet operations. - const ei_linspaced_op_impl impl; + const linspaced_op_impl impl; }; -// all functors allow linear access, except ei_scalar_identity_op. So we fix here a quick meta +// all functors allow linear access, except scalar_identity_op. So we fix here a quick meta // to indicate whether a functor allows linear access, just always answering 'yes' except for -// ei_scalar_identity_op. -// FIXME move this to ei_functor_traits adding a ei_functor_default -template struct ei_functor_has_linear_access { enum { ret = 1 }; }; -template struct ei_functor_has_linear_access > { enum { ret = 0 }; }; +// scalar_identity_op. +// FIXME move this to functor_traits adding a functor_default +template struct functor_has_linear_access { enum { ret = 1 }; }; +template struct functor_has_linear_access > { enum { ret = 0 }; }; // in CwiseBinaryOp, we require the Lhs and Rhs to have the same scalar type, except for multiplication // where we only require them to have the same _real_ scalar type so one may multiply, say, float by complex. -// FIXME move this to ei_functor_traits adding a ei_functor_default -template struct ei_functor_allows_mixing_real_and_complex { enum { ret = 0 }; }; -template struct ei_functor_allows_mixing_real_and_complex > { enum { ret = 1 }; }; +// FIXME move this to functor_traits adding a functor_default +template struct functor_allows_mixing_real_and_complex { enum { ret = 0 }; }; +template struct functor_allows_mixing_real_and_complex > { enum { ret = 1 }; }; /** \internal * \brief Template functor to add a scalar to a fixed other one * \sa class CwiseUnaryOp, Array::operator+ */ -/* If you wonder why doing the ei_pset1() in packetOp() is an optimization check ei_scalar_multiple_op */ +/* If you wonder why doing the pset1() in packetOp() is an optimization check scalar_multiple_op */ template -struct ei_scalar_add_op { - typedef typename ei_packet_traits::type Packet; +struct scalar_add_op { + typedef typename packet_traits::type Packet; // FIXME default copy constructors seems bugged with std::complex<> - inline ei_scalar_add_op(const ei_scalar_add_op& other) : m_other(other.m_other) { } - inline ei_scalar_add_op(const Scalar& other) : m_other(other) { } + inline scalar_add_op(const scalar_add_op& other) : m_other(other.m_other) { } + inline scalar_add_op(const Scalar& other) : m_other(other) { } inline Scalar operator() (const Scalar& a) const { return a + m_other; } inline const Packet packetOp(const Packet& a) const - { return ei_padd(a, ei_pset1(m_other)); } + { return internal::padd(a, pset1(m_other)); } const Scalar m_other; }; template -struct ei_functor_traits > -{ enum { Cost = NumTraits::AddCost, PacketAccess = ei_packet_traits::HasAdd }; }; +struct functor_traits > +{ enum { Cost = NumTraits::AddCost, PacketAccess = packet_traits::HasAdd }; }; /** \internal * \brief Template functor to compute the square root of a scalar * \sa class CwiseUnaryOp, Cwise::sqrt() */ -template struct ei_scalar_sqrt_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_sqrt_op) - inline const Scalar operator() (const Scalar& a) const { return ei_sqrt(a); } - typedef typename ei_packet_traits::type Packet; - inline Packet packetOp(const Packet& a) const { return ei_psqrt(a); } +template struct scalar_sqrt_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op) + inline const Scalar operator() (const Scalar& a) const { return sqrt(a); } + typedef typename packet_traits::type Packet; + inline Packet packetOp(const Packet& a) const { return internal::psqrt(a); } }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 5 * NumTraits::MulCost, - PacketAccess = ei_packet_traits::HasSqrt + PacketAccess = packet_traits::HasSqrt }; }; @@ -660,18 +662,18 @@ struct ei_functor_traits > * \brief Template functor to compute the cosine of a scalar * \sa class CwiseUnaryOp, Cwise::cos() */ -template struct ei_scalar_cos_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_cos_op) - inline Scalar operator() (const Scalar& a) const { return ei_cos(a); } - typedef typename ei_packet_traits::type Packet; - inline Packet packetOp(const Packet& a) const { return ei_pcos(a); } +template struct scalar_cos_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_cos_op) + inline Scalar operator() (const Scalar& a) const { return cos(a); } + typedef typename packet_traits::type Packet; + inline Packet packetOp(const Packet& a) const { return internal::pcos(a); } }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 5 * NumTraits::MulCost, - PacketAccess = ei_packet_traits::HasCos + PacketAccess = packet_traits::HasCos }; }; @@ -679,18 +681,18 @@ struct ei_functor_traits > * \brief Template functor to compute the sine of a scalar * \sa class CwiseUnaryOp, Cwise::sin() */ -template struct ei_scalar_sin_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_sin_op) - inline const Scalar operator() (const Scalar& a) const { return ei_sin(a); } - typedef typename ei_packet_traits::type Packet; - inline Packet packetOp(const Packet& a) const { return ei_psin(a); } +template struct scalar_sin_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_sin_op) + inline const Scalar operator() (const Scalar& a) const { return sin(a); } + typedef typename packet_traits::type Packet; + inline Packet packetOp(const Packet& a) const { return internal::psin(a); } }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 5 * NumTraits::MulCost, - PacketAccess = ei_packet_traits::HasSin + PacketAccess = packet_traits::HasSin }; }; @@ -699,15 +701,15 @@ struct ei_functor_traits > * \sa class CwiseUnaryOp, Cwise::pow */ template -struct ei_scalar_pow_op { +struct scalar_pow_op { // FIXME default copy constructors seems bugged with std::complex<> - inline ei_scalar_pow_op(const ei_scalar_pow_op& other) : m_exponent(other.m_exponent) { } - inline ei_scalar_pow_op(const Scalar& exponent) : m_exponent(exponent) {} - inline Scalar operator() (const Scalar& a) const { return ei_pow(a, m_exponent); } + inline scalar_pow_op(const scalar_pow_op& other) : m_exponent(other.m_exponent) { } + inline scalar_pow_op(const Scalar& exponent) : m_exponent(exponent) {} + inline Scalar operator() (const Scalar& a) const { return internal::pow(a, m_exponent); } const Scalar m_exponent; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 5 * NumTraits::MulCost, PacketAccess = false }; }; /** \internal @@ -715,155 +717,157 @@ struct ei_functor_traits > * \sa class CwiseUnaryOp, Cwise::inverse() */ template -struct ei_scalar_inverse_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_inverse_op) +struct scalar_inverse_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_inverse_op) inline Scalar operator() (const Scalar& a) const { return Scalar(1)/a; } template inline const Packet packetOp(const Packet& a) const - { return ei_pdiv(ei_pset1(Scalar(1)),a); } + { return internal::pdiv(pset1(Scalar(1)),a); } }; template -struct ei_functor_traits > -{ enum { Cost = NumTraits::MulCost, PacketAccess = ei_packet_traits::HasDiv }; }; +struct functor_traits > +{ enum { Cost = NumTraits::MulCost, PacketAccess = packet_traits::HasDiv }; }; /** \internal * \brief Template functor to compute the square of a scalar * \sa class CwiseUnaryOp, Cwise::square() */ template -struct ei_scalar_square_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_square_op) +struct scalar_square_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_square_op) inline Scalar operator() (const Scalar& a) const { return a*a; } template inline const Packet packetOp(const Packet& a) const - { return ei_pmul(a,a); } + { return internal::pmul(a,a); } }; template -struct ei_functor_traits > -{ enum { Cost = NumTraits::MulCost, PacketAccess = ei_packet_traits::HasMul }; }; +struct functor_traits > +{ enum { Cost = NumTraits::MulCost, PacketAccess = packet_traits::HasMul }; }; /** \internal * \brief Template functor to compute the cube of a scalar * \sa class CwiseUnaryOp, Cwise::cube() */ template -struct ei_scalar_cube_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_cube_op) +struct scalar_cube_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_cube_op) inline Scalar operator() (const Scalar& a) const { return a*a*a; } template inline const Packet packetOp(const Packet& a) const - { return ei_pmul(a,ei_pmul(a,a)); } + { return internal::pmul(a,pmul(a,a)); } }; template -struct ei_functor_traits > -{ enum { Cost = 2*NumTraits::MulCost, PacketAccess = ei_packet_traits::HasMul }; }; +struct functor_traits > +{ enum { Cost = 2*NumTraits::MulCost, PacketAccess = packet_traits::HasMul }; }; // default functor traits for STL functors: template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = NumTraits::MulCost, PacketAccess = false }; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = NumTraits::MulCost, PacketAccess = false }; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = NumTraits::AddCost, PacketAccess = false }; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = NumTraits::AddCost, PacketAccess = false }; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = NumTraits::AddCost, PacketAccess = false }; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 1, PacketAccess = false }; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 1, PacketAccess = false }; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 1, PacketAccess = false }; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 1, PacketAccess = false }; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 1, PacketAccess = false }; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 1, PacketAccess = false }; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 1, PacketAccess = false }; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 1, PacketAccess = false }; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 1, PacketAccess = false }; }; template -struct ei_functor_traits > -{ enum { Cost = ei_functor_traits::Cost, PacketAccess = false }; }; +struct functor_traits > +{ enum { Cost = functor_traits::Cost, PacketAccess = false }; }; template -struct ei_functor_traits > -{ enum { Cost = ei_functor_traits::Cost, PacketAccess = false }; }; +struct functor_traits > +{ enum { Cost = functor_traits::Cost, PacketAccess = false }; }; template -struct ei_functor_traits > -{ enum { Cost = 1 + ei_functor_traits::Cost, PacketAccess = false }; }; +struct functor_traits > +{ enum { Cost = 1 + functor_traits::Cost, PacketAccess = false }; }; template -struct ei_functor_traits > -{ enum { Cost = 1 + ei_functor_traits::Cost, PacketAccess = false }; }; +struct functor_traits > +{ enum { Cost = 1 + functor_traits::Cost, PacketAccess = false }; }; #ifdef EIGEN_STDEXT_SUPPORT template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 0, PacketAccess = false }; }; template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 0, PacketAccess = false }; }; template -struct ei_functor_traits > > +struct functor_traits > > { enum { Cost = 0, PacketAccess = false }; }; template -struct ei_functor_traits > > +struct functor_traits > > { enum { Cost = 0, PacketAccess = false }; }; template -struct ei_functor_traits > -{ enum { Cost = ei_functor_traits::Cost + ei_functor_traits::Cost, PacketAccess = false }; }; +struct functor_traits > +{ enum { Cost = functor_traits::Cost + functor_traits::Cost, PacketAccess = false }; }; template -struct ei_functor_traits > -{ enum { Cost = ei_functor_traits::Cost + ei_functor_traits::Cost + ei_functor_traits::Cost, PacketAccess = false }; }; +struct functor_traits > +{ enum { Cost = functor_traits::Cost + functor_traits::Cost + functor_traits::Cost, PacketAccess = false }; }; #endif // EIGEN_STDEXT_SUPPORT -// allow to add new functors and specializations of ei_functor_traits from outside Eigen. -// this macro is really needed because ei_functor_traits must be specialized after it is declared but before it is used... +// allow to add new functors and specializations of functor_traits from outside Eigen. +// this macro is really needed because functor_traits must be specialized after it is declared but before it is used... #ifdef EIGEN_FUNCTORS_PLUGIN #include EIGEN_FUNCTORS_PLUGIN #endif +} // end namespace internal + #endif // EIGEN_FUNCTORS_H diff --git a/Eigen/src/Core/Fuzzy.h b/Eigen/src/Core/Fuzzy.h index 4a3b5e4dc..0a3620df9 100644 --- a/Eigen/src/Core/Fuzzy.h +++ b/Eigen/src/Core/Fuzzy.h @@ -28,8 +28,6 @@ // TODO support small integer types properly i.e. do exact compare on coeffs --- taking a HS norm is guaranteed to cause integer overflow. -#ifndef EIGEN_LEGACY_COMPARES - /** \returns \c true if \c *this is approximately equal to \a other, within the precision * determined by \a prec. * @@ -42,10 +40,10 @@ * \note Because of the multiplicativeness of this comparison, one can't use this function * to check whether \c *this is approximately equal to the zero matrix or vector. * Indeed, \c isApprox(zero) returns false unless \c *this itself is exactly the zero matrix - * or vector. If you want to test whether \c *this is zero, use ei_isMuchSmallerThan(const + * or vector. If you want to test whether \c *this is zero, use internal::isMuchSmallerThan(const * RealScalar&, RealScalar) instead. * - * \sa ei_isMuchSmallerThan(const RealScalar&, RealScalar) const + * \sa internal::isMuchSmallerThan(const RealScalar&, RealScalar) const */ template template @@ -54,10 +52,10 @@ bool DenseBase::isApprox( RealScalar prec ) const { - const typename ei_nested::type nested(derived()); - const typename ei_nested::type otherNested(other.derived()); -// std::cerr << typeid(Derived).name() << " => " << typeid(typename ei_nested::type).name() << "\n"; -// std::cerr << typeid(OtherDerived).name() << " => " << typeid(typename ei_nested::type).name() << "\n"; + const typename internal::nested::type nested(derived()); + const typename internal::nested::type otherNested(other.derived()); +// std::cerr << typeid(Derived).name() << " => " << typeid(typename internal::nested::type).name() << "\n"; +// std::cerr << typeid(OtherDerived).name() << " => " << typeid(typename internal::nested::type).name() << "\n"; // return false; return (nested - otherNested).cwiseAbs2().sum() <= prec * prec * std::min(nested.cwiseAbs2().sum(), otherNested.cwiseAbs2().sum()); } @@ -104,137 +102,4 @@ bool DenseBase::isMuchSmallerThan( return derived().cwiseAbs2().sum() <= prec * prec * other.derived().cwiseAbs2().sum(); } -#else - -template -struct ei_fuzzy_selector; - -/** \returns \c true if \c *this is approximately equal to \a other, within the precision - * determined by \a prec. - * - * \note The fuzzy compares are done multiplicatively. Two vectors \f$ v \f$ and \f$ w \f$ - * are considered to be approximately equal within precision \f$ p \f$ if - * \f[ \Vert v - w \Vert \leqslant p\,\min(\Vert v\Vert, \Vert w\Vert). \f] - * For matrices, the comparison is done on all columns. - * - * \note Because of the multiplicativeness of this comparison, one can't use this function - * to check whether \c *this is approximately equal to the zero matrix or vector. - * Indeed, \c isApprox(zero) returns false unless \c *this itself is exactly the zero matrix - * or vector. If you want to test whether \c *this is zero, use ei_isMuchSmallerThan(const - * RealScalar&, RealScalar) instead. - * - * \sa ei_isMuchSmallerThan(const RealScalar&, RealScalar) const - */ -template -template -bool DenseBase::isApprox( - const DenseBase& other, - RealScalar prec -) const -{ - return ei_fuzzy_selector::isApprox(derived(), other.derived(), prec); -} - -/** \returns \c true if the norm of \c *this is much smaller than \a other, - * within the precision determined by \a prec. - * - * \note The fuzzy compares are done multiplicatively. A vector \f$ v \f$ is - * considered to be much smaller than \f$ x \f$ within precision \f$ p \f$ if - * \f[ \Vert v \Vert \leqslant p\,\vert x\vert. \f] - * For matrices, the comparison is done on all columns. - * - * \sa isApprox(), isMuchSmallerThan(const DenseBase&, RealScalar) const - */ -template -bool DenseBase::isMuchSmallerThan( - const typename NumTraits::Real& other, - RealScalar prec -) const -{ - return ei_fuzzy_selector::isMuchSmallerThan(derived(), other, prec); -} - -/** \returns \c true if the norm of \c *this is much smaller than the norm of \a other, - * within the precision determined by \a prec. - * - * \note The fuzzy compares are done multiplicatively. A vector \f$ v \f$ is - * considered to be much smaller than a vector \f$ w \f$ within precision \f$ p \f$ if - * \f[ \Vert v \Vert \leqslant p\,\Vert w\Vert. \f] - * For matrices, the comparison is done on all columns. - * - * \sa isApprox(), isMuchSmallerThan(const RealScalar&, RealScalar) const - */ -template -template -bool DenseBase::isMuchSmallerThan( - const DenseBase& other, - RealScalar prec -) const -{ - return ei_fuzzy_selector::isMuchSmallerThan(derived(), other.derived(), prec); -} - - -template -struct ei_fuzzy_selector -{ - typedef typename Derived::RealScalar RealScalar; - static bool isApprox(const Derived& self, const OtherDerived& other, RealScalar prec) - { - EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived) - ei_assert(self.size() == other.size()); - return((self - other).squaredNorm() <= std::min(self.squaredNorm(), other.squaredNorm()) * prec * prec); - } - static bool isMuchSmallerThan(const Derived& self, const RealScalar& other, RealScalar prec) - { - return(self.squaredNorm() <= ei_abs2(other * prec)); - } - static bool isMuchSmallerThan(const Derived& self, const OtherDerived& other, RealScalar prec) - { - EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived) - ei_assert(self.size() == other.size()); - return(self.squaredNorm() <= other.squaredNorm() * prec * prec); - } -}; - -template -struct ei_fuzzy_selector -{ - typedef typename Derived::RealScalar RealScalar; - typedef typename Derived::Index Index; - static bool isApprox(const Derived& self, const OtherDerived& other, RealScalar prec) - { - EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived) - ei_assert(self.rows() == other.rows() && self.cols() == other.cols()); - typename Derived::Nested nested(self); - typename OtherDerived::Nested otherNested(other); - for(Index i = 0; i < self.cols(); ++i) - if((nested.col(i) - otherNested.col(i)).squaredNorm() - > std::min(nested.col(i).squaredNorm(), otherNested.col(i).squaredNorm()) * prec * prec) - return false; - return true; - } - static bool isMuchSmallerThan(const Derived& self, const RealScalar& other, RealScalar prec) - { - typename Derived::Nested nested(self); - for(Index i = 0; i < self.cols(); ++i) - if(nested.col(i).squaredNorm() > ei_abs2(other * prec)) - return false; - return true; - } - static bool isMuchSmallerThan(const Derived& self, const OtherDerived& other, RealScalar prec) - { - EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived) - ei_assert(self.rows() == other.rows() && self.cols() == other.cols()); - typename Derived::Nested nested(self); - typename OtherDerived::Nested otherNested(other); - for(Index i = 0; i < self.cols(); ++i) - if(nested.col(i).squaredNorm() > otherNested.col(i).squaredNorm() * prec * prec) - return false; - return true; - } -}; - -#endif - #endif // EIGEN_FUZZY_H diff --git a/Eigen/src/Core/GenericPacketMath.h b/Eigen/src/Core/GenericPacketMath.h index 8ace18174..7d3fdadf0 100644 --- a/Eigen/src/Core/GenericPacketMath.h +++ b/Eigen/src/Core/GenericPacketMath.h @@ -26,6 +26,8 @@ #ifndef EIGEN_GENERIC_PACKET_MATH_H #define EIGEN_GENERIC_PACKET_MATH_H +namespace internal { + /** \internal * \file GenericPacketMath.h * @@ -50,7 +52,7 @@ #define EIGEN_DEBUG_UNALIGNED_STORE #endif -struct ei_default_packet_traits +struct default_packet_traits { enum { HasAdd = 1, @@ -79,7 +81,7 @@ struct ei_default_packet_traits }; }; -template struct ei_packet_traits : ei_default_packet_traits +template struct packet_traits : default_packet_traits { typedef T type; enum { @@ -103,92 +105,92 @@ template struct ei_packet_traits : ei_default_packet_traits /** \internal \returns a + b (coeff-wise) */ template inline Packet -ei_padd(const Packet& a, +padd(const Packet& a, const Packet& b) { return a+b; } /** \internal \returns a - b (coeff-wise) */ template inline Packet -ei_psub(const Packet& a, +psub(const Packet& a, const Packet& b) { return a-b; } /** \internal \returns -a (coeff-wise) */ template inline Packet -ei_pnegate(const Packet& a) { return -a; } +pnegate(const Packet& a) { return -a; } /** \internal \returns conj(a) (coeff-wise) */ template inline Packet -ei_pconj(const Packet& a) { return ei_conj(a); } +pconj(const Packet& a) { return conj(a); } /** \internal \returns a * b (coeff-wise) */ template inline Packet -ei_pmul(const Packet& a, +pmul(const Packet& a, const Packet& b) { return a*b; } /** \internal \returns a / b (coeff-wise) */ template inline Packet -ei_pdiv(const Packet& a, +pdiv(const Packet& a, const Packet& b) { return a/b; } /** \internal \returns the min of \a a and \a b (coeff-wise) */ template inline Packet -ei_pmin(const Packet& a, +pmin(const Packet& a, const Packet& b) { return std::min(a, b); } /** \internal \returns the max of \a a and \a b (coeff-wise) */ template inline Packet -ei_pmax(const Packet& a, +pmax(const Packet& a, const Packet& b) { return std::max(a, b); } /** \internal \returns the absolute value of \a a */ template inline Packet -ei_pabs(const Packet& a) { return ei_abs(a); } +pabs(const Packet& a) { return abs(a); } /** \internal \returns the bitwise and of \a a and \a b */ template inline Packet -ei_pand(const Packet& a, const Packet& b) { return a & b; } +pand(const Packet& a, const Packet& b) { return a & b; } /** \internal \returns the bitwise or of \a a and \a b */ template inline Packet -ei_por(const Packet& a, const Packet& b) { return a | b; } +por(const Packet& a, const Packet& b) { return a | b; } /** \internal \returns the bitwise xor of \a a and \a b */ template inline Packet -ei_pxor(const Packet& a, const Packet& b) { return a ^ b; } +pxor(const Packet& a, const Packet& b) { return a ^ b; } /** \internal \returns the bitwise andnot of \a a and \a b */ template inline Packet -ei_pandnot(const Packet& a, const Packet& b) { return a & (!b); } +pandnot(const Packet& a, const Packet& b) { return a & (!b); } /** \internal \returns a packet version of \a *from, from must be 16 bytes aligned */ template inline Packet -ei_pload(const typename ei_unpacket_traits::type* from) { return *from; } +pload(const typename unpacket_traits::type* from) { return *from; } /** \internal \returns a packet version of \a *from, (un-aligned load) */ template inline Packet -ei_ploadu(const typename ei_unpacket_traits::type* from) { return *from; } +ploadu(const typename unpacket_traits::type* from) { return *from; } /** \internal \returns a packet with elements of \a *from duplicated, e.g.: (from[0],from[0],from[1],from[1]) */ template inline Packet -ei_ploaddup(const typename ei_unpacket_traits::type* from) { return *from; } +ploaddup(const typename unpacket_traits::type* from) { return *from; } /** \internal \returns a packet with constant coefficients \a a, e.g.: (a,a,a,a) */ template inline Packet -ei_pset1(const typename ei_unpacket_traits::type& a) { return a; } +pset1(const typename unpacket_traits::type& a) { return a; } /** \internal \brief Returns a packet with coefficients (a,a+1,...,a+packet_size-1). */ -template inline typename ei_packet_traits::type -ei_plset(const Scalar& a) { return a; } +template inline typename packet_traits::type +plset(const Scalar& a) { return a; } /** \internal copy the packet \a from to \a *to, \a to must be 16 bytes aligned */ -template inline void ei_pstore(Scalar* to, const Packet& from) +template inline void pstore(Scalar* to, const Packet& from) { (*to) = from; } /** \internal copy the packet \a from to \a *to, (un-aligned store) */ -template inline void ei_pstoreu(Scalar* to, const Packet& from) +template inline void pstoreu(Scalar* to, const Packet& from) { (*to) = from; } /** \internal tries to do cache prefetching of \a addr */ -template inline void ei_prefetch(const Scalar* addr) +template inline void prefetch(const Scalar* addr) { #if !defined(_MSC_VER) __builtin_prefetch(addr); @@ -196,31 +198,31 @@ __builtin_prefetch(addr); } /** \internal \returns the first element of a packet */ -template inline typename ei_unpacket_traits::type ei_pfirst(const Packet& a) +template inline typename unpacket_traits::type pfirst(const Packet& a) { return a; } /** \internal \returns a packet where the element i contains the sum of the packet of \a vec[i] */ template inline Packet -ei_preduxp(const Packet* vecs) { return vecs[0]; } +preduxp(const Packet* vecs) { return vecs[0]; } /** \internal \returns the sum of the elements of \a a*/ -template inline typename ei_unpacket_traits::type ei_predux(const Packet& a) +template inline typename unpacket_traits::type predux(const Packet& a) { return a; } /** \internal \returns the product of the elements of \a a*/ -template inline typename ei_unpacket_traits::type ei_predux_mul(const Packet& a) +template inline typename unpacket_traits::type predux_mul(const Packet& a) { return a; } /** \internal \returns the min of the elements of \a a*/ -template inline typename ei_unpacket_traits::type ei_predux_min(const Packet& a) +template inline typename unpacket_traits::type predux_min(const Packet& a) { return a; } /** \internal \returns the max of the elements of \a a*/ -template inline typename ei_unpacket_traits::type ei_predux_max(const Packet& a) +template inline typename unpacket_traits::type predux_max(const Packet& a) { return a; } /** \internal \returns the reversed elements of \a a*/ -template inline Packet ei_preverse(const Packet& a) +template inline Packet preverse(const Packet& a) { return a; } /************************** @@ -229,23 +231,23 @@ template inline Packet ei_preverse(const Packet& a) /** \internal \returns the sin of \a a (coeff-wise) */ template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS -Packet ei_psin(const Packet& a) { return ei_sin(a); } +Packet psin(const Packet& a) { return sin(a); } /** \internal \returns the cos of \a a (coeff-wise) */ template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS -Packet ei_pcos(const Packet& a) { return ei_cos(a); } +Packet pcos(const Packet& a) { return cos(a); } /** \internal \returns the exp of \a a (coeff-wise) */ template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS -Packet ei_pexp(const Packet& a) { return ei_exp(a); } +Packet pexp(const Packet& a) { return exp(a); } /** \internal \returns the log of \a a (coeff-wise) */ template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS -Packet ei_plog(const Packet& a) { return ei_log(a); } +Packet plog(const Packet& a) { return log(a); } /** \internal \returns the square-root of \a a (coeff-wise) */ template EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS -Packet ei_psqrt(const Packet& a) { return ei_sqrt(a); } +Packet psqrt(const Packet& a) { return sqrt(a); } /*************************************************************************** * The following functions might not have to be overwritten for vectorized types @@ -253,36 +255,36 @@ Packet ei_psqrt(const Packet& a) { return ei_sqrt(a); } /** \internal \returns a * b + c (coeff-wise) */ template inline Packet -ei_pmadd(const Packet& a, +pmadd(const Packet& a, const Packet& b, const Packet& c) -{ return ei_padd(ei_pmul(a, b),c); } +{ return padd(pmul(a, b),c); } /** \internal \returns a packet version of \a *from. * \If LoadMode equals Aligned, \a from must be 16 bytes aligned */ template -inline Packet ei_ploadt(const typename ei_unpacket_traits::type* from) +inline Packet ploadt(const typename unpacket_traits::type* from) { if(LoadMode == Aligned) - return ei_pload(from); + return pload(from); else - return ei_ploadu(from); + return ploadu(from); } /** \internal copy the packet \a from to \a *to. * If StoreMode equals Aligned, \a to must be 16 bytes aligned */ template -inline void ei_pstoret(Scalar* to, const Packet& from) +inline void pstoret(Scalar* to, const Packet& from) { if(LoadMode == Aligned) - ei_pstore(to, from); + pstore(to, from); else - ei_pstoreu(to, from); + pstoreu(to, from); } -/** \internal default implementation of ei_palign() allowing partial specialization */ +/** \internal default implementation of palign() allowing partial specialization */ template -struct ei_palign_impl +struct palign_impl { // by default data are aligned, so there is nothing to be done :) inline static void run(PacketType&, const PacketType&) {} @@ -291,20 +293,22 @@ struct ei_palign_impl /** \internal update \a first using the concatenation of the \a Offset last elements * of \a first and packet_size minus \a Offset first elements of \a second */ template -inline void ei_palign(PacketType& first, const PacketType& second) +inline void palign(PacketType& first, const PacketType& second) { - ei_palign_impl::run(first,second); + palign_impl::run(first,second); } /*************************************************************************** * Fast complex products (GCC generates a function call which is very slow) ***************************************************************************/ -template<> inline std::complex ei_pmul(const std::complex& a, const std::complex& b) -{ return std::complex(ei_real(a)*ei_real(b) - ei_imag(a)*ei_imag(b), ei_imag(a)*ei_real(b) + ei_real(a)*ei_imag(b)); } +template<> inline std::complex pmul(const std::complex& a, const std::complex& b) +{ return std::complex(real(a)*real(b) - imag(a)*imag(b), imag(a)*real(b) + real(a)*imag(b)); } + +template<> inline std::complex pmul(const std::complex& a, const std::complex& b) +{ return std::complex(real(a)*real(b) - imag(a)*imag(b), imag(a)*real(b) + real(a)*imag(b)); } -template<> inline std::complex ei_pmul(const std::complex& a, const std::complex& b) -{ return std::complex(ei_real(a)*ei_real(b) - ei_imag(a)*ei_imag(b), ei_imag(a)*ei_real(b) + ei_real(a)*ei_imag(b)); } +} // end namespace internal #endif // EIGEN_GENERIC_PACKET_MATH_H diff --git a/Eigen/src/Core/GlobalFunctions.h b/Eigen/src/Core/GlobalFunctions.h index 001c5b0b6..44d610f25 100644 --- a/Eigen/src/Core/GlobalFunctions.h +++ b/Eigen/src/Core/GlobalFunctions.h @@ -28,7 +28,7 @@ #define EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(NAME,FUNCTOR) \ template \ - inline const Eigen::CwiseUnaryOp, Derived> \ + inline const Eigen::CwiseUnaryOp, Derived> \ NAME(const Eigen::ArrayBase& x) { \ return x.derived(); \ } @@ -38,7 +38,7 @@ template \ struct NAME##_retval > \ { \ - typedef const Eigen::CwiseUnaryOp, Derived> type; \ + typedef const Eigen::CwiseUnaryOp, Derived> type; \ }; \ template \ struct NAME##_impl > \ @@ -52,17 +52,17 @@ namespace std { - EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(real,ei_scalar_real_op) - EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(imag,ei_scalar_imag_op) - EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(sin,ei_scalar_sin_op) - EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(cos,ei_scalar_cos_op) - EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(exp,ei_scalar_exp_op) - EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(log,ei_scalar_log_op) - EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(abs,ei_scalar_abs_op) - EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(sqrt,ei_scalar_sqrt_op) + EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(real,scalar_real_op) + EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(imag,scalar_imag_op) + EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(sin,scalar_sin_op) + EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(cos,scalar_cos_op) + EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(exp,scalar_exp_op) + EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(log,scalar_log_op) + EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(abs,scalar_abs_op) + EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(sqrt,scalar_sqrt_op) template - inline const Eigen::CwiseUnaryOp, Derived> + inline const Eigen::CwiseUnaryOp, Derived> pow(const Eigen::ArrayBase& x, const typename Derived::Scalar& exponent) { \ return x.derived().pow(exponent); \ } @@ -70,17 +70,20 @@ namespace std namespace Eigen { - EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(ei_real,ei_scalar_real_op) - EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(ei_imag,ei_scalar_imag_op) - EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(ei_sin,ei_scalar_sin_op) - EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(ei_cos,ei_scalar_cos_op) - EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(ei_exp,ei_scalar_exp_op) - EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(ei_log,ei_scalar_log_op) - EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(ei_abs,ei_scalar_abs_op) - EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(ei_abs2,ei_scalar_abs2_op) - EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(ei_sqrt,ei_scalar_sqrt_op) + namespace internal + { + EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(real,scalar_real_op) + EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(imag,scalar_imag_op) + EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(sin,scalar_sin_op) + EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(cos,scalar_cos_op) + EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(exp,scalar_exp_op) + EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(log,scalar_log_op) + EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(abs,scalar_abs_op) + EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(abs2,scalar_abs2_op) + EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(sqrt,scalar_sqrt_op) + } } -// TODO: cleanly disable those functions that are not supported on Array (ei_real_ref, ei_random, ei_isApprox...) +// TODO: cleanly disable those functions that are not supported on Array (internal::real_ref, internal::random, internal::isApprox...) #endif // EIGEN_GLOBAL_FUNCTIONS_H diff --git a/Eigen/src/Core/IO.h b/Eigen/src/Core/IO.h index 7c742d867..baaf046ce 100644 --- a/Eigen/src/Core/IO.h +++ b/Eigen/src/Core/IO.h @@ -30,6 +30,11 @@ enum { DontAlignCols = 1 }; enum { StreamPrecision = -1, FullPrecision = -2 }; +namespace internal { +template +std::ostream & print_matrix(std::ostream & s, const Derived& _m, const IOFormat& fmt); +} + /** \class IOFormat * \ingroup Core_Module * @@ -106,7 +111,7 @@ class WithFormat friend std::ostream & operator << (std::ostream & s, const WithFormat& wf) { - return ei_print_matrix(s, wf.m_matrix.eval(), wf.m_format); + return internal::print_matrix(s, wf.m_matrix.eval(), wf.m_format); } protected: @@ -128,18 +133,20 @@ DenseBase::format(const IOFormat& fmt) const return WithFormat(derived(), fmt); } +namespace internal { + template -struct ei_significant_decimals_default_impl +struct significant_decimals_default_impl { typedef typename NumTraits::Real RealScalar; static inline int run() { - return ei_cast(std::ceil(-ei_log(NumTraits::epsilon())/ei_log(RealScalar(10)))); + return cast(std::ceil(-log(NumTraits::epsilon())/log(RealScalar(10)))); } }; template -struct ei_significant_decimals_default_impl +struct significant_decimals_default_impl { static inline int run() { @@ -148,14 +155,14 @@ struct ei_significant_decimals_default_impl }; template -struct ei_significant_decimals_impl - : ei_significant_decimals_default_impl::IsInteger> +struct significant_decimals_impl + : significant_decimals_default_impl::IsInteger> {}; /** \internal * print the matrix \a _m to the output stream \a s using the output format \a fmt */ template -std::ostream & ei_print_matrix(std::ostream & s, const Derived& _m, const IOFormat& fmt) +std::ostream & print_matrix(std::ostream & s, const Derived& _m, const IOFormat& fmt) { if(_m.size() == 0) { @@ -182,7 +189,7 @@ std::ostream & ei_print_matrix(std::ostream & s, const Derived& _m, const IOForm } else { - explicit_precision = ei_significant_decimals_impl::run(); + explicit_precision = significant_decimals_impl::run(); } } else @@ -228,6 +235,8 @@ std::ostream & ei_print_matrix(std::ostream & s, const Derived& _m, const IOForm return s; } +} // end namespace internal + /** \relates DenseBase * * Outputs the matrix, to the given stream. @@ -244,7 +253,7 @@ std::ostream & operator << (std::ostream & s, const DenseBase & m) { - return ei_print_matrix(s, m.eval(), EIGEN_DEFAULT_IO_FORMAT); + return internal::print_matrix(s, m.eval(), EIGEN_DEFAULT_IO_FORMAT); } #endif // EIGEN_IO_H diff --git a/Eigen/src/Core/Map.h b/Eigen/src/Core/Map.h index 763948453..d163e371a 100644 --- a/Eigen/src/Core/Map.h +++ b/Eigen/src/Core/Map.h @@ -76,9 +76,11 @@ * * \sa Matrix::Map() */ + +namespace internal { template -struct ei_traits > - : public ei_traits +struct traits > + : public traits { typedef typename PlainObjectType::Index Index; typedef typename PlainObjectType::Scalar Scalar; @@ -99,7 +101,7 @@ struct ei_traits > || HasNoOuterStride || ( OuterStrideAtCompileTime!=Dynamic && ((static_cast(sizeof(Scalar))*OuterStrideAtCompileTime)%16)==0 ) ), - Flags0 = ei_traits::Flags, + Flags0 = traits::Flags, Flags1 = IsAligned ? (int(Flags0) | AlignedBit) : (int(Flags0) & ~AlignedBit), Flags2 = HasNoStride ? int(Flags1) : int(Flags1 & ~LinearAccessBit), Flags = KeepsPacketAccess ? int(Flags2) : (int(Flags2) & ~PacketAccessBit) @@ -107,6 +109,7 @@ struct ei_traits > private: enum { Options }; // Expressions don't support Options }; +} template class Map : public MapBase > diff --git a/Eigen/src/Core/MapBase.h b/Eigen/src/Core/MapBase.h index 6b1a25ce2..b1cc3245d 100644 --- a/Eigen/src/Core/MapBase.h +++ b/Eigen/src/Core/MapBase.h @@ -34,22 +34,22 @@ * \sa class Map, class Block */ template class MapBase - : public ei_dense_xpr_base::type + : public internal::dense_xpr_base::type { public: - typedef typename ei_dense_xpr_base::type Base; + typedef typename internal::dense_xpr_base::type Base; enum { - RowsAtCompileTime = ei_traits::RowsAtCompileTime, - ColsAtCompileTime = ei_traits::ColsAtCompileTime, + RowsAtCompileTime = internal::traits::RowsAtCompileTime, + ColsAtCompileTime = internal::traits::ColsAtCompileTime, SizeAtCompileTime = Base::SizeAtCompileTime }; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::Index Index; - typedef typename ei_traits::Scalar Scalar; - typedef typename ei_packet_traits::type PacketScalar; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Index Index; + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::packet_traits::type PacketScalar; typedef typename NumTraits::Real RealScalar; using Base::derived; @@ -111,40 +111,40 @@ template class MapBase inline const Scalar& coeff(Index index) const { - ei_assert(Derived::IsVectorAtCompileTime || (ei_traits::Flags & LinearAccessBit)); + eigen_assert(Derived::IsVectorAtCompileTime || (internal::traits::Flags & LinearAccessBit)); return m_data[index * innerStride()]; } inline Scalar& coeffRef(Index index) { - ei_assert(Derived::IsVectorAtCompileTime || (ei_traits::Flags & LinearAccessBit)); + eigen_assert(Derived::IsVectorAtCompileTime || (internal::traits::Flags & LinearAccessBit)); return const_cast(m_data)[index * innerStride()]; } template inline PacketScalar packet(Index row, Index col) const { - return ei_ploadt + return internal::ploadt (m_data + (col * colStride() + row * rowStride())); } template inline PacketScalar packet(Index index) const { - return ei_ploadt(m_data + index * innerStride()); + return internal::ploadt(m_data + index * innerStride()); } template inline void writePacket(Index row, Index col, const PacketScalar& x) { - ei_pstoret + internal::pstoret (const_cast(m_data) + (col * colStride() + row * rowStride()), x); } template inline void writePacket(Index index, const PacketScalar& x) { - ei_pstoret + internal::pstoret (const_cast(m_data) + index * innerStride(), x); } @@ -160,15 +160,15 @@ template class MapBase m_cols(ColsAtCompileTime == Dynamic ? size : Index(ColsAtCompileTime)) { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) - ei_assert(size >= 0); - ei_assert(data == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == size); + eigen_assert(size >= 0); + eigen_assert(data == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == size); checkSanity(); } inline MapBase(const Scalar* data, Index rows, Index cols) : m_data(data), m_rows(rows), m_cols(cols) { - ei_assert( (data == 0) + eigen_assert( (data == 0) || ( rows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows) && cols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols))); checkSanity(); @@ -186,16 +186,16 @@ template class MapBase void checkSanity() const { - EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(ei_traits::Flags&PacketAccessBit, - ei_inner_stride_at_compile_time::ret==1), + EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(internal::traits::Flags&PacketAccessBit, + internal::inner_stride_at_compile_time::ret==1), PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1); - ei_assert(EIGEN_IMPLIES(ei_traits::Flags&AlignedBit, (size_t(m_data) % (sizeof(Scalar)*ei_packet_traits::size)) == 0) + eigen_assert(EIGEN_IMPLIES(internal::traits::Flags&AlignedBit, (size_t(m_data) % (sizeof(Scalar)*internal::packet_traits::size)) == 0) && "data is not aligned"); } const Scalar* EIGEN_RESTRICT m_data; - const ei_variable_if_dynamic m_rows; - const ei_variable_if_dynamic m_cols; + const internal::variable_if_dynamic m_rows; + const internal::variable_if_dynamic m_cols; }; #endif // EIGEN_MAPBASE_H diff --git a/Eigen/src/Core/MathFunctions.h b/Eigen/src/Core/MathFunctions.h index 53e576258..600545b95 100644 --- a/Eigen/src/Core/MathFunctions.h +++ b/Eigen/src/Core/MathFunctions.h @@ -25,20 +25,22 @@ #ifndef EIGEN_MATHFUNCTIONS_H #define EIGEN_MATHFUNCTIONS_H -/** \internal \struct ei_global_math_functions_filtering_base +namespace internal { + +/** \internal \struct global_math_functions_filtering_base * * What it does: * Defines a typedef 'type' as follows: * - if type T has a member typedef Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl, then - * ei_global_math_functions_filtering_base::type is a typedef for it. - * - otherwise, ei_global_math_functions_filtering_base::type is a typedef for T. + * global_math_functions_filtering_base::type is a typedef for it. + * - otherwise, global_math_functions_filtering_base::type is a typedef for T. * * How it's used: - * To allow to defined the global math functions (like ei_sin...) in certain cases, like the Array expressions. - * When you do ei_sin(array1+array2), the object array1+array2 has a complicated expression type, all what you want to know - * is that it inherits ArrayBase. So we implement a partial specialization of ei_sin_impl for ArrayBase. - * So we must make sure to use ei_sin_impl > and not ei_sin_impl, otherwise our partial specialization - * won't be used. How does ei_sin know that? That's exactly what ei_global_math_functions_filtering_base tells it. + * To allow to defined the global math functions (like sin...) in certain cases, like the Array expressions. + * When you do sin(array1+array2), the object array1+array2 has a complicated expression type, all what you want to know + * is that it inherits ArrayBase. So we implement a partial specialization of sin_impl for ArrayBase. + * So we must make sure to use sin_impl > and not sin_impl, otherwise our partial specialization + * won't be used. How does sin know that? That's exactly what global_math_functions_filtering_base tells it. * * How it's implemented: * SFINAE in the style of enable_if. Highly susceptible of breaking compilers. With GCC, it sure does work, but if you replace @@ -46,32 +48,32 @@ */ template -struct ei_global_math_functions_filtering_base +struct global_math_functions_filtering_base { typedef T type; }; -template struct ei_always_void { typedef void type; }; +template struct always_void { typedef void type; }; template -struct ei_global_math_functions_filtering_base +struct global_math_functions_filtering_base ::type + typename always_void::type > { typedef typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl type; }; -#define EIGEN_MATHFUNC_IMPL(func, scalar) ei_##func##_impl::type> -#define EIGEN_MATHFUNC_RETVAL(func, scalar) typename ei_##func##_retval::type>::type +#define EIGEN_MATHFUNC_IMPL(func, scalar) func##_impl::type> +#define EIGEN_MATHFUNC_RETVAL(func, scalar) typename func##_retval::type>::type /**************************************************************************** -* Implementation of ei_real * +* Implementation of real * ****************************************************************************/ template -struct ei_real_impl +struct real_impl { typedef typename NumTraits::Real RealScalar; static inline RealScalar run(const Scalar& x) @@ -81,7 +83,7 @@ struct ei_real_impl }; template -struct ei_real_impl > +struct real_impl > { static inline RealScalar run(const std::complex& x) { @@ -90,23 +92,23 @@ struct ei_real_impl > }; template -struct ei_real_retval +struct real_retval { typedef typename NumTraits::Real type; }; template -inline EIGEN_MATHFUNC_RETVAL(real, Scalar) ei_real(const Scalar& x) +inline EIGEN_MATHFUNC_RETVAL(real, Scalar) real(const Scalar& x) { return EIGEN_MATHFUNC_IMPL(real, Scalar)::run(x); } /**************************************************************************** -* Implementation of ei_imag * +* Implementation of imag * ****************************************************************************/ template -struct ei_imag_impl +struct imag_impl { typedef typename NumTraits::Real RealScalar; static inline RealScalar run(const Scalar&) @@ -116,7 +118,7 @@ struct ei_imag_impl }; template -struct ei_imag_impl > +struct imag_impl > { static inline RealScalar run(const std::complex& x) { @@ -125,23 +127,23 @@ struct ei_imag_impl > }; template -struct ei_imag_retval +struct imag_retval { typedef typename NumTraits::Real type; }; template -inline EIGEN_MATHFUNC_RETVAL(imag, Scalar) ei_imag(const Scalar& x) +inline EIGEN_MATHFUNC_RETVAL(imag, Scalar) imag(const Scalar& x) { return EIGEN_MATHFUNC_IMPL(imag, Scalar)::run(x); } /**************************************************************************** -* Implementation of ei_real_ref * +* Implementation of real_ref * ****************************************************************************/ template -struct ei_real_ref_impl +struct real_ref_impl { typedef typename NumTraits::Real RealScalar; static inline RealScalar& run(Scalar& x) @@ -155,29 +157,29 @@ struct ei_real_ref_impl }; template -struct ei_real_ref_retval +struct real_ref_retval { typedef typename NumTraits::Real & type; }; template -inline typename ei_makeconst< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) >::type ei_real_ref(const Scalar& x) +inline typename makeconst< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) >::type real_ref(const Scalar& x) { - return ei_real_ref_impl::run(x); + return real_ref_impl::run(x); } template -inline EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) ei_real_ref(Scalar& x) +inline EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) real_ref(Scalar& x) { return EIGEN_MATHFUNC_IMPL(real_ref, Scalar)::run(x); } /**************************************************************************** -* Implementation of ei_imag_ref * +* Implementation of imag_ref * ****************************************************************************/ template -struct ei_imag_ref_default_impl +struct imag_ref_default_impl { typedef typename NumTraits::Real RealScalar; static inline RealScalar& run(Scalar& x) @@ -191,7 +193,7 @@ struct ei_imag_ref_default_impl }; template -struct ei_imag_ref_default_impl +struct imag_ref_default_impl { static inline Scalar run(Scalar&) { @@ -204,32 +206,32 @@ struct ei_imag_ref_default_impl }; template -struct ei_imag_ref_impl : ei_imag_ref_default_impl::IsComplex> {}; +struct imag_ref_impl : imag_ref_default_impl::IsComplex> {}; template -struct ei_imag_ref_retval +struct imag_ref_retval { typedef typename NumTraits::Real & type; }; template -inline typename ei_makeconst< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) >::type ei_imag_ref(const Scalar& x) +inline typename makeconst< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) >::type imag_ref(const Scalar& x) { - return ei_imag_ref_impl::run(x); + return imag_ref_impl::run(x); } template -inline EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) ei_imag_ref(Scalar& x) +inline EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) imag_ref(Scalar& x) { return EIGEN_MATHFUNC_IMPL(imag_ref, Scalar)::run(x); } /**************************************************************************** -* Implementation of ei_conj * +* Implementation of conj * ****************************************************************************/ template -struct ei_conj_impl +struct conj_impl { static inline Scalar run(const Scalar& x) { @@ -238,7 +240,7 @@ struct ei_conj_impl }; template -struct ei_conj_impl > +struct conj_impl > { static inline std::complex run(const std::complex& x) { @@ -247,23 +249,23 @@ struct ei_conj_impl > }; template -struct ei_conj_retval +struct conj_retval { typedef Scalar type; }; template -inline EIGEN_MATHFUNC_RETVAL(conj, Scalar) ei_conj(const Scalar& x) +inline EIGEN_MATHFUNC_RETVAL(conj, Scalar) conj(const Scalar& x) { return EIGEN_MATHFUNC_IMPL(conj, Scalar)::run(x); } /**************************************************************************** -* Implementation of ei_abs * +* Implementation of abs * ****************************************************************************/ template -struct ei_abs_impl +struct abs_impl { typedef typename NumTraits::Real RealScalar; static inline RealScalar run(const Scalar& x) @@ -273,23 +275,23 @@ struct ei_abs_impl }; template -struct ei_abs_retval +struct abs_retval { typedef typename NumTraits::Real type; }; template -inline EIGEN_MATHFUNC_RETVAL(abs, Scalar) ei_abs(const Scalar& x) +inline EIGEN_MATHFUNC_RETVAL(abs, Scalar) abs(const Scalar& x) { return EIGEN_MATHFUNC_IMPL(abs, Scalar)::run(x); } /**************************************************************************** -* Implementation of ei_abs2 * +* Implementation of abs2 * ****************************************************************************/ template -struct ei_abs2_impl +struct abs2_impl { typedef typename NumTraits::Real RealScalar; static inline RealScalar run(const Scalar& x) @@ -299,7 +301,7 @@ struct ei_abs2_impl }; template -struct ei_abs2_impl > +struct abs2_impl > { static inline RealScalar run(const std::complex& x) { @@ -308,92 +310,92 @@ struct ei_abs2_impl > }; template -struct ei_abs2_retval +struct abs2_retval { typedef typename NumTraits::Real type; }; template -inline EIGEN_MATHFUNC_RETVAL(abs2, Scalar) ei_abs2(const Scalar& x) +inline EIGEN_MATHFUNC_RETVAL(abs2, Scalar) abs2(const Scalar& x) { return EIGEN_MATHFUNC_IMPL(abs2, Scalar)::run(x); } /**************************************************************************** -* Implementation of ei_norm1 * +* Implementation of norm1 * ****************************************************************************/ template -struct ei_norm1_default_impl +struct norm1_default_impl { typedef typename NumTraits::Real RealScalar; static inline RealScalar run(const Scalar& x) { - return ei_abs(ei_real(x)) + ei_abs(ei_imag(x)); + return abs(real(x)) + abs(imag(x)); } }; template -struct ei_norm1_default_impl +struct norm1_default_impl { static inline Scalar run(const Scalar& x) { - return ei_abs(x); + return abs(x); } }; template -struct ei_norm1_impl : ei_norm1_default_impl::IsComplex> {}; +struct norm1_impl : norm1_default_impl::IsComplex> {}; template -struct ei_norm1_retval +struct norm1_retval { typedef typename NumTraits::Real type; }; template -inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) ei_norm1(const Scalar& x) +inline EIGEN_MATHFUNC_RETVAL(norm1, Scalar) norm1(const Scalar& x) { return EIGEN_MATHFUNC_IMPL(norm1, Scalar)::run(x); } /**************************************************************************** -* Implementation of ei_hypot * +* Implementation of hypot * ****************************************************************************/ template -struct ei_hypot_impl +struct hypot_impl { typedef typename NumTraits::Real RealScalar; static inline RealScalar run(const Scalar& x, const Scalar& y) { - RealScalar _x = ei_abs(x); - RealScalar _y = ei_abs(y); + RealScalar _x = abs(x); + RealScalar _y = abs(y); RealScalar p = std::max(_x, _y); RealScalar q = std::min(_x, _y); RealScalar qp = q/p; - return p * ei_sqrt(RealScalar(1) + qp*qp); + return p * sqrt(RealScalar(1) + qp*qp); } }; template -struct ei_hypot_retval +struct hypot_retval { typedef typename NumTraits::Real type; }; template -inline EIGEN_MATHFUNC_RETVAL(hypot, Scalar) ei_hypot(const Scalar& x, const Scalar& y) +inline EIGEN_MATHFUNC_RETVAL(hypot, Scalar) hypot(const Scalar& x, const Scalar& y) { return EIGEN_MATHFUNC_IMPL(hypot, Scalar)::run(x, y); } /**************************************************************************** -* Implementation of ei_cast * +* Implementation of cast * ****************************************************************************/ template -struct ei_cast_impl +struct cast_impl { static inline NewType run(const OldType& x) { @@ -401,20 +403,20 @@ struct ei_cast_impl } }; -// here, for once, we're plainly returning NewType: we don't want ei_cast to do weird things. +// here, for once, we're plainly returning NewType: we don't want cast to do weird things. template -inline NewType ei_cast(const OldType& x) +inline NewType cast(const OldType& x) { - return ei_cast_impl::run(x); + return cast_impl::run(x); } /**************************************************************************** -* Implementation of ei_sqrt * +* Implementation of sqrt * ****************************************************************************/ template -struct ei_sqrt_default_impl +struct sqrt_default_impl { static inline Scalar run(const Scalar& x) { @@ -423,7 +425,7 @@ struct ei_sqrt_default_impl }; template -struct ei_sqrt_default_impl +struct sqrt_default_impl { static inline Scalar run(const Scalar&) { @@ -433,26 +435,26 @@ struct ei_sqrt_default_impl }; template -struct ei_sqrt_impl : ei_sqrt_default_impl::IsInteger> {}; +struct sqrt_impl : sqrt_default_impl::IsInteger> {}; template -struct ei_sqrt_retval +struct sqrt_retval { typedef Scalar type; }; template -inline EIGEN_MATHFUNC_RETVAL(sqrt, Scalar) ei_sqrt(const Scalar& x) +inline EIGEN_MATHFUNC_RETVAL(sqrt, Scalar) sqrt(const Scalar& x) { return EIGEN_MATHFUNC_IMPL(sqrt, Scalar)::run(x); } /**************************************************************************** -* Implementation of ei_exp * +* Implementation of exp * ****************************************************************************/ template -struct ei_exp_default_impl +struct exp_default_impl { static inline Scalar run(const Scalar& x) { @@ -461,7 +463,7 @@ struct ei_exp_default_impl }; template -struct ei_exp_default_impl +struct exp_default_impl { static inline Scalar run(const Scalar&) { @@ -471,26 +473,26 @@ struct ei_exp_default_impl }; template -struct ei_exp_impl : ei_exp_default_impl::IsInteger> {}; +struct exp_impl : exp_default_impl::IsInteger> {}; template -struct ei_exp_retval +struct exp_retval { typedef Scalar type; }; template -inline EIGEN_MATHFUNC_RETVAL(exp, Scalar) ei_exp(const Scalar& x) +inline EIGEN_MATHFUNC_RETVAL(exp, Scalar) exp(const Scalar& x) { return EIGEN_MATHFUNC_IMPL(exp, Scalar)::run(x); } /**************************************************************************** -* Implementation of ei_cos * +* Implementation of cos * ****************************************************************************/ template -struct ei_cos_default_impl +struct cos_default_impl { static inline Scalar run(const Scalar& x) { @@ -499,7 +501,7 @@ struct ei_cos_default_impl }; template -struct ei_cos_default_impl +struct cos_default_impl { static inline Scalar run(const Scalar&) { @@ -509,26 +511,26 @@ struct ei_cos_default_impl }; template -struct ei_cos_impl : ei_cos_default_impl::IsInteger> {}; +struct cos_impl : cos_default_impl::IsInteger> {}; template -struct ei_cos_retval +struct cos_retval { typedef Scalar type; }; template -inline EIGEN_MATHFUNC_RETVAL(cos, Scalar) ei_cos(const Scalar& x) +inline EIGEN_MATHFUNC_RETVAL(cos, Scalar) cos(const Scalar& x) { return EIGEN_MATHFUNC_IMPL(cos, Scalar)::run(x); } /**************************************************************************** -* Implementation of ei_sin * +* Implementation of sin * ****************************************************************************/ template -struct ei_sin_default_impl +struct sin_default_impl { static inline Scalar run(const Scalar& x) { @@ -537,7 +539,7 @@ struct ei_sin_default_impl }; template -struct ei_sin_default_impl +struct sin_default_impl { static inline Scalar run(const Scalar&) { @@ -547,26 +549,26 @@ struct ei_sin_default_impl }; template -struct ei_sin_impl : ei_sin_default_impl::IsInteger> {}; +struct sin_impl : sin_default_impl::IsInteger> {}; template -struct ei_sin_retval +struct sin_retval { typedef Scalar type; }; template -inline EIGEN_MATHFUNC_RETVAL(sin, Scalar) ei_sin(const Scalar& x) +inline EIGEN_MATHFUNC_RETVAL(sin, Scalar) sin(const Scalar& x) { return EIGEN_MATHFUNC_IMPL(sin, Scalar)::run(x); } /**************************************************************************** -* Implementation of ei_log * +* Implementation of log * ****************************************************************************/ template -struct ei_log_default_impl +struct log_default_impl { static inline Scalar run(const Scalar& x) { @@ -575,7 +577,7 @@ struct ei_log_default_impl }; template -struct ei_log_default_impl +struct log_default_impl { static inline Scalar run(const Scalar&) { @@ -585,26 +587,26 @@ struct ei_log_default_impl }; template -struct ei_log_impl : ei_log_default_impl::IsInteger> {}; +struct log_impl : log_default_impl::IsInteger> {}; template -struct ei_log_retval +struct log_retval { typedef Scalar type; }; template -inline EIGEN_MATHFUNC_RETVAL(log, Scalar) ei_log(const Scalar& x) +inline EIGEN_MATHFUNC_RETVAL(log, Scalar) log(const Scalar& x) { return EIGEN_MATHFUNC_IMPL(log, Scalar)::run(x); } /**************************************************************************** -* Implementation of ei_atan2 * +* Implementation of atan2 * ****************************************************************************/ template -struct ei_atan2_default_impl +struct atan2_default_impl { typedef Scalar retval; static inline Scalar run(const Scalar& x, const Scalar& y) @@ -614,7 +616,7 @@ struct ei_atan2_default_impl }; template -struct ei_atan2_default_impl +struct atan2_default_impl { static inline Scalar run(const Scalar&, const Scalar&) { @@ -624,26 +626,26 @@ struct ei_atan2_default_impl }; template -struct ei_atan2_impl : ei_atan2_default_impl::IsInteger> {}; +struct atan2_impl : atan2_default_impl::IsInteger> {}; template -struct ei_atan2_retval +struct atan2_retval { typedef Scalar type; }; template -inline EIGEN_MATHFUNC_RETVAL(atan2, Scalar) ei_atan2(const Scalar& x, const Scalar& y) +inline EIGEN_MATHFUNC_RETVAL(atan2, Scalar) atan2(const Scalar& x, const Scalar& y) { return EIGEN_MATHFUNC_IMPL(atan2, Scalar)::run(x, y); } /**************************************************************************** -* Implementation of ei_pow * +* Implementation of pow * ****************************************************************************/ template -struct ei_pow_default_impl +struct pow_default_impl { typedef Scalar retval; static inline Scalar run(const Scalar& x, const Scalar& y) @@ -653,12 +655,12 @@ struct ei_pow_default_impl }; template -struct ei_pow_default_impl +struct pow_default_impl { static inline Scalar run(Scalar x, Scalar y) { Scalar res = 1; - ei_assert(!NumTraits::IsSigned || y >= 0); + eigen_assert(!NumTraits::IsSigned || y >= 0); if(y & 1) res *= x; y >>= 1; while(y) @@ -672,43 +674,43 @@ struct ei_pow_default_impl }; template -struct ei_pow_impl : ei_pow_default_impl::IsInteger> {}; +struct pow_impl : pow_default_impl::IsInteger> {}; template -struct ei_pow_retval +struct pow_retval { typedef Scalar type; }; template -inline EIGEN_MATHFUNC_RETVAL(pow, Scalar) ei_pow(const Scalar& x, const Scalar& y) +inline EIGEN_MATHFUNC_RETVAL(pow, Scalar) pow(const Scalar& x, const Scalar& y) { return EIGEN_MATHFUNC_IMPL(pow, Scalar)::run(x, y); } /**************************************************************************** -* Implementation of ei_random * +* Implementation of random * ****************************************************************************/ template -struct ei_random_default_impl {}; +struct random_default_impl {}; template -struct ei_random_impl : ei_random_default_impl::IsComplex, NumTraits::IsInteger> {}; +struct random_impl : random_default_impl::IsComplex, NumTraits::IsInteger> {}; template -struct ei_random_retval +struct random_retval { typedef Scalar type; }; -template inline EIGEN_MATHFUNC_RETVAL(random, Scalar) ei_random(const Scalar& x, const Scalar& y); -template inline EIGEN_MATHFUNC_RETVAL(random, Scalar) ei_random(); +template inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y); +template inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(); template -struct ei_random_default_impl +struct random_default_impl { static inline Scalar run(const Scalar& x, const Scalar& y) { @@ -721,7 +723,7 @@ struct ei_random_default_impl }; template -struct ei_random_default_impl +struct random_default_impl { static inline Scalar run(const Scalar& x, const Scalar& y) { @@ -734,28 +736,28 @@ struct ei_random_default_impl }; template -struct ei_random_default_impl +struct random_default_impl { static inline Scalar run(const Scalar& x, const Scalar& y) { - return Scalar(ei_random(ei_real(x), ei_real(y)), - ei_random(ei_imag(x), ei_imag(y))); + return Scalar(random(real(x), real(y)), + random(imag(x), imag(y))); } static inline Scalar run() { typedef typename NumTraits::Real RealScalar; - return Scalar(ei_random(), ei_random()); + return Scalar(random(), random()); } }; template -inline EIGEN_MATHFUNC_RETVAL(random, Scalar) ei_random(const Scalar& x, const Scalar& y) +inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y) { return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(x, y); } template -inline EIGEN_MATHFUNC_RETVAL(random, Scalar) ei_random() +inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random() { return EIGEN_MATHFUNC_IMPL(random, Scalar)::run(); } @@ -767,20 +769,20 @@ inline EIGEN_MATHFUNC_RETVAL(random, Scalar) ei_random() template -struct ei_scalar_fuzzy_default_impl {}; +struct scalar_fuzzy_default_impl {}; template -struct ei_scalar_fuzzy_default_impl +struct scalar_fuzzy_default_impl { typedef typename NumTraits::Real RealScalar; template static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec) { - return ei_abs(x) <= ei_abs(y) * prec; + return abs(x) <= abs(y) * prec; } static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec) { - return ei_abs(x - y) <= std::min(ei_abs(x), ei_abs(y)) * prec; + return abs(x - y) <= std::min(abs(x), abs(y)) * prec; } static inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, const RealScalar& prec) { @@ -789,7 +791,7 @@ struct ei_scalar_fuzzy_default_impl }; template -struct ei_scalar_fuzzy_default_impl +struct scalar_fuzzy_default_impl { typedef typename NumTraits::Real RealScalar; template @@ -808,57 +810,57 @@ struct ei_scalar_fuzzy_default_impl }; template -struct ei_scalar_fuzzy_default_impl +struct scalar_fuzzy_default_impl { typedef typename NumTraits::Real RealScalar; template static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, const RealScalar& prec) { - return ei_abs2(x) <= ei_abs2(y) * prec * prec; + return abs2(x) <= abs2(y) * prec * prec; } static inline bool isApprox(const Scalar& x, const Scalar& y, const RealScalar& prec) { - return ei_abs2(x - y) <= std::min(ei_abs2(x), ei_abs2(y)) * prec * prec; + return abs2(x - y) <= std::min(abs2(x), abs2(y)) * prec * prec; } }; template -struct ei_scalar_fuzzy_impl : ei_scalar_fuzzy_default_impl::IsComplex, NumTraits::IsInteger> {}; +struct scalar_fuzzy_impl : scalar_fuzzy_default_impl::IsComplex, NumTraits::IsInteger> {}; template -inline bool ei_isMuchSmallerThan(const Scalar& x, const OtherScalar& y, +inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, typename NumTraits::Real precision = NumTraits::dummy_precision()) { - return ei_scalar_fuzzy_impl::template isMuchSmallerThan(x, y, precision); + return scalar_fuzzy_impl::template isMuchSmallerThan(x, y, precision); } template -inline bool ei_isApprox(const Scalar& x, const Scalar& y, +inline bool isApprox(const Scalar& x, const Scalar& y, typename NumTraits::Real precision = NumTraits::dummy_precision()) { - return ei_scalar_fuzzy_impl::isApprox(x, y, precision); + return scalar_fuzzy_impl::isApprox(x, y, precision); } template -inline bool ei_isApproxOrLessThan(const Scalar& x, const Scalar& y, +inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, typename NumTraits::Real precision = NumTraits::dummy_precision()) { - return ei_scalar_fuzzy_impl::isApproxOrLessThan(x, y, precision); + return scalar_fuzzy_impl::isApproxOrLessThan(x, y, precision); } /****************************************** *** The special case of the bool type *** ******************************************/ -template<> struct ei_random_impl +template<> struct random_impl { static inline bool run() { - return ei_random(0,1)==0 ? false : true; + return random(0,1)==0 ? false : true; } }; -template<> struct ei_scalar_fuzzy_impl +template<> struct scalar_fuzzy_impl { static inline bool isApprox(bool x, bool y, bool) { @@ -866,4 +868,6 @@ template<> struct ei_scalar_fuzzy_impl } }; +} // end namespace internal + #endif // EIGEN_MATHFUNCTIONS_H diff --git a/Eigen/src/Core/Matrix.h b/Eigen/src/Core/Matrix.h index 7bc234453..e0dbd101e 100644 --- a/Eigen/src/Core/Matrix.h +++ b/Eigen/src/Core/Matrix.h @@ -109,8 +109,10 @@ * * \see MatrixBase for the majority of the API methods for matrices, \ref TopicClassHierarchy */ + +namespace internal { template -struct ei_traits > +struct traits > { typedef _Scalar Scalar; typedef Dense StorageKind; @@ -121,13 +123,14 @@ struct ei_traits > ColsAtCompileTime = _Cols, MaxRowsAtCompileTime = _MaxRows, MaxColsAtCompileTime = _MaxCols, - Flags = ei_compute_matrix_flags<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::ret, + Flags = compute_matrix_flags<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::ret, CoeffReadCost = NumTraits::ReadCost, Options = _Options, InnerStrideAtCompileTime = 1, OuterStrideAtCompileTime = (Options&RowMajor) ? ColsAtCompileTime : RowsAtCompileTime }; }; +} template class Matrix @@ -217,8 +220,8 @@ class Matrix } // FIXME is it still needed - Matrix(ei_constructor_without_unaligned_array_assert) - : Base(ei_constructor_without_unaligned_array_assert()) + Matrix(internal::constructor_without_unaligned_array_assert) + : Base(internal::constructor_without_unaligned_array_assert()) { Base::_check_template_params(); EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED } /** \brief Constructs a vector or row-vector with given dimension. \only_for_vectors @@ -232,8 +235,8 @@ class Matrix { Base::_check_template_params(); EIGEN_STATIC_ASSERT_VECTOR_ONLY(Matrix) - ei_assert(dim > 0); - ei_assert(SizeAtCompileTime == Dynamic || SizeAtCompileTime == dim); + eigen_assert(dim > 0); + eigen_assert(SizeAtCompileTime == Dynamic || SizeAtCompileTime == dim); EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED } @@ -340,7 +343,7 @@ class Matrix protected: template - friend struct ei_conservative_resize_like_impl; + friend struct internal::conservative_resize_like_impl; using Base::m_storage; }; diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h index 3e45cdaf1..5ef723e8c 100644 --- a/Eigen/src/Core/MatrixBase.h +++ b/Eigen/src/Core/MatrixBase.h @@ -61,10 +61,10 @@ template class MatrixBase public: #ifndef EIGEN_PARSED_BY_DOXYGEN typedef MatrixBase StorageBaseType; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::Index Index; - typedef typename ei_traits::Scalar Scalar; - typedef typename ei_packet_traits::type PacketScalar; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Index Index; + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::packet_traits::type PacketScalar; typedef typename NumTraits::Real RealScalar; typedef DenseBase Base; @@ -115,30 +115,30 @@ template class MatrixBase * the return type of eval() is a const reference to a matrix, not a matrix! It is however guaranteed * that the return type of eval() is either PlainObject or const PlainObject&. */ - typedef Matrix::Scalar, - ei_traits::RowsAtCompileTime, - ei_traits::ColsAtCompileTime, - AutoAlign | (ei_traits::Flags&RowMajorBit ? RowMajor : ColMajor), - ei_traits::MaxRowsAtCompileTime, - ei_traits::MaxColsAtCompileTime + typedef Matrix::Scalar, + internal::traits::RowsAtCompileTime, + internal::traits::ColsAtCompileTime, + AutoAlign | (internal::traits::Flags&RowMajorBit ? RowMajor : ColMajor), + internal::traits::MaxRowsAtCompileTime, + internal::traits::MaxColsAtCompileTime > PlainObject; #ifndef EIGEN_PARSED_BY_DOXYGEN /** \internal Represents a matrix with all coefficients equal to one another*/ - typedef CwiseNullaryOp,Derived> ConstantReturnType; + typedef CwiseNullaryOp,Derived> ConstantReturnType; /** \internal the return type of MatrixBase::adjoint() */ - typedef typename ei_meta_if::IsComplex, - CwiseUnaryOp, Eigen::Transpose >, + typedef typename internal::meta_if::IsComplex, + CwiseUnaryOp, Eigen::Transpose >, Transpose >::ret AdjointReturnType; /** \internal Return type of eigenvalues() */ - typedef Matrix, ei_traits::ColsAtCompileTime, 1, ColMajor> EigenvaluesReturnType; + typedef Matrix, internal::traits::ColsAtCompileTime, 1, ColMajor> EigenvaluesReturnType; /** \internal the return type of identity */ - typedef CwiseNullaryOp,Derived> IdentityReturnType; + typedef CwiseNullaryOp,Derived> IdentityReturnType; /** \internal the return type of unit vectors */ - typedef Block, SquareMatrixType>, - ei_traits::RowsAtCompileTime, - ei_traits::ColsAtCompileTime> BasisReturnType; + typedef Block, SquareMatrixType>, + internal::traits::RowsAtCompileTime, + internal::traits::ColsAtCompileTime> BasisReturnType; #endif // not EIGEN_PARSED_BY_DOXYGEN #define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::MatrixBase @@ -277,8 +277,8 @@ template class MatrixBase inline const ForceAlignedAccess forceAlignedAccess() const; inline ForceAlignedAccess forceAlignedAccess(); - template inline typename ei_makeconst,Derived&>::ret>::type forceAlignedAccessIf() const; - template inline typename ei_meta_if,Derived&>::ret forceAlignedAccessIf(); + template inline typename internal::makeconst,Derived&>::ret>::type forceAlignedAccessIf() const; + template inline typename internal::meta_if,Derived&>::ret forceAlignedAccessIf(); Scalar trace() const; @@ -299,7 +299,7 @@ template class MatrixBase const FullPivLU fullPivLu() const; const PartialPivLU partialPivLu() const; const PartialPivLU lu() const; - const ei_inverse_impl inverse() const; + const internal::inverse_impl inverse() const; template void computeInverseAndDetWithCheck( ResultType& inverse, @@ -346,9 +346,9 @@ template class MatrixBase SizeMinusOne = SizeAtCompileTime==Dynamic ? Dynamic : SizeAtCompileTime-1 }; typedef Block::ColsAtCompileTime==1 ? SizeMinusOne : 1, - ei_traits::ColsAtCompileTime==1 ? 1 : SizeMinusOne> StartMinusOne; - typedef CwiseUnaryOp::Scalar>, + internal::traits::ColsAtCompileTime==1 ? SizeMinusOne : 1, + internal::traits::ColsAtCompileTime==1 ? 1 : SizeMinusOne> StartMinusOne; + typedef CwiseUnaryOp::Scalar>, StartMinusOne > HNormalizedReturnType; HNormalizedReturnType hnormalized() const; @@ -383,7 +383,7 @@ template class MatrixBase ///////// MatrixFunctions module ///////// - typedef typename ei_stem_function::type StemFunction; + typedef typename internal::stem_function::type StemFunction; const MatrixExponentialReturnValue exp() const; const MatrixFunctionReturnValue matrixFunction(StemFunction f) const; const MatrixFunctionReturnValue cosh() const; diff --git a/Eigen/src/Core/NestByValue.h b/Eigen/src/Core/NestByValue.h index 885002e26..a6104d2a4 100644 --- a/Eigen/src/Core/NestByValue.h +++ b/Eigen/src/Core/NestByValue.h @@ -38,16 +38,19 @@ * * \sa MatrixBase::nestByValue() */ + +namespace internal { template -struct ei_traits > : public ei_traits +struct traits > : public traits {}; +} template class NestByValue - : public ei_dense_xpr_base< NestByValue >::type + : public internal::dense_xpr_base< NestByValue >::type { public: - typedef typename ei_dense_xpr_base::type Base; + typedef typename internal::dense_xpr_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(NestByValue) inline NestByValue(const ExpressionType& matrix) : m_expression(matrix) {} diff --git a/Eigen/src/Core/NoAlias.h b/Eigen/src/Core/NoAlias.h index 53ad3bfee..fe63477bc 100644 --- a/Eigen/src/Core/NoAlias.h +++ b/Eigen/src/Core/NoAlias.h @@ -51,17 +51,17 @@ class NoAlias * \sa MatrixBase::lazyAssign() */ template EIGEN_STRONG_INLINE ExpressionType& operator=(const StorageBase& other) - { return ei_assign_selector::run(m_expression,other.derived()); } + { return internal::assign_selector::run(m_expression,other.derived()); } /** \sa MatrixBase::operator+= */ template EIGEN_STRONG_INLINE ExpressionType& operator+=(const StorageBase& other) { - typedef SelfCwiseBinaryOp, ExpressionType, OtherDerived> SelfAdder; + typedef SelfCwiseBinaryOp, ExpressionType, OtherDerived> SelfAdder; SelfAdder tmp(m_expression); - typedef typename ei_nested::type OtherDerivedNested; - typedef typename ei_cleantype::type _OtherDerivedNested; - ei_assign_selector::run(tmp,OtherDerivedNested(other.derived())); + typedef typename internal::nested::type OtherDerivedNested; + typedef typename internal::cleantype::type _OtherDerivedNested; + internal::assign_selector::run(tmp,OtherDerivedNested(other.derived())); return m_expression; } @@ -69,11 +69,11 @@ class NoAlias template EIGEN_STRONG_INLINE ExpressionType& operator-=(const StorageBase& other) { - typedef SelfCwiseBinaryOp, ExpressionType, OtherDerived> SelfAdder; + typedef SelfCwiseBinaryOp, ExpressionType, OtherDerived> SelfAdder; SelfAdder tmp(m_expression); - typedef typename ei_nested::type OtherDerivedNested; - typedef typename ei_cleantype::type _OtherDerivedNested; - ei_assign_selector::run(tmp,OtherDerivedNested(other.derived())); + typedef typename internal::nested::type OtherDerivedNested; + typedef typename internal::cleantype::type _OtherDerivedNested; + internal::assign_selector::run(tmp,OtherDerivedNested(other.derived())); return m_expression; } diff --git a/Eigen/src/Core/NumTraits.h b/Eigen/src/Core/NumTraits.h index 9e6e35a04..fb7b0b0c4 100644 --- a/Eigen/src/Core/NumTraits.h +++ b/Eigen/src/Core/NumTraits.h @@ -40,7 +40,7 @@ * is a typedef to \a U. * \li A typedef \a NonInteger, giving the type that should be used for operations producing non-integral values, * such as quotients, square roots, etc. If \a T is a floating-point type, then this typedef just gives - * \a T again. Note however that many Eigen functions such as ei_sqrt simply refuse to + * \a T again. Note however that many Eigen functions such as internal::sqrt simply refuse to * take integers. Outside of a few cases, Eigen doesn't do automatic type promotion. Thus, this typedef is * only intended as a helper for code that needs to explicitly promote types. * \li A typedef \a Nested giving the type to use to nest a value inside of the expression tree. If you don't know what @@ -71,9 +71,9 @@ template struct GenericNumTraits }; typedef T Real; - typedef typename ei_meta_if< + typedef typename internal::meta_if< IsInteger, - typename ei_meta_if::ret, + typename internal::meta_if::ret, T >::ret NonInteger; typedef T Nested; diff --git a/Eigen/src/Core/PermutationMatrix.h b/Eigen/src/Core/PermutationMatrix.h index afe37ef6d..9e99b6f91 100644 --- a/Eigen/src/Core/PermutationMatrix.h +++ b/Eigen/src/Core/PermutationMatrix.h @@ -48,20 +48,25 @@ * * \sa class DiagonalMatrix */ -template struct ei_permut_matrix_product_retval; + +namespace internal { + +template struct permut_matrix_product_retval; template -struct ei_traits > - : ei_traits > +struct traits > + : traits > {}; +} // end namespace internal + template class PermutationMatrix : public EigenBase > { public: #ifndef EIGEN_PARSED_BY_DOXYGEN - typedef ei_traits Traits; + typedef internal::traits Traits; typedef Matrix DenseMatrixType; enum { @@ -211,7 +216,7 @@ class PermutationMatrix : public EigenBase=0 && j>=0 && i=0 && j>=0 && i=0 && j>=0 && i=0 && j>=0 && i -inline const ei_permut_matrix_product_retval, Derived, OnTheRight> +inline const internal::permut_matrix_product_retval, Derived, OnTheRight> operator*(const MatrixBase& matrix, const PermutationMatrix &permutation) { - return ei_permut_matrix_product_retval + return internal::permut_matrix_product_retval , Derived, OnTheRight> (permutation, matrix.derived()); } @@ -313,29 +318,31 @@ operator*(const MatrixBase& matrix, /** \returns the matrix with the permutation applied to the rows. */ template -inline const ei_permut_matrix_product_retval +inline const internal::permut_matrix_product_retval , Derived, OnTheLeft> operator*(const PermutationMatrix &permutation, const MatrixBase& matrix) { - return ei_permut_matrix_product_retval + return internal::permut_matrix_product_retval , Derived, OnTheLeft> (permutation, matrix.derived()); } +namespace internal { + template -struct ei_traits > +struct traits > { typedef typename MatrixType::PlainObject ReturnType; }; template -struct ei_permut_matrix_product_retval - : public ReturnByValue > +struct permut_matrix_product_retval + : public ReturnByValue > { - typedef typename ei_cleantype::type MatrixTypeNestedCleaned; + typedef typename cleantype::type MatrixTypeNestedCleaned; - ei_permut_matrix_product_retval(const PermutationType& perm, const MatrixType& matrix) + permut_matrix_product_retval(const PermutationType& perm, const MatrixType& matrix) : m_permutation(perm), m_matrix(matrix) {} @@ -346,7 +353,7 @@ struct ei_permut_matrix_product_retval { const int n = Side==OnTheLeft ? rows() : cols(); - if(ei_is_same_type::ret && ei_extract_data(dst) == ei_extract_data(m_matrix)) + if(is_same_type::ret && extract_data(dst) == extract_data(m_matrix)) { // apply the permutation inplace Matrix mask(m_permutation.size()); @@ -396,10 +403,12 @@ struct ei_permut_matrix_product_retval /* Template partial specialization for transposed/inverse permutations */ template -struct ei_traits > > - : ei_traits > +struct traits > > + : traits > {}; +} // end namespace internal + template class Transpose > : public EigenBase > > @@ -409,7 +418,7 @@ class Transpose > public: #ifndef EIGEN_PARSED_BY_DOXYGEN - typedef ei_traits Traits; + typedef internal::traits Traits; typedef Matrix DenseMatrixType; enum { @@ -446,19 +455,19 @@ class Transpose > /** \returns the matrix with the inverse permutation applied to the columns. */ template friend - inline const ei_permut_matrix_product_retval + inline const internal::permut_matrix_product_retval operator*(const MatrixBase& matrix, const Transpose& trPerm) { - return ei_permut_matrix_product_retval(trPerm.m_permutation, matrix.derived()); + return internal::permut_matrix_product_retval(trPerm.m_permutation, matrix.derived()); } /** \returns the matrix with the inverse permutation applied to the rows. */ template - inline const ei_permut_matrix_product_retval + inline const internal::permut_matrix_product_retval operator*(const MatrixBase& matrix) const { - return ei_permut_matrix_product_retval(m_permutation, matrix.derived()); + return internal::permut_matrix_product_retval(m_permutation, matrix.derived()); } const PermutationType& nestedPermutation() const { return m_permutation; } diff --git a/Eigen/src/Core/PlainObjectBase.h b/Eigen/src/Core/PlainObjectBase.h index 3e2b36be9..0848475b3 100644 --- a/Eigen/src/Core/PlainObjectBase.h +++ b/Eigen/src/Core/PlainObjectBase.h @@ -32,24 +32,29 @@ # define EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED #endif -template (Derived::IsVectorAtCompileTime)> struct ei_conservative_resize_like_impl; -template struct ei_matrix_swap_impl; +namespace internal { + +template (Derived::IsVectorAtCompileTime)> struct conservative_resize_like_impl; + +template struct matrix_swap_impl; + +} // end namespace internal /** * \brief %Dense storage base class for matrices and arrays. * \sa \ref TopicClassHierarchy */ template -class PlainObjectBase : public ei_dense_xpr_base::type +class PlainObjectBase : public internal::dense_xpr_base::type { public: - enum { Options = ei_traits::Options }; - typedef typename ei_dense_xpr_base::type Base; + enum { Options = internal::traits::Options }; + typedef typename internal::dense_xpr_base::type Base; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::Index Index; - typedef typename ei_traits::Scalar Scalar; - typedef typename ei_packet_traits::type PacketScalar; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Index Index; + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::packet_traits::type PacketScalar; typedef typename NumTraits::Real RealScalar; using Base::RowsAtCompileTime; @@ -109,7 +114,7 @@ class PlainObjectBase : public ei_dense_xpr_base::type template EIGEN_STRONG_INLINE PacketScalar packet(Index row, Index col) const { - return ei_ploadt + return internal::ploadt (m_storage.data() + (Flags & RowMajorBit ? col + row * m_storage.cols() : row + col * m_storage.rows())); @@ -118,13 +123,13 @@ class PlainObjectBase : public ei_dense_xpr_base::type template EIGEN_STRONG_INLINE PacketScalar packet(Index index) const { - return ei_ploadt(m_storage.data() + index); + return internal::ploadt(m_storage.data() + index); } template EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketScalar& x) { - ei_pstoret + internal::pstoret (m_storage.data() + (Flags & RowMajorBit ? col + row * m_storage.cols() : row + col * m_storage.rows()), x); @@ -133,7 +138,7 @@ class PlainObjectBase : public ei_dense_xpr_base::type template EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar& x) { - ei_pstoret(m_storage.data() + index, x); + internal::pstoret(m_storage.data() + index, x); } /** \returns a const pointer to the data array of this matrix */ @@ -186,7 +191,7 @@ class PlainObjectBase : public ei_dense_xpr_base::type inline void resize(Index size) { EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase) - ei_assert(SizeAtCompileTime == Dynamic || SizeAtCompileTime == size); + eigen_assert(SizeAtCompileTime == Dynamic || SizeAtCompileTime == size); #ifdef EIGEN_INITIALIZE_MATRICES_BY_ZERO bool size_changed = size != this->size(); #endif @@ -239,12 +244,12 @@ class PlainObjectBase : public ei_dense_xpr_base::type const Index othersize = other.rows()*other.cols(); if(RowsAtCompileTime == 1) { - ei_assert(other.rows() == 1 || other.cols() == 1); + eigen_assert(other.rows() == 1 || other.cols() == 1); resize(1, othersize); } else if(ColsAtCompileTime == 1) { - ei_assert(other.rows() == 1 || other.cols() == 1); + eigen_assert(other.rows() == 1 || other.cols() == 1); resize(othersize, 1); } else resize(other.rows(), other.cols()); @@ -261,7 +266,7 @@ class PlainObjectBase : public ei_dense_xpr_base::type */ EIGEN_STRONG_INLINE void conservativeResize(Index rows, Index cols) { - ei_conservative_resize_like_impl::run(*this, rows, cols); + internal::conservative_resize_like_impl::run(*this, rows, cols); } EIGEN_STRONG_INLINE void conservativeResize(Index rows, NoChange_t) @@ -286,13 +291,13 @@ class PlainObjectBase : public ei_dense_xpr_base::type */ EIGEN_STRONG_INLINE void conservativeResize(Index size) { - ei_conservative_resize_like_impl::run(*this, size); + internal::conservative_resize_like_impl::run(*this, size); } template EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase& other) { - ei_conservative_resize_like_impl::run(*this, other); + internal::conservative_resize_like_impl::run(*this, other); } /** This is a special case of the templated operator=. Its purpose is to @@ -327,8 +332,8 @@ class PlainObjectBase : public ei_dense_xpr_base::type #ifndef EIGEN_PARSED_BY_DOXYGEN // FIXME is it still needed ? /** \internal */ - PlainObjectBase(ei_constructor_without_unaligned_array_assert) - : m_storage(ei_constructor_without_unaligned_array_assert()) + PlainObjectBase(internal::constructor_without_unaligned_array_assert) + : m_storage(internal::constructor_without_unaligned_array_assert()) { // _check_template_params(); EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED } @@ -430,7 +435,7 @@ class PlainObjectBase : public ei_dense_xpr_base::type EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase& other) { #ifdef EIGEN_NO_AUTOMATIC_RESIZING - ei_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.size()) + eigen_assert((this->size()==0 || (IsVectorAtCompileTime ? (this->size() == other.size()) : (rows() == other.rows() && cols() == other.cols()))) && "Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined"); #else @@ -455,15 +460,15 @@ class PlainObjectBase : public ei_dense_xpr_base::type template EIGEN_STRONG_INLINE Derived& _set(const DenseBase& other) { - _set_selector(other.derived(), typename ei_meta_if(int(OtherDerived::Flags) & EvalBeforeAssigningBit), ei_meta_true, ei_meta_false>::ret()); + _set_selector(other.derived(), typename internal::meta_if(int(OtherDerived::Flags) & EvalBeforeAssigningBit), internal::meta_true, internal::meta_false>::ret()); return this->derived(); } template - EIGEN_STRONG_INLINE void _set_selector(const OtherDerived& other, const ei_meta_true&) { _set_noalias(other.eval()); } + EIGEN_STRONG_INLINE void _set_selector(const OtherDerived& other, const internal::meta_true&) { _set_noalias(other.eval()); } template - EIGEN_STRONG_INLINE void _set_selector(const OtherDerived& other, const ei_meta_false&) { _set_noalias(other); } + EIGEN_STRONG_INLINE void _set_selector(const OtherDerived& other, const internal::meta_false&) { _set_noalias(other); } /** \internal Like _set() but additionally makes the assumption that no aliasing effect can happen (which * is the case when creating a new matrix) so one can enforce lazy evaluation. @@ -478,19 +483,19 @@ class PlainObjectBase : public ei_dense_xpr_base::type //_resize_to_match(other); // the 'false' below means to enforce lazy evaluation. We don't use lazyAssign() because // it wouldn't allow to copy a row-vector into a column-vector. - return ei_assign_selector::run(this->derived(), other.derived()); + return internal::assign_selector::run(this->derived(), other.derived()); } template - EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename ei_enable_if::type* = 0) + EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if::type* = 0) { - ei_assert(rows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows) + eigen_assert(rows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows) && cols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)); m_storage.resize(rows*cols,rows,cols); EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED } template - EIGEN_STRONG_INLINE void _init2(const Scalar& x, const Scalar& y, typename ei_enable_if::type* = 0) + EIGEN_STRONG_INLINE void _init2(const Scalar& x, const Scalar& y, typename internal::enable_if::type* = 0) { EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2) m_storage.data()[0] = x; @@ -498,7 +503,7 @@ class PlainObjectBase : public ei_dense_xpr_base::type } template - friend struct ei_matrix_swap_impl; + friend struct internal::matrix_swap_impl; /** \internal generic implementation of swap for dense storage since for dynamic-sized matrices of same type it is enough to swap the * data pointers. @@ -506,8 +511,8 @@ class PlainObjectBase : public ei_dense_xpr_base::type template void _swap(DenseBase EIGEN_REF_TO_TEMPORARY other) { - enum { SwapPointers = ei_is_same_type::ret && Base::SizeAtCompileTime==Dynamic }; - ei_matrix_swap_impl::run(this->derived(), other.const_cast_derived()); + enum { SwapPointers = internal::is_same_type::ret && Base::SizeAtCompileTime==Dynamic }; + internal::matrix_swap_impl::run(this->derived(), other.const_cast_derived()); } public: @@ -529,7 +534,7 @@ class PlainObjectBase : public ei_dense_xpr_base::type }; template -struct ei_conservative_resize_like_impl +struct internal::conservative_resize_like_impl { typedef typename Derived::Index Index; static void run(DenseBase& _this, Index rows, Index cols) @@ -588,8 +593,10 @@ struct ei_conservative_resize_like_impl } }; +namespace internal { + template -struct ei_conservative_resize_like_impl +struct conservative_resize_like_impl { typedef typename Derived::Index Index; static void run(DenseBase& _this, Index size) @@ -615,7 +622,7 @@ struct ei_conservative_resize_like_impl }; template -struct ei_matrix_swap_impl +struct matrix_swap_impl { static inline void run(MatrixTypeA& a, MatrixTypeB& b) { @@ -624,7 +631,7 @@ struct ei_matrix_swap_impl }; template -struct ei_matrix_swap_impl +struct matrix_swap_impl { static inline void run(MatrixTypeA& a, MatrixTypeB& b) { @@ -632,4 +639,6 @@ struct ei_matrix_swap_impl } }; +} // end namespace internal + #endif // EIGEN_DENSESTORAGEBASE_H diff --git a/Eigen/src/Core/Product.h b/Eigen/src/Core/Product.h index 57f7811c8..3bb73fa5f 100644 --- a/Eigen/src/Core/Product.h +++ b/Eigen/src/Core/Product.h @@ -45,20 +45,22 @@ * * \sa ProductReturnType, MatrixBase::operator*(const MatrixBase&) */ -template::value> +template::value> class GeneralProduct; -template struct ei_product_type_selector; - enum { Large = 2, Small = 3 }; -template struct ei_product_type +namespace internal { + +template struct product_type_selector; + +template struct product_type { - typedef typename ei_cleantype::type _Lhs; - typedef typename ei_cleantype::type _Rhs; + typedef typename cleantype::type _Lhs; + typedef typename cleantype::type _Rhs; enum { Rows = _Lhs::MaxRowsAtCompileTime, Cols = _Rhs::MaxColsAtCompileTime, @@ -73,11 +75,11 @@ private: cols_select = Cols == Dynamic || Cols >=EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD ? Large : (Cols==1 ? 1 : Small), depth_select = Depth == Dynamic || Depth>=EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD ? Large : (Depth==1 ? 1 : Small) }; - typedef ei_product_type_selector product_type_selector; + typedef product_type_selector selector; public: enum { - value = product_type_selector::ret + value = selector::ret }; #ifdef EIGEN_DEBUG_PRODUCT static void debug() @@ -93,32 +95,35 @@ public: #endif }; + /* The following allows to select the kind of product at compile time * based on the three dimensions of the product. * This is a compile time mapping from {1,Small,Large}^3 -> {product types} */ // FIXME I'm not sure the current mapping is the ideal one. -template struct ei_product_type_selector { enum { ret = OuterProduct }; }; -template struct ei_product_type_selector<1, 1, Depth> { enum { ret = InnerProduct }; }; -template<> struct ei_product_type_selector<1, 1, 1> { enum { ret = InnerProduct }; }; -template<> struct ei_product_type_selector { enum { ret = CoeffBasedProductMode }; }; -template<> struct ei_product_type_selector<1, Small,Small> { enum { ret = CoeffBasedProductMode }; }; -template<> struct ei_product_type_selector { enum { ret = CoeffBasedProductMode }; }; -template<> struct ei_product_type_selector { enum { ret = LazyCoeffBasedProductMode }; }; -template<> struct ei_product_type_selector { enum { ret = LazyCoeffBasedProductMode }; }; -template<> struct ei_product_type_selector { enum { ret = LazyCoeffBasedProductMode }; }; -template<> struct ei_product_type_selector<1, Large,Small> { enum { ret = CoeffBasedProductMode }; }; -template<> struct ei_product_type_selector<1, Large,Large> { enum { ret = GemvProduct }; }; -template<> struct ei_product_type_selector<1, Small,Large> { enum { ret = CoeffBasedProductMode }; }; -template<> struct ei_product_type_selector { enum { ret = CoeffBasedProductMode }; }; -template<> struct ei_product_type_selector { enum { ret = GemvProduct }; }; -template<> struct ei_product_type_selector { enum { ret = CoeffBasedProductMode }; }; -template<> struct ei_product_type_selector { enum { ret = GemmProduct }; }; -template<> struct ei_product_type_selector { enum { ret = GemmProduct }; }; -template<> struct ei_product_type_selector { enum { ret = GemmProduct }; }; -template<> struct ei_product_type_selector { enum { ret = GemmProduct }; }; -template<> struct ei_product_type_selector { enum { ret = GemmProduct }; }; -template<> struct ei_product_type_selector { enum { ret = GemmProduct }; }; -template<> struct ei_product_type_selector { enum { ret = GemmProduct }; }; +template struct product_type_selector { enum { ret = OuterProduct }; }; +template struct product_type_selector<1, 1, Depth> { enum { ret = InnerProduct }; }; +template<> struct product_type_selector<1, 1, 1> { enum { ret = InnerProduct }; }; +template<> struct product_type_selector { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector<1, Small,Small> { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = LazyCoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = LazyCoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = LazyCoeffBasedProductMode }; }; +template<> struct product_type_selector<1, Large,Small> { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector<1, Large,Large> { enum { ret = GemvProduct }; }; +template<> struct product_type_selector<1, Small,Large> { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = GemvProduct }; }; +template<> struct product_type_selector { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector { enum { ret = GemmProduct }; }; +template<> struct product_type_selector { enum { ret = GemmProduct }; }; +template<> struct product_type_selector { enum { ret = GemmProduct }; }; +template<> struct product_type_selector { enum { ret = GemmProduct }; }; +template<> struct product_type_selector { enum { ret = GemmProduct }; }; +template<> struct product_type_selector { enum { ret = GemmProduct }; }; +template<> struct product_type_selector { enum { ret = GemmProduct }; }; + +} // end namespace internal /** \class ProductReturnType * \ingroup Core_Module @@ -127,7 +132,7 @@ template<> struct ei_product_type_selector { en * * \param Lhs the type of the left-hand side * \param Rhs the type of the right-hand side - * \param ProductMode the type of the product (determined automatically by ei_product_mode) + * \param ProductMode the type of the product (determined automatically by internal::product_mode) * * This class defines the typename Type representing the optimized product expression * between two matrix expressions. In practice, using ProductReturnType::Type @@ -141,8 +146,8 @@ template struct ProductReturnType { // TODO use the nested type to reduce instanciations ???? -// typedef typename ei_nested::type LhsNested; -// typedef typename ei_nested::type RhsNested; +// typedef typename internal::nested::type LhsNested; +// typedef typename internal::nested::type RhsNested; typedef GeneralProduct Type; }; @@ -150,16 +155,16 @@ struct ProductReturnType template struct ProductReturnType { - typedef typename ei_nested::type >::type LhsNested; - typedef typename ei_nested::type >::type RhsNested; + typedef typename internal::nested::type >::type LhsNested; + typedef typename internal::nested::type >::type RhsNested; typedef CoeffBasedProduct Type; }; template struct ProductReturnType { - typedef typename ei_nested::type >::type LhsNested; - typedef typename ei_nested::type >::type RhsNested; + typedef typename internal::nested::type >::type LhsNested; + typedef typename internal::nested::type >::type RhsNested; typedef CoeffBasedProduct Type; }; @@ -179,21 +184,25 @@ struct LazyProductReturnType : public ProductReturnType with: operator=(Scalar x); +namespace internal { + template -struct ei_traits > - : ei_traits::ReturnType,1,1> > +struct traits > + : traits::ReturnType,1,1> > {}; +} + template class GeneralProduct - : ei_no_assignment_operator, - public Matrix::ReturnType,1,1> + : internal::no_assignment_operator, + public Matrix::ReturnType,1,1> { - typedef Matrix::ReturnType,1,1> Base; + typedef Matrix::ReturnType,1,1> Base; public: GeneralProduct(const Lhs& lhs, const Rhs& rhs) { - EIGEN_STATIC_ASSERT((ei_is_same_type::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type::ret), YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) Base::coeffRef(0,0) = (lhs.transpose().cwiseProduct(rhs)).sum(); @@ -210,13 +219,17 @@ class GeneralProduct /*********************************************************************** * Implementation of Outer Vector Vector Product ***********************************************************************/ -template struct ei_outer_product_selector; + +namespace internal { +template struct outer_product_selector; template -struct ei_traits > - : ei_traits, Lhs, Rhs> > +struct traits > + : traits, Lhs, Rhs> > {}; +} + template class GeneralProduct : public ProductBase, Lhs, Rhs> @@ -226,17 +239,19 @@ class GeneralProduct GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs) { - EIGEN_STATIC_ASSERT((ei_is_same_type::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type::ret), YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) } template void scaleAndAddTo(Dest& dest, Scalar alpha) const { - ei_outer_product_selector<(int(Dest::Flags)&RowMajorBit) ? RowMajor : ColMajor>::run(*this, dest, alpha); + internal::outer_product_selector<(int(Dest::Flags)&RowMajorBit) ? RowMajor : ColMajor>::run(*this, dest, alpha); } }; -template<> struct ei_outer_product_selector { +namespace internal { + +template<> struct outer_product_selector { template static EIGEN_DONT_INLINE void run(const ProductType& prod, Dest& dest, typename ProductType::Scalar alpha) { typedef typename Dest::Index Index; @@ -248,7 +263,7 @@ template<> struct ei_outer_product_selector { } }; -template<> struct ei_outer_product_selector { +template<> struct outer_product_selector { template static EIGEN_DONT_INLINE void run(const ProductType& prod, Dest& dest, typename ProductType::Scalar alpha) { typedef typename Dest::Index Index; @@ -260,6 +275,8 @@ template<> struct ei_outer_product_selector { } }; +} // end namespace internal + /*********************************************************************** * Implementation of General Matrix Vector Product ***********************************************************************/ @@ -271,13 +288,17 @@ template<> struct ei_outer_product_selector { * Therefore we need a lower level meta selector. * Furthermore, if the matrix is the rhs, then the product has to be transposed. */ +namespace internal { + template -struct ei_traits > - : ei_traits, Lhs, Rhs> > +struct traits > + : traits, Lhs, Rhs> > {}; template -struct ei_gemv_selector; +struct gemv_selector; + +} // end namespace internal template class GeneralProduct @@ -291,37 +312,39 @@ class GeneralProduct GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs) { -// EIGEN_STATIC_ASSERT((ei_is_same_type::ret), +// EIGEN_STATIC_ASSERT((internal::is_same_type::ret), // YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) } enum { Side = Lhs::IsVectorAtCompileTime ? OnTheLeft : OnTheRight }; - typedef typename ei_meta_if::ret MatrixType; + typedef typename internal::meta_if::ret MatrixType; template void scaleAndAddTo(Dest& dst, Scalar alpha) const { - ei_assert(m_lhs.rows() == dst.rows() && m_rhs.cols() == dst.cols()); - ei_gemv_selector::HasUsableDirectAccess)>::run(*this, dst, alpha); + eigen_assert(m_lhs.rows() == dst.rows() && m_rhs.cols() == dst.cols()); + internal::gemv_selector::HasUsableDirectAccess)>::run(*this, dst, alpha); } }; +namespace internal { + // The vector is on the left => transposition template -struct ei_gemv_selector +struct gemv_selector { template static void run(const ProductType& prod, Dest& dest, typename ProductType::Scalar alpha) { Transpose destT(dest); enum { OtherStorageOrder = StorageOrder == RowMajor ? ColMajor : RowMajor }; - ei_gemv_selector + gemv_selector ::run(GeneralProduct,Transpose, GemvProduct> (prod.rhs().transpose(), prod.lhs().transpose()), destT, alpha); } }; -template<> struct ei_gemv_selector +template<> struct gemv_selector { template static void run(const ProductType& prod, Dest& dest, typename ProductType::Scalar alpha) @@ -344,15 +367,15 @@ template<> struct ei_gemv_selector * RhsBlasTraits::extractScalarFactor(prod.rhs()); enum { - // FIXME find a way to allow an inner stride on the result if ei_packet_traits::size==1 + // FIXME find a way to allow an inner stride on the result if packet_traits::size==1 EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime==1, ComplexByReal = (NumTraits::IsComplex) && (!NumTraits::IsComplex) }; - bool alphaIsCompatible = (!ComplexByReal) || (ei_imag(actualAlpha)==RealScalar(0)); + bool alphaIsCompatible = (!ComplexByReal) || (imag(actualAlpha)==RealScalar(0)); bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible; - RhsScalar compatibleAlpha = ei_get_factor::run(actualAlpha); + RhsScalar compatibleAlpha = get_factor::run(actualAlpha); ResScalar* actualDest; if (evalToDest) @@ -371,7 +394,7 @@ template<> struct ei_gemv_selector MappedDest(actualDest, dest.size()) = dest; } - ei_general_matrix_vector_product + general_matrix_vector_product ::run( actualLhs.rows(), actualLhs.cols(), &actualLhs.const_cast_derived().coeffRef(0,0), actualLhs.outerStride(), @@ -390,7 +413,7 @@ template<> struct ei_gemv_selector } }; -template<> struct ei_gemv_selector +template<> struct gemv_selector { template static void run(const ProductType& prod, Dest& dest, typename ProductType::Scalar alpha) @@ -412,9 +435,9 @@ template<> struct ei_gemv_selector * RhsBlasTraits::extractScalarFactor(prod.rhs()); enum { - // FIXME I think here we really have to check for ei_packet_traits::size==1 + // FIXME I think here we really have to check for packet_traits::size==1 // because in this case it is fine to have an inner stride - DirectlyUseRhs = ((ei_packet_traits::size==1) || (_ActualRhsType::Flags&ActualPacketAccessBit)) + DirectlyUseRhs = ((packet_traits::size==1) || (_ActualRhsType::Flags&ActualPacketAccessBit)) && (!(_ActualRhsType::Flags & RowMajorBit)) }; @@ -427,7 +450,7 @@ template<> struct ei_gemv_selector Map(rhs_data, actualRhs.size()) = actualRhs; } - ei_general_matrix_vector_product + general_matrix_vector_product ::run( actualLhs.rows(), actualLhs.cols(), &actualLhs.const_cast_derived().coeffRef(0,0), actualLhs.outerStride(), @@ -439,7 +462,7 @@ template<> struct ei_gemv_selector } }; -template<> struct ei_gemv_selector +template<> struct gemv_selector { template static void run(const ProductType& prod, Dest& dest, typename ProductType::Scalar alpha) @@ -452,7 +475,7 @@ template<> struct ei_gemv_selector } }; -template<> struct ei_gemv_selector +template<> struct gemv_selector { template static void run(const ProductType& prod, Dest& dest, typename ProductType::Scalar alpha) @@ -465,6 +488,8 @@ template<> struct ei_gemv_selector } }; +} // end namespace internal + /*************************************************************************** * Implementation of matrix base methods ***************************************************************************/ @@ -500,7 +525,7 @@ MatrixBase::operator*(const MatrixBase &other) const INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION) EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT) #ifdef EIGEN_DEBUG_PRODUCT - ei_product_type::debug(); + internal::product_type::debug(); #endif return typename ProductReturnType::Type(derived(), other.derived()); } diff --git a/Eigen/src/Core/ProductBase.h b/Eigen/src/Core/ProductBase.h index bc2a0f743..87702f4db 100644 --- a/Eigen/src/Core/ProductBase.h +++ b/Eigen/src/Core/ProductBase.h @@ -29,29 +29,32 @@ * \ingroup Core_Module * */ + +namespace internal { template -struct ei_traits > +struct traits > { typedef MatrixXpr XprKind; - typedef typename ei_cleantype<_Lhs>::type Lhs; - typedef typename ei_cleantype<_Rhs>::type Rhs; - typedef typename ei_scalar_product_traits::ReturnType Scalar; - typedef typename ei_promote_storage_type::StorageKind, - typename ei_traits::StorageKind>::ret StorageKind; - typedef typename ei_promote_index_type::Index, - typename ei_traits::Index>::type Index; + typedef typename cleantype<_Lhs>::type Lhs; + typedef typename cleantype<_Rhs>::type Rhs; + typedef typename scalar_product_traits::ReturnType Scalar; + typedef typename promote_storage_type::StorageKind, + typename traits::StorageKind>::ret StorageKind; + typedef typename promote_index_type::Index, + typename traits::Index>::type Index; enum { - RowsAtCompileTime = ei_traits::RowsAtCompileTime, - ColsAtCompileTime = ei_traits::ColsAtCompileTime, - MaxRowsAtCompileTime = ei_traits::MaxRowsAtCompileTime, - MaxColsAtCompileTime = ei_traits::MaxColsAtCompileTime, + RowsAtCompileTime = traits::RowsAtCompileTime, + ColsAtCompileTime = traits::ColsAtCompileTime, + MaxRowsAtCompileTime = traits::MaxRowsAtCompileTime, + MaxColsAtCompileTime = traits::MaxColsAtCompileTime, Flags = (MaxRowsAtCompileTime==1 ? RowMajorBit : 0) | EvalBeforeNestingBit | EvalBeforeAssigningBit | NestByRefBit, // Note that EvalBeforeNestingBit and NestByRefBit - // are not used in practice because ei_nested is overloaded for products + // are not used in practice because nested is overloaded for products CoeffReadCost = 0 // FIXME why is it needed ? }; }; +} #define EIGEN_PRODUCT_PUBLIC_INTERFACE(Derived) \ typedef ProductBase Base; \ @@ -77,16 +80,16 @@ class ProductBase : public MatrixBase EIGEN_DENSE_PUBLIC_INTERFACE(ProductBase) protected: typedef typename Lhs::Nested LhsNested; - typedef typename ei_cleantype::type _LhsNested; - typedef ei_blas_traits<_LhsNested> LhsBlasTraits; + typedef typename internal::cleantype::type _LhsNested; + typedef internal::blas_traits<_LhsNested> LhsBlasTraits; typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType; - typedef typename ei_cleantype::type _ActualLhsType; + typedef typename internal::cleantype::type _ActualLhsType; typedef typename Rhs::Nested RhsNested; - typedef typename ei_cleantype::type _RhsNested; - typedef ei_blas_traits<_RhsNested> RhsBlasTraits; + typedef typename internal::cleantype::type _RhsNested; + typedef internal::blas_traits<_RhsNested> RhsBlasTraits; typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType; - typedef typename ei_cleantype::type _ActualRhsType; + typedef typename internal::cleantype::type _ActualRhsType; // Diagonal of a product: no need to evaluate the arguments because they are going to be evaluated only once typedef CoeffBasedProduct FullyLazyCoeffBaseProductType; @@ -98,7 +101,7 @@ class ProductBase : public MatrixBase ProductBase(const Lhs& lhs, const Rhs& rhs) : m_lhs(lhs), m_rhs(rhs) { - ei_assert(lhs.cols() == rhs.rows() + eigen_assert(lhs.cols() == rhs.rows() && "invalid matrix product" && "if you wanted a coeff-wise or a dot product use the respective explicit functions"); } @@ -157,11 +160,13 @@ class ProductBase : public MatrixBase // here we need to overload the nested rule for products // such that the nested type is a const reference to a plain matrix +namespace internal { template -struct ei_nested, N, PlainObject> +struct nested, N, PlainObject> { typedef PlainObject const& type; }; +} template class ScaledProduct; @@ -178,7 +183,7 @@ operator*(const ProductBase& prod, typename Derived::Scalar x) { return ScaledProduct(prod.derived(), x); } template -typename ei_enable_if::ret, +typename internal::enable_if::ret, const ScaledProduct >::type operator*(const ProductBase& prod, typename Derived::RealScalar x) { return ScaledProduct(prod.derived(), x); } @@ -190,20 +195,21 @@ operator*(typename Derived::Scalar x,const ProductBase& prod) { return ScaledProduct(prod.derived(), x); } template -typename ei_enable_if::ret, +typename internal::enable_if::ret, const ScaledProduct >::type operator*(typename Derived::RealScalar x,const ProductBase& prod) { return ScaledProduct(prod.derived(), x); } - +namespace internal { template -struct ei_traits > - : ei_traits, +struct traits > + : traits, typename NestedProduct::_LhsNested, typename NestedProduct::_RhsNested> > { - typedef typename ei_traits::StorageKind StorageKind; + typedef typename traits::StorageKind StorageKind; }; +} template class ScaledProduct diff --git a/Eigen/src/Core/Random.h b/Eigen/src/Core/Random.h index 3c3dc45ab..b7d90103a 100644 --- a/Eigen/src/Core/Random.h +++ b/Eigen/src/Core/Random.h @@ -25,15 +25,20 @@ #ifndef EIGEN_RANDOM_H #define EIGEN_RANDOM_H -template struct ei_scalar_random_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_random_op) +namespace internal { + +template struct scalar_random_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_random_op) template - inline const Scalar operator() (Index, Index = 0) const { return ei_random(); } + inline const Scalar operator() (Index, Index = 0) const { return random(); } }; + template -struct ei_functor_traits > +struct functor_traits > { enum { Cost = 5 * NumTraits::MulCost, PacketAccess = false, IsRepeatable = false }; }; +} // end namespace internal + /** \returns a random matrix expression * * The parameters \a rows and \a cols are the number of rows and of columns of @@ -53,10 +58,10 @@ struct ei_functor_traits > * \sa MatrixBase::setRandom(), MatrixBase::Random(Index), MatrixBase::Random() */ template -inline const CwiseNullaryOp::Scalar>, Derived> +inline const CwiseNullaryOp::Scalar>, Derived> DenseBase::Random(Index rows, Index cols) { - return NullaryExpr(rows, cols, ei_scalar_random_op()); + return NullaryExpr(rows, cols, internal::scalar_random_op()); } /** \returns a random vector expression @@ -80,10 +85,10 @@ DenseBase::Random(Index rows, Index cols) * \sa MatrixBase::setRandom(), MatrixBase::Random(Index,Index), MatrixBase::Random() */ template -inline const CwiseNullaryOp::Scalar>, Derived> +inline const CwiseNullaryOp::Scalar>, Derived> DenseBase::Random(Index size) { - return NullaryExpr(size, ei_scalar_random_op()); + return NullaryExpr(size, internal::scalar_random_op()); } /** \returns a fixed-size random matrix or vector expression @@ -101,10 +106,10 @@ DenseBase::Random(Index size) * \sa MatrixBase::setRandom(), MatrixBase::Random(Index,Index), MatrixBase::Random(Index) */ template -inline const CwiseNullaryOp::Scalar>, Derived> +inline const CwiseNullaryOp::Scalar>, Derived> DenseBase::Random() { - return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, ei_scalar_random_op()); + return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_random_op()); } /** Sets all coefficients in this expression to random values. diff --git a/Eigen/src/Core/Redux.h b/Eigen/src/Core/Redux.h index 504a51229..f5a584cd4 100644 --- a/Eigen/src/Core/Redux.h +++ b/Eigen/src/Core/Redux.h @@ -26,6 +26,8 @@ #ifndef EIGEN_REDUX_H #define EIGEN_REDUX_H +namespace internal { + // TODO // * implement other kind of vectorization // * factorize code @@ -35,11 +37,11 @@ ***************************************************************************/ template -struct ei_redux_traits +struct redux_traits { public: enum { - PacketSize = ei_packet_traits::size, + PacketSize = packet_traits::size, InnerMaxSize = int(Derived::IsRowMajor) ? Derived::MaxColsAtCompileTime : Derived::MaxRowsAtCompileTime @@ -47,7 +49,7 @@ public: enum { MightVectorize = (int(Derived::Flags)&ActualPacketAccessBit) - && (ei_functor_traits::PacketAccess), + && (functor_traits::PacketAccess), MayLinearVectorize = MightVectorize && (int(Derived::Flags)&LinearAccessBit), MaySliceVectorize = MightVectorize && int(InnerMaxSize)>=3*PacketSize }; @@ -63,10 +65,10 @@ public: enum { Cost = ( Derived::SizeAtCompileTime == Dynamic || Derived::CoeffReadCost == Dynamic - || (Derived::SizeAtCompileTime!=1 && ei_functor_traits::Cost == Dynamic) + || (Derived::SizeAtCompileTime!=1 && functor_traits::Cost == Dynamic) ) ? Dynamic : Derived::SizeAtCompileTime * Derived::CoeffReadCost - + (Derived::SizeAtCompileTime-1) * ei_functor_traits::Cost, + + (Derived::SizeAtCompileTime-1) * functor_traits::Cost, UnrollingLimit = EIGEN_UNROLLING_LIMIT * (int(Traversal) == int(DefaultTraversal) ? 1 : int(PacketSize)) }; @@ -85,7 +87,7 @@ public: /*** no vectorization ***/ template -struct ei_redux_novec_unroller +struct redux_novec_unroller { enum { HalfLength = Length/2 @@ -95,13 +97,13 @@ struct ei_redux_novec_unroller EIGEN_STRONG_INLINE static Scalar run(const Derived &mat, const Func& func) { - return func(ei_redux_novec_unroller::run(mat,func), - ei_redux_novec_unroller::run(mat,func)); + return func(redux_novec_unroller::run(mat,func), + redux_novec_unroller::run(mat,func)); } }; template -struct ei_redux_novec_unroller +struct redux_novec_unroller { enum { outer = Start / Derived::InnerSizeAtCompileTime, @@ -120,7 +122,7 @@ struct ei_redux_novec_unroller // to prevent false warnings regarding failed inlining though // for 0 length run() will never be called at all. template -struct ei_redux_novec_unroller +struct redux_novec_unroller { typedef typename Derived::Scalar Scalar; EIGEN_STRONG_INLINE static Scalar run(const Derived&, const Func&) { return Scalar(); } @@ -129,36 +131,36 @@ struct ei_redux_novec_unroller /*** vectorization ***/ template -struct ei_redux_vec_unroller +struct redux_vec_unroller { enum { - PacketSize = ei_packet_traits::size, + PacketSize = packet_traits::size, HalfLength = Length/2 }; typedef typename Derived::Scalar Scalar; - typedef typename ei_packet_traits::type PacketScalar; + typedef typename packet_traits::type PacketScalar; EIGEN_STRONG_INLINE static PacketScalar run(const Derived &mat, const Func& func) { return func.packetOp( - ei_redux_vec_unroller::run(mat,func), - ei_redux_vec_unroller::run(mat,func) ); + redux_vec_unroller::run(mat,func), + redux_vec_unroller::run(mat,func) ); } }; template -struct ei_redux_vec_unroller +struct redux_vec_unroller { enum { - index = Start * ei_packet_traits::size, + index = Start * packet_traits::size, outer = index / int(Derived::InnerSizeAtCompileTime), inner = index % int(Derived::InnerSizeAtCompileTime), alignment = (Derived::Flags & AlignedBit) ? Aligned : Unaligned }; typedef typename Derived::Scalar Scalar; - typedef typename ei_packet_traits::type PacketScalar; + typedef typename packet_traits::type PacketScalar; EIGEN_STRONG_INLINE static PacketScalar run(const Derived &mat, const Func&) { @@ -171,19 +173,19 @@ struct ei_redux_vec_unroller ***************************************************************************/ template::Traversal, - int Unrolling = ei_redux_traits::Unrolling + int Traversal = redux_traits::Traversal, + int Unrolling = redux_traits::Unrolling > -struct ei_redux_impl; +struct redux_impl; template -struct ei_redux_impl +struct redux_impl { typedef typename Derived::Scalar Scalar; typedef typename Derived::Index Index; static EIGEN_STRONG_INLINE Scalar run(const Derived& mat, const Func& func) { - ei_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix"); + eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix"); Scalar res; res = mat.coeffByOuterInner(0, 0); for(Index i = 1; i < mat.innerSize(); ++i) @@ -196,23 +198,23 @@ struct ei_redux_impl }; template -struct ei_redux_impl - : public ei_redux_novec_unroller +struct redux_impl + : public redux_novec_unroller {}; template -struct ei_redux_impl +struct redux_impl { typedef typename Derived::Scalar Scalar; - typedef typename ei_packet_traits::type PacketScalar; + typedef typename packet_traits::type PacketScalar; typedef typename Derived::Index Index; static Scalar run(const Derived& mat, const Func& func) { const Index size = mat.size(); - ei_assert(size && "you are using an empty matrix"); - const Index packetSize = ei_packet_traits::size; - const Index alignedStart = ei_first_aligned(mat); + eigen_assert(size && "you are using an empty matrix"); + const Index packetSize = packet_traits::size; + const Index alignedStart = first_aligned(mat); enum { alignment = (Derived::Flags & DirectAccessBit) || (Derived::Flags & AlignedBit) ? Aligned : Unaligned @@ -246,19 +248,19 @@ struct ei_redux_impl }; template -struct ei_redux_impl +struct redux_impl { typedef typename Derived::Scalar Scalar; - typedef typename ei_packet_traits::type PacketScalar; + typedef typename packet_traits::type PacketScalar; typedef typename Derived::Index Index; static Scalar run(const Derived& mat, const Func& func) { - ei_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix"); + eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix"); const Index innerSize = mat.innerSize(); const Index outerSize = mat.outerSize(); enum { - packetSize = ei_packet_traits::size + packetSize = packet_traits::size }; const Index packetedInnerSize = ((innerSize)/packetSize)*packetSize; Scalar res; @@ -277,7 +279,7 @@ struct ei_redux_impl else // too small to vectorize anything. // since this is dynamic-size hence inefficient anyway for such small sizes, don't try to optimize. { - res = ei_redux_impl::run(mat, func); + res = redux_impl::run(mat, func); } return res; @@ -285,25 +287,31 @@ struct ei_redux_impl }; template -struct ei_redux_impl +struct redux_impl { typedef typename Derived::Scalar Scalar; - typedef typename ei_packet_traits::type PacketScalar; + typedef typename packet_traits::type PacketScalar; enum { - PacketSize = ei_packet_traits::size, + PacketSize = packet_traits::size, Size = Derived::SizeAtCompileTime, VectorizedSize = (Size / PacketSize) * PacketSize }; EIGEN_STRONG_INLINE static Scalar run(const Derived& mat, const Func& func) { - ei_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix"); - Scalar res = func.predux(ei_redux_vec_unroller::run(mat,func)); + eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix"); + Scalar res = func.predux(redux_vec_unroller::run(mat,func)); if (VectorizedSize != Size) - res = func(res,ei_redux_novec_unroller::run(mat,func)); + res = func(res,redux_novec_unroller::run(mat,func)); return res; } }; +} // end namespace internal + +/*************************************************************************** +* Part 4 : public API +***************************************************************************/ + /** \returns the result of a full redux operation on the whole matrix or vector using \a func * @@ -314,30 +322,30 @@ struct ei_redux_impl template -EIGEN_STRONG_INLINE typename ei_result_of::Scalar)>::type +EIGEN_STRONG_INLINE typename internal::result_of::Scalar)>::type DenseBase::redux(const Func& func) const { - typedef typename ei_cleantype::type ThisNested; - return ei_redux_impl + typedef typename internal::cleantype::type ThisNested; + return internal::redux_impl ::run(derived(), func); } /** \returns the minimum of all coefficients of *this */ template -EIGEN_STRONG_INLINE typename ei_traits::Scalar +EIGEN_STRONG_INLINE typename internal::traits::Scalar DenseBase::minCoeff() const { - return this->redux(Eigen::ei_scalar_min_op()); + return this->redux(Eigen::internal::scalar_min_op()); } /** \returns the maximum of all coefficients of *this */ template -EIGEN_STRONG_INLINE typename ei_traits::Scalar +EIGEN_STRONG_INLINE typename internal::traits::Scalar DenseBase::maxCoeff() const { - return this->redux(Eigen::ei_scalar_max_op()); + return this->redux(Eigen::internal::scalar_max_op()); } /** \returns the sum of all coefficients of *this @@ -345,12 +353,12 @@ DenseBase::maxCoeff() const * \sa trace(), prod(), mean() */ template -EIGEN_STRONG_INLINE typename ei_traits::Scalar +EIGEN_STRONG_INLINE typename internal::traits::Scalar DenseBase::sum() const { if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0)) return Scalar(0); - return this->redux(Eigen::ei_scalar_sum_op()); + return this->redux(Eigen::internal::scalar_sum_op()); } /** \returns the mean of all coefficients of *this @@ -358,10 +366,10 @@ DenseBase::sum() const * \sa trace(), prod(), sum() */ template -EIGEN_STRONG_INLINE typename ei_traits::Scalar +EIGEN_STRONG_INLINE typename internal::traits::Scalar DenseBase::mean() const { - return Scalar(this->redux(Eigen::ei_scalar_sum_op())) / Scalar(this->size()); + return Scalar(this->redux(Eigen::internal::scalar_sum_op())) / Scalar(this->size()); } /** \returns the product of all coefficients of *this @@ -372,12 +380,12 @@ DenseBase::mean() const * \sa sum(), mean(), trace() */ template -EIGEN_STRONG_INLINE typename ei_traits::Scalar +EIGEN_STRONG_INLINE typename internal::traits::Scalar DenseBase::prod() const { if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0)) return Scalar(1); - return this->redux(Eigen::ei_scalar_product_op()); + return this->redux(Eigen::internal::scalar_product_op()); } /** \returns the trace of \c *this, i.e. the sum of the coefficients on the main diagonal. @@ -387,7 +395,7 @@ DenseBase::prod() const * \sa diagonal(), sum() */ template -EIGEN_STRONG_INLINE typename ei_traits::Scalar +EIGEN_STRONG_INLINE typename internal::traits::Scalar MatrixBase::trace() const { return derived().diagonal().sum(); diff --git a/Eigen/src/Core/Replicate.h b/Eigen/src/Core/Replicate.h index 87dea0533..d5022c2cd 100644 --- a/Eigen/src/Core/Replicate.h +++ b/Eigen/src/Core/Replicate.h @@ -39,15 +39,17 @@ * * \sa DenseBase::replicate() */ + +namespace internal { template -struct ei_traits > - : ei_traits +struct traits > + : traits { typedef typename MatrixType::Scalar Scalar; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::XprKind XprKind; - typedef typename ei_nested::type MatrixTypeNested; - typedef typename ei_unref::type _MatrixTypeNested; + typedef typename traits::StorageKind StorageKind; + typedef typename traits::XprKind XprKind; + typedef typename nested::type MatrixTypeNested; + typedef typename unref::type _MatrixTypeNested; enum { RowsAtCompileTime = RowFactor==Dynamic || int(MatrixType::RowsAtCompileTime)==Dynamic ? Dynamic @@ -65,29 +67,30 @@ struct ei_traits > CoeffReadCost = _MatrixTypeNested::CoeffReadCost }; }; +} template class Replicate - : public ei_dense_xpr_base< Replicate >::type + : public internal::dense_xpr_base< Replicate >::type { public: - typedef typename ei_dense_xpr_base::type Base; + typedef typename internal::dense_xpr_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(Replicate) template inline explicit Replicate(const OriginalMatrixType& matrix) : m_matrix(matrix), m_rowFactor(RowFactor), m_colFactor(ColFactor) { - EIGEN_STATIC_ASSERT((ei_is_same_type::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type::ret), THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE) - ei_assert(RowFactor!=Dynamic && ColFactor!=Dynamic); + eigen_assert(RowFactor!=Dynamic && ColFactor!=Dynamic); } template inline Replicate(const OriginalMatrixType& matrix, int rowFactor, int colFactor) : m_matrix(matrix), m_rowFactor(rowFactor), m_colFactor(colFactor) { - EIGEN_STATIC_ASSERT((ei_is_same_type::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type::ret), THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE) } @@ -97,10 +100,10 @@ template class Replicate inline Scalar coeff(Index row, Index col) const { // try to avoid using modulo; this is a pure optimization strategy - const Index actual_row = ei_traits::RowsAtCompileTime==1 ? 0 + const Index actual_row = internal::traits::RowsAtCompileTime==1 ? 0 : RowFactor==1 ? row : row%m_matrix.rows(); - const Index actual_col = ei_traits::ColsAtCompileTime==1 ? 0 + const Index actual_col = internal::traits::ColsAtCompileTime==1 ? 0 : ColFactor==1 ? col : col%m_matrix.cols(); @@ -109,10 +112,10 @@ template class Replicate template inline PacketScalar packet(Index row, Index col) const { - const Index actual_row = ei_traits::RowsAtCompileTime==1 ? 0 + const Index actual_row = internal::traits::RowsAtCompileTime==1 ? 0 : RowFactor==1 ? row : row%m_matrix.rows(); - const Index actual_col = ei_traits::ColsAtCompileTime==1 ? 0 + const Index actual_col = internal::traits::ColsAtCompileTime==1 ? 0 : ColFactor==1 ? col : col%m_matrix.cols(); @@ -122,8 +125,8 @@ template class Replicate protected: const typename MatrixType::Nested m_matrix; - const ei_variable_if_dynamic m_rowFactor; - const ei_variable_if_dynamic m_colFactor; + const internal::variable_if_dynamic m_rowFactor; + const internal::variable_if_dynamic m_colFactor; }; /** diff --git a/Eigen/src/Core/ReturnByValue.h b/Eigen/src/Core/ReturnByValue.h index 82f194b56..c0d65f5cb 100644 --- a/Eigen/src/Core/ReturnByValue.h +++ b/Eigen/src/Core/ReturnByValue.h @@ -30,36 +30,43 @@ * \ingroup Core_Module * */ + +namespace internal { + template -struct ei_traits > - : public ei_traits::ReturnType> +struct traits > + : public traits::ReturnType> { enum { // We're disabling the DirectAccess because e.g. the constructor of // the Block-with-DirectAccess expression requires to have a coeffRef method. // Also, we don't want to have to implement the stride stuff. - Flags = (ei_traits::ReturnType>::Flags + Flags = (traits::ReturnType>::Flags | EvalBeforeNestingBit) & ~DirectAccessBit }; }; /* The ReturnByValue object doesn't even have a coeff() method. * So the only way that nesting it in an expression can work, is by evaluating it into a plain matrix. - * So ei_nested always gives the plain return matrix type. + * So internal::nested always gives the plain return matrix type. + * + * FIXME: I don't understand why we need this specialization: isn't this taken care of by the EvalBeforeNestingBit ?? */ template -struct ei_nested, n, PlainObject> +struct nested, n, PlainObject> { - typedef typename ei_traits::ReturnType type; + typedef typename traits::ReturnType type; }; +} // end namespace internal + template class ReturnByValue - : public ei_dense_xpr_base< ReturnByValue >::type + : public internal::dense_xpr_base< ReturnByValue >::type { public: - typedef typename ei_traits::ReturnType ReturnType; + typedef typename internal::traits::ReturnType ReturnType; - typedef typename ei_dense_xpr_base::type Base; + typedef typename internal::dense_xpr_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(ReturnByValue) template diff --git a/Eigen/src/Core/Reverse.h b/Eigen/src/Core/Reverse.h index abc44bde6..13fdc50a7 100644 --- a/Eigen/src/Core/Reverse.h +++ b/Eigen/src/Core/Reverse.h @@ -40,15 +40,18 @@ * * \sa MatrixBase::reverse(), VectorwiseOp::reverse() */ + +namespace internal { + template -struct ei_traits > - : ei_traits +struct traits > + : traits { typedef typename MatrixType::Scalar Scalar; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::XprKind XprKind; - typedef typename ei_nested::type MatrixTypeNested; - typedef typename ei_unref::type _MatrixTypeNested; + typedef typename traits::StorageKind StorageKind; + typedef typename traits::XprKind XprKind; + typedef typename nested::type MatrixTypeNested; + typedef typename unref::type _MatrixTypeNested; enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime, @@ -65,21 +68,24 @@ struct ei_traits > }; }; -template struct ei_reverse_packet_cond +template struct reverse_packet_cond { - static inline PacketScalar run(const PacketScalar& x) { return ei_preverse(x); } + static inline PacketScalar run(const PacketScalar& x) { return preverse(x); } }; -template struct ei_reverse_packet_cond + +template struct reverse_packet_cond { static inline PacketScalar run(const PacketScalar& x) { return x; } }; +} // end namespace internal + template class Reverse - : public ei_dense_xpr_base< Reverse >::type + : public internal::dense_xpr_base< Reverse >::type { public: - typedef typename ei_dense_xpr_base::type Base; + typedef typename internal::dense_xpr_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(Reverse) using Base::IsRowMajor; @@ -89,7 +95,7 @@ template class Reverse protected: enum { - PacketSize = ei_packet_traits::size, + PacketSize = internal::packet_traits::size, IsColMajor = !IsRowMajor, ReverseRow = (Direction == Vertical) || (Direction == BothDirections), ReverseCol = (Direction == Horizontal) || (Direction == BothDirections), @@ -99,7 +105,7 @@ template class Reverse || ((Direction == Vertical) && IsColMajor) || ((Direction == Horizontal) && IsRowMajor) }; - typedef ei_reverse_packet_cond reverse_packet; + typedef internal::reverse_packet_cond reverse_packet; public: inline Reverse(const MatrixType& matrix) : m_matrix(matrix) { } @@ -116,7 +122,7 @@ template class Reverse inline Scalar& operator()(Index row, Index col) { - ei_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); + eigen_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); return coeffRef(row, col); } @@ -144,7 +150,7 @@ template class Reverse inline Scalar& operator()(Index index) { - ei_assert(index >= 0 && index < m_matrix.size()); + eigen_assert(index >= 0 && index < m_matrix.size()); return coeffRef(index); } @@ -168,13 +174,13 @@ template class Reverse template inline const PacketScalar packet(Index index) const { - return ei_preverse(m_matrix.template packet( m_matrix.size() - index - PacketSize )); + return internal::preverse(m_matrix.template packet( m_matrix.size() - index - PacketSize )); } template inline void writePacket(Index index, const PacketScalar& x) { - m_matrix.const_cast_derived().template writePacket(m_matrix.size() - index - PacketSize, ei_preverse(x)); + m_matrix.const_cast_derived().template writePacket(m_matrix.size() - index - PacketSize, internal::preverse(x)); } protected: diff --git a/Eigen/src/Core/Select.h b/Eigen/src/Core/Select.h index 000c70905..bad6a74f9 100644 --- a/Eigen/src/Core/Select.h +++ b/Eigen/src/Core/Select.h @@ -40,13 +40,14 @@ * \sa DenseBase::select(const DenseBase&, const DenseBase&) const */ +namespace internal { template -struct ei_traits > - : ei_traits +struct traits > + : traits { - typedef typename ei_traits::Scalar Scalar; + typedef typename traits::Scalar Scalar; typedef Dense StorageKind; - typedef typename ei_traits::XprKind XprKind; + typedef typename traits::XprKind XprKind; typedef typename ConditionMatrixType::Nested ConditionMatrixNested; typedef typename ThenMatrixType::Nested ThenMatrixNested; typedef typename ElseMatrixType::Nested ElseMatrixNested; @@ -56,19 +57,20 @@ struct ei_traits > MaxRowsAtCompileTime = ConditionMatrixType::MaxRowsAtCompileTime, MaxColsAtCompileTime = ConditionMatrixType::MaxColsAtCompileTime, Flags = (unsigned int)ThenMatrixType::Flags & ElseMatrixType::Flags & HereditaryBits, - CoeffReadCost = ei_traits::type>::CoeffReadCost - + EIGEN_SIZE_MAX(ei_traits::type>::CoeffReadCost, - ei_traits::type>::CoeffReadCost) + CoeffReadCost = traits::type>::CoeffReadCost + + EIGEN_SIZE_MAX(traits::type>::CoeffReadCost, + traits::type>::CoeffReadCost) }; }; +} template -class Select : ei_no_assignment_operator, - public ei_dense_xpr_base< Select >::type +class Select : internal::no_assignment_operator, + public internal::dense_xpr_base< Select >::type { public: - typedef typename ei_dense_xpr_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(Select) Select(const ConditionMatrixType& conditionMatrix, @@ -76,8 +78,8 @@ class Select : ei_no_assignment_operator, const ElseMatrixType& elseMatrix) : m_condition(conditionMatrix), m_then(thenMatrix), m_else(elseMatrix) { - ei_assert(m_condition.rows() == m_then.rows() && m_condition.rows() == m_else.rows()); - ei_assert(m_condition.cols() == m_then.cols() && m_condition.cols() == m_else.cols()); + eigen_assert(m_condition.rows() == m_then.rows() && m_condition.rows() == m_else.rows()); + eigen_assert(m_condition.cols() == m_then.cols() && m_condition.cols() == m_else.cols()); } Index rows() const { return m_condition.rows(); } diff --git a/Eigen/src/Core/SelfAdjointView.h b/Eigen/src/Core/SelfAdjointView.h index d72a94e15..489240dd9 100644 --- a/Eigen/src/Core/SelfAdjointView.h +++ b/Eigen/src/Core/SelfAdjointView.h @@ -40,11 +40,13 @@ * * \sa class TriangularBase, MatrixBase::selfAdjointView() */ + +namespace internal { template -struct ei_traits > : ei_traits +struct traits > : traits { - typedef typename ei_nested::type MatrixTypeNested; - typedef typename ei_unref::type _MatrixTypeNested; + typedef typename nested::type MatrixTypeNested; + typedef typename unref::type _MatrixTypeNested; typedef MatrixType ExpressionType; enum { Mode = UpLo | SelfAdjoint, @@ -53,6 +55,7 @@ struct ei_traits > : ei_traits CoeffReadCost = _MatrixTypeNested::CoeffReadCost }; }; +} template @@ -67,17 +70,17 @@ template class SelfAdjointView typedef TriangularBase Base; /** \brief The type of coefficients in this matrix */ - typedef typename ei_traits::Scalar Scalar; + typedef typename internal::traits::Scalar Scalar; typedef typename MatrixType::Index Index; enum { - Mode = ei_traits::Mode + Mode = internal::traits::Mode }; typedef typename MatrixType::PlainObject PlainObject; inline SelfAdjointView(const MatrixType& matrix) : m_matrix(matrix) - { ei_assert(ei_are_flags_consistent::ret); } + { eigen_assert(internal::are_flags_consistent::ret); } inline Index rows() const { return m_matrix.rows(); } inline Index cols() const { return m_matrix.cols(); } @@ -164,7 +167,7 @@ template class SelfAdjointView /** Real part of #Scalar */ typedef typename NumTraits::Real RealScalar; /** Return type of eigenvalues() */ - typedef Matrix::ColsAtCompileTime, 1> EigenvaluesReturnType; + typedef Matrix::ColsAtCompileTime, 1> EigenvaluesReturnType; EigenvaluesReturnType eigenvalues() const; RealScalar operatorNorm() const; @@ -175,16 +178,18 @@ template class SelfAdjointView // template -// ei_selfadjoint_matrix_product_returntype > +// internal::selfadjoint_matrix_product_returntype > // operator*(const MatrixBase& lhs, const SelfAdjointView& rhs) // { -// return ei_matrix_selfadjoint_product_returntype >(lhs.derived(),rhs); +// return internal::matrix_selfadjoint_product_returntype >(lhs.derived(),rhs); // } // selfadjoint to dense matrix +namespace internal { + template -struct ei_triangular_assignment_selector +struct triangular_assignment_selector { enum { col = (UnrollCount-1) / Derived1::RowsAtCompileTime, @@ -193,23 +198,23 @@ struct ei_triangular_assignment_selector::run(dst, src); + triangular_assignment_selector::run(dst, src); if(row == col) - dst.coeffRef(row, col) = ei_real(src.coeff(row, col)); + dst.coeffRef(row, col) = real(src.coeff(row, col)); else if(row < col) - dst.coeffRef(col, row) = ei_conj(dst.coeffRef(row, col) = src.coeff(row, col)); + dst.coeffRef(col, row) = conj(dst.coeffRef(row, col) = src.coeff(row, col)); } }; template -struct ei_triangular_assignment_selector +struct triangular_assignment_selector { inline static void run(Derived1 &, const Derived2 &) {} }; template -struct ei_triangular_assignment_selector +struct triangular_assignment_selector { enum { col = (UnrollCount-1) / Derived1::RowsAtCompileTime, @@ -218,23 +223,23 @@ struct ei_triangular_assignment_selector::run(dst, src); + triangular_assignment_selector::run(dst, src); if(row == col) - dst.coeffRef(row, col) = ei_real(src.coeff(row, col)); + dst.coeffRef(row, col) = real(src.coeff(row, col)); else if(row > col) - dst.coeffRef(col, row) = ei_conj(dst.coeffRef(row, col) = src.coeff(row, col)); + dst.coeffRef(col, row) = conj(dst.coeffRef(row, col) = src.coeff(row, col)); } }; template -struct ei_triangular_assignment_selector +struct triangular_assignment_selector { inline static void run(Derived1 &, const Derived2 &) {} }; template -struct ei_triangular_assignment_selector +struct triangular_assignment_selector { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -244,7 +249,7 @@ struct ei_triangular_assignment_selector -struct ei_triangular_assignment_selector +struct triangular_assignment_selector { inline static void run(Derived1 &dst, const Derived2 &src) { @@ -262,13 +267,15 @@ struct ei_triangular_assignment_selector -struct ei_traits > - : ei_traits > +struct traits > + : traits > { enum { // Note that it is still a good idea to preserve the DirectAccessBit // so that assign can correctly align the data. - Flags = ei_traits >::Flags | (Lhs::Flags&DirectAccessBit) | (Lhs::Flags&LvalueBit), + Flags = traits >::Flags | (Lhs::Flags&DirectAccessBit) | (Lhs::Flags&LvalueBit), OuterStrideAtCompileTime = Lhs::OuterStrideAtCompileTime, InnerStrideAtCompileTime = Lhs::InnerStrideAtCompileTime }; }; +} template class SelfCwiseBinaryOp - : public ei_dense_xpr_base< SelfCwiseBinaryOp >::type + : public internal::dense_xpr_base< SelfCwiseBinaryOp >::type { public: - typedef typename ei_dense_xpr_base::type Base; + typedef typename internal::dense_xpr_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(SelfCwiseBinaryOp) - typedef typename ei_packet_traits::type Packet; + typedef typename internal::packet_traits::type Packet; inline SelfCwiseBinaryOp(Lhs& xpr, const BinaryOp& func = BinaryOp()) : m_matrix(xpr), m_functor(func) {} @@ -88,7 +91,7 @@ template class SelfCwiseBinaryOp void copyCoeff(Index row, Index col, const DenseBase& other) { OtherDerived& _other = other.const_cast_derived(); - ei_internal_assert(row >= 0 && row < rows() + eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); Scalar& tmp = m_matrix.coeffRef(row,col); tmp = m_functor(tmp, _other.coeff(row,col)); @@ -98,7 +101,7 @@ template class SelfCwiseBinaryOp void copyCoeff(Index index, const DenseBase& other) { OtherDerived& _other = other.const_cast_derived(); - ei_internal_assert(index >= 0 && index < m_matrix.size()); + eigen_internal_assert(index >= 0 && index < m_matrix.size()); Scalar& tmp = m_matrix.coeffRef(index); tmp = m_functor(tmp, _other.coeff(index)); } @@ -107,7 +110,7 @@ template class SelfCwiseBinaryOp void copyPacket(Index row, Index col, const DenseBase& other) { OtherDerived& _other = other.const_cast_derived(); - ei_internal_assert(row >= 0 && row < rows() + eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); m_matrix.template writePacket(row, col, m_functor.packetOp(m_matrix.template packet(row, col),_other.template packet(row, col)) ); @@ -117,7 +120,7 @@ template class SelfCwiseBinaryOp void copyPacket(Index index, const DenseBase& other) { OtherDerived& _other = other.const_cast_derived(); - ei_internal_assert(index >= 0 && index < m_matrix.size()); + eigen_internal_assert(index >= 0 && index < m_matrix.size()); m_matrix.template writePacket(index, m_functor.packetOp(m_matrix.template packet(index),_other.template packet(index)) ); } @@ -131,10 +134,10 @@ template class SelfCwiseBinaryOp EIGEN_CHECK_BINARY_COMPATIBILIY(BinaryOp,typename Lhs::Scalar,typename RhsDerived::Scalar); #ifdef EIGEN_DEBUG_ASSIGN - ei_assign_traits::debug(); + internal::assign_traits::debug(); #endif - ei_assert(rows() == rhs.rows() && cols() == rhs.cols()); - ei_assign_impl::run(*this,rhs.derived()); + eigen_assert(rows() == rhs.rows() && cols() == rhs.cols()); + internal::assign_impl::run(*this,rhs.derived()); #ifndef EIGEN_NO_DEBUG this->checkTransposeAliasing(rhs.derived()); #endif @@ -146,7 +149,7 @@ template class SelfCwiseBinaryOp // at first... SelfCwiseBinaryOp& operator=(const Rhs& _rhs) { - typename ei_nested::type rhs(_rhs); + typename internal::nested::type rhs(_rhs); return Base::operator=(rhs); } @@ -162,7 +165,7 @@ template inline Derived& DenseBase::operator*=(const Scalar& other) { typedef typename Derived::PlainObject PlainObject; - SelfCwiseBinaryOp, Derived, typename PlainObject::ConstantReturnType> tmp(derived()); + SelfCwiseBinaryOp, Derived, typename PlainObject::ConstantReturnType> tmp(derived()); tmp = PlainObject::Constant(rows(),cols(),other); return derived(); } @@ -170,9 +173,9 @@ inline Derived& DenseBase::operator*=(const Scalar& other) template inline Derived& DenseBase::operator/=(const Scalar& other) { - typedef typename ei_meta_if::IsInteger, - ei_scalar_quotient_op, - ei_scalar_product_op >::ret BinOp; + typedef typename internal::meta_if::IsInteger, + internal::scalar_quotient_op, + internal::scalar_product_op >::ret BinOp; typedef typename Derived::PlainObject PlainObject; SelfCwiseBinaryOp tmp(derived()); tmp = PlainObject::Constant(rows(),cols(), NumTraits::IsInteger ? other : Scalar(1)/other); diff --git a/Eigen/src/Core/SolveTriangular.h b/Eigen/src/Core/SolveTriangular.h index 960da31f3..0b9d3db9d 100644 --- a/Eigen/src/Core/SolveTriangular.h +++ b/Eigen/src/Core/SolveTriangular.h @@ -25,8 +25,10 @@ #ifndef EIGEN_SOLVETRIANGULAR_H #define EIGEN_SOLVETRIANGULAR_H +namespace internal { + template -class ei_trsolve_traits +class trsolve_traits { private: enum { @@ -43,19 +45,19 @@ class ei_trsolve_traits template::Unrolling, + int Unrolling = trsolve_traits::Unrolling, int StorageOrder = (int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor, - int RhsVectors = ei_trsolve_traits::RhsVectors + int RhsVectors = trsolve_traits::RhsVectors > -struct ei_triangular_solver_selector; +struct triangular_solver_selector; // forward and backward substitution, row-major, rhs is a vector template -struct ei_triangular_solver_selector +struct triangular_solver_selector { typedef typename Lhs::Scalar LhsScalar; typedef typename Rhs::Scalar RhsScalar; - typedef ei_blas_traits LhsProductTraits; + typedef blas_traits LhsProductTraits; typedef typename LhsProductTraits::ExtractType ActualLhsType; typedef typename Lhs::Index Index; enum { @@ -82,7 +84,7 @@ struct ei_triangular_solver_selector::run( + general_matrix_vector_product::run( actualPanelWidth, r, &(actualLhs.const_cast_derived().coeffRef(startRow,startCol)), actualLhs.outerStride(), &(other.coeffRef(startCol)), other.innerStride(), @@ -106,11 +108,11 @@ struct ei_triangular_solver_selector -struct ei_triangular_solver_selector +struct triangular_solver_selector { typedef typename Lhs::Scalar LhsScalar; typedef typename Rhs::Scalar RhsScalar; - typedef ei_blas_traits LhsProductTraits; + typedef blas_traits LhsProductTraits; typedef typename LhsProductTraits::ExtractType ActualLhsType; typedef typename Lhs::Index Index; enum { @@ -148,7 +150,7 @@ struct ei_triangular_solver_selector::run( + general_matrix_vector_product::run( r, actualPanelWidth, &(actualLhs.const_cast_derived().coeffRef(endBlock,startBlock)), actualLhs.outerStride(), &other.coeff(startBlock), other.innerStride(), @@ -160,31 +162,31 @@ struct ei_triangular_solver_selector -struct ei_triangular_solver_selector +struct triangular_solver_selector { static void run(const Lhs& lhs, Rhs& rhs) { Transpose rhsTr(rhs); Transpose lhsTr(lhs); - ei_triangular_solver_selector,Transpose,OnTheLeft,TriangularView::TransposeMode>::run(lhsTr,rhsTr); + triangular_solver_selector,Transpose,OnTheLeft,TriangularView::TransposeMode>::run(lhsTr,rhsTr); } }; template -struct ei_triangular_solve_matrix; +struct triangular_solve_matrix; // the rhs is a matrix template -struct ei_triangular_solver_selector +struct triangular_solver_selector { typedef typename Rhs::Scalar Scalar; typedef typename Rhs::Index Index; - typedef ei_blas_traits LhsProductTraits; + typedef blas_traits LhsProductTraits; typedef typename LhsProductTraits::DirectLinearAccessType ActualLhsType; static void run(const Lhs& lhs, Rhs& rhs) { const ActualLhsType actualLhs = LhsProductTraits::extract(lhs); - ei_triangular_solve_matrix ::run(lhs.rows(), Side==OnTheLeft? rhs.cols() : rhs.rows(), &actualLhs.coeff(0,0), actualLhs.outerStride(), &rhs.coeffRef(0,0), rhs.outerStride()); } @@ -196,10 +198,10 @@ struct ei_triangular_solver_selector -struct ei_triangular_solver_unroller; +struct triangular_solver_unroller; template -struct ei_triangular_solver_unroller { +struct triangular_solver_unroller { enum { IsLower = ((Mode&Lower)==Lower), I = IsLower ? Index : Size - Index - 1, @@ -213,21 +215,23 @@ struct ei_triangular_solver_unroller { if(!(Mode & UnitDiag)) rhs.coeffRef(I) /= lhs.coeff(I,I); - ei_triangular_solver_unroller::run(lhs,rhs); + triangular_solver_unroller::run(lhs,rhs); } }; template -struct ei_triangular_solver_unroller { +struct triangular_solver_unroller { static void run(const Lhs&, Rhs&) {} }; template -struct ei_triangular_solver_selector { +struct triangular_solver_selector { static void run(const Lhs& lhs, Rhs& rhs) - { ei_triangular_solver_unroller::run(lhs,rhs); } + { triangular_solver_unroller::run(lhs,rhs); } }; +} // end namespace internal + /*************************************************************************** * TriangularView methods ***************************************************************************/ @@ -246,17 +250,17 @@ template void TriangularView::solveInPlace(const MatrixBase& _other) const { OtherDerived& other = _other.const_cast_derived(); - ei_assert(cols() == rows()); - ei_assert( (Side==OnTheLeft && cols() == other.rows()) || (Side==OnTheRight && cols() == other.cols()) ); - ei_assert(!(Mode & ZeroDiag)); - ei_assert(Mode & (Upper|Lower)); - - enum { copy = ei_traits::Flags & RowMajorBit && OtherDerived::IsVectorAtCompileTime }; - typedef typename ei_meta_if::type, OtherDerived&>::ret OtherCopy; + eigen_assert(cols() == rows()); + eigen_assert( (Side==OnTheLeft && cols() == other.rows()) || (Side==OnTheRight && cols() == other.cols()) ); + eigen_assert(!(Mode & ZeroDiag)); + eigen_assert(Mode & (Upper|Lower)); + + enum { copy = internal::traits::Flags & RowMajorBit && OtherDerived::IsVectorAtCompileTime }; + typedef typename internal::meta_if::type, OtherDerived&>::ret OtherCopy; OtherCopy otherCopy(other); - ei_triangular_solver_selector::type, + internal::triangular_solver_selector::type, Side, Mode>::run(nestedExpression(), otherCopy); if (copy) @@ -296,10 +300,10 @@ void TriangularView::solveInPlace(const MatrixBase template -typename ei_plain_matrix_type_column_major::type +typename internal::plain_matrix_type_column_major::type TriangularView::solve(const MatrixBase& rhs) const { - typename ei_plain_matrix_type_column_major::type res(rhs); + typename internal::plain_matrix_type_column_major::type res(rhs); solveInPlace(res); return res; } diff --git a/Eigen/src/Core/StableNorm.h b/Eigen/src/Core/StableNorm.h index c3c230796..fdf113bfe 100644 --- a/Eigen/src/Core/StableNorm.h +++ b/Eigen/src/Core/StableNorm.h @@ -25,13 +25,14 @@ #ifndef EIGEN_STABLENORM_H #define EIGEN_STABLENORM_H +namespace internal { template -inline void ei_stable_norm_kernel(const ExpressionType& bl, Scalar& ssq, Scalar& scale, Scalar& invScale) +inline void stable_norm_kernel(const ExpressionType& bl, Scalar& ssq, Scalar& scale, Scalar& invScale) { Scalar max = bl.cwiseAbs().maxCoeff(); if (max>scale) { - ssq = ssq * ei_abs2(scale/max); + ssq = ssq * abs2(scale/max); scale = max; invScale = Scalar(1)/scale; } @@ -39,6 +40,7 @@ inline void ei_stable_norm_kernel(const ExpressionType& bl, Scalar& ssq, Scalar& // then we can neglect this sub vector ssq += (bl*invScale).squaredNorm(); } +} /** \returns the \em l2 norm of \c *this avoiding underflow and overflow. * This version use a blockwise two passes algorithm: @@ -51,7 +53,7 @@ inline void ei_stable_norm_kernel(const ExpressionType& bl, Scalar& ssq, Scalar& * \sa norm(), blueNorm(), hypotNorm() */ template -inline typename NumTraits::Scalar>::Real +inline typename NumTraits::Scalar>::Real MatrixBase::stableNorm() const { const Index blockSize = 4096; @@ -62,12 +64,12 @@ MatrixBase::stableNorm() const Alignment = (int(Flags)&DirectAccessBit) || (int(Flags)&AlignedBit) ? 1 : 0 }; Index n = size(); - Index bi = ei_first_aligned(derived()); + Index bi = internal::first_aligned(derived()); if (bi>0) - ei_stable_norm_kernel(this->head(bi), ssq, scale, invScale); + internal::stable_norm_kernel(this->head(bi), ssq, scale, invScale); for (; bisegment(bi,std::min(blockSize, n - bi)).template forceAlignedAccessIf(), ssq, scale, invScale); - return scale * ei_sqrt(ssq); + internal::stable_norm_kernel(this->segment(bi,std::min(blockSize, n - bi)).template forceAlignedAccessIf(), ssq, scale, invScale); + return scale * internal::sqrt(ssq); } /** \returns the \em l2 norm of \c *this using the Blue's algorithm. @@ -80,7 +82,7 @@ MatrixBase::stableNorm() const * \sa norm(), stableNorm(), hypotNorm() */ template -inline typename NumTraits::Scalar>::Real +inline typename NumTraits::Scalar>::Real MatrixBase::blueNorm() const { static Index nmax = -1; @@ -116,7 +118,7 @@ MatrixBase::blueNorm() const overfl = rbig*s2m; // overflow boundary for abig eps = RealScalar(std::pow(double(ibeta), 1-it)); - relerr = ei_sqrt(eps); // tolerance for neglecting asml + relerr = internal::sqrt(eps); // tolerance for neglecting asml abig = RealScalar(1.0/eps - 1.0); if (RealScalar(nbig)>abig) nmax = int(abig); // largest safe n else nmax = nbig; @@ -128,23 +130,23 @@ MatrixBase::blueNorm() const RealScalar abig = RealScalar(0); for(Index j=0; j ab2) abig += ei_abs2(ax*s2m); - else if(ax < b1) asml += ei_abs2(ax*s1m); - else amed += ei_abs2(ax); + RealScalar ax = internal::abs(coeff(j)); + if(ax > ab2) abig += internal::abs2(ax*s2m); + else if(ax < b1) asml += internal::abs2(ax*s1m); + else amed += internal::abs2(ax); } if(abig > RealScalar(0)) { - abig = ei_sqrt(abig); + abig = internal::sqrt(abig); if(abig > overfl) { - ei_assert(false && "overflow"); + eigen_assert(false && "overflow"); return rbig; } if(amed > RealScalar(0)) { abig = abig/s2m; - amed = ei_sqrt(amed); + amed = internal::sqrt(amed); } else return abig/s2m; @@ -153,20 +155,20 @@ MatrixBase::blueNorm() const { if (amed > RealScalar(0)) { - abig = ei_sqrt(amed); - amed = ei_sqrt(asml) / s1m; + abig = internal::sqrt(amed); + amed = internal::sqrt(asml) / s1m; } else - return ei_sqrt(asml)/s1m; + return internal::sqrt(asml)/s1m; } else - return ei_sqrt(amed); + return internal::sqrt(amed); asml = std::min(abig, amed); abig = std::max(abig, amed); if(asml <= abig*relerr) return abig; else - return abig * ei_sqrt(RealScalar(1) + ei_abs2(asml/abig)); + return abig * internal::sqrt(RealScalar(1) + internal::abs2(asml/abig)); } /** \returns the \em l2 norm of \c *this avoiding undeflow and overflow. @@ -175,10 +177,10 @@ MatrixBase::blueNorm() const * \sa norm(), stableNorm() */ template -inline typename NumTraits::Scalar>::Real +inline typename NumTraits::Scalar>::Real MatrixBase::hypotNorm() const { - return this->cwiseAbs().redux(ei_scalar_hypot_op()); + return this->cwiseAbs().redux(internal::scalar_hypot_op()); } #endif // EIGEN_STABLENORM_H diff --git a/Eigen/src/Core/Stride.h b/Eigen/src/Core/Stride.h index 47515b548..9425253ec 100644 --- a/Eigen/src/Core/Stride.h +++ b/Eigen/src/Core/Stride.h @@ -67,14 +67,14 @@ class Stride Stride() : m_outer(OuterStrideAtCompileTime), m_inner(InnerStrideAtCompileTime) { - ei_assert(InnerStrideAtCompileTime != Dynamic && OuterStrideAtCompileTime != Dynamic); + eigen_assert(InnerStrideAtCompileTime != Dynamic && OuterStrideAtCompileTime != Dynamic); } /** Constructor allowing to pass the strides at runtime */ Stride(Index outerStride, Index innerStride) : m_outer(outerStride), m_inner(innerStride) { - ei_assert(innerStride>=0 && outerStride>=0); + eigen_assert(innerStride>=0 && outerStride>=0); } /** Copy constructor */ @@ -88,8 +88,8 @@ class Stride inline Index inner() const { return m_inner.value(); } protected: - ei_variable_if_dynamic m_outer; - ei_variable_if_dynamic m_inner; + internal::variable_if_dynamic m_outer; + internal::variable_if_dynamic m_inner; }; /** \brief Convenience specialization of Stride to specify only an inner stride diff --git a/Eigen/src/Core/Swap.h b/Eigen/src/Core/Swap.h index 086d7f32c..abbef4443 100644 --- a/Eigen/src/Core/Swap.h +++ b/Eigen/src/Core/Swap.h @@ -32,17 +32,19 @@ * * \brief Internal helper class for swapping two expressions */ +namespace internal { template -struct ei_traits > : ei_traits {}; +struct traits > : traits {}; +} template class SwapWrapper - : public ei_dense_xpr_base >::type + : public internal::dense_xpr_base >::type { public: - typedef typename ei_dense_xpr_base::type Base; + typedef typename internal::dense_xpr_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(SwapWrapper) - typedef typename ei_packet_traits::type Packet; + typedef typename internal::packet_traits::type Packet; inline SwapWrapper(ExpressionType& xpr) : m_expression(xpr) {} @@ -65,7 +67,7 @@ template class SwapWrapper void copyCoeff(Index row, Index col, const DenseBase& other) { OtherDerived& _other = other.const_cast_derived(); - ei_internal_assert(row >= 0 && row < rows() + eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); Scalar tmp = m_expression.coeff(row, col); m_expression.coeffRef(row, col) = _other.coeff(row, col); @@ -76,7 +78,7 @@ template class SwapWrapper void copyCoeff(Index index, const DenseBase& other) { OtherDerived& _other = other.const_cast_derived(); - ei_internal_assert(index >= 0 && index < m_expression.size()); + eigen_internal_assert(index >= 0 && index < m_expression.size()); Scalar tmp = m_expression.coeff(index); m_expression.coeffRef(index) = _other.coeff(index); _other.coeffRef(index) = tmp; @@ -86,7 +88,7 @@ template class SwapWrapper void copyPacket(Index row, Index col, const DenseBase& other) { OtherDerived& _other = other.const_cast_derived(); - ei_internal_assert(row >= 0 && row < rows() + eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); Packet tmp = m_expression.template packet(row, col); m_expression.template writePacket(row, col, @@ -99,7 +101,7 @@ template class SwapWrapper void copyPacket(Index index, const DenseBase& other) { OtherDerived& _other = other.const_cast_derived(); - ei_internal_assert(index >= 0 && index < m_expression.size()); + eigen_internal_assert(index >= 0 && index < m_expression.size()); Packet tmp = m_expression.template packet(index); m_expression.template writePacket(index, _other.template packet(index) diff --git a/Eigen/src/Core/Transpose.h b/Eigen/src/Core/Transpose.h index de8ae0a5b..a011f7df3 100644 --- a/Eigen/src/Core/Transpose.h +++ b/Eigen/src/Core/Transpose.h @@ -39,14 +39,16 @@ * * \sa MatrixBase::transpose(), MatrixBase::adjoint() */ + +namespace internal { template -struct ei_traits > : ei_traits +struct traits > : traits { typedef typename MatrixType::Scalar Scalar; - typedef typename ei_nested::type MatrixTypeNested; - typedef typename ei_unref::type _MatrixTypeNested; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::XprKind XprKind; + typedef typename nested::type MatrixTypeNested; + typedef typename unref::type _MatrixTypeNested; + typedef typename traits::StorageKind StorageKind; + typedef typename traits::XprKind XprKind; enum { RowsAtCompileTime = MatrixType::ColsAtCompileTime, ColsAtCompileTime = MatrixType::RowsAtCompileTime, @@ -54,19 +56,20 @@ struct ei_traits > : ei_traits MaxColsAtCompileTime = MatrixType::MaxRowsAtCompileTime, Flags = int(_MatrixTypeNested::Flags & ~NestByRefBit) ^ RowMajorBit, CoeffReadCost = _MatrixTypeNested::CoeffReadCost, - InnerStrideAtCompileTime = ei_inner_stride_at_compile_time::ret, - OuterStrideAtCompileTime = ei_outer_stride_at_compile_time::ret + InnerStrideAtCompileTime = inner_stride_at_compile_time::ret, + OuterStrideAtCompileTime = outer_stride_at_compile_time::ret }; }; +} template class TransposeImpl; template class Transpose - : public TransposeImpl::StorageKind> + : public TransposeImpl::StorageKind> { public: - typedef typename TransposeImpl::StorageKind>::Base Base; + typedef typename TransposeImpl::StorageKind>::Base Base; EIGEN_GENERIC_PUBLIC_INTERFACE(Transpose) inline Transpose(const MatrixType& matrix) : m_matrix(matrix) {} @@ -77,35 +80,39 @@ template class Transpose inline Index cols() const { return m_matrix.rows(); } /** \returns the nested expression */ - const typename ei_cleantype::type& + const typename internal::cleantype::type& nestedExpression() const { return m_matrix; } /** \returns the nested expression */ - typename ei_cleantype::type& + typename internal::cleantype::type& nestedExpression() { return m_matrix.const_cast_derived(); } protected: const typename MatrixType::Nested m_matrix; }; -template::ret> -struct ei_TransposeImpl_base +namespace internal { + +template::ret> +struct TransposeImpl_base { - typedef typename ei_dense_xpr_base >::type type; + typedef typename dense_xpr_base >::type type; }; template -struct ei_TransposeImpl_base +struct TransposeImpl_base { - typedef typename ei_dense_xpr_base >::type type; + typedef typename dense_xpr_base >::type type; }; +} // end namespace internal + template class TransposeImpl - : public ei_TransposeImpl_base::type + : public internal::TransposeImpl_base::type { public: - typedef typename ei_TransposeImpl_base::type Base; + typedef typename internal::TransposeImpl_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(Transpose) inline Index innerStride() const { return derived().nestedExpression().innerStride(); } @@ -214,7 +221,7 @@ DenseBase::transpose() const * m = m.adjoint().eval(); * \endcode * - * \sa adjointInPlace(), transpose(), conjugate(), class Transpose, class ei_scalar_conjugate_op */ + * \sa adjointInPlace(), transpose(), conjugate(), class Transpose, class internal::scalar_conjugate_op */ template inline const typename MatrixBase::AdjointReturnType MatrixBase::adjoint() const @@ -226,19 +233,21 @@ MatrixBase::adjoint() const * "in place" transpose implementation ***************************************************************************/ +namespace internal { + template -struct ei_inplace_transpose_selector; +struct inplace_transpose_selector; template -struct ei_inplace_transpose_selector { // square matrix +struct inplace_transpose_selector { // square matrix static void run(MatrixType& m) { m.template triangularView().swap(m.transpose()); } }; template -struct ei_inplace_transpose_selector { // non square matrix +struct inplace_transpose_selector { // non square matrix static void run(MatrixType& m) { if (m.rows()==m.cols()) m.template triangularView().swap(m.transpose()); @@ -247,6 +256,8 @@ struct ei_inplace_transpose_selector { // non square matrix } }; +} // end namespace internal + /** This is the "in place" version of transpose(): it replaces \c *this by its own transpose. * Thus, doing * \code @@ -268,7 +279,7 @@ struct ei_inplace_transpose_selector { // non square matrix template inline void DenseBase::transposeInPlace() { - ei_inplace_transpose_selector::run(derived()); + internal::inplace_transpose_selector::run(derived()); } /*************************************************************************** @@ -303,45 +314,47 @@ inline void MatrixBase::adjointInPlace() // The following is to detect aliasing problems in most common cases. +namespace internal { + template -struct ei_blas_traits > - : ei_blas_traits +struct blas_traits > + : blas_traits { typedef SelfCwiseBinaryOp XprType; static inline const XprType extract(const XprType& x) { return x; } }; template -struct ei_check_transpose_aliasing_compile_time_selector +struct check_transpose_aliasing_compile_time_selector { - enum { ret = ei_blas_traits::IsTransposed != DestIsTransposed + enum { ret = blas_traits::IsTransposed != DestIsTransposed }; }; template -struct ei_check_transpose_aliasing_compile_time_selector > +struct check_transpose_aliasing_compile_time_selector > { - enum { ret = ei_blas_traits::IsTransposed != DestIsTransposed - || ei_blas_traits::IsTransposed != DestIsTransposed + enum { ret = blas_traits::IsTransposed != DestIsTransposed + || blas_traits::IsTransposed != DestIsTransposed }; }; template -struct ei_check_transpose_aliasing_run_time_selector +struct check_transpose_aliasing_run_time_selector { static bool run(const Scalar* dest, const OtherDerived& src) { - return (ei_blas_traits::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(Scalar*)ei_extract_data(src)); + return (blas_traits::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(Scalar*)extract_data(src)); } }; template -struct ei_check_transpose_aliasing_run_time_selector > +struct check_transpose_aliasing_run_time_selector > { static bool run(const Scalar* dest, const CwiseBinaryOp& src) { - return ((ei_blas_traits::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(Scalar*)ei_extract_data(src.lhs()))) - || ((ei_blas_traits::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(Scalar*)ei_extract_data(src.rhs()))); + return ((blas_traits::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(Scalar*)extract_data(src.lhs()))) + || ((blas_traits::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(Scalar*)extract_data(src.rhs()))); } }; @@ -353,16 +366,16 @@ struct ei_check_transpose_aliasing_run_time_selector::IsTransposed,OtherDerived>::ret + = check_transpose_aliasing_compile_time_selector + ::IsTransposed,OtherDerived>::ret > struct checkTransposeAliasing_impl { static void run(const Derived& dst, const OtherDerived& other) { - ei_assert((!ei_check_transpose_aliasing_run_time_selector - ::IsTransposed,OtherDerived> - ::run(ei_extract_data(dst), other)) + eigen_assert((!check_transpose_aliasing_run_time_selector + ::IsTransposed,OtherDerived> + ::run(extract_data(dst), other)) && "aliasing detected during tranposition, use transposeInPlace() " "or evaluate the rhs into a temporary using .eval()"); @@ -377,12 +390,13 @@ struct checkTransposeAliasing_impl } }; +} // end namespace internal template template void DenseBase::checkTransposeAliasing(const OtherDerived& other) const { - checkTransposeAliasing_impl::run(derived(), other); + internal::checkTransposeAliasing_impl::run(derived(), other); } #endif diff --git a/Eigen/src/Core/Transpositions.h b/Eigen/src/Core/Transpositions.h index 6703b1e58..b7c3c339f 100644 --- a/Eigen/src/Core/Transpositions.h +++ b/Eigen/src/Core/Transpositions.h @@ -53,7 +53,10 @@ * * \sa class PermutationMatrix */ -template struct ei_transposition_matrix_product_retval; + +namespace internal { +template struct transposition_matrix_product_retval; +} template class Transpositions @@ -188,11 +191,11 @@ class Transpositions /** \returns the \a matrix with the \a transpositions applied to the columns. */ template -inline const ei_transposition_matrix_product_retval, Derived, OnTheRight> +inline const internal::transposition_matrix_product_retval, Derived, OnTheRight> operator*(const MatrixBase& matrix, const Transpositions &transpositions) { - return ei_transposition_matrix_product_retval + return internal::transposition_matrix_product_retval , Derived, OnTheRight> (transpositions, matrix.derived()); } @@ -200,30 +203,32 @@ operator*(const MatrixBase& matrix, /** \returns the \a matrix with the \a transpositions applied to the rows. */ template -inline const ei_transposition_matrix_product_retval +inline const internal::transposition_matrix_product_retval , Derived, OnTheLeft> operator*(const Transpositions &transpositions, const MatrixBase& matrix) { - return ei_transposition_matrix_product_retval + return internal::transposition_matrix_product_retval , Derived, OnTheLeft> (transpositions, matrix.derived()); } +namespace internal { + template -struct ei_traits > +struct traits > { typedef typename MatrixType::PlainObject ReturnType; }; template -struct ei_transposition_matrix_product_retval - : public ReturnByValue > +struct transposition_matrix_product_retval + : public ReturnByValue > { - typedef typename ei_cleantype::type MatrixTypeNestedCleaned; + typedef typename cleantype::type MatrixTypeNestedCleaned; typedef typename TranspositionType::Index Index; - ei_transposition_matrix_product_retval(const TranspositionType& tr, const MatrixType& matrix) + transposition_matrix_product_retval(const TranspositionType& tr, const MatrixType& matrix) : m_transpositions(tr), m_matrix(matrix) {} @@ -235,7 +240,7 @@ struct ei_transposition_matrix_product_retval const int size = m_transpositions.size(); Index j = 0; - if(!(ei_is_same_type::ret && ei_extract_data(dst) == ei_extract_data(m_matrix))) + if(!(is_same_type::ret && extract_data(dst) == extract_data(m_matrix))) dst = m_matrix; for(int k=(Transposed?size-1:0) ; Transposed?k>=0:k @@ -269,19 +276,19 @@ class Transpose > /** \returns the \a matrix with the inverse transpositions applied to the columns. */ template friend - inline const ei_transposition_matrix_product_retval + inline const internal::transposition_matrix_product_retval operator*(const MatrixBase& matrix, const Transpose& trt) { - return ei_transposition_matrix_product_retval(trt.m_transpositions, matrix.derived()); + return internal::transposition_matrix_product_retval(trt.m_transpositions, matrix.derived()); } /** \returns the \a matrix with the inverse transpositions applied to the rows. */ template - inline const ei_transposition_matrix_product_retval + inline const internal::transposition_matrix_product_retval operator*(const MatrixBase& matrix) const { - return ei_transposition_matrix_product_retval(m_transpositions, matrix.derived()); + return internal::transposition_matrix_product_retval(m_transpositions, matrix.derived()); } const TranspositionType& nestedTranspositions() const { return m_transpositions; } diff --git a/Eigen/src/Core/TriangularMatrix.h b/Eigen/src/Core/TriangularMatrix.h index 6e4e5b2cc..dc540f9bc 100644 --- a/Eigen/src/Core/TriangularMatrix.h +++ b/Eigen/src/Core/TriangularMatrix.h @@ -38,18 +38,18 @@ template class TriangularBase : public EigenBase public: enum { - Mode = ei_traits::Mode, - CoeffReadCost = ei_traits::CoeffReadCost, - RowsAtCompileTime = ei_traits::RowsAtCompileTime, - ColsAtCompileTime = ei_traits::ColsAtCompileTime, - MaxRowsAtCompileTime = ei_traits::MaxRowsAtCompileTime, - MaxColsAtCompileTime = ei_traits::MaxColsAtCompileTime + Mode = internal::traits::Mode, + CoeffReadCost = internal::traits::CoeffReadCost, + RowsAtCompileTime = internal::traits::RowsAtCompileTime, + ColsAtCompileTime = internal::traits::ColsAtCompileTime, + MaxRowsAtCompileTime = internal::traits::MaxRowsAtCompileTime, + MaxColsAtCompileTime = internal::traits::MaxColsAtCompileTime }; - typedef typename ei_traits::Scalar Scalar; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::Index Index; + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Index Index; - inline TriangularBase() { ei_assert(!((Mode&UnitDiag) && (Mode&ZeroDiag))); } + inline TriangularBase() { eigen_assert(!((Mode&UnitDiag) && (Mode&ZeroDiag))); } inline Index rows() const { return derived().rows(); } inline Index cols() const { return derived().cols(); } @@ -94,8 +94,8 @@ template class TriangularBase : public EigenBase { EIGEN_ONLY_USED_FOR_DEBUG(row); EIGEN_ONLY_USED_FOR_DEBUG(col); - ei_assert(col>=0 && col=0 && row=row) + eigen_assert(col>=0 && col=0 && row=row) || (Mode==Lower && col<=row) || ((Mode==StrictlyUpper || Mode==UnitUpper) && col>row) || ((Mode==StrictlyLower || Mode==UnitLower) && col class TriangularBase : public EigenBase * * \sa MatrixBase::triangularView() */ +namespace internal { template -struct ei_traits > : ei_traits +struct traits > : traits { - typedef typename ei_nested::type MatrixTypeNested; - typedef typename ei_unref::type _MatrixTypeNested; + typedef typename nested::type MatrixTypeNested; + typedef typename unref::type _MatrixTypeNested; typedef MatrixType ExpressionType; enum { Mode = _Mode, @@ -141,6 +142,7 @@ struct ei_traits > : ei_traits CoeffReadCost = _MatrixTypeNested::CoeffReadCost }; }; +} template class TriangularView public: typedef TriangularBase Base; - typedef typename ei_traits::Scalar Scalar; + typedef typename internal::traits::Scalar Scalar; typedef _MatrixType MatrixType; typedef typename MatrixType::PlainObject DenseMatrixType; protected: typedef typename MatrixType::Nested MatrixTypeNested; - typedef typename ei_cleantype::type _MatrixTypeNested; - typedef typename ei_cleantype::type MatrixConjugateReturnType; + typedef typename internal::cleantype::type _MatrixTypeNested; + typedef typename internal::cleantype::type MatrixConjugateReturnType; public: using Base::evalToLazy; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::Index Index; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Index Index; enum { Mode = _Mode, @@ -179,7 +181,7 @@ template class TriangularView }; inline TriangularView(const MatrixType& matrix) : m_matrix(matrix) - { ei_assert(ei_are_flags_consistent::ret); } + { eigen_assert(internal::are_flags_consistent::ret); } inline Index rows() const { return m_matrix.rows(); } inline Index cols() const { return m_matrix.cols(); } @@ -191,9 +193,9 @@ template class TriangularView /** \sa MatrixBase::operator-=() */ template TriangularView& operator-=(const Other& other) { return *this = m_matrix - other; } /** \sa MatrixBase::operator*=() */ - TriangularView& operator*=(const typename ei_traits::Scalar& other) { return *this = m_matrix * other; } + TriangularView& operator*=(const typename internal::traits::Scalar& other) { return *this = m_matrix * other; } /** \sa MatrixBase::operator/=() */ - TriangularView& operator/=(const typename ei_traits::Scalar& other) { return *this = m_matrix / other; } + TriangularView& operator/=(const typename internal::traits::Scalar& other) { return *this = m_matrix / other; } /** \sa MatrixBase::fill() */ void fill(const Scalar& value) { setConstant(value); } @@ -292,14 +294,14 @@ template class TriangularView template - typename ei_plain_matrix_type_column_major::type + typename internal::plain_matrix_type_column_major::type solve(const MatrixBase& other) const; template void solveInPlace(const MatrixBase& other) const; template - typename ei_plain_matrix_type_column_major::type + typename internal::plain_matrix_type_column_major::type solve(const MatrixBase& other) const { return solve(other); } @@ -349,8 +351,10 @@ template class TriangularView * Implementation of triangular evaluation/assignment ***************************************************************************/ +namespace internal { + template -struct ei_triangular_assignment_selector +struct triangular_assignment_selector { enum { col = (UnrollCount-1) / Derived1::RowsAtCompileTime, @@ -359,9 +363,9 @@ struct ei_triangular_assignment_selector inline static void run(Derived1 &dst, const Derived2 &src) { - ei_triangular_assignment_selector::run(dst, src); + triangular_assignment_selector::run(dst, src); - ei_assert( Mode == Upper || Mode == Lower + eigen_assert( Mode == Upper || Mode == Lower || Mode == StrictlyUpper || Mode == StrictlyLower || Mode == UnitUpper || Mode == UnitLower); if((Mode == Upper && row <= col) @@ -383,13 +387,13 @@ struct ei_triangular_assignment_selector // prevent buggy user code from causing an infinite recursion template -struct ei_triangular_assignment_selector +struct triangular_assignment_selector { inline static void run(Derived1 &, const Derived2 &) {} }; template -struct ei_triangular_assignment_selector +struct triangular_assignment_selector { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -407,7 +411,7 @@ struct ei_triangular_assignment_selector -struct ei_triangular_assignment_selector +struct triangular_assignment_selector { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -425,7 +429,7 @@ struct ei_triangular_assignment_selector -struct ei_triangular_assignment_selector +struct triangular_assignment_selector { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -443,7 +447,7 @@ struct ei_triangular_assignment_selector -struct ei_triangular_assignment_selector +struct triangular_assignment_selector { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -461,7 +465,7 @@ struct ei_triangular_assignment_selector -struct ei_triangular_assignment_selector +struct triangular_assignment_selector { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -481,7 +485,7 @@ struct ei_triangular_assignment_selector -struct ei_triangular_assignment_selector +struct triangular_assignment_selector { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -501,6 +505,8 @@ struct ei_triangular_assignment_selector template @@ -509,7 +515,7 @@ TriangularView::operator=(const MatrixBase& othe { if(OtherDerived::Flags & EvalBeforeAssigningBit) { - typename ei_plain_matrix_type::type other_evaluated(other.rows(), other.cols()); + typename internal::plain_matrix_type::type other_evaluated(other.rows(), other.cols()); other_evaluated.template triangularView().lazyAssign(other.derived()); lazyAssign(other_evaluated); } @@ -525,12 +531,12 @@ void TriangularView::lazyAssign(const MatrixBase { enum { unroll = MatrixType::SizeAtCompileTime != Dynamic - && ei_traits::CoeffReadCost != Dynamic - && MatrixType::SizeAtCompileTime*ei_traits::CoeffReadCost/2 <= EIGEN_UNROLLING_LIMIT + && internal::traits::CoeffReadCost != Dynamic + && MatrixType::SizeAtCompileTime*internal::traits::CoeffReadCost/2 <= EIGEN_UNROLLING_LIMIT }; - ei_assert(m_matrix.rows() == other.rows() && m_matrix.cols() == other.cols()); + eigen_assert(m_matrix.rows() == other.rows() && m_matrix.cols() == other.cols()); - ei_triangular_assignment_selector + internal::triangular_assignment_selector inline TriangularView& TriangularView::operator=(const TriangularBase& other) { - ei_assert(Mode == int(OtherDerived::Mode)); - if(ei_traits::Flags & EvalBeforeAssigningBit) + eigen_assert(Mode == int(OtherDerived::Mode)); + if(internal::traits::Flags & EvalBeforeAssigningBit) { typename OtherDerived::DenseMatrixType other_evaluated(other.rows(), other.cols()); other_evaluated.template triangularView().lazyAssign(other.derived().nestedExpression()); @@ -562,13 +568,13 @@ void TriangularView::lazyAssign(const TriangularBase::CoeffReadCost != Dynamic - && MatrixType::SizeAtCompileTime * ei_traits::CoeffReadCost / 2 + && internal::traits::CoeffReadCost != Dynamic + && MatrixType::SizeAtCompileTime * internal::traits::CoeffReadCost / 2 <= EIGEN_UNROLLING_LIMIT }; - ei_assert(m_matrix.rows() == other.rows() && m_matrix.cols() == other.cols()); + eigen_assert(m_matrix.rows() == other.rows() && m_matrix.cols() == other.cols()); - ei_triangular_assignment_selector + internal::triangular_assignment_selector template void TriangularBase::evalTo(MatrixBase &other) const { - if(ei_traits::Flags & EvalBeforeAssigningBit) + if(internal::traits::Flags & EvalBeforeAssigningBit) { - typename ei_plain_matrix_type::type other_evaluated(rows(), cols()); + typename internal::plain_matrix_type::type other_evaluated(rows(), cols()); evalToLazy(other_evaluated); other.derived().swap(other_evaluated); } @@ -603,14 +609,14 @@ void TriangularBase::evalToLazy(MatrixBase &other) const { enum { unroll = DenseDerived::SizeAtCompileTime != Dynamic - && ei_traits::CoeffReadCost != Dynamic - && DenseDerived::SizeAtCompileTime * ei_traits::CoeffReadCost / 2 + && internal::traits::CoeffReadCost != Dynamic + && DenseDerived::SizeAtCompileTime * internal::traits::CoeffReadCost / 2 <= EIGEN_UNROLLING_LIMIT }; - ei_assert(this->rows() == other.rows() && this->cols() == other.cols()); + eigen_assert(this->rows() == other.rows() && this->cols() == other.cols()); - ei_triangular_assignment_selector - ::ExpressionType, Derived::Mode, + internal::triangular_assignment_selector + ::ExpressionType, Derived::Mode, unroll ? int(DenseDerived::SizeAtCompileTime) : Dynamic, true // clear the opposite triangular part >::run(other.derived(), derived().nestedExpression()); @@ -680,14 +686,14 @@ bool MatrixBase::isUpperTriangular(RealScalar prec) const Index maxi = std::min(j, rows()-1); for(Index i = 0; i <= maxi; ++i) { - RealScalar absValue = ei_abs(coeff(i,j)); + RealScalar absValue = internal::abs(coeff(i,j)); if(absValue > maxAbsOnUpperPart) maxAbsOnUpperPart = absValue; } } RealScalar threshold = maxAbsOnUpperPart * prec; for(Index j = 0; j < cols(); ++j) for(Index i = j+1; i < rows(); ++i) - if(ei_abs(coeff(i, j)) > threshold) return false; + if(internal::abs(coeff(i, j)) > threshold) return false; return true; } @@ -703,7 +709,7 @@ bool MatrixBase::isLowerTriangular(RealScalar prec) const for(Index j = 0; j < cols(); ++j) for(Index i = j; i < rows(); ++i) { - RealScalar absValue = ei_abs(coeff(i,j)); + RealScalar absValue = internal::abs(coeff(i,j)); if(absValue > maxAbsOnLowerPart) maxAbsOnLowerPart = absValue; } RealScalar threshold = maxAbsOnLowerPart * prec; @@ -711,7 +717,7 @@ bool MatrixBase::isLowerTriangular(RealScalar prec) const { Index maxi = std::min(j, rows()-1); for(Index i = 0; i < maxi; ++i) - if(ei_abs(coeff(i, j)) > threshold) return false; + if(internal::abs(coeff(i, j)) > threshold) return false; } return true; } diff --git a/Eigen/src/Core/VectorBlock.h b/Eigen/src/Core/VectorBlock.h index 84040bca1..912277633 100644 --- a/Eigen/src/Core/VectorBlock.h +++ b/Eigen/src/Core/VectorBlock.h @@ -56,24 +56,27 @@ * * \sa class Block, DenseBase::segment(Index,Index,Index,Index), DenseBase::segment(Index,Index) */ + +namespace internal { template -struct ei_traits > - : public ei_traits::Flags & RowMajorBit ? 1 : Size, - ei_traits::Flags & RowMajorBit ? Size : 1> > +struct traits > + : public traits::Flags & RowMajorBit ? 1 : Size, + traits::Flags & RowMajorBit ? Size : 1> > { }; +} template class VectorBlock : public Block::Flags & RowMajorBit ? 1 : Size, - ei_traits::Flags & RowMajorBit ? Size : 1> + internal::traits::Flags & RowMajorBit ? 1 : Size, + internal::traits::Flags & RowMajorBit ? Size : 1> { typedef Block::Flags & RowMajorBit ? 1 : Size, - ei_traits::Flags & RowMajorBit ? Size : 1> Base; + internal::traits::Flags & RowMajorBit ? 1 : Size, + internal::traits::Flags & RowMajorBit ? Size : 1> Base; enum { - IsColVector = !(ei_traits::Flags & RowMajorBit) + IsColVector = !(internal::traits::Flags & RowMajorBit) }; public: EIGEN_DENSE_PUBLIC_INTERFACE(VectorBlock) diff --git a/Eigen/src/Core/VectorwiseOp.h b/Eigen/src/Core/VectorwiseOp.h index 7f7ab842e..4c794d5b5 100644 --- a/Eigen/src/Core/VectorwiseOp.h +++ b/Eigen/src/Core/VectorwiseOp.h @@ -45,16 +45,17 @@ template< typename MatrixType, typename MemberOp, int Direction> class PartialReduxExpr; +namespace internal { template -struct ei_traits > - : ei_traits +struct traits > + : traits { typedef typename MemberOp::result_type Scalar; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::XprKind XprKind; + typedef typename traits::StorageKind StorageKind; + typedef typename traits::XprKind XprKind; typedef typename MatrixType::Scalar InputScalar; - typedef typename ei_nested::type MatrixTypeNested; - typedef typename ei_cleantype::type _MatrixTypeNested; + typedef typename nested::type MatrixTypeNested; + typedef typename cleantype::type _MatrixTypeNested; enum { RowsAtCompileTime = Direction==Vertical ? 1 : MatrixType::RowsAtCompileTime, ColsAtCompileTime = Direction==Horizontal ? 1 : MatrixType::ColsAtCompileTime, @@ -70,20 +71,21 @@ struct ei_traits > typedef typename MemberOp::template Cost CostOpType; #endif enum { - CoeffReadCost = TraversalSize * ei_traits<_MatrixTypeNested>::CoeffReadCost + int(CostOpType::value) + CoeffReadCost = TraversalSize * traits<_MatrixTypeNested>::CoeffReadCost + int(CostOpType::value) }; }; +} template< typename MatrixType, typename MemberOp, int Direction> -class PartialReduxExpr : ei_no_assignment_operator, - public ei_dense_xpr_base< PartialReduxExpr >::type +class PartialReduxExpr : internal::no_assignment_operator, + public internal::dense_xpr_base< PartialReduxExpr >::type { public: - typedef typename ei_dense_xpr_base::type Base; + typedef typename internal::dense_xpr_base::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(PartialReduxExpr) - typedef typename ei_traits::MatrixTypeNested MatrixTypeNested; - typedef typename ei_traits::_MatrixTypeNested _MatrixTypeNested; + typedef typename internal::traits::MatrixTypeNested MatrixTypeNested; + typedef typename internal::traits::_MatrixTypeNested _MatrixTypeNested; PartialReduxExpr(const MatrixType& mat, const MemberOp& func = MemberOp()) : m_matrix(mat), m_functor(func) {} @@ -114,8 +116,8 @@ class PartialReduxExpr : ei_no_assignment_operator, #define EIGEN_MEMBER_FUNCTOR(MEMBER,COST) \ template \ - struct ei_member_##MEMBER { \ - EIGEN_EMPTY_STRUCT_CTOR(ei_member_##MEMBER) \ + struct member_##MEMBER { \ + EIGEN_EMPTY_STRUCT_CTOR(member_##MEMBER) \ typedef ResultType result_type; \ template struct Cost \ { enum { value = COST }; }; \ @@ -124,11 +126,13 @@ class PartialReduxExpr : ei_no_assignment_operator, { return mat.MEMBER(); } \ } +namespace internal { + EIGEN_MEMBER_FUNCTOR(squaredNorm, Size * NumTraits::MulCost + (Size-1)*NumTraits::AddCost); EIGEN_MEMBER_FUNCTOR(norm, (Size+5) * NumTraits::MulCost + (Size-1)*NumTraits::AddCost); EIGEN_MEMBER_FUNCTOR(stableNorm, (Size+5) * NumTraits::MulCost + (Size-1)*NumTraits::AddCost); EIGEN_MEMBER_FUNCTOR(blueNorm, (Size+5) * NumTraits::MulCost + (Size-1)*NumTraits::AddCost); -EIGEN_MEMBER_FUNCTOR(hypotNorm, (Size-1) * ei_functor_traits >::Cost ); +EIGEN_MEMBER_FUNCTOR(hypotNorm, (Size-1) * functor_traits >::Cost ); EIGEN_MEMBER_FUNCTOR(sum, (Size-1)*NumTraits::AddCost); EIGEN_MEMBER_FUNCTOR(mean, (Size-1)*NumTraits::AddCost + NumTraits::MulCost); EIGEN_MEMBER_FUNCTOR(minCoeff, (Size-1)*NumTraits::AddCost); @@ -139,20 +143,20 @@ EIGEN_MEMBER_FUNCTOR(count, (Size-1)*NumTraits::AddCost); EIGEN_MEMBER_FUNCTOR(prod, (Size-1)*NumTraits::MulCost); -/** \internal */ template -struct ei_member_redux { - typedef typename ei_result_of< +struct member_redux { + typedef typename result_of< BinaryOp(Scalar) >::type result_type; template struct Cost - { enum { value = (Size-1) * ei_functor_traits::Cost }; }; - ei_member_redux(const BinaryOp func) : m_functor(func) {} + { enum { value = (Size-1) * functor_traits::Cost }; }; + member_redux(const BinaryOp func) : m_functor(func) {} template inline result_type operator()(const DenseBase& mat) const { return mat.redux(m_functor); } const BinaryOp m_functor; }; +} /** \class VectorwiseOp * \ingroup Core_Module @@ -178,11 +182,11 @@ template class VectorwiseOp typedef typename ExpressionType::Scalar Scalar; typedef typename ExpressionType::RealScalar RealScalar; typedef typename ExpressionType::Index Index; - typedef typename ei_meta_if::ret, + typedef typename internal::meta_if::ret, ExpressionType, const ExpressionType&>::ret ExpressionTypeNested; template class Functor, - typename Scalar=typename ei_traits::Scalar> struct ReturnType + typename Scalar=typename internal::traits::Scalar> struct ReturnType { typedef PartialReduxExpr, @@ -193,7 +197,7 @@ template class VectorwiseOp template struct ReduxReturnType { typedef PartialReduxExpr::Scalar>, + internal::member_redux::Scalar>, Direction > Type; }; @@ -207,7 +211,7 @@ template class VectorwiseOp /** \internal * \returns the i-th subvector according to the \c Direction */ - typedef typename ei_meta_if::ret SubVector; SubVector subVector(Index i) @@ -265,7 +269,7 @@ template class VectorwiseOp * Output: \verbinclude PartialRedux_minCoeff.out * * \sa DenseBase::minCoeff() */ - const typename ReturnType::Type minCoeff() const + const typename ReturnType::Type minCoeff() const { return _expression(); } /** \returns a row (or column) vector expression of the largest coefficient @@ -275,7 +279,7 @@ template class VectorwiseOp * Output: \verbinclude PartialRedux_maxCoeff.out * * \sa DenseBase::maxCoeff() */ - const typename ReturnType::Type maxCoeff() const + const typename ReturnType::Type maxCoeff() const { return _expression(); } /** \returns a row (or column) vector expression of the squared norm @@ -285,7 +289,7 @@ template class VectorwiseOp * Output: \verbinclude PartialRedux_squaredNorm.out * * \sa DenseBase::squaredNorm() */ - const typename ReturnType::Type squaredNorm() const + const typename ReturnType::Type squaredNorm() const { return _expression(); } /** \returns a row (or column) vector expression of the norm @@ -295,7 +299,7 @@ template class VectorwiseOp * Output: \verbinclude PartialRedux_norm.out * * \sa DenseBase::norm() */ - const typename ReturnType::Type norm() const + const typename ReturnType::Type norm() const { return _expression(); } @@ -304,7 +308,7 @@ template class VectorwiseOp * blue's algorithm. * * \sa DenseBase::blueNorm() */ - const typename ReturnType::Type blueNorm() const + const typename ReturnType::Type blueNorm() const { return _expression(); } @@ -313,7 +317,7 @@ template class VectorwiseOp * underflow and overflow. * * \sa DenseBase::stableNorm() */ - const typename ReturnType::Type stableNorm() const + const typename ReturnType::Type stableNorm() const { return _expression(); } @@ -322,7 +326,7 @@ template class VectorwiseOp * underflow and overflow using a concatenation of hypot() calls. * * \sa DenseBase::hypotNorm() */ - const typename ReturnType::Type hypotNorm() const + const typename ReturnType::Type hypotNorm() const { return _expression(); } /** \returns a row (or column) vector expression of the sum @@ -332,28 +336,28 @@ template class VectorwiseOp * Output: \verbinclude PartialRedux_sum.out * * \sa DenseBase::sum() */ - const typename ReturnType::Type sum() const + const typename ReturnType::Type sum() const { return _expression(); } /** \returns a row (or column) vector expression of the mean * of each column (or row) of the referenced expression. * * \sa DenseBase::mean() */ - const typename ReturnType::Type mean() const + const typename ReturnType::Type mean() const { return _expression(); } /** \returns a row (or column) vector expression representing * whether \b all coefficients of each respective column (or row) are \c true. * * \sa DenseBase::all() */ - const typename ReturnType::Type all() const + const typename ReturnType::Type all() const { return _expression(); } /** \returns a row (or column) vector expression representing * whether \b at \b least one coefficient of each respective column (or row) is \c true. * * \sa DenseBase::any() */ - const typename ReturnType::Type any() const + const typename ReturnType::Type any() const { return _expression(); } /** \returns a row (or column) vector expression representing @@ -363,7 +367,7 @@ template class VectorwiseOp * Output: \verbinclude PartialRedux_count.out * * \sa DenseBase::count() */ - const PartialReduxExpr, Direction> count() const + const PartialReduxExpr, Direction> count() const { return _expression(); } /** \returns a row (or column) vector expression of the product @@ -373,7 +377,7 @@ template class VectorwiseOp * Output: \verbinclude PartialRedux_prod.out * * \sa DenseBase::prod() */ - const typename ReturnType::Type prod() const + const typename ReturnType::Type prod() const { return _expression(); } @@ -413,7 +417,7 @@ template class VectorwiseOp ExpressionType& operator=(const DenseBase& other) { EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived) - //ei_assert((m_matrix.isNull()) == (other.isNull())); FIXME + //eigen_assert((m_matrix.isNull()) == (other.isNull())); FIXME for(Index j=0; j(m_matrix); @@ -441,7 +445,7 @@ template class VectorwiseOp /** Returns the expression of the sum of the vector \a other to each subvector of \c *this */ template EIGEN_STRONG_INLINE - CwiseBinaryOp, + CwiseBinaryOp, ExpressionType, typename ExtendedType::Type> operator+(const DenseBase& other) const @@ -452,7 +456,7 @@ template class VectorwiseOp /** Returns the expression of the difference between each subvector of \c *this and the vector \a other */ template - CwiseBinaryOp, + CwiseBinaryOp, ExpressionType, typename ExtendedType::Type> operator-(const DenseBase& other) const @@ -470,21 +474,21 @@ template class VectorwiseOp const CrossReturnType cross(const MatrixBase& other) const; enum { - HNormalized_Size = Direction==Vertical ? ei_traits::RowsAtCompileTime - : ei_traits::ColsAtCompileTime, + HNormalized_Size = Direction==Vertical ? internal::traits::RowsAtCompileTime + : internal::traits::ColsAtCompileTime, HNormalized_SizeMinusOne = HNormalized_Size==Dynamic ? Dynamic : HNormalized_Size-1 }; typedef Block::RowsAtCompileTime), + : int(internal::traits::RowsAtCompileTime), Direction==Horizontal ? int(HNormalized_SizeMinusOne) - : int(ei_traits::ColsAtCompileTime)> + : int(internal::traits::ColsAtCompileTime)> HNormalized_Block; typedef Block::RowsAtCompileTime), - Direction==Horizontal ? 1 : int(ei_traits::ColsAtCompileTime)> + Direction==Vertical ? 1 : int(internal::traits::RowsAtCompileTime), + Direction==Horizontal ? 1 : int(internal::traits::ColsAtCompileTime)> HNormalized_Factors; - typedef CwiseBinaryOp::Scalar>, + typedef CwiseBinaryOp::Scalar>, HNormalized_Block, Replicate -struct ei_visitor_impl +struct visitor_impl { enum { col = (UnrollCount-1) / Derived::RowsAtCompileTime, @@ -35,13 +37,13 @@ struct ei_visitor_impl inline static void run(const Derived &mat, Visitor& visitor) { - ei_visitor_impl::run(mat, visitor); + visitor_impl::run(mat, visitor); visitor(mat.coeff(row, col), row, col); } }; template -struct ei_visitor_impl +struct visitor_impl { inline static void run(const Derived &mat, Visitor& visitor) { @@ -50,7 +52,7 @@ struct ei_visitor_impl }; template -struct ei_visitor_impl +struct visitor_impl { typedef typename Derived::Index Index; inline static void run(const Derived& mat, Visitor& visitor) @@ -64,6 +66,7 @@ struct ei_visitor_impl } }; +} // end namespace internal /** Applies the visitor \a visitor to the whole coefficients of the matrix or vector. * @@ -88,19 +91,21 @@ void DenseBase::visit(Visitor& visitor) const { enum { unroll = SizeAtCompileTime != Dynamic && CoeffReadCost != Dynamic - && (SizeAtCompileTime == 1 || ei_functor_traits::Cost != Dynamic) - && SizeAtCompileTime * CoeffReadCost + (SizeAtCompileTime-1) * ei_functor_traits::Cost + && (SizeAtCompileTime == 1 || internal::functor_traits::Cost != Dynamic) + && SizeAtCompileTime * CoeffReadCost + (SizeAtCompileTime-1) * internal::functor_traits::Cost <= EIGEN_UNROLLING_LIMIT }; - return ei_visitor_impl::run(derived(), visitor); } +namespace internal { + /** \internal * \brief Base class to implement min and max visitors */ template -struct ei_coeff_visitor +struct coeff_visitor { typedef typename Derived::Index Index; typedef typename Derived::Scalar Scalar; @@ -120,7 +125,7 @@ struct ei_coeff_visitor * \sa DenseBase::minCoeff(Index*, Index*) */ template -struct ei_min_coeff_visitor : ei_coeff_visitor +struct min_coeff_visitor : coeff_visitor { typedef typename Derived::Index Index; typedef typename Derived::Scalar Scalar; @@ -136,7 +141,7 @@ struct ei_min_coeff_visitor : ei_coeff_visitor }; template -struct ei_functor_traits > { +struct functor_traits > { enum { Cost = NumTraits::AddCost }; @@ -148,7 +153,7 @@ struct ei_functor_traits > { * \sa DenseBase::maxCoeff(Index*, Index*) */ template -struct ei_max_coeff_visitor : ei_coeff_visitor +struct max_coeff_visitor : coeff_visitor { typedef typename Derived::Index Index; typedef typename Derived::Scalar Scalar; @@ -164,22 +169,24 @@ struct ei_max_coeff_visitor : ei_coeff_visitor }; template -struct ei_functor_traits > { +struct functor_traits > { enum { Cost = NumTraits::AddCost }; }; +} // end namespace internal + /** \returns the minimum of all coefficients of *this * and puts in *row and *col its location. * * \sa DenseBase::minCoeff(Index*), DenseBase::maxCoeff(Index*,Index*), DenseBase::visitor(), DenseBase::minCoeff() */ template -typename ei_traits::Scalar +typename internal::traits::Scalar DenseBase::minCoeff(Index* row, Index* col) const { - ei_min_coeff_visitor minVisitor; + internal::min_coeff_visitor minVisitor; this->visit(minVisitor); *row = minVisitor.row; if (col) *col = minVisitor.col; @@ -192,11 +199,11 @@ DenseBase::minCoeff(Index* row, Index* col) const * \sa DenseBase::minCoeff(Index*,Index*), DenseBase::maxCoeff(Index*,Index*), DenseBase::visitor(), DenseBase::minCoeff() */ template -typename ei_traits::Scalar +typename internal::traits::Scalar DenseBase::minCoeff(Index* index) const { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) - ei_min_coeff_visitor minVisitor; + internal::min_coeff_visitor minVisitor; this->visit(minVisitor); *index = (RowsAtCompileTime==1) ? minVisitor.col : minVisitor.row; return minVisitor.res; @@ -208,10 +215,10 @@ DenseBase::minCoeff(Index* index) const * \sa DenseBase::minCoeff(Index*,Index*), DenseBase::visitor(), DenseBase::maxCoeff() */ template -typename ei_traits::Scalar +typename internal::traits::Scalar DenseBase::maxCoeff(Index* row, Index* col) const { - ei_max_coeff_visitor maxVisitor; + internal::max_coeff_visitor maxVisitor; this->visit(maxVisitor); *row = maxVisitor.row; if (col) *col = maxVisitor.col; @@ -224,11 +231,11 @@ DenseBase::maxCoeff(Index* row, Index* col) const * \sa DenseBase::maxCoeff(Index*,Index*), DenseBase::minCoeff(Index*,Index*), DenseBase::visitor(), DenseBase::maxCoeff() */ template -typename ei_traits::Scalar +typename internal::traits::Scalar DenseBase::maxCoeff(Index* index) const { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) - ei_max_coeff_visitor maxVisitor; + internal::max_coeff_visitor maxVisitor; this->visit(maxVisitor); *index = (RowsAtCompileTime==1) ? maxVisitor.col : maxVisitor.row; return maxVisitor.res; diff --git a/Eigen/src/Core/arch/AltiVec/Complex.h b/Eigen/src/Core/arch/AltiVec/Complex.h index ecada02f4..cf5ed512a 100644 --- a/Eigen/src/Core/arch/AltiVec/Complex.h +++ b/Eigen/src/Core/arch/AltiVec/Complex.h @@ -25,13 +25,15 @@ #ifndef EIGEN_COMPLEX_ALTIVEC_H #define EIGEN_COMPLEX_ALTIVEC_H -static Packet4ui ei_p4ui_CONJ_XOR = vec_mergeh((Packet4ui)ei_p4i_ZERO, (Packet4ui)ei_p4f_ZERO_);//{ 0x00000000, 0x80000000, 0x00000000, 0x80000000 }; -static Packet16uc ei_p16uc_COMPLEX_RE = vec_sld((Packet16uc) vec_splat((Packet4ui)ei_p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)ei_p16uc_FORWARD, 2), 8);//{ 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 }; -static Packet16uc ei_p16uc_COMPLEX_IM = vec_sld((Packet16uc) vec_splat((Packet4ui)ei_p16uc_FORWARD, 1), (Packet16uc) vec_splat((Packet4ui)ei_p16uc_FORWARD, 3), 8);//{ 4,5,6,7, 4,5,6,7, 12,13,14,15, 12,13,14,15 }; -static Packet16uc ei_p16uc_COMPLEX_REV = vec_sld(ei_p16uc_REVERSE, ei_p16uc_REVERSE, 8);//{ 4,5,6,7, 0,1,2,3, 12,13,14,15, 8,9,10,11 }; -static Packet16uc ei_p16uc_COMPLEX_REV2 = vec_sld(ei_p16uc_FORWARD, ei_p16uc_FORWARD, 8);//{ 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 }; -static Packet16uc ei_p16uc_PSET_HI = (Packet16uc) vec_mergeh((Packet4ui) vec_splat((Packet4ui)ei_p16uc_FORWARD, 0), (Packet4ui) vec_splat((Packet4ui)ei_p16uc_FORWARD, 1));//{ 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 }; -static Packet16uc ei_p16uc_PSET_LO = (Packet16uc) vec_mergeh((Packet4ui) vec_splat((Packet4ui)ei_p16uc_FORWARD, 2), (Packet4ui) vec_splat((Packet4ui)ei_p16uc_FORWARD, 3));//{ 8,9,10,11, 12,13,14,15, 8,9,10,11, 12,13,14,15 }; +namespace internal { + +static Packet4ui p4ui_CONJ_XOR = vec_mergeh((Packet4ui)p4i_ZERO, (Packet4ui)p4f_ZERO_);//{ 0x00000000, 0x80000000, 0x00000000, 0x80000000 }; +static Packet16uc p16uc_COMPLEX_RE = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8);//{ 0,1,2,3, 0,1,2,3, 8,9,10,11, 8,9,10,11 }; +static Packet16uc p16uc_COMPLEX_IM = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 1), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8);//{ 4,5,6,7, 4,5,6,7, 12,13,14,15, 12,13,14,15 }; +static Packet16uc p16uc_COMPLEX_REV = vec_sld(p16uc_REVERSE, p16uc_REVERSE, 8);//{ 4,5,6,7, 0,1,2,3, 12,13,14,15, 8,9,10,11 }; +static Packet16uc p16uc_COMPLEX_REV2 = vec_sld(p16uc_FORWARD, p16uc_FORWARD, 8);//{ 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 }; +static Packet16uc p16uc_PSET_HI = (Packet16uc) vec_mergeh((Packet4ui) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet4ui) vec_splat((Packet4ui)p16uc_FORWARD, 1));//{ 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 }; +static Packet16uc p16uc_PSET_LO = (Packet16uc) vec_mergeh((Packet4ui) vec_splat((Packet4ui)p16uc_FORWARD, 2), (Packet4ui) vec_splat((Packet4ui)p16uc_FORWARD, 3));//{ 8,9,10,11, 12,13,14,15, 8,9,10,11, 12,13,14,15 }; //---------- float ---------- struct Packet2cf @@ -41,7 +43,7 @@ struct Packet2cf Packet4f v; }; -template<> struct ei_packet_traits > : ei_default_packet_traits +template<> struct packet_traits > : default_packet_traits { typedef Packet2cf type; enum { @@ -61,106 +63,106 @@ template<> struct ei_packet_traits > : ei_default_packet_tr }; }; -template<> struct ei_unpacket_traits { typedef std::complex type; enum {size=2}; }; +template<> struct unpacket_traits { typedef std::complex type; enum {size=2}; }; -template<> EIGEN_STRONG_INLINE Packet2cf ei_pset1(const std::complex& from) +template<> EIGEN_STRONG_INLINE Packet2cf pset1(const std::complex& from) { Packet2cf res; /* On AltiVec we cannot load 64-bit registers, so wa have to take care of alignment */ if ((ptrdiff_t)&from % 16 == 0) { - res.v = ei_pload((const float *)&from); - res.v = vec_perm(res.v, res.v, ei_p16uc_PSET_HI); + res.v = pload((const float *)&from); + res.v = vec_perm(res.v, res.v, p16uc_PSET_HI); } else { - res.v = ei_ploadu((const float *)&from); - res.v = vec_perm(res.v, res.v, ei_p16uc_PSET_LO); + res.v = ploadu((const float *)&from); + res.v = vec_perm(res.v, res.v, p16uc_PSET_LO); } return res; } -template<> EIGEN_STRONG_INLINE Packet2cf ei_padd(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_add(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_psub(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_sub(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pnegate(const Packet2cf& a) { return Packet2cf(ei_psub(ei_p4f_ZERO, a.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pconj(const Packet2cf& a) { return Packet2cf((Packet4f)vec_xor((Packet4ui)a.v, ei_p4ui_CONJ_XOR)); } +template<> EIGEN_STRONG_INLINE Packet2cf padd(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_add(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf psub(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_sub(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(psub(p4f_ZERO, a.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) { return Packet2cf((Packet4f)vec_xor((Packet4ui)a.v, p4ui_CONJ_XOR)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pmul(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) { Packet4f v1, v2; // Permute and multiply the real parts of a and b - v1 = vec_perm(a.v, a.v, ei_p16uc_COMPLEX_RE); + v1 = vec_perm(a.v, a.v, p16uc_COMPLEX_RE); // Get the imaginary parts of a - v2 = vec_perm(a.v, a.v, ei_p16uc_COMPLEX_IM); + v2 = vec_perm(a.v, a.v, p16uc_COMPLEX_IM); // multiply a_re * b - v1 = vec_madd(v1, b.v, ei_p4f_ZERO); + v1 = vec_madd(v1, b.v, p4f_ZERO); // multiply a_im * b and get the conjugate result - v2 = vec_madd(v2, b.v, ei_p4f_ZERO); - v2 = (Packet4f) vec_xor((Packet4ui)v2, ei_p4ui_CONJ_XOR); + v2 = vec_madd(v2, b.v, p4f_ZERO); + v2 = (Packet4f) vec_xor((Packet4ui)v2, p4ui_CONJ_XOR); // permute back to a proper order - v2 = vec_perm(v2, v2, ei_p16uc_COMPLEX_REV); + v2 = vec_perm(v2, v2, p16uc_COMPLEX_REV); return Packet2cf(vec_add(v1, v2)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pand (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_and(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_por (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_or(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pxor (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_xor(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pandnot(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_and(a.v, vec_nor(b.v,b.v))); } +template<> EIGEN_STRONG_INLINE Packet2cf pand (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_and(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf por (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_or(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pxor (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_xor(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pandnot(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_and(a.v, vec_nor(b.v,b.v))); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pload >(const std::complex* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(ei_pload((const float*)from)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_ploadu >(const std::complex* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ei_ploadu((const float*)from)); } +template<> EIGEN_STRONG_INLINE Packet2cf pload >(const std::complex* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload((const float*)from)); } +template<> EIGEN_STRONG_INLINE Packet2cf ploadu >(const std::complex* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu((const float*)from)); } -template<> EIGEN_STRONG_INLINE void ei_pstore >(std::complex * to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE ei_pstore((float*)to, from.v); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu >(std::complex * to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE ei_pstoreu((float*)to, from.v); } +template<> EIGEN_STRONG_INLINE void pstore >(std::complex * to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((float*)to, from.v); } +template<> EIGEN_STRONG_INLINE void pstoreu >(std::complex * to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((float*)to, from.v); } -template<> EIGEN_STRONG_INLINE void ei_prefetch >(const std::complex * addr) { vec_dstt((float *)addr, DST_CTRL(2,2,32), DST_CHAN); } +template<> EIGEN_STRONG_INLINE void prefetch >(const std::complex * addr) { vec_dstt((float *)addr, DST_CTRL(2,2,32), DST_CHAN); } -template<> EIGEN_STRONG_INLINE std::complex ei_pfirst(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex pfirst(const Packet2cf& a) { std::complex EIGEN_ALIGN16 res[2]; - ei_pstore((float *)&res, a.v); + pstore((float *)&res, a.v); return res[0]; } -template<> EIGEN_STRONG_INLINE Packet2cf ei_preverse(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a) { Packet4f rev_a; - rev_a = vec_perm(a.v, a.v, ei_p16uc_COMPLEX_REV2); + rev_a = vec_perm(a.v, a.v, p16uc_COMPLEX_REV2); return Packet2cf(rev_a); } -template<> EIGEN_STRONG_INLINE std::complex ei_predux(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex predux(const Packet2cf& a) { Packet4f b; b = (Packet4f) vec_sld(a.v, a.v, 8); - b = ei_padd(a.v, b); - return ei_pfirst(Packet2cf(sum)); + b = padd(a.v, b); + return pfirst(Packet2cf(sum)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_preduxp(const Packet2cf* vecs) +template<> EIGEN_STRONG_INLINE Packet2cf preduxp(const Packet2cf* vecs) { Packet4f b1, b2; b1 = (Packet4f) vec_sld(vecs[0].v, vecs[1].v, 8); b2 = (Packet4f) vec_sld(vecs[1].v, vecs[0].v, 8); b2 = (Packet4f) vec_sld(b2, b2, 8); - b2 = ei_padd(b1, b2); + b2 = padd(b1, b2); return Packet2cf(b2); } -template<> EIGEN_STRONG_INLINE std::complex ei_predux_mul(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex predux_mul(const Packet2cf& a) { Packet4f b; Packet2cf prod; b = (Packet4f) vec_sld(a.v, a.v, 8); - prod = ei_pmul(a, Packet2cf(b)); + prod = pmul(a, Packet2cf(b)); - return ei_pfirst(prod); + return pfirst(prod); } template -struct ei_palign_impl +struct palign_impl { EIGEN_STRONG_INLINE static void run(Packet2cf& first, const Packet2cf& second) { @@ -171,45 +173,47 @@ struct ei_palign_impl } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const - { return ei_padd(pmul(x,y),c); } + { return padd(pmul(x,y),c); } EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const { - return ei_pmul(a, ei_pconj(b)); + return pmul(a, pconj(b)); } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const - { return ei_padd(pmul(x,y),c); } + { return padd(pmul(x,y),c); } EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const { - return ei_pmul(ei_pconj(a), b); + return pmul(pconj(a), b); } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const - { return ei_padd(pmul(x,y),c); } + { return padd(pmul(x,y),c); } EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const { - return ei_pconj(ei_pmul(a, b)); + return pconj(pmul(a, b)); } }; -template<> EIGEN_STRONG_INLINE Packet2cf ei_pdiv(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pdiv(const Packet2cf& a, const Packet2cf& b) { // TODO optimize it for AltiVec - Packet2cf res = ei_conj_helper().pmul(a,b); - Packet4f s = vec_madd(b.v, b.v, ei_p4f_ZERO); - return Packet2cf(ei_pdiv(res.v, vec_add(s,vec_perm(s, s, ei_p16uc_COMPLEX_REV)))); + Packet2cf res = conj_helper().pmul(a,b); + Packet4f s = vec_madd(b.v, b.v, p4f_ZERO); + return Packet2cf(pdiv(res.v, vec_add(s,vec_perm(s, s, p16uc_COMPLEX_REV)))); } +} // end namespace internal + #endif // EIGEN_COMPLEX_ALTIVEC_H diff --git a/Eigen/src/Core/arch/AltiVec/PacketMath.h b/Eigen/src/Core/arch/AltiVec/PacketMath.h index 8205beae5..88a8e3669 100644 --- a/Eigen/src/Core/arch/AltiVec/PacketMath.h +++ b/Eigen/src/Core/arch/AltiVec/PacketMath.h @@ -25,6 +25,8 @@ #ifndef EIGEN_PACKET_MATH_ALTIVEC_H #define EIGEN_PACKET_MATH_ALTIVEC_H +namespace internal { + #ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD #define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 4 #endif @@ -53,38 +55,38 @@ typedef __vector unsigned char Packet16uc; // and it doesn't really work to declare them global, so we define macros instead #define _EIGEN_DECLARE_CONST_FAST_Packet4f(NAME,X) \ - Packet4f ei_p4f_##NAME = (Packet4f) vec_splat_s32(X) + Packet4f p4f_##NAME = (Packet4f) vec_splat_s32(X) #define _EIGEN_DECLARE_CONST_FAST_Packet4i(NAME,X) \ - Packet4i ei_p4i_##NAME = vec_splat_s32(X) + Packet4i p4i_##NAME = vec_splat_s32(X) #define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \ - Packet4f ei_p4f_##NAME = ei_pset1(X) + Packet4f p4f_##NAME = pset1(X) #define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \ - Packet4f ei_p4f_##NAME = vreinterpretq_f32_u32(ei_pset1(X)) + Packet4f p4f_##NAME = vreinterpretq_f32_u32(pset1(X)) #define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \ - Packet4i ei_p4i_##NAME = ei_pset1(X) + Packet4i p4i_##NAME = pset1(X) #define DST_CHAN 1 #define DST_CTRL(size, count, stride) (((size) << 24) | ((count) << 16) | (stride)) // Define global static constants: -static Packet4f ei_p4f_COUNTDOWN = { 3.0, 2.0, 1.0, 0.0 }; -static Packet4i ei_p4i_COUNTDOWN = { 3, 2, 1, 0 }; -static Packet16uc ei_p16uc_REVERSE = {12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3}; -static Packet16uc ei_p16uc_FORWARD = vec_lvsl(0, (float*)0); +static Packet4f p4f_COUNTDOWN = { 3.0, 2.0, 1.0, 0.0 }; +static Packet4i p4i_COUNTDOWN = { 3, 2, 1, 0 }; +static Packet16uc p16uc_REVERSE = {12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3}; +static Packet16uc p16uc_FORWARD = vec_lvsl(0, (float*)0); static _EIGEN_DECLARE_CONST_FAST_Packet4f(ZERO, 0); static _EIGEN_DECLARE_CONST_FAST_Packet4i(ZERO, 0); static _EIGEN_DECLARE_CONST_FAST_Packet4i(ONE,1); static _EIGEN_DECLARE_CONST_FAST_Packet4i(MINUS16,-16); static _EIGEN_DECLARE_CONST_FAST_Packet4i(MINUS1,-1); -static Packet4f ei_p4f_ONE = vec_ctf(ei_p4i_ONE, 0); -static Packet4f ei_p4f_ZERO_ = (Packet4f) vec_sl((Packet4ui)ei_p4i_MINUS1, (Packet4ui)ei_p4i_MINUS1); +static Packet4f p4f_ONE = vec_ctf(p4i_ONE, 0); +static Packet4f p4f_ZERO_ = (Packet4f) vec_sl((Packet4ui)p4i_MINUS1, (Packet4ui)p4i_MINUS1); -template<> struct ei_packet_traits : ei_default_packet_traits +template<> struct packet_traits : default_packet_traits { typedef Packet4f type; enum { @@ -100,7 +102,7 @@ template<> struct ei_packet_traits : ei_default_packet_traits HasSqrt = 0 }; }; -template<> struct ei_packet_traits : ei_default_packet_traits +template<> struct packet_traits : default_packet_traits { typedef Packet4i type; enum { @@ -111,8 +113,8 @@ template<> struct ei_packet_traits : ei_default_packet_traits }; }; -template<> struct ei_unpacket_traits { typedef float type; enum {size=4}; }; -template<> struct ei_unpacket_traits { typedef int type; enum {size=4}; }; +template<> struct unpacket_traits { typedef float type; enum {size=4}; }; +template<> struct unpacket_traits { typedef int type; enum {size=4}; }; /* inline std::ostream & operator <<(std::ostream & s, const Packet4f & v) { @@ -158,7 +160,7 @@ inline std::ostream & operator <<(std::ostream & s, const Packetbi & v) return s; } */ -template<> EIGEN_STRONG_INLINE Packet4f ei_pset1(const float& from) { +template<> EIGEN_STRONG_INLINE Packet4f pset1(const float& from) { // Taken from http://developer.apple.com/hardwaredrivers/ve/alignment.html float EIGEN_ALIGN16 af[4]; af[0] = from; @@ -167,7 +169,7 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_pset1(const float& from) { return vc; } -template<> EIGEN_STRONG_INLINE Packet4i ei_pset1(const int& from) { +template<> EIGEN_STRONG_INLINE Packet4i pset1(const int& from) { int EIGEN_ALIGN16 ai[4]; ai[0] = from; Packet4i vc = vec_ld(0, ai); @@ -175,22 +177,22 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_pset1(const int& from) return vc; } -template<> EIGEN_STRONG_INLINE Packet4f ei_plset(const float& a) { return vec_add(ei_pset1(a), ei_p4f_COUNTDOWN); } -template<> EIGEN_STRONG_INLINE Packet4i ei_plset(const int& a) { return vec_add(ei_pset1(a), ei_p4i_COUNTDOWN); } +template<> EIGEN_STRONG_INLINE Packet4f plset(const float& a) { return vec_add(pset1(a), p4f_COUNTDOWN); } +template<> EIGEN_STRONG_INLINE Packet4i plset(const int& a) { return vec_add(pset1(a), p4i_COUNTDOWN); } -template<> EIGEN_STRONG_INLINE Packet4f ei_padd(const Packet4f& a, const Packet4f& b) { return vec_add(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_padd(const Packet4i& a, const Packet4i& b) { return vec_add(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f padd(const Packet4f& a, const Packet4f& b) { return vec_add(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i padd(const Packet4i& a, const Packet4i& b) { return vec_add(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_psub(const Packet4f& a, const Packet4f& b) { return vec_sub(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_psub(const Packet4i& a, const Packet4i& b) { return vec_sub(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f psub(const Packet4f& a, const Packet4f& b) { return vec_sub(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i psub(const Packet4i& a, const Packet4i& b) { return vec_sub(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pnegate(const Packet4f& a) { return ei_psub(ei_p4f_ZERO, a); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pnegate(const Packet4i& a) { return ei_psub(ei_p4i_ZERO, a); } +template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a) { return psub(p4f_ZERO, a); } +template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) { return psub(p4i_ZERO, a); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pmul(const Packet4f& a, const Packet4f& b) { return vec_madd(a,b,ei_p4f_ZERO); } +template<> EIGEN_STRONG_INLINE Packet4f pmul(const Packet4f& a, const Packet4f& b) { return vec_madd(a,b,p4f_ZERO); } /* Commented out: it's actually slower than processing it scalar * -template<> EIGEN_STRONG_INLINE Packet4i ei_pmul(const Packet4i& a, const Packet4i& b) +template<> EIGEN_STRONG_INLINE Packet4i pmul(const Packet4i& a, const Packet4i& b) { // Detailed in: http://freevec.org/content/32bit_signed_integer_multiplication_altivec //Set up constants, variables @@ -201,21 +203,21 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_pmul(const Packet4i& a, con b1 = vec_abs(b); // Get the signs using xor - Packet4bi sgn = (Packet4bi) vec_cmplt(vec_xor(a, b), ei_p4i_ZERO); + Packet4bi sgn = (Packet4bi) vec_cmplt(vec_xor(a, b), p4i_ZERO); // Do the multiplication for the asbolute values. - bswap = (Packet4i) vec_rl((Packet4ui) b1, (Packet4ui) ei_p4i_MINUS16 ); + bswap = (Packet4i) vec_rl((Packet4ui) b1, (Packet4ui) p4i_MINUS16 ); low_prod = vec_mulo((Packet8i) a1, (Packet8i)b1); - high_prod = vec_msum((Packet8i) a1, (Packet8i) bswap, ei_p4i_ZERO); - high_prod = (Packet4i) vec_sl((Packet4ui) high_prod, (Packet4ui) ei_p4i_MINUS16); + high_prod = vec_msum((Packet8i) a1, (Packet8i) bswap, p4i_ZERO); + high_prod = (Packet4i) vec_sl((Packet4ui) high_prod, (Packet4ui) p4i_MINUS16); prod = vec_add( low_prod, high_prod ); // NOR the product and select only the negative elements according to the sign mask prod_ = vec_nor(prod, prod); - prod_ = vec_sel(ei_p4i_ZERO, prod_, sgn); + prod_ = vec_sel(p4i_ZERO, prod_, sgn); // Add 1 to the result to get the negative numbers - v1sel = vec_sel(ei_p4i_ZERO, ei_p4i_ONE, sgn); + v1sel = vec_sel(p4i_ZERO, p4i_ONE, sgn); prod_ = vec_add(prod_, v1sel); // Merge the results back to the final vector. @@ -224,7 +226,7 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_pmul(const Packet4i& a, con return prod; } */ -template<> EIGEN_STRONG_INLINE Packet4f ei_pdiv(const Packet4f& a, const Packet4f& b) +template<> EIGEN_STRONG_INLINE Packet4f pdiv(const Packet4f& a, const Packet4f& b) { Packet4f t, y_0, y_1, res; @@ -232,45 +234,45 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_pdiv(const Packet4f& a, con y_0 = vec_re(b); // Do one Newton-Raphson iteration to get the needed accuracy - t = vec_nmsub(y_0, b, ei_p4f_ONE); + t = vec_nmsub(y_0, b, p4f_ONE); y_1 = vec_madd(y_0, t, y_0); - res = vec_madd(a, y_1, ei_p4f_ZERO); + res = vec_madd(a, y_1, p4f_ZERO); return res; } -template<> EIGEN_STRONG_INLINE Packet4i ei_pdiv(const Packet4i& /*a*/, const Packet4i& /*b*/) -{ ei_assert(false && "packet integer division are not supported by AltiVec"); - return ei_pset1(0); +template<> EIGEN_STRONG_INLINE Packet4i pdiv(const Packet4i& /*a*/, const Packet4i& /*b*/) +{ eigen_assert(false && "packet integer division are not supported by AltiVec"); + return pset1(0); } // for some weird raisons, it has to be overloaded for packet of integers -template<> EIGEN_STRONG_INLINE Packet4f ei_pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) { return vec_madd(a, b, c); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return ei_padd(ei_pmul(a,b), c); } +template<> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) { return vec_madd(a, b, c); } +template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return padd(pmul(a,b), c); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pmin(const Packet4f& a, const Packet4f& b) { return vec_min(a, b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmin(const Packet4i& a, const Packet4i& b) { return vec_min(a, b); } +template<> EIGEN_STRONG_INLINE Packet4f pmin(const Packet4f& a, const Packet4f& b) { return vec_min(a, b); } +template<> EIGEN_STRONG_INLINE Packet4i pmin(const Packet4i& a, const Packet4i& b) { return vec_min(a, b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pmax(const Packet4f& a, const Packet4f& b) { return vec_max(a, b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmax(const Packet4i& a, const Packet4i& b) { return vec_max(a, b); } +template<> EIGEN_STRONG_INLINE Packet4f pmax(const Packet4f& a, const Packet4f& b) { return vec_max(a, b); } +template<> EIGEN_STRONG_INLINE Packet4i pmax(const Packet4i& a, const Packet4i& b) { return vec_max(a, b); } // Logical Operations are not supported for float, so we have to reinterpret casts using NEON intrinsics -template<> EIGEN_STRONG_INLINE Packet4f ei_pand(const Packet4f& a, const Packet4f& b) { return vec_and(a, b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pand(const Packet4i& a, const Packet4i& b) { return vec_and(a, b); } +template<> EIGEN_STRONG_INLINE Packet4f pand(const Packet4f& a, const Packet4f& b) { return vec_and(a, b); } +template<> EIGEN_STRONG_INLINE Packet4i pand(const Packet4i& a, const Packet4i& b) { return vec_and(a, b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_por(const Packet4f& a, const Packet4f& b) { return vec_or(a, b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_por(const Packet4i& a, const Packet4i& b) { return vec_or(a, b); } +template<> EIGEN_STRONG_INLINE Packet4f por(const Packet4f& a, const Packet4f& b) { return vec_or(a, b); } +template<> EIGEN_STRONG_INLINE Packet4i por(const Packet4i& a, const Packet4i& b) { return vec_or(a, b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pxor(const Packet4f& a, const Packet4f& b) { return vec_xor(a, b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pxor(const Packet4i& a, const Packet4i& b) { return vec_xor(a, b); } +template<> EIGEN_STRONG_INLINE Packet4f pxor(const Packet4f& a, const Packet4f& b) { return vec_xor(a, b); } +template<> EIGEN_STRONG_INLINE Packet4i pxor(const Packet4i& a, const Packet4i& b) { return vec_xor(a, b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pandnot(const Packet4f& a, const Packet4f& b) { return vec_and(a, vec_nor(b, b)); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pandnot(const Packet4i& a, const Packet4i& b) { return vec_and(a, vec_nor(b, b)); } +template<> EIGEN_STRONG_INLINE Packet4f pandnot(const Packet4f& a, const Packet4f& b) { return vec_and(a, vec_nor(b, b)); } +template<> EIGEN_STRONG_INLINE Packet4i pandnot(const Packet4i& a, const Packet4i& b) { return vec_and(a, vec_nor(b, b)); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pload(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return vec_ld(0, from); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pload(const int* from) { EIGEN_DEBUG_ALIGNED_LOAD return vec_ld(0, from); } +template<> EIGEN_STRONG_INLINE Packet4f pload(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return vec_ld(0, from); } +template<> EIGEN_STRONG_INLINE Packet4i pload(const int* from) { EIGEN_DEBUG_ALIGNED_LOAD return vec_ld(0, from); } -template<> EIGEN_STRONG_INLINE Packet4f ei_ploadu(const float* from) +template<> EIGEN_STRONG_INLINE Packet4f ploadu(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD // Taken from http://developer.apple.com/hardwaredrivers/ve/alignment.html @@ -282,7 +284,7 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_ploadu(const float* from) return (Packet4f) vec_perm(MSQ, LSQ, mask); // align the data } -template<> EIGEN_STRONG_INLINE Packet4i ei_ploadu(const int* from) +template<> EIGEN_STRONG_INLINE Packet4i ploadu(const int* from) { EIGEN_DEBUG_ALIGNED_LOAD // Taken from http://developer.apple.com/hardwaredrivers/ve/alignment.html @@ -294,10 +296,10 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_ploadu(const int* from) return (Packet4i) vec_perm(MSQ, LSQ, mask); // align the data } -template<> EIGEN_STRONG_INLINE void ei_pstore(float* to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE vec_st(from, 0, to); } -template<> EIGEN_STRONG_INLINE void ei_pstore(int* to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE vec_st(from, 0, to); } +template<> EIGEN_STRONG_INLINE void pstore(float* to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE vec_st(from, 0, to); } +template<> EIGEN_STRONG_INLINE void pstore(int* to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE vec_st(from, 0, to); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu(float* to, const Packet4f& from) +template<> EIGEN_STRONG_INLINE void pstoreu(float* to, const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE // Taken from http://developer.apple.com/hardwaredrivers/ve/alignment.html @@ -315,7 +317,7 @@ template<> EIGEN_STRONG_INLINE void ei_pstoreu(float* to, const Packet4f vec_st( LSQ, 15, (unsigned char *)to ); // Store the LSQ part first vec_st( MSQ, 0, (unsigned char *)to ); // Store the MSQ part } -template<> EIGEN_STRONG_INLINE void ei_pstoreu(int* to, const Packet4i& from) +template<> EIGEN_STRONG_INLINE void pstoreu(int* to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE // Taken from http://developer.apple.com/hardwaredrivers/ve/alignment.html @@ -334,29 +336,29 @@ template<> EIGEN_STRONG_INLINE void ei_pstoreu(int* to, const Packet4i vec_st( MSQ, 0, (unsigned char *)to ); // Store the MSQ part } -template<> EIGEN_STRONG_INLINE void ei_prefetch(const float* addr) { vec_dstt(addr, DST_CTRL(2,2,32), DST_CHAN); } -template<> EIGEN_STRONG_INLINE void ei_prefetch(const int* addr) { vec_dstt(addr, DST_CTRL(2,2,32), DST_CHAN); } +template<> EIGEN_STRONG_INLINE void prefetch(const float* addr) { vec_dstt(addr, DST_CTRL(2,2,32), DST_CHAN); } +template<> EIGEN_STRONG_INLINE void prefetch(const int* addr) { vec_dstt(addr, DST_CTRL(2,2,32), DST_CHAN); } -template<> EIGEN_STRONG_INLINE float ei_pfirst(const Packet4f& a) { float EIGEN_ALIGN16 x[4]; vec_st(a, 0, x); return x[0]; } -template<> EIGEN_STRONG_INLINE int ei_pfirst(const Packet4i& a) { int EIGEN_ALIGN16 x[4]; vec_st(a, 0, x); return x[0]; } +template<> EIGEN_STRONG_INLINE float pfirst(const Packet4f& a) { float EIGEN_ALIGN16 x[4]; vec_st(a, 0, x); return x[0]; } +template<> EIGEN_STRONG_INLINE int pfirst(const Packet4i& a) { int EIGEN_ALIGN16 x[4]; vec_st(a, 0, x); return x[0]; } -template<> EIGEN_STRONG_INLINE Packet4f ei_preverse(const Packet4f& a) { return (Packet4f)vec_perm((Packet16uc)a,(Packet16uc)a, ei_p16uc_REVERSE); } -template<> EIGEN_STRONG_INLINE Packet4i ei_preverse(const Packet4i& a) { return (Packet4i)vec_perm((Packet16uc)a,(Packet16uc)a, ei_p16uc_REVERSE); } +template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a) { return (Packet4f)vec_perm((Packet16uc)a,(Packet16uc)a, p16uc_REVERSE); } +template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a) { return (Packet4i)vec_perm((Packet16uc)a,(Packet16uc)a, p16uc_REVERSE); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pabs(const Packet4f& a) { return vec_abs(a); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pabs(const Packet4i& a) { return vec_abs(a); } +template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a) { return vec_abs(a); } +template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a) { return vec_abs(a); } -template<> EIGEN_STRONG_INLINE float ei_predux(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux(const Packet4f& a) { Packet4f b, sum; b = (Packet4f) vec_sld(a, a, 8); sum = vec_add(a, b); b = (Packet4f) vec_sld(sum, sum, 4); sum = vec_add(sum, b); - return ei_pfirst(sum); + return pfirst(sum); } -template<> EIGEN_STRONG_INLINE Packet4f ei_preduxp(const Packet4f* vecs) +template<> EIGEN_STRONG_INLINE Packet4f preduxp(const Packet4f* vecs) { Packet4f v[4], sum[4]; @@ -384,15 +386,15 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_preduxp(const Packet4f* vec return sum[0]; } -template<> EIGEN_STRONG_INLINE int ei_predux(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux(const Packet4i& a) { Packet4i sum; - sum = vec_sums(a, ei_p4i_ZERO); - sum = vec_sld(sum, ei_p4i_ZERO, 12); - return ei_pfirst(sum); + sum = vec_sums(a, p4i_ZERO); + sum = vec_sld(sum, p4i_ZERO, 12); + return pfirst(sum); } -template<> EIGEN_STRONG_INLINE Packet4i ei_preduxp(const Packet4i* vecs) +template<> EIGEN_STRONG_INLINE Packet4i preduxp(const Packet4i* vecs) { Packet4i v[4], sum[4]; @@ -422,56 +424,56 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_preduxp(const Packet4i* vec // Other reduction functions: // mul -template<> EIGEN_STRONG_INLINE float ei_predux_mul(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_mul(const Packet4f& a) { Packet4f prod; - prod = ei_pmul(a, (Packet4f)vec_sld(a, a, 8)); - return ei_pfirst(ei_pmul(prod, (Packet4f)vec_sld(prod, prod, 4))); + prod = pmul(a, (Packet4f)vec_sld(a, a, 8)); + return pfirst(pmul(prod, (Packet4f)vec_sld(prod, prod, 4))); } -template<> EIGEN_STRONG_INLINE int ei_predux_mul(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_mul(const Packet4i& a) { EIGEN_ALIGN16 int aux[4]; - ei_pstore(aux, a); + pstore(aux, a); return aux[0] * aux[1] * aux[2] * aux[3]; } // min -template<> EIGEN_STRONG_INLINE float ei_predux_min(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_min(const Packet4f& a) { Packet4f b, res; b = vec_min(a, vec_sld(a, a, 8)); res = vec_min(b, vec_sld(b, b, 4)); - return ei_pfirst(res); + return pfirst(res); } -template<> EIGEN_STRONG_INLINE int ei_predux_min(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_min(const Packet4i& a) { Packet4i b, res; b = vec_min(a, vec_sld(a, a, 8)); res = vec_min(b, vec_sld(b, b, 4)); - return ei_pfirst(res); + return pfirst(res); } // max -template<> EIGEN_STRONG_INLINE float ei_predux_max(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_max(const Packet4f& a) { Packet4f b, res; b = vec_max(a, vec_sld(a, a, 8)); res = vec_max(b, vec_sld(b, b, 4)); - return ei_pfirst(res); + return pfirst(res); } -template<> EIGEN_STRONG_INLINE int ei_predux_max(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_max(const Packet4i& a) { Packet4i b, res; b = vec_max(a, vec_sld(a, a, 8)); res = vec_max(b, vec_sld(b, b, 4)); - return ei_pfirst(res); + return pfirst(res); } template -struct ei_palign_impl +struct palign_impl { EIGEN_STRONG_INLINE static void run(Packet4f& first, const Packet4f& second) { @@ -481,7 +483,7 @@ struct ei_palign_impl }; template -struct ei_palign_impl +struct palign_impl { EIGEN_STRONG_INLINE static void run(Packet4i& first, const Packet4i& second) { @@ -489,4 +491,7 @@ struct ei_palign_impl first = vec_sld(first, second, Offset*4); } }; + +} // end namespace internal + #endif // EIGEN_PACKET_MATH_ALTIVEC_H diff --git a/Eigen/src/Core/arch/NEON/Complex.h b/Eigen/src/Core/arch/NEON/Complex.h index 9678040e7..d1943ba3b 100644 --- a/Eigen/src/Core/arch/NEON/Complex.h +++ b/Eigen/src/Core/arch/NEON/Complex.h @@ -22,11 +22,13 @@ // License and a copy of the GNU General Public License along with // Eigen. If not, see . -#ifndef EIGEN_COMPLEX_ALTIVEC_H -#define EIGEN_COMPLEX_ALTIVEC_H +#ifndef EIGEN_COMPLEX_NEON_H +#define EIGEN_COMPLEX_NEON_H -static uint32x4_t ei_p4ui_CONJ_XOR = { 0x00000000, 0x80000000, 0x00000000, 0x80000000 }; -static uint32x2_t ei_p2ui_CONJ_XOR = { 0x00000000, 0x80000000 }; +namespace internal { + +static uint32x4_t p4ui_CONJ_XOR = { 0x00000000, 0x80000000, 0x00000000, 0x80000000 }; +static uint32x2_t p2ui_CONJ_XOR = { 0x00000000, 0x80000000 }; //---------- float ---------- struct Packet2cf @@ -36,7 +38,7 @@ struct Packet2cf Packet4f v; }; -template<> struct ei_packet_traits > : ei_default_packet_traits +template<> struct packet_traits > : default_packet_traits { typedef Packet2cf type; enum { @@ -56,9 +58,9 @@ template<> struct ei_packet_traits > : ei_default_packet_tr }; }; -template<> struct ei_unpacket_traits { typedef std::complex type; enum {size=2}; }; +template<> struct unpacket_traits { typedef std::complex type; enum {size=2}; }; -template<> EIGEN_STRONG_INLINE Packet2cf ei_pset1(const std::complex& from) +template<> EIGEN_STRONG_INLINE Packet2cf pset1(const std::complex& from) { float32x2_t r64; r64 = vld1_f32((float *)&from); @@ -66,15 +68,15 @@ template<> EIGEN_STRONG_INLINE Packet2cf ei_pset1(const std::complex< return Packet2cf(vcombine_f32(r64, r64)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_padd(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(ei_padd(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_psub(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(ei_psub(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pnegate(const Packet2cf& a) { return Packet2cf(ei_pnegate(a.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pconj(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE Packet2cf padd(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(padd(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf psub(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(psub(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(a.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) { - return Packet2cf(vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a.v), ei_p4ui_CONJ_XOR))); + return Packet2cf(vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a.v), p4ui_CONJ_XOR))); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pmul(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) { Packet4f v1, v2; float32x2_t a_lo, a_hi; @@ -88,7 +90,7 @@ template<> EIGEN_STRONG_INLINE Packet2cf ei_pmul(const Packet2cf& a, // Multiply the imag a with b v2 = vmulq_f32(v2, b.v); // Conjugate v2 - v2 = vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(v2), ei_p4ui_CONJ_XOR)); + v2 = vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(v2), p4ui_CONJ_XOR)); // Swap real/imag elements in v2. a_lo = vrev64_f32(vget_low_f32(v2)); a_hi = vrev64_f32(vget_high_f32(v2)); @@ -97,39 +99,39 @@ template<> EIGEN_STRONG_INLINE Packet2cf ei_pmul(const Packet2cf& a, return Packet2cf(vaddq_f32(v1, v2)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pand (const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pand (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(a.v),vreinterpretq_u32_f32(b.v)))); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_por (const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf por (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(a.v),vreinterpretq_u32_f32(b.v)))); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pxor (const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pxor (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a.v),vreinterpretq_u32_f32(b.v)))); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pandnot(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pandnot(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(a.v),vreinterpretq_u32_f32(b.v)))); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pload >(const std::complex* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(ei_pload((const float*)from)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_ploadu >(const std::complex* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ei_ploadu((const float*)from)); } +template<> EIGEN_STRONG_INLINE Packet2cf pload >(const std::complex* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload((const float*)from)); } +template<> EIGEN_STRONG_INLINE Packet2cf ploadu >(const std::complex* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu((const float*)from)); } -template<> EIGEN_STRONG_INLINE void ei_pstore >(std::complex * to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE ei_pstore((float*)to, from.v); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu >(std::complex * to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE ei_pstoreu((float*)to, from.v); } +template<> EIGEN_STRONG_INLINE void pstore >(std::complex * to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((float*)to, from.v); } +template<> EIGEN_STRONG_INLINE void pstoreu >(std::complex * to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((float*)to, from.v); } -template<> EIGEN_STRONG_INLINE void ei_prefetch >(const std::complex * addr) { __pld((float *)addr); } +template<> EIGEN_STRONG_INLINE void prefetch >(const std::complex * addr) { __pld((float *)addr); } -template<> EIGEN_STRONG_INLINE std::complex ei_pfirst(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex pfirst(const Packet2cf& a) { std::complex EIGEN_ALIGN16 x[2]; vst1q_f32((float *)x, a.v); return x[0]; } -template<> EIGEN_STRONG_INLINE Packet2cf ei_preverse(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a) { float32x2_t a_lo, a_hi; Packet4f a_r128; @@ -141,12 +143,12 @@ template<> EIGEN_STRONG_INLINE Packet2cf ei_preverse(const Packet2cf& a) return Packet2cf(a_r128); } -EIGEN_STRONG_INLINE Packet2cf ei_pcplxflip/**/(const Packet2cf& x) +EIGEN_STRONG_INLINE Packet2cf pcplxflip/**/(const Packet2cf& x) { return Packet2cf(vrev64q_f32(a.v)); } -template<> EIGEN_STRONG_INLINE std::complex ei_predux(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex predux(const Packet2cf& a) { float32x2_t a1, a2; std::complex s; @@ -159,7 +161,7 @@ template<> EIGEN_STRONG_INLINE std::complex ei_predux(const Pa return s; } -template<> EIGEN_STRONG_INLINE Packet2cf ei_preduxp(const Packet2cf* vecs) +template<> EIGEN_STRONG_INLINE Packet2cf preduxp(const Packet2cf* vecs) { Packet4f sum1, sum2, sum; @@ -171,7 +173,7 @@ template<> EIGEN_STRONG_INLINE Packet2cf ei_preduxp(const Packet2cf* return Packet2cf(sum); } -template<> EIGEN_STRONG_INLINE std::complex ei_predux_mul(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex predux_mul(const Packet2cf& a) { float32x2_t a1, a2, v1, v2, prod; std::complex s; @@ -187,7 +189,7 @@ template<> EIGEN_STRONG_INLINE std::complex ei_predux_mul(cons // Multiply the imag a with b v2 = vmul_f32(v2, a2); // Conjugate v2 - v2 = vreinterpret_f32_u32(veor_u32(vreinterpret_u32_f32(v2), ei_p2ui_CONJ_XOR)); + v2 = vreinterpret_f32_u32(veor_u32(vreinterpret_u32_f32(v2), p2ui_CONJ_XOR)); // Swap real/imag elements in v2. v2 = vrev64_f32(v2); // Add v1, v2 @@ -199,7 +201,7 @@ template<> EIGEN_STRONG_INLINE std::complex ei_predux_mul(cons } template -struct ei_palign_impl +struct palign_impl { EIGEN_STRONG_INLINE static void run(Packet2cf& first, const Packet2cf& second) { @@ -210,43 +212,43 @@ struct ei_palign_impl } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const - { return ei_padd(pmul(x,y),c); } + { return padd(pmul(x,y),c); } EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const { - return ei_pmul(a, ei_pconj(b)); + return pmul(a, pconj(b)); } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const - { return ei_padd(pmul(x,y),c); } + { return padd(pmul(x,y),c); } EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const { - return ei_pmul(ei_pconj(a), b); + return pmul(pconj(a), b); } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const - { return ei_padd(pmul(x,y),c); } + { return padd(pmul(x,y),c); } EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const { - return ei_pconj(ei_pmul(a, b)); + return pconj(pmul(a, b)); } }; -template<> EIGEN_STRONG_INLINE Packet2cf ei_pdiv(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pdiv(const Packet2cf& a, const Packet2cf& b) { // TODO optimize it for AltiVec - Packet2cf res = ei_conj_helper().pmul(a,b); + Packet2cf res = conj_helper().pmul(a,b); Packet4f s, rev_s; float32x2_t a_lo, a_hi; @@ -256,7 +258,9 @@ template<> EIGEN_STRONG_INLINE Packet2cf ei_pdiv(const Packet2cf& a, a_hi = vrev64_f32(vget_high_f32(s)); rev_s = vcombine_f32(a_lo, a_hi); - return Packet2cf(ei_pdiv(res.v, vaddq_f32(s,rev_s))); + return Packet2cf(pdiv(res.v, vaddq_f32(s,rev_s))); } -#endif // EIGEN_COMPLEX_ALTIVEC_H +} // end namespace internal + +#endif // EIGEN_COMPLEX_NEON_H diff --git a/Eigen/src/Core/arch/NEON/PacketMath.h b/Eigen/src/Core/arch/NEON/PacketMath.h index 8220ed07c..cae35d737 100644 --- a/Eigen/src/Core/arch/NEON/PacketMath.h +++ b/Eigen/src/Core/arch/NEON/PacketMath.h @@ -27,6 +27,8 @@ #ifndef EIGEN_PACKET_MATH_NEON_H #define EIGEN_PACKET_MATH_NEON_H +namespace internal { + #ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD #define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8 #endif @@ -45,19 +47,19 @@ typedef float32x4_t Packet4f; typedef int32x4_t Packet4i; #define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \ - const Packet4f ei_p4f_##NAME = ei_pset1(X) + const Packet4f p4f_##NAME = pset1(X) #define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \ - const Packet4f ei_p4f_##NAME = vreinterpretq_f32_u32(ei_pset1(X)) + const Packet4f p4f_##NAME = vreinterpretq_f32_u32(pset1(X)) #define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \ - const Packet4i ei_p4i_##NAME = ei_pset1(X) + const Packet4i p4i_##NAME = pset1(X) #ifndef __pld #define __pld(x) asm volatile ( " pld [%[addr]]\n" :: [addr] "r" (x) : "cc" ); #endif -template<> struct ei_packet_traits : ei_default_packet_traits +template<> struct packet_traits : default_packet_traits { typedef Packet4f type; enum { @@ -74,7 +76,7 @@ template<> struct ei_packet_traits : ei_default_packet_traits HasSqrt = 0 }; }; -template<> struct ei_packet_traits : ei_default_packet_traits +template<> struct packet_traits : default_packet_traits { typedef Packet4i type; enum { @@ -85,36 +87,36 @@ template<> struct ei_packet_traits : ei_default_packet_traits }; }; -template<> struct ei_unpacket_traits { typedef float type; enum {size=4}; }; -template<> struct ei_unpacket_traits { typedef int type; enum {size=4}; }; +template<> struct unpacket_traits { typedef float type; enum {size=4}; }; +template<> struct unpacket_traits { typedef int type; enum {size=4}; }; -template<> EIGEN_STRONG_INLINE Packet4f ei_pset1(const float& from) { return vdupq_n_f32(from); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pset1(const int& from) { return vdupq_n_s32(from); } +template<> EIGEN_STRONG_INLINE Packet4f pset1(const float& from) { return vdupq_n_f32(from); } +template<> EIGEN_STRONG_INLINE Packet4i pset1(const int& from) { return vdupq_n_s32(from); } -template<> EIGEN_STRONG_INLINE Packet4f ei_plset(const float& a) +template<> EIGEN_STRONG_INLINE Packet4f plset(const float& a) { Packet4f countdown = { 3, 2, 1, 0 }; - return vaddq_f32(ei_pset1(a), countdown); + return vaddq_f32(pset1(a), countdown); } -template<> EIGEN_STRONG_INLINE Packet4i ei_plset(const int& a) +template<> EIGEN_STRONG_INLINE Packet4i plset(const int& a) { Packet4i countdown = { 3, 2, 1, 0 }; - return vaddq_s32(ei_pset1(a), countdown); + return vaddq_s32(pset1(a), countdown); } -template<> EIGEN_STRONG_INLINE Packet4f ei_padd(const Packet4f& a, const Packet4f& b) { return vaddq_f32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_padd(const Packet4i& a, const Packet4i& b) { return vaddq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f padd(const Packet4f& a, const Packet4f& b) { return vaddq_f32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i padd(const Packet4i& a, const Packet4i& b) { return vaddq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_psub(const Packet4f& a, const Packet4f& b) { return vsubq_f32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_psub(const Packet4i& a, const Packet4i& b) { return vsubq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f psub(const Packet4f& a, const Packet4f& b) { return vsubq_f32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i psub(const Packet4i& a, const Packet4i& b) { return vsubq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pnegate(const Packet4f& a) { return vnegq_f32(a); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pnegate(const Packet4i& a) { return vnegq_s32(a); } +template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a) { return vnegq_f32(a); } +template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) { return vnegq_s32(a); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pmul(const Packet4f& a, const Packet4f& b) { return vmulq_f32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmul(const Packet4i& a, const Packet4i& b) { return vmulq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f pmul(const Packet4f& a, const Packet4f& b) { return vmulq_f32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pmul(const Packet4i& a, const Packet4i& b) { return vmulq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pdiv(const Packet4f& a, const Packet4f& b) +template<> EIGEN_STRONG_INLINE Packet4f pdiv(const Packet4f& a, const Packet4f& b) { Packet4f inv, restep, div; @@ -135,59 +137,59 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_pdiv(const Packet4f& a, con return div; } -template<> EIGEN_STRONG_INLINE Packet4i ei_pdiv(const Packet4i& /*a*/, const Packet4i& /*b*/) -{ ei_assert(false && "packet integer division are not supported by NEON"); - return ei_pset1(0); +template<> EIGEN_STRONG_INLINE Packet4i pdiv(const Packet4i& /*a*/, const Packet4i& /*b*/) +{ eigen_assert(false && "packet integer division are not supported by NEON"); + return pset1(0); } // for some weird raisons, it has to be overloaded for packet of integers -template<> EIGEN_STRONG_INLINE Packet4i ei_pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return ei_padd(ei_pmul(a,b), c); } +template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return padd(pmul(a,b), c); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pmin(const Packet4f& a, const Packet4f& b) { return vminq_f32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmin(const Packet4i& a, const Packet4i& b) { return vminq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f pmin(const Packet4f& a, const Packet4f& b) { return vminq_f32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pmin(const Packet4i& a, const Packet4i& b) { return vminq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pmax(const Packet4f& a, const Packet4f& b) { return vmaxq_f32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmax(const Packet4i& a, const Packet4i& b) { return vmaxq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f pmax(const Packet4f& a, const Packet4f& b) { return vmaxq_f32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pmax(const Packet4i& a, const Packet4i& b) { return vmaxq_s32(a,b); } // Logical Operations are not supported for float, so we have to reinterpret casts using NEON intrinsics -template<> EIGEN_STRONG_INLINE Packet4f ei_pand(const Packet4f& a, const Packet4f& b) +template<> EIGEN_STRONG_INLINE Packet4f pand(const Packet4f& a, const Packet4f& b) { return vreinterpretq_f32_u32(vandq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pand(const Packet4i& a, const Packet4i& b) { return vandq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pand(const Packet4i& a, const Packet4i& b) { return vandq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_por(const Packet4f& a, const Packet4f& b) +template<> EIGEN_STRONG_INLINE Packet4f por(const Packet4f& a, const Packet4f& b) { return vreinterpretq_f32_u32(vorrq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); } -template<> EIGEN_STRONG_INLINE Packet4i ei_por(const Packet4i& a, const Packet4i& b) { return vorrq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i por(const Packet4i& a, const Packet4i& b) { return vorrq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pxor(const Packet4f& a, const Packet4f& b) +template<> EIGEN_STRONG_INLINE Packet4f pxor(const Packet4f& a, const Packet4f& b) { return vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pxor(const Packet4i& a, const Packet4i& b) { return veorq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pxor(const Packet4i& a, const Packet4i& b) { return veorq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pandnot(const Packet4f& a, const Packet4f& b) +template<> EIGEN_STRONG_INLINE Packet4f pandnot(const Packet4f& a, const Packet4f& b) { return vreinterpretq_f32_u32(vbicq_u32(vreinterpretq_u32_f32(a),vreinterpretq_u32_f32(b))); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pandnot(const Packet4i& a, const Packet4i& b) { return vbicq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pandnot(const Packet4i& a, const Packet4i& b) { return vbicq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pload(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f32(from); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pload(const int* from) { EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s32(from); } +template<> EIGEN_STRONG_INLINE Packet4f pload(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f32(from); } +template<> EIGEN_STRONG_INLINE Packet4i pload(const int* from) { EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s32(from); } -template<> EIGEN_STRONG_INLINE Packet4f ei_ploadu(const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_f32(from); } -template<> EIGEN_STRONG_INLINE Packet4i ei_ploadu(const int* from) { EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_s32(from); } +template<> EIGEN_STRONG_INLINE Packet4f ploadu(const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_f32(from); } +template<> EIGEN_STRONG_INLINE Packet4i ploadu(const int* from) { EIGEN_DEBUG_UNALIGNED_LOAD return vld1q_s32(from); } -template<> EIGEN_STRONG_INLINE Packet4f ei_ploaddup(const float* from) +template<> EIGEN_STRONG_INLINE Packet4f ploaddup(const float* from) { float32x2_t lo, ho; lo = vdup_n_f32(*from); hi = vdup_n_f32(*from); return vcombine_f32(lo, hi); } -template<> EIGEN_STRONG_INLINE Packet4i ei_ploaddup(const float* from) +template<> EIGEN_STRONG_INLINE Packet4i ploaddup(const float* from) { int32x2_t lo, ho; lo = vdup_n_s32(*from); @@ -195,20 +197,20 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_ploaddup(const float* from) return vcombine_s32(lo, hi); } -template<> EIGEN_STRONG_INLINE void ei_pstore(float* to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_f32(to, from); } -template<> EIGEN_STRONG_INLINE void ei_pstore(int* to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_s32(to, from); } +template<> EIGEN_STRONG_INLINE void pstore(float* to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_f32(to, from); } +template<> EIGEN_STRONG_INLINE void pstore(int* to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_s32(to, from); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu(float* to, const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_f32(to, from); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu(int* to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_s32(to, from); } +template<> EIGEN_STRONG_INLINE void pstoreu(float* to, const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_f32(to, from); } +template<> EIGEN_STRONG_INLINE void pstoreu(int* to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_s32(to, from); } -template<> EIGEN_STRONG_INLINE void ei_prefetch(const float* addr) { __pld(addr); } -template<> EIGEN_STRONG_INLINE void ei_prefetch(const int* addr) { __pld(addr); } +template<> EIGEN_STRONG_INLINE void prefetch(const float* addr) { __pld(addr); } +template<> EIGEN_STRONG_INLINE void prefetch(const int* addr) { __pld(addr); } // FIXME only store the 2 first elements ? -template<> EIGEN_STRONG_INLINE float ei_pfirst(const Packet4f& a) { float EIGEN_ALIGN16 x[4]; vst1q_f32(x, a); return x[0]; } -template<> EIGEN_STRONG_INLINE int ei_pfirst(const Packet4i& a) { int EIGEN_ALIGN16 x[4]; vst1q_s32(x, a); return x[0]; } +template<> EIGEN_STRONG_INLINE float pfirst(const Packet4f& a) { float EIGEN_ALIGN16 x[4]; vst1q_f32(x, a); return x[0]; } +template<> EIGEN_STRONG_INLINE int pfirst(const Packet4i& a) { int EIGEN_ALIGN16 x[4]; vst1q_s32(x, a); return x[0]; } -template<> EIGEN_STRONG_INLINE Packet4f ei_preverse(const Packet4f& a) { +template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a) { float32x2_t a_lo, a_hi; Packet4f a_r64; @@ -217,7 +219,7 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_preverse(const Packet4f& a) { a_hi = vget_high_f32(a_r64); return vcombine_f32(a_hi, a_lo); } -template<> EIGEN_STRONG_INLINE Packet4i ei_preverse(const Packet4i& a) { +template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a) { int32x2_t a_lo, a_hi; Packet4i a_r64; @@ -226,10 +228,10 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_preverse(const Packet4i& a) { a_hi = vget_high_s32(a_r64); return vcombine_s32(a_hi, a_lo); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pabs(const Packet4f& a) { return vabsq_f32(a); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pabs(const Packet4i& a) { return vabsq_s32(a); } +template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a) { return vabsq_f32(a); } +template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a) { return vabsq_s32(a); } -template<> EIGEN_STRONG_INLINE float ei_predux(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux(const Packet4f& a) { float32x2_t a_lo, a_hi, sum; float s[2]; @@ -243,7 +245,7 @@ template<> EIGEN_STRONG_INLINE float ei_predux(const Packet4f& a) return s[0]; } -template<> EIGEN_STRONG_INLINE Packet4f ei_preduxp(const Packet4f* vecs) +template<> EIGEN_STRONG_INLINE Packet4f preduxp(const Packet4f* vecs) { float32x4x2_t vtrn1, vtrn2, res1, res2; Packet4f sum1, sum2, sum; @@ -263,7 +265,7 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_preduxp(const Packet4f* vec return sum; } -template<> EIGEN_STRONG_INLINE int ei_predux(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux(const Packet4i& a) { int32x2_t a_lo, a_hi, sum; int32_t s[2]; @@ -277,7 +279,7 @@ template<> EIGEN_STRONG_INLINE int ei_predux(const Packet4i& a) return s[0]; } -template<> EIGEN_STRONG_INLINE Packet4i ei_preduxp(const Packet4i* vecs) +template<> EIGEN_STRONG_INLINE Packet4i preduxp(const Packet4i* vecs) { int32x4x2_t vtrn1, vtrn2, res1, res2; Packet4i sum1, sum2, sum; @@ -299,7 +301,7 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_preduxp(const Packet4i* vec // Other reduction functions: // mul -template<> EIGEN_STRONG_INLINE float ei_predux_mul(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_mul(const Packet4f& a) { float32x2_t a_lo, a_hi, prod; float s[2]; @@ -315,7 +317,7 @@ template<> EIGEN_STRONG_INLINE float ei_predux_mul(const Packet4f& a) return s[0]; } -template<> EIGEN_STRONG_INLINE int ei_predux_mul(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_mul(const Packet4i& a) { int32x2_t a_lo, a_hi, prod; int32_t s[2]; @@ -333,7 +335,7 @@ template<> EIGEN_STRONG_INLINE int ei_predux_mul(const Packet4i& a) } // min -template<> EIGEN_STRONG_INLINE float ei_predux_min(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_min(const Packet4f& a) { float32x2_t a_lo, a_hi, min; float s[2]; @@ -346,7 +348,7 @@ template<> EIGEN_STRONG_INLINE float ei_predux_min(const Packet4f& a) return s[0]; } -template<> EIGEN_STRONG_INLINE int ei_predux_min(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_min(const Packet4i& a) { int32x2_t a_lo, a_hi, min; int32_t s[2]; @@ -361,7 +363,7 @@ template<> EIGEN_STRONG_INLINE int ei_predux_min(const Packet4i& a) } // max -template<> EIGEN_STRONG_INLINE float ei_predux_max(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_max(const Packet4f& a) { float32x2_t a_lo, a_hi, max; float s[2]; @@ -374,7 +376,7 @@ template<> EIGEN_STRONG_INLINE float ei_predux_max(const Packet4f& a) return s[0]; } -template<> EIGEN_STRONG_INLINE int ei_predux_max(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_max(const Packet4i& a) { int32x2_t a_lo, a_hi, max; int32_t s[2]; @@ -389,7 +391,7 @@ template<> EIGEN_STRONG_INLINE int ei_predux_max(const Packet4i& a) } template -struct ei_palign_impl +struct palign_impl { EIGEN_STRONG_INLINE static void run(Packet4f& first, const Packet4f& second) { @@ -399,7 +401,7 @@ struct ei_palign_impl }; template -struct ei_palign_impl +struct palign_impl { EIGEN_STRONG_INLINE static void run(Packet4i& first, const Packet4i& second) { @@ -407,4 +409,7 @@ struct ei_palign_impl first = vextq_s32(first, second, Offset); } }; + +} // end namespace internal + #endif // EIGEN_PACKET_MATH_NEON_H diff --git a/Eigen/src/Core/arch/SSE/Complex.h b/Eigen/src/Core/arch/SSE/Complex.h index 819d59364..cc686fc84 100644 --- a/Eigen/src/Core/arch/SSE/Complex.h +++ b/Eigen/src/Core/arch/SSE/Complex.h @@ -25,6 +25,8 @@ #ifndef EIGEN_COMPLEX_SSE_H #define EIGEN_COMPLEX_SSE_H +namespace internal { + //---------- float ---------- struct Packet2cf { @@ -33,7 +35,7 @@ struct Packet2cf __m128 v; }; -template<> struct ei_packet_traits > : ei_default_packet_traits +template<> struct packet_traits > : default_packet_traits { typedef Packet2cf type; enum { @@ -54,85 +56,85 @@ template<> struct ei_packet_traits > : ei_default_packet_tr }; }; -template<> struct ei_unpacket_traits { typedef std::complex type; enum {size=2}; }; +template<> struct unpacket_traits { typedef std::complex type; enum {size=2}; }; -template<> EIGEN_STRONG_INLINE Packet2cf ei_padd(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_add_ps(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_psub(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_sub_ps(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pnegate(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE Packet2cf padd(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_add_ps(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf psub(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_sub_ps(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x80000000,0x80000000,0x80000000)); return Packet2cf(_mm_xor_ps(a.v,mask)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pconj(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE Packet2cf pconj(const Packet2cf& a) { const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000)); return Packet2cf(_mm_xor_ps(a.v,mask)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pmul(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) { // TODO optimize it for SSE3 and 4 #ifdef EIGEN_VECTORIZE_SSE3 return Packet2cf(_mm_addsub_ps(_mm_mul_ps(_mm_moveldup_ps(a.v), b.v), _mm_mul_ps(_mm_movehdup_ps(a.v), - ei_vec4f_swizzle1(b.v, 1, 0, 3, 2)))); -// return Packet2cf(_mm_addsub_ps(_mm_mul_ps(ei_vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v), -// _mm_mul_ps(ei_vec4f_swizzle1(a.v, 1, 1, 3, 3), -// ei_vec4f_swizzle1(b.v, 1, 0, 3, 2)))); + vec4f_swizzle1(b.v, 1, 0, 3, 2)))); +// return Packet2cf(_mm_addsub_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v), +// _mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3), +// vec4f_swizzle1(b.v, 1, 0, 3, 2)))); #else const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x00000000,0x80000000,0x00000000)); - return Packet2cf(_mm_add_ps(_mm_mul_ps(ei_vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v), - _mm_xor_ps(_mm_mul_ps(ei_vec4f_swizzle1(a.v, 1, 1, 3, 3), - ei_vec4f_swizzle1(b.v, 1, 0, 3, 2)), mask))); + return Packet2cf(_mm_add_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v), + _mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3), + vec4f_swizzle1(b.v, 1, 0, 3, 2)), mask))); #endif } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pand (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_and_ps(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_por (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_or_ps(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pxor (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_xor_ps(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pandnot(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_andnot_ps(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pand (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_and_ps(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf por (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_or_ps(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pxor (const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_xor_ps(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pandnot(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_andnot_ps(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pload (const std::complex* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(ei_pload(&ei_real_ref(*from))); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_ploadu(const std::complex* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ei_ploadu(&ei_real_ref(*from))); } +template<> EIGEN_STRONG_INLINE Packet2cf pload (const std::complex* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload(&real_ref(*from))); } +template<> EIGEN_STRONG_INLINE Packet2cf ploadu(const std::complex* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu(&real_ref(*from))); } -template<> EIGEN_STRONG_INLINE void ei_pstore >(std::complex * to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE ei_pstore(&ei_real_ref(*to), from.v); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu >(std::complex * to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE ei_pstoreu(&ei_real_ref(*to), from.v); } +template<> EIGEN_STRONG_INLINE void pstore >(std::complex * to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore(&real_ref(*to), from.v); } +template<> EIGEN_STRONG_INLINE void pstoreu >(std::complex * to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu(&real_ref(*to), from.v); } -template<> EIGEN_STRONG_INLINE void ei_prefetch >(const std::complex * addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } +template<> EIGEN_STRONG_INLINE void prefetch >(const std::complex * addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pset1(const std::complex& from) +template<> EIGEN_STRONG_INLINE Packet2cf pset1(const std::complex& from) { Packet2cf res; res.v = _mm_loadl_pi(res.v, (const __m64*)&from); return Packet2cf(_mm_movelh_ps(res.v,res.v)); } -template<> EIGEN_STRONG_INLINE std::complex ei_pfirst(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex pfirst(const Packet2cf& a) { std::complex res; _mm_storel_pi((__m64*)&res, a.v); return res; } -template<> EIGEN_STRONG_INLINE Packet2cf ei_preverse(const Packet2cf& a) { return Packet2cf(_mm_castpd_ps(ei_preverse(_mm_castps_pd(a.v)))); } +template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a) { return Packet2cf(_mm_castpd_ps(preverse(_mm_castps_pd(a.v)))); } -template<> EIGEN_STRONG_INLINE std::complex ei_predux(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex predux(const Packet2cf& a) { - return ei_pfirst(Packet2cf(_mm_add_ps(a.v, _mm_movehl_ps(a.v,a.v)))); + return pfirst(Packet2cf(_mm_add_ps(a.v, _mm_movehl_ps(a.v,a.v)))); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_preduxp(const Packet2cf* vecs) +template<> EIGEN_STRONG_INLINE Packet2cf preduxp(const Packet2cf* vecs) { return Packet2cf(_mm_add_ps(_mm_movelh_ps(vecs[0].v,vecs[1].v), _mm_movehl_ps(vecs[1].v,vecs[0].v))); } -template<> EIGEN_STRONG_INLINE std::complex ei_predux_mul(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex predux_mul(const Packet2cf& a) { - return ei_pfirst(ei_pmul(a, Packet2cf(_mm_movehl_ps(a.v,a.v)))); + return pfirst(pmul(a, Packet2cf(_mm_movehl_ps(a.v,a.v)))); } template -struct ei_palign_impl +struct palign_impl { EIGEN_STRONG_INLINE static void run(Packet2cf& first, const Packet2cf& second) { @@ -144,89 +146,89 @@ struct ei_palign_impl } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const - { return ei_padd(pmul(x,y),c); } + { return padd(pmul(x,y),c); } EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const { #ifdef EIGEN_VECTORIZE_SSE3 - return ei_pmul(a, ei_pconj(b)); + return pmul(a, pconj(b)); #else const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000)); - return Packet2cf(_mm_add_ps(_mm_xor_ps(_mm_mul_ps(ei_vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v), mask), - _mm_mul_ps(ei_vec4f_swizzle1(a.v, 1, 1, 3, 3), - ei_vec4f_swizzle1(b.v, 1, 0, 3, 2)))); + return Packet2cf(_mm_add_ps(_mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v), mask), + _mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3), + vec4f_swizzle1(b.v, 1, 0, 3, 2)))); #endif } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const - { return ei_padd(pmul(x,y),c); } + { return padd(pmul(x,y),c); } EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const { #ifdef EIGEN_VECTORIZE_SSE3 - return ei_pmul(ei_pconj(a), b); + return pmul(pconj(a), b); #else const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000)); - return Packet2cf(_mm_add_ps(_mm_mul_ps(ei_vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v), - _mm_xor_ps(_mm_mul_ps(ei_vec4f_swizzle1(a.v, 1, 1, 3, 3), - ei_vec4f_swizzle1(b.v, 1, 0, 3, 2)), mask))); + return Packet2cf(_mm_add_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v), + _mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3), + vec4f_swizzle1(b.v, 1, 0, 3, 2)), mask))); #endif } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf& y, const Packet2cf& c) const - { return ei_padd(pmul(x,y),c); } + { return padd(pmul(x,y),c); } EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& b) const { #ifdef EIGEN_VECTORIZE_SSE3 - return ei_pconj(ei_pmul(a, b)); + return pconj(pmul(a, b)); #else const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0x00000000,0x80000000,0x00000000,0x80000000)); - return Packet2cf(_mm_sub_ps(_mm_xor_ps(_mm_mul_ps(ei_vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v), mask), - _mm_mul_ps(ei_vec4f_swizzle1(a.v, 1, 1, 3, 3), - ei_vec4f_swizzle1(b.v, 1, 0, 3, 2)))); + return Packet2cf(_mm_sub_ps(_mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a.v, 0, 0, 2, 2), b.v), mask), + _mm_mul_ps(vec4f_swizzle1(a.v, 1, 1, 3, 3), + vec4f_swizzle1(b.v, 1, 0, 3, 2)))); #endif } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet4f& x, const Packet2cf& y, const Packet2cf& c) const - { return ei_padd(c, pmul(x,y)); } + { return padd(c, pmul(x,y)); } EIGEN_STRONG_INLINE Packet2cf pmul(const Packet4f& x, const Packet2cf& y) const - { return Packet2cf(ei_pmul(x, y.v)); } + { return Packet2cf(Eigen::internal::pmul(x, y.v)); } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet4f& y, const Packet2cf& c) const - { return ei_padd(c, pmul(x,y)); } + { return padd(c, pmul(x,y)); } EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& x, const Packet4f& y) const - { return Packet2cf(ei_pmul(x.v, y)); } + { return Packet2cf(Eigen::internal::pmul(x.v, y)); } }; -template<> EIGEN_STRONG_INLINE Packet2cf ei_pdiv(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pdiv(const Packet2cf& a, const Packet2cf& b) { // TODO optimize it for SSE3 and 4 - Packet2cf res = ei_conj_helper().pmul(a,b); + Packet2cf res = conj_helper().pmul(a,b); __m128 s = _mm_mul_ps(b.v,b.v); return Packet2cf(_mm_div_ps(res.v,_mm_add_ps(s,_mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(s), 0xb1))))); } -EIGEN_STRONG_INLINE Packet2cf ei_pcplxflip/**/(const Packet2cf& x) +EIGEN_STRONG_INLINE Packet2cf pcplxflip/**/(const Packet2cf& x) { - return Packet2cf(ei_vec4f_swizzle1(x.v, 1, 0, 3, 2)); + return Packet2cf(vec4f_swizzle1(x.v, 1, 0, 3, 2)); } @@ -238,7 +240,7 @@ struct Packet1cd __m128d v; }; -template<> struct ei_packet_traits > : ei_default_packet_traits +template<> struct packet_traits > : default_packet_traits { typedef Packet1cd type; enum { @@ -259,77 +261,77 @@ template<> struct ei_packet_traits > : ei_default_packet_t }; }; -template<> struct ei_unpacket_traits { typedef std::complex type; enum {size=1}; }; +template<> struct unpacket_traits { typedef std::complex type; enum {size=1}; }; -template<> EIGEN_STRONG_INLINE Packet1cd ei_padd(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_add_pd(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_psub(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_sub_pd(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_pnegate(const Packet1cd& a) { return Packet1cd(ei_pnegate(a.v)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_pconj(const Packet1cd& a) +template<> EIGEN_STRONG_INLINE Packet1cd padd(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_add_pd(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet1cd psub(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_sub_pd(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(a.v)); } +template<> EIGEN_STRONG_INLINE Packet1cd pconj(const Packet1cd& a) { const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x80000000,0x0,0x0,0x0)); return Packet1cd(_mm_xor_pd(a.v,mask)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_pmul(const Packet1cd& a, const Packet1cd& b) +template<> EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) { // TODO optimize it for SSE3 and 4 #ifdef EIGEN_VECTORIZE_SSE3 - return Packet1cd(_mm_addsub_pd(_mm_mul_pd(ei_vec2d_swizzle1(a.v, 0, 0), b.v), - _mm_mul_pd(ei_vec2d_swizzle1(a.v, 1, 1), - ei_vec2d_swizzle1(b.v, 1, 0)))); + return Packet1cd(_mm_addsub_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 0, 0), b.v), + _mm_mul_pd(vec2d_swizzle1(a.v, 1, 1), + vec2d_swizzle1(b.v, 1, 0)))); #else const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x0,0x0,0x80000000,0x0)); - return Packet1cd(_mm_add_pd(_mm_mul_pd(ei_vec2d_swizzle1(a.v, 0, 0), b.v), - _mm_xor_pd(_mm_mul_pd(ei_vec2d_swizzle1(a.v, 1, 1), - ei_vec2d_swizzle1(b.v, 1, 0)), mask))); + return Packet1cd(_mm_add_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 0, 0), b.v), + _mm_xor_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 1, 1), + vec2d_swizzle1(b.v, 1, 0)), mask))); #endif } -template<> EIGEN_STRONG_INLINE Packet1cd ei_pand (const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_and_pd(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_por (const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_or_pd(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_pxor (const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_xor_pd(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_pandnot(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_andnot_pd(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet1cd pand (const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_and_pd(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet1cd por (const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_or_pd(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet1cd pxor (const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_xor_pd(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet1cd pandnot(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_andnot_pd(a.v,b.v)); } // FIXME force unaligned load, this is a temporary fix -template<> EIGEN_STRONG_INLINE Packet1cd ei_pload (const std::complex* from) -{ EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(ei_pload((const double*)from)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_ploadu(const std::complex* from) -{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ei_ploadu((const double*)from)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_pset1(const std::complex& from) -{ /* here we really have to use unaligned loads :( */ return ei_ploadu(&from); } +template<> EIGEN_STRONG_INLINE Packet1cd pload (const std::complex* from) +{ EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload((const double*)from)); } +template<> EIGEN_STRONG_INLINE Packet1cd ploadu(const std::complex* from) +{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu((const double*)from)); } +template<> EIGEN_STRONG_INLINE Packet1cd pset1(const std::complex& from) +{ /* here we really have to use unaligned loads :( */ return ploadu(&from); } // FIXME force unaligned store, this is a temporary fix -template<> EIGEN_STRONG_INLINE void ei_pstore >(std::complex * to, const Packet1cd& from) { EIGEN_DEBUG_ALIGNED_STORE ei_pstore((double*)to, from.v); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu >(std::complex * to, const Packet1cd& from) { EIGEN_DEBUG_UNALIGNED_STORE ei_pstoreu((double*)to, from.v); } +template<> EIGEN_STRONG_INLINE void pstore >(std::complex * to, const Packet1cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, from.v); } +template<> EIGEN_STRONG_INLINE void pstoreu >(std::complex * to, const Packet1cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, from.v); } -template<> EIGEN_STRONG_INLINE void ei_prefetch >(const std::complex * addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } +template<> EIGEN_STRONG_INLINE void prefetch >(const std::complex * addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } -template<> EIGEN_STRONG_INLINE std::complex ei_pfirst(const Packet1cd& a) +template<> EIGEN_STRONG_INLINE std::complex pfirst(const Packet1cd& a) { EIGEN_ALIGN16 double res[2]; _mm_store_pd(res, a.v); return std::complex(res[0],res[1]); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_preverse(const Packet1cd& a) { return a; } +template<> EIGEN_STRONG_INLINE Packet1cd preverse(const Packet1cd& a) { return a; } -template<> EIGEN_STRONG_INLINE std::complex ei_predux(const Packet1cd& a) +template<> EIGEN_STRONG_INLINE std::complex predux(const Packet1cd& a) { - return ei_pfirst(a); + return pfirst(a); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_preduxp(const Packet1cd* vecs) +template<> EIGEN_STRONG_INLINE Packet1cd preduxp(const Packet1cd* vecs) { return vecs[0]; } -template<> EIGEN_STRONG_INLINE std::complex ei_predux_mul(const Packet1cd& a) +template<> EIGEN_STRONG_INLINE std::complex predux_mul(const Packet1cd& a) { - return ei_pfirst(a); + return pfirst(a); } template -struct ei_palign_impl +struct palign_impl { EIGEN_STRONG_INLINE static void run(Packet1cd& /*first*/, const Packet1cd& /*second*/) { @@ -338,89 +340,91 @@ struct ei_palign_impl } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const - { return ei_padd(pmul(x,y),c); } + { return padd(pmul(x,y),c); } EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const { #ifdef EIGEN_VECTORIZE_SSE3 - return ei_pmul(a, ei_pconj(b)); + return pmul(a, pconj(b)); #else const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x80000000,0x0,0x0,0x0)); - return Packet1cd(_mm_add_pd(_mm_xor_pd(_mm_mul_pd(ei_vec2d_swizzle1(a.v, 0, 0), b.v), mask), - _mm_mul_pd(ei_vec2d_swizzle1(a.v, 1, 1), - ei_vec2d_swizzle1(b.v, 1, 0)))); + return Packet1cd(_mm_add_pd(_mm_xor_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 0, 0), b.v), mask), + _mm_mul_pd(vec2d_swizzle1(a.v, 1, 1), + vec2d_swizzle1(b.v, 1, 0)))); #endif } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const - { return ei_padd(pmul(x,y),c); } + { return padd(pmul(x,y),c); } EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const { #ifdef EIGEN_VECTORIZE_SSE3 - return ei_pmul(ei_pconj(a), b); + return pmul(pconj(a), b); #else const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x80000000,0x0,0x0,0x0)); - return Packet1cd(_mm_add_pd(_mm_mul_pd(ei_vec2d_swizzle1(a.v, 0, 0), b.v), - _mm_xor_pd(_mm_mul_pd(ei_vec2d_swizzle1(a.v, 1, 1), - ei_vec2d_swizzle1(b.v, 1, 0)), mask))); + return Packet1cd(_mm_add_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 0, 0), b.v), + _mm_xor_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 1, 1), + vec2d_swizzle1(b.v, 1, 0)), mask))); #endif } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd& y, const Packet1cd& c) const - { return ei_padd(pmul(x,y),c); } + { return padd(pmul(x,y),c); } EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const { #ifdef EIGEN_VECTORIZE_SSE3 - return ei_pconj(ei_pmul(a, b)); + return pconj(pmul(a, b)); #else const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x80000000,0x0,0x0,0x0)); - return Packet1cd(_mm_sub_pd(_mm_xor_pd(_mm_mul_pd(ei_vec2d_swizzle1(a.v, 0, 0), b.v), mask), - _mm_mul_pd(ei_vec2d_swizzle1(a.v, 1, 1), - ei_vec2d_swizzle1(b.v, 1, 0)))); + return Packet1cd(_mm_sub_pd(_mm_xor_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 0, 0), b.v), mask), + _mm_mul_pd(vec2d_swizzle1(a.v, 1, 1), + vec2d_swizzle1(b.v, 1, 0)))); #endif } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet2d& x, const Packet1cd& y, const Packet1cd& c) const - { return ei_padd(c, pmul(x,y)); } + { return padd(c, pmul(x,y)); } EIGEN_STRONG_INLINE Packet1cd pmul(const Packet2d& x, const Packet1cd& y) const - { return Packet1cd(ei_pmul(x, y.v)); } + { return Packet1cd(Eigen::internal::pmul(x, y.v)); } }; -template<> struct ei_conj_helper +template<> struct conj_helper { EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet2d& y, const Packet1cd& c) const - { return ei_padd(c, pmul(x,y)); } + { return padd(c, pmul(x,y)); } EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& x, const Packet2d& y) const - { return Packet1cd(ei_pmul(x.v, y)); } + { return Packet1cd(Eigen::internal::pmul(x.v, y)); } }; -template<> EIGEN_STRONG_INLINE Packet1cd ei_pdiv(const Packet1cd& a, const Packet1cd& b) +template<> EIGEN_STRONG_INLINE Packet1cd pdiv(const Packet1cd& a, const Packet1cd& b) { // TODO optimize it for SSE3 and 4 - Packet1cd res = ei_conj_helper().pmul(a,b); + Packet1cd res = conj_helper().pmul(a,b); __m128d s = _mm_mul_pd(b.v,b.v); return Packet1cd(_mm_div_pd(res.v, _mm_add_pd(s,_mm_shuffle_pd(s, s, 0x1)))); } -EIGEN_STRONG_INLINE Packet1cd ei_pcplxflip/**/(const Packet1cd& x) +EIGEN_STRONG_INLINE Packet1cd pcplxflip/**/(const Packet1cd& x) { - return Packet1cd(ei_preverse(x.v)); + return Packet1cd(preverse(x.v)); } +} // end namespace internal + #endif // EIGEN_COMPLEX_SSE_H diff --git a/Eigen/src/Core/arch/SSE/MathFunctions.h b/Eigen/src/Core/arch/SSE/MathFunctions.h index cb73fd205..9d56d8218 100644 --- a/Eigen/src/Core/arch/SSE/MathFunctions.h +++ b/Eigen/src/Core/arch/SSE/MathFunctions.h @@ -30,8 +30,10 @@ #ifndef EIGEN_MATH_FUNCTIONS_SSE_H #define EIGEN_MATH_FUNCTIONS_SSE_H +namespace internal { + template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED -Packet4f ei_plog(const Packet4f& _x) +Packet4f plog(const Packet4f& _x) { Packet4f x = _x; _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f); @@ -64,15 +66,15 @@ Packet4f ei_plog(const Packet4f& _x) Packet4f invalid_mask = _mm_cmple_ps(x, _mm_setzero_ps()); - x = ei_pmax(x, ei_p4f_min_norm_pos); /* cut off denormalized stuff */ + x = pmax(x, p4f_min_norm_pos); /* cut off denormalized stuff */ emm0 = _mm_srli_epi32(_mm_castps_si128(x), 23); /* keep only the fractional part */ - x = _mm_and_ps(x, ei_p4f_inv_mant_mask); - x = _mm_or_ps(x, ei_p4f_half); + x = _mm_and_ps(x, p4f_inv_mant_mask); + x = _mm_or_ps(x, p4f_half); - emm0 = _mm_sub_epi32(emm0, ei_p4i_0x7f); - Packet4f e = ei_padd(_mm_cvtepi32_ps(emm0), ei_p4f_1); + emm0 = _mm_sub_epi32(emm0, p4i_0x7f); + Packet4f e = padd(_mm_cvtepi32_ps(emm0), p4f_1); /* part2: if( x < SQRTHF ) { @@ -80,38 +82,38 @@ Packet4f ei_plog(const Packet4f& _x) x = x + x - 1.0; } else { x = x - 1.0; } */ - Packet4f mask = _mm_cmplt_ps(x, ei_p4f_cephes_SQRTHF); + Packet4f mask = _mm_cmplt_ps(x, p4f_cephes_SQRTHF); Packet4f tmp = _mm_and_ps(x, mask); - x = ei_psub(x, ei_p4f_1); - e = ei_psub(e, _mm_and_ps(ei_p4f_1, mask)); - x = ei_padd(x, tmp); + x = psub(x, p4f_1); + e = psub(e, _mm_and_ps(p4f_1, mask)); + x = padd(x, tmp); - Packet4f x2 = ei_pmul(x,x); - Packet4f x3 = ei_pmul(x2,x); + Packet4f x2 = pmul(x,x); + Packet4f x3 = pmul(x2,x); Packet4f y, y1, y2; - y = ei_pmadd(ei_p4f_cephes_log_p0, x, ei_p4f_cephes_log_p1); - y1 = ei_pmadd(ei_p4f_cephes_log_p3, x, ei_p4f_cephes_log_p4); - y2 = ei_pmadd(ei_p4f_cephes_log_p6, x, ei_p4f_cephes_log_p7); - y = ei_pmadd(y , x, ei_p4f_cephes_log_p2); - y1 = ei_pmadd(y1, x, ei_p4f_cephes_log_p5); - y2 = ei_pmadd(y2, x, ei_p4f_cephes_log_p8); - y = ei_pmadd(y, x3, y1); - y = ei_pmadd(y, x3, y2); - y = ei_pmul(y, x3); - - y1 = ei_pmul(e, ei_p4f_cephes_log_q1); - tmp = ei_pmul(x2, ei_p4f_half); - y = ei_padd(y, y1); - x = ei_psub(x, tmp); - y2 = ei_pmul(e, ei_p4f_cephes_log_q2); - x = ei_padd(x, y); - x = ei_padd(x, y2); + y = pmadd(p4f_cephes_log_p0, x, p4f_cephes_log_p1); + y1 = pmadd(p4f_cephes_log_p3, x, p4f_cephes_log_p4); + y2 = pmadd(p4f_cephes_log_p6, x, p4f_cephes_log_p7); + y = pmadd(y , x, p4f_cephes_log_p2); + y1 = pmadd(y1, x, p4f_cephes_log_p5); + y2 = pmadd(y2, x, p4f_cephes_log_p8); + y = pmadd(y, x3, y1); + y = pmadd(y, x3, y2); + y = pmul(y, x3); + + y1 = pmul(e, p4f_cephes_log_q1); + tmp = pmul(x2, p4f_half); + y = padd(y, y1); + x = psub(x, tmp); + y2 = pmul(e, p4f_cephes_log_q2); + x = padd(x, y); + x = padd(x, y2); return _mm_or_ps(x, invalid_mask); // negative arg will be NAN } template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED -Packet4f ei_pexp(const Packet4f& _x) +Packet4f pexp(const Packet4f& _x) { Packet4f x = _x; _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f); @@ -137,40 +139,40 @@ Packet4f ei_pexp(const Packet4f& _x) Packet4i emm0; // clamp x - x = ei_pmax(ei_pmin(x, ei_p4f_exp_hi), ei_p4f_exp_lo); + x = pmax(pmin(x, p4f_exp_hi), p4f_exp_lo); /* express exp(x) as exp(g + n*log(2)) */ - fx = ei_pmadd(x, ei_p4f_cephes_LOG2EF, ei_p4f_half); + fx = pmadd(x, p4f_cephes_LOG2EF, p4f_half); /* how to perform a floorf with SSE: just below */ emm0 = _mm_cvttps_epi32(fx); tmp = _mm_cvtepi32_ps(emm0); /* if greater, substract 1 */ Packet4f mask = _mm_cmpgt_ps(tmp, fx); - mask = _mm_and_ps(mask, ei_p4f_1); - fx = ei_psub(tmp, mask); + mask = _mm_and_ps(mask, p4f_1); + fx = psub(tmp, mask); - tmp = ei_pmul(fx, ei_p4f_cephes_exp_C1); - Packet4f z = ei_pmul(fx, ei_p4f_cephes_exp_C2); - x = ei_psub(x, tmp); - x = ei_psub(x, z); + tmp = pmul(fx, p4f_cephes_exp_C1); + Packet4f z = pmul(fx, p4f_cephes_exp_C2); + x = psub(x, tmp); + x = psub(x, z); - z = ei_pmul(x,x); + z = pmul(x,x); - Packet4f y = ei_p4f_cephes_exp_p0; - y = ei_pmadd(y, x, ei_p4f_cephes_exp_p1); - y = ei_pmadd(y, x, ei_p4f_cephes_exp_p2); - y = ei_pmadd(y, x, ei_p4f_cephes_exp_p3); - y = ei_pmadd(y, x, ei_p4f_cephes_exp_p4); - y = ei_pmadd(y, x, ei_p4f_cephes_exp_p5); - y = ei_pmadd(y, z, x); - y = ei_padd(y, ei_p4f_1); + Packet4f y = p4f_cephes_exp_p0; + y = pmadd(y, x, p4f_cephes_exp_p1); + y = pmadd(y, x, p4f_cephes_exp_p2); + y = pmadd(y, x, p4f_cephes_exp_p3); + y = pmadd(y, x, p4f_cephes_exp_p4); + y = pmadd(y, x, p4f_cephes_exp_p5); + y = pmadd(y, z, x); + y = padd(y, p4f_1); /* build 2^n */ emm0 = _mm_cvttps_epi32(fx); - emm0 = _mm_add_epi32(emm0, ei_p4i_0x7f); + emm0 = _mm_add_epi32(emm0, p4i_0x7f); emm0 = _mm_slli_epi32(emm0, 23); - return ei_pmul(y, _mm_castsi128_ps(emm0)); + return pmul(y, _mm_castsi128_ps(emm0)); } /* evaluation of 4 sines at onces, using SSE2 intrinsics. @@ -186,7 +188,7 @@ Packet4f ei_pexp(const Packet4f& _x) */ template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED -Packet4f ei_psin(const Packet4f& _x) +Packet4f psin(const Packet4f& _x) { Packet4f x = _x; _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f); @@ -215,24 +217,24 @@ Packet4f ei_psin(const Packet4f& _x) Packet4i emm0, emm2; sign_bit = x; /* take the absolute value */ - x = ei_pabs(x); + x = pabs(x); /* take the modulo */ /* extract the sign bit (upper one) */ - sign_bit = _mm_and_ps(sign_bit, ei_p4f_sign_mask); + sign_bit = _mm_and_ps(sign_bit, p4f_sign_mask); /* scale by 4/Pi */ - y = ei_pmul(x, ei_p4f_cephes_FOPI); + y = pmul(x, p4f_cephes_FOPI); /* store the integer part of y in mm0 */ emm2 = _mm_cvttps_epi32(y); /* j=(j+1) & (~1) (see the cephes sources) */ - emm2 = _mm_add_epi32(emm2, ei_p4i_1); - emm2 = _mm_and_si128(emm2, ei_p4i_not1); + emm2 = _mm_add_epi32(emm2, p4i_1); + emm2 = _mm_and_si128(emm2, p4i_not1); y = _mm_cvtepi32_ps(emm2); /* get the swap sign flag */ - emm0 = _mm_and_si128(emm2, ei_p4i_4); + emm0 = _mm_and_si128(emm2, p4i_4); emm0 = _mm_slli_epi32(emm0, 29); /* get the polynom selection mask there is one polynom for 0 <= x <= Pi/4 @@ -240,7 +242,7 @@ Packet4f ei_psin(const Packet4f& _x) Both branches will be computed. */ - emm2 = _mm_and_si128(emm2, ei_p4i_2); + emm2 = _mm_and_si128(emm2, p4i_2); emm2 = _mm_cmpeq_epi32(emm2, _mm_setzero_si128()); Packet4f swap_sign_bit = _mm_castsi128_ps(emm0); @@ -249,33 +251,33 @@ Packet4f ei_psin(const Packet4f& _x) /* The magic pass: "Extended precision modular arithmetic" x = ((x - y * DP1) - y * DP2) - y * DP3; */ - xmm1 = ei_pmul(y, ei_p4f_minus_cephes_DP1); - xmm2 = ei_pmul(y, ei_p4f_minus_cephes_DP2); - xmm3 = ei_pmul(y, ei_p4f_minus_cephes_DP3); - x = ei_padd(x, xmm1); - x = ei_padd(x, xmm2); - x = ei_padd(x, xmm3); + xmm1 = pmul(y, p4f_minus_cephes_DP1); + xmm2 = pmul(y, p4f_minus_cephes_DP2); + xmm3 = pmul(y, p4f_minus_cephes_DP3); + x = padd(x, xmm1); + x = padd(x, xmm2); + x = padd(x, xmm3); /* Evaluate the first polynom (0 <= x <= Pi/4) */ - y = ei_p4f_coscof_p0; + y = p4f_coscof_p0; Packet4f z = _mm_mul_ps(x,x); - y = ei_pmadd(y, z, ei_p4f_coscof_p1); - y = ei_pmadd(y, z, ei_p4f_coscof_p2); - y = ei_pmul(y, z); - y = ei_pmul(y, z); - Packet4f tmp = ei_pmul(z, ei_p4f_half); - y = ei_psub(y, tmp); - y = ei_padd(y, ei_p4f_1); + y = pmadd(y, z, p4f_coscof_p1); + y = pmadd(y, z, p4f_coscof_p2); + y = pmul(y, z); + y = pmul(y, z); + Packet4f tmp = pmul(z, p4f_half); + y = psub(y, tmp); + y = padd(y, p4f_1); /* Evaluate the second polynom (Pi/4 <= x <= 0) */ - Packet4f y2 = ei_p4f_sincof_p0; - y2 = ei_pmadd(y2, z, ei_p4f_sincof_p1); - y2 = ei_pmadd(y2, z, ei_p4f_sincof_p2); - y2 = ei_pmul(y2, z); - y2 = ei_pmul(y2, x); - y2 = ei_padd(y2, x); + Packet4f y2 = p4f_sincof_p0; + y2 = pmadd(y2, z, p4f_sincof_p1); + y2 = pmadd(y2, z, p4f_sincof_p2); + y2 = pmul(y2, z); + y2 = pmul(y2, x); + y2 = padd(y2, x); /* select the correct result from the two polynoms */ y2 = _mm_and_ps(poly_mask, y2); @@ -285,9 +287,9 @@ Packet4f ei_psin(const Packet4f& _x) return _mm_xor_ps(y, sign_bit); } -/* almost the same as ei_psin */ +/* almost the same as psin */ template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED -Packet4f ei_pcos(const Packet4f& _x) +Packet4f pcos(const Packet4f& _x) { Packet4f x = _x; _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f); @@ -312,25 +314,25 @@ Packet4f ei_pcos(const Packet4f& _x) Packet4f xmm1, xmm2 = _mm_setzero_ps(), xmm3, y; Packet4i emm0, emm2; - x = ei_pabs(x); + x = pabs(x); /* scale by 4/Pi */ - y = ei_pmul(x, ei_p4f_cephes_FOPI); + y = pmul(x, p4f_cephes_FOPI); /* get the integer part of y */ emm2 = _mm_cvttps_epi32(y); /* j=(j+1) & (~1) (see the cephes sources) */ - emm2 = _mm_add_epi32(emm2, ei_p4i_1); - emm2 = _mm_and_si128(emm2, ei_p4i_not1); + emm2 = _mm_add_epi32(emm2, p4i_1); + emm2 = _mm_and_si128(emm2, p4i_not1); y = _mm_cvtepi32_ps(emm2); - emm2 = _mm_sub_epi32(emm2, ei_p4i_2); + emm2 = _mm_sub_epi32(emm2, p4i_2); /* get the swap sign flag */ - emm0 = _mm_andnot_si128(emm2, ei_p4i_4); + emm0 = _mm_andnot_si128(emm2, p4i_4); emm0 = _mm_slli_epi32(emm0, 29); /* get the polynom selection mask */ - emm2 = _mm_and_si128(emm2, ei_p4i_2); + emm2 = _mm_and_si128(emm2, p4i_2); emm2 = _mm_cmpeq_epi32(emm2, _mm_setzero_si128()); Packet4f sign_bit = _mm_castsi128_ps(emm0); @@ -338,31 +340,31 @@ Packet4f ei_pcos(const Packet4f& _x) /* The magic pass: "Extended precision modular arithmetic" x = ((x - y * DP1) - y * DP2) - y * DP3; */ - xmm1 = ei_pmul(y, ei_p4f_minus_cephes_DP1); - xmm2 = ei_pmul(y, ei_p4f_minus_cephes_DP2); - xmm3 = ei_pmul(y, ei_p4f_minus_cephes_DP3); - x = ei_padd(x, xmm1); - x = ei_padd(x, xmm2); - x = ei_padd(x, xmm3); + xmm1 = pmul(y, p4f_minus_cephes_DP1); + xmm2 = pmul(y, p4f_minus_cephes_DP2); + xmm3 = pmul(y, p4f_minus_cephes_DP3); + x = padd(x, xmm1); + x = padd(x, xmm2); + x = padd(x, xmm3); /* Evaluate the first polynom (0 <= x <= Pi/4) */ - y = ei_p4f_coscof_p0; - Packet4f z = ei_pmul(x,x); + y = p4f_coscof_p0; + Packet4f z = pmul(x,x); - y = ei_pmadd(y,z,ei_p4f_coscof_p1); - y = ei_pmadd(y,z,ei_p4f_coscof_p2); - y = ei_pmul(y, z); - y = ei_pmul(y, z); - Packet4f tmp = _mm_mul_ps(z, ei_p4f_half); - y = ei_psub(y, tmp); - y = ei_padd(y, ei_p4f_1); + y = pmadd(y,z,p4f_coscof_p1); + y = pmadd(y,z,p4f_coscof_p2); + y = pmul(y, z); + y = pmul(y, z); + Packet4f tmp = _mm_mul_ps(z, p4f_half); + y = psub(y, tmp); + y = padd(y, p4f_1); /* Evaluate the second polynom (Pi/4 <= x <= 0) */ - Packet4f y2 = ei_p4f_sincof_p0; - y2 = ei_pmadd(y2, z, ei_p4f_sincof_p1); - y2 = ei_pmadd(y2, z, ei_p4f_sincof_p2); - y2 = ei_pmul(y2, z); - y2 = ei_pmadd(y2, x, x); + Packet4f y2 = p4f_sincof_p0; + y2 = pmadd(y2, z, p4f_sincof_p1); + y2 = pmadd(y2, z, p4f_sincof_p2); + y2 = pmul(y2, z); + y2 = pmadd(y2, x, x); /* select the correct result from the two polynoms */ y2 = _mm_and_ps(poly_mask, y2); @@ -376,16 +378,18 @@ Packet4f ei_pcos(const Packet4f& _x) // This is based on Quake3's fast inverse square root. // For detail see here: http://www.beyond3d.com/content/articles/8/ template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED -Packet4f ei_psqrt(const Packet4f& _x) +Packet4f psqrt(const Packet4f& _x) { - Packet4f half = ei_pmul(_x, ei_pset1(.5f)); + Packet4f half = pmul(_x, pset1(.5f)); /* select only the inverse sqrt of non-zero inputs */ - Packet4f non_zero_mask = _mm_cmpgt_ps(_x, ei_pset1(std::numeric_limits::epsilon())); + Packet4f non_zero_mask = _mm_cmpgt_ps(_x, pset1(std::numeric_limits::epsilon())); Packet4f x = _mm_and_ps(non_zero_mask, _mm_rsqrt_ps(_x)); - x = ei_pmul(x, ei_psub(ei_pset1(1.5f), ei_pmul(half, ei_pmul(x,x)))); - return ei_pmul(_x,x); + x = pmul(x, psub(pset1(1.5f), pmul(half, pmul(x,x)))); + return pmul(_x,x); } +} // end namespace internal + #endif // EIGEN_MATH_FUNCTIONS_SSE_H diff --git a/Eigen/src/Core/arch/SSE/PacketMath.h b/Eigen/src/Core/arch/SSE/PacketMath.h index a7206e77d..98a5a3426 100644 --- a/Eigen/src/Core/arch/SSE/PacketMath.h +++ b/Eigen/src/Core/arch/SSE/PacketMath.h @@ -25,6 +25,8 @@ #ifndef EIGEN_PACKET_MATH_SSE_H #define EIGEN_PACKET_MATH_SSE_H +namespace internal { + #ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD #define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8 #endif @@ -37,36 +39,36 @@ typedef __m128 Packet4f; typedef __m128i Packet4i; typedef __m128d Packet2d; -template<> struct ei_is_arithmetic<__m128> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<__m128i> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<__m128d> { enum { ret = true }; }; +template<> struct is_arithmetic<__m128> { enum { ret = true }; }; +template<> struct is_arithmetic<__m128i> { enum { ret = true }; }; +template<> struct is_arithmetic<__m128d> { enum { ret = true }; }; -#define ei_vec4f_swizzle1(v,p,q,r,s) \ +#define vec4f_swizzle1(v,p,q,r,s) \ (_mm_castsi128_ps(_mm_shuffle_epi32( _mm_castps_si128(v), ((s)<<6|(r)<<4|(q)<<2|(p))))) -#define ei_vec4i_swizzle1(v,p,q,r,s) \ +#define vec4i_swizzle1(v,p,q,r,s) \ (_mm_shuffle_epi32( v, ((s)<<6|(r)<<4|(q)<<2|(p)))) -#define ei_vec2d_swizzle1(v,p,q) \ +#define vec2d_swizzle1(v,p,q) \ (_mm_castsi128_pd(_mm_shuffle_epi32( _mm_castpd_si128(v), ((q*2+1)<<6|(q*2)<<4|(p*2+1)<<2|(p*2))))) -#define ei_vec4f_swizzle2(a,b,p,q,r,s) \ +#define vec4f_swizzle2(a,b,p,q,r,s) \ (_mm_shuffle_ps( (a), (b), ((s)<<6|(r)<<4|(q)<<2|(p)))) -#define ei_vec4i_swizzle2(a,b,p,q,r,s) \ +#define vec4i_swizzle2(a,b,p,q,r,s) \ (_mm_castps_si128( (_mm_shuffle_ps( _mm_castsi128_ps(a), _mm_castsi128_ps(b), ((s)<<6|(r)<<4|(q)<<2|(p)))))) #define _EIGEN_DECLARE_CONST_Packet4f(NAME,X) \ - const Packet4f ei_p4f_##NAME = ei_pset1(X) + const Packet4f p4f_##NAME = pset1(X) #define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \ - const Packet4f ei_p4f_##NAME = _mm_castsi128_ps(ei_pset1(X)) + const Packet4f p4f_##NAME = _mm_castsi128_ps(pset1(X)) #define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \ - const Packet4i ei_p4i_##NAME = ei_pset1(X) + const Packet4i p4i_##NAME = pset1(X) -template<> struct ei_packet_traits : ei_default_packet_traits +template<> struct packet_traits : default_packet_traits { typedef Packet4f type; enum { @@ -82,7 +84,7 @@ template<> struct ei_packet_traits : ei_default_packet_traits HasSqrt = 1 }; }; -template<> struct ei_packet_traits : ei_default_packet_traits +template<> struct packet_traits : default_packet_traits { typedef Packet2d type; enum { @@ -93,7 +95,7 @@ template<> struct ei_packet_traits : ei_default_packet_traits HasDiv = 1 }; }; -template<> struct ei_packet_traits : ei_default_packet_traits +template<> struct packet_traits : default_packet_traits { typedef Packet4i type; enum { @@ -104,125 +106,125 @@ template<> struct ei_packet_traits : ei_default_packet_traits }; }; -template<> struct ei_unpacket_traits { typedef float type; enum {size=4}; }; -template<> struct ei_unpacket_traits { typedef double type; enum {size=2}; }; -template<> struct ei_unpacket_traits { typedef int type; enum {size=4}; }; +template<> struct unpacket_traits { typedef float type; enum {size=4}; }; +template<> struct unpacket_traits { typedef double type; enum {size=2}; }; +template<> struct unpacket_traits { typedef int type; enum {size=4}; }; #ifdef __GNUC__ // Sometimes GCC implements _mm_set1_p* using multiple moves, -// that is inefficient :( (e.g., see ei_gemm_pack_rhs) -template<> EIGEN_STRONG_INLINE Packet4f ei_pset1(const float& from) { +// that is inefficient :( (e.g., see gemm_pack_rhs) +template<> EIGEN_STRONG_INLINE Packet4f pset1(const float& from) { Packet4f res = _mm_set_ss(from); - return ei_vec4f_swizzle1(res,0,0,0,0); + return vec4f_swizzle1(res,0,0,0,0); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pset1(const double& from) { +template<> EIGEN_STRONG_INLINE Packet2d pset1(const double& from) { // NOTE the SSE3 intrinsic _mm_loaddup_pd is never faster but sometimes much slower Packet2d res = _mm_set_sd(from); - return ei_vec2d_swizzle1(res, 0, 0); + return vec2d_swizzle1(res, 0, 0); } #else -template<> EIGEN_STRONG_INLINE Packet4f ei_pset1(const float& from) { return _mm_set1_ps(from); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pset1(const double& from) { return _mm_set1_pd(from); } +template<> EIGEN_STRONG_INLINE Packet4f pset1(const float& from) { return _mm_set1_ps(from); } +template<> EIGEN_STRONG_INLINE Packet2d pset1(const double& from) { return _mm_set1_pd(from); } #endif -template<> EIGEN_STRONG_INLINE Packet4i ei_pset1(const int& from) { return _mm_set1_epi32(from); } +template<> EIGEN_STRONG_INLINE Packet4i pset1(const int& from) { return _mm_set1_epi32(from); } -template<> EIGEN_STRONG_INLINE Packet4f ei_plset(const float& a) { return _mm_add_ps(ei_pset1(a), _mm_set_ps(3,2,1,0)); } -template<> EIGEN_STRONG_INLINE Packet2d ei_plset(const double& a) { return _mm_add_pd(ei_pset1(a),_mm_set_pd(1,0)); } -template<> EIGEN_STRONG_INLINE Packet4i ei_plset(const int& a) { return _mm_add_epi32(ei_pset1(a),_mm_set_epi32(3,2,1,0)); } +template<> EIGEN_STRONG_INLINE Packet4f plset(const float& a) { return _mm_add_ps(pset1(a), _mm_set_ps(3,2,1,0)); } +template<> EIGEN_STRONG_INLINE Packet2d plset(const double& a) { return _mm_add_pd(pset1(a),_mm_set_pd(1,0)); } +template<> EIGEN_STRONG_INLINE Packet4i plset(const int& a) { return _mm_add_epi32(pset1(a),_mm_set_epi32(3,2,1,0)); } -template<> EIGEN_STRONG_INLINE Packet4f ei_padd(const Packet4f& a, const Packet4f& b) { return _mm_add_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_padd(const Packet2d& a, const Packet2d& b) { return _mm_add_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_padd(const Packet4i& a, const Packet4i& b) { return _mm_add_epi32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f padd(const Packet4f& a, const Packet4f& b) { return _mm_add_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d padd(const Packet2d& a, const Packet2d& b) { return _mm_add_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i padd(const Packet4i& a, const Packet4i& b) { return _mm_add_epi32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_psub(const Packet4f& a, const Packet4f& b) { return _mm_sub_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_psub(const Packet2d& a, const Packet2d& b) { return _mm_sub_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_psub(const Packet4i& a, const Packet4i& b) { return _mm_sub_epi32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f psub(const Packet4f& a, const Packet4f& b) { return _mm_sub_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d psub(const Packet2d& a, const Packet2d& b) { return _mm_sub_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i psub(const Packet4i& a, const Packet4i& b) { return _mm_sub_epi32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pnegate(const Packet4f& a) +template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a) { const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x80000000,0x80000000,0x80000000,0x80000000)); return _mm_xor_ps(a,mask); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pnegate(const Packet2d& a) +template<> EIGEN_STRONG_INLINE Packet2d pnegate(const Packet2d& a) { const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0x0,0x80000000,0x0,0x80000000)); return _mm_xor_pd(a,mask); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pnegate(const Packet4i& a) +template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) { - return ei_psub(_mm_setr_epi32(0,0,0,0), a); + return psub(_mm_setr_epi32(0,0,0,0), a); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pmul(const Packet4f& a, const Packet4f& b) { return _mm_mul_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pmul(const Packet2d& a, const Packet2d& b) { return _mm_mul_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmul(const Packet4i& a, const Packet4i& b) +template<> EIGEN_STRONG_INLINE Packet4f pmul(const Packet4f& a, const Packet4f& b) { return _mm_mul_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d pmul(const Packet2d& a, const Packet2d& b) { return _mm_mul_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pmul(const Packet4i& a, const Packet4i& b) { #ifdef EIGEN_VECTORIZE_SSE4_1 return _mm_mullo_epi32(a,b); #else // this version is slightly faster than 4 scalar products - return ei_vec4i_swizzle1( - ei_vec4i_swizzle2( + return vec4i_swizzle1( + vec4i_swizzle2( _mm_mul_epu32(a,b), - _mm_mul_epu32(ei_vec4i_swizzle1(a,1,0,3,2), - ei_vec4i_swizzle1(b,1,0,3,2)), + _mm_mul_epu32(vec4i_swizzle1(a,1,0,3,2), + vec4i_swizzle1(b,1,0,3,2)), 0,2,0,2), 0,2,1,3); #endif } -template<> EIGEN_STRONG_INLINE Packet4f ei_pdiv(const Packet4f& a, const Packet4f& b) { return _mm_div_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pdiv(const Packet2d& a, const Packet2d& b) { return _mm_div_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pdiv(const Packet4i& /*a*/, const Packet4i& /*b*/) -{ ei_assert(false && "packet integer division are not supported by SSE"); - return ei_pset1(0); +template<> EIGEN_STRONG_INLINE Packet4f pdiv(const Packet4f& a, const Packet4f& b) { return _mm_div_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d pdiv(const Packet2d& a, const Packet2d& b) { return _mm_div_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pdiv(const Packet4i& /*a*/, const Packet4i& /*b*/) +{ eigen_assert(false && "packet integer division are not supported by SSE"); + return pset1(0); } // for some weird raisons, it has to be overloaded for packet of integers -template<> EIGEN_STRONG_INLINE Packet4i ei_pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return ei_padd(ei_pmul(a,b), c); } +template<> EIGEN_STRONG_INLINE Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) { return padd(pmul(a,b), c); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pmin(const Packet4f& a, const Packet4f& b) { return _mm_min_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pmin(const Packet2d& a, const Packet2d& b) { return _mm_min_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmin(const Packet4i& a, const Packet4i& b) +template<> EIGEN_STRONG_INLINE Packet4f pmin(const Packet4f& a, const Packet4f& b) { return _mm_min_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d pmin(const Packet2d& a, const Packet2d& b) { return _mm_min_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pmin(const Packet4i& a, const Packet4i& b) { // after some bench, this version *is* faster than a scalar implementation Packet4i mask = _mm_cmplt_epi32(a,b); return _mm_or_si128(_mm_and_si128(mask,a),_mm_andnot_si128(mask,b)); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pmax(const Packet4f& a, const Packet4f& b) { return _mm_max_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pmax(const Packet2d& a, const Packet2d& b) { return _mm_max_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmax(const Packet4i& a, const Packet4i& b) +template<> EIGEN_STRONG_INLINE Packet4f pmax(const Packet4f& a, const Packet4f& b) { return _mm_max_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d pmax(const Packet2d& a, const Packet2d& b) { return _mm_max_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pmax(const Packet4i& a, const Packet4i& b) { // after some bench, this version *is* faster than a scalar implementation Packet4i mask = _mm_cmpgt_epi32(a,b); return _mm_or_si128(_mm_and_si128(mask,a),_mm_andnot_si128(mask,b)); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pand(const Packet4f& a, const Packet4f& b) { return _mm_and_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pand(const Packet2d& a, const Packet2d& b) { return _mm_and_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pand(const Packet4i& a, const Packet4i& b) { return _mm_and_si128(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f pand(const Packet4f& a, const Packet4f& b) { return _mm_and_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d pand(const Packet2d& a, const Packet2d& b) { return _mm_and_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pand(const Packet4i& a, const Packet4i& b) { return _mm_and_si128(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_por(const Packet4f& a, const Packet4f& b) { return _mm_or_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_por(const Packet2d& a, const Packet2d& b) { return _mm_or_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_por(const Packet4i& a, const Packet4i& b) { return _mm_or_si128(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f por(const Packet4f& a, const Packet4f& b) { return _mm_or_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d por(const Packet2d& a, const Packet2d& b) { return _mm_or_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i por(const Packet4i& a, const Packet4i& b) { return _mm_or_si128(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pxor(const Packet4f& a, const Packet4f& b) { return _mm_xor_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pxor(const Packet2d& a, const Packet2d& b) { return _mm_xor_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pxor(const Packet4i& a, const Packet4i& b) { return _mm_xor_si128(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f pxor(const Packet4f& a, const Packet4f& b) { return _mm_xor_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d pxor(const Packet2d& a, const Packet2d& b) { return _mm_xor_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pxor(const Packet4i& a, const Packet4i& b) { return _mm_xor_si128(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pandnot(const Packet4f& a, const Packet4f& b) { return _mm_andnot_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pandnot(const Packet2d& a, const Packet2d& b) { return _mm_andnot_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pandnot(const Packet4i& a, const Packet4i& b) { return _mm_andnot_si128(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f pandnot(const Packet4f& a, const Packet4f& b) { return _mm_andnot_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d pandnot(const Packet2d& a, const Packet2d& b) { return _mm_andnot_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pandnot(const Packet4i& a, const Packet4i& b) { return _mm_andnot_si128(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pload(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_ps(from); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pload(const double* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_pd(from); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pload(const int* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_si128(reinterpret_cast(from)); } +template<> EIGEN_STRONG_INLINE Packet4f pload(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_ps(from); } +template<> EIGEN_STRONG_INLINE Packet2d pload(const double* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_pd(from); } +template<> EIGEN_STRONG_INLINE Packet4i pload(const int* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_si128(reinterpret_cast(from)); } #if defined(_MSC_VER) - template<> EIGEN_STRONG_INLINE Packet4f ei_ploadu(const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm_loadu_ps(from); } - template<> EIGEN_STRONG_INLINE Packet2d ei_ploadu(const double* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm_loadu_pd(from); } - template<> EIGEN_STRONG_INLINE Packet4i ei_ploadu(const int* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm_loadu_si128(reinterpret_cast(from)); } + template<> EIGEN_STRONG_INLINE Packet4f ploadu(const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm_loadu_ps(from); } + template<> EIGEN_STRONG_INLINE Packet2d ploadu(const double* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm_loadu_pd(from); } + template<> EIGEN_STRONG_INLINE Packet4i ploadu(const int* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm_loadu_si128(reinterpret_cast(from)); } #else // Fast unaligned loads. Note that here we cannot directly use intrinsics: this would // require pointer casting to incompatible pointer types and leads to invalid code @@ -230,7 +232,7 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_pload(const int* from) // a correct instruction dependency. // TODO: do the same for MSVC (ICC is compatible) // NOTE: with the code below, MSVC's compiler crashes! -template<> EIGEN_STRONG_INLINE Packet4f ei_ploadu(const float* from) +template<> EIGEN_STRONG_INLINE Packet4f ploadu(const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD __m128d res; @@ -238,7 +240,7 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_ploadu(const float* from) res = _mm_loadh_pd(res, (const double*)(from+2)) ; return _mm_castpd_ps(res); } -template<> EIGEN_STRONG_INLINE Packet2d ei_ploadu(const double* from) +template<> EIGEN_STRONG_INLINE Packet2d ploadu(const double* from) { EIGEN_DEBUG_UNALIGNED_LOAD __m128d res; @@ -246,7 +248,7 @@ template<> EIGEN_STRONG_INLINE Packet2d ei_ploadu(const double* from) res = _mm_loadh_pd(res,from+1); return res; } -template<> EIGEN_STRONG_INLINE Packet4i ei_ploadu(const int* from) +template<> EIGEN_STRONG_INLINE Packet4i ploadu(const int* from) { EIGEN_DEBUG_UNALIGNED_LOAD __m128d res; @@ -256,71 +258,71 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_ploadu(const int* from) } #endif -template<> EIGEN_STRONG_INLINE Packet4f ei_ploaddup(const float* from) +template<> EIGEN_STRONG_INLINE Packet4f ploaddup(const float* from) { - return ei_vec4f_swizzle1(_mm_castpd_ps(_mm_load_sd((const double*)from)), 0, 0, 1, 1); + return vec4f_swizzle1(_mm_castpd_ps(_mm_load_sd((const double*)from)), 0, 0, 1, 1); } -template<> EIGEN_STRONG_INLINE Packet2d ei_ploaddup(const double* from) -{ return ei_pset1(from[0]); } -template<> EIGEN_STRONG_INLINE Packet4i ei_ploaddup(const int* from) +template<> EIGEN_STRONG_INLINE Packet2d ploaddup(const double* from) +{ return pset1(from[0]); } +template<> EIGEN_STRONG_INLINE Packet4i ploaddup(const int* from) { Packet4i tmp; tmp = _mm_loadl_epi64(reinterpret_cast(from)); - return ei_vec4i_swizzle1(tmp, 0, 0, 1, 1); + return vec4i_swizzle1(tmp, 0, 0, 1, 1); } -template<> EIGEN_STRONG_INLINE void ei_pstore(float* to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_ps(to, from); } -template<> EIGEN_STRONG_INLINE void ei_pstore(double* to, const Packet2d& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_pd(to, from); } -template<> EIGEN_STRONG_INLINE void ei_pstore(int* to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(reinterpret_cast(to), from); } +template<> EIGEN_STRONG_INLINE void pstore(float* to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_ps(to, from); } +template<> EIGEN_STRONG_INLINE void pstore(double* to, const Packet2d& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_pd(to, from); } +template<> EIGEN_STRONG_INLINE void pstore(int* to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(reinterpret_cast(to), from); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu(double* to, const Packet2d& from) { +template<> EIGEN_STRONG_INLINE void pstoreu(double* to, const Packet2d& from) { EIGEN_DEBUG_UNALIGNED_STORE _mm_storel_pd((to), from); _mm_storeh_pd((to+1), from); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu(float* to, const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE ei_pstoreu((double*)to, _mm_castps_pd(from)); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu(int* to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE ei_pstoreu((double*)to, _mm_castsi128_pd(from)); } +template<> EIGEN_STRONG_INLINE void pstoreu(float* to, const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, _mm_castps_pd(from)); } +template<> EIGEN_STRONG_INLINE void pstoreu(int* to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, _mm_castsi128_pd(from)); } -template<> EIGEN_STRONG_INLINE void ei_prefetch(const float* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } -template<> EIGEN_STRONG_INLINE void ei_prefetch(const double* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } -template<> EIGEN_STRONG_INLINE void ei_prefetch(const int* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } +template<> EIGEN_STRONG_INLINE void prefetch(const float* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } +template<> EIGEN_STRONG_INLINE void prefetch(const double* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } +template<> EIGEN_STRONG_INLINE void prefetch(const int* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } #if defined(_MSC_VER) && (_MSC_VER <= 1500) && defined(_WIN64) && !defined(__INTEL_COMPILER) // The temporary variable fixes an internal compilation error. // Direct of the struct members fixed bug #62. -template<> EIGEN_STRONG_INLINE float ei_pfirst(const Packet4f& a) { return a.m128_f32[0]; } -template<> EIGEN_STRONG_INLINE double ei_pfirst(const Packet2d& a) { return a.m128d_f64[0]; } -template<> EIGEN_STRONG_INLINE int ei_pfirst(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; } +template<> EIGEN_STRONG_INLINE float pfirst(const Packet4f& a) { return a.m128_f32[0]; } +template<> EIGEN_STRONG_INLINE double pfirst(const Packet2d& a) { return a.m128d_f64[0]; } +template<> EIGEN_STRONG_INLINE int pfirst(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; } #elif defined(_MSC_VER) && (_MSC_VER <= 1500) && !defined(__INTEL_COMPILER) // The temporary variable fixes an internal compilation error. -template<> EIGEN_STRONG_INLINE float ei_pfirst(const Packet4f& a) { float x = _mm_cvtss_f32(a); return x; } -template<> EIGEN_STRONG_INLINE double ei_pfirst(const Packet2d& a) { double x = _mm_cvtsd_f64(a); return x; } -template<> EIGEN_STRONG_INLINE int ei_pfirst(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; } +template<> EIGEN_STRONG_INLINE float pfirst(const Packet4f& a) { float x = _mm_cvtss_f32(a); return x; } +template<> EIGEN_STRONG_INLINE double pfirst(const Packet2d& a) { double x = _mm_cvtsd_f64(a); return x; } +template<> EIGEN_STRONG_INLINE int pfirst(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; } #else -template<> EIGEN_STRONG_INLINE float ei_pfirst(const Packet4f& a) { return _mm_cvtss_f32(a); } -template<> EIGEN_STRONG_INLINE double ei_pfirst(const Packet2d& a) { return _mm_cvtsd_f64(a); } -template<> EIGEN_STRONG_INLINE int ei_pfirst(const Packet4i& a) { return _mm_cvtsi128_si32(a); } +template<> EIGEN_STRONG_INLINE float pfirst(const Packet4f& a) { return _mm_cvtss_f32(a); } +template<> EIGEN_STRONG_INLINE double pfirst(const Packet2d& a) { return _mm_cvtsd_f64(a); } +template<> EIGEN_STRONG_INLINE int pfirst(const Packet4i& a) { return _mm_cvtsi128_si32(a); } #endif -template<> EIGEN_STRONG_INLINE Packet4f ei_preverse(const Packet4f& a) +template<> EIGEN_STRONG_INLINE Packet4f preverse(const Packet4f& a) { return _mm_shuffle_ps(a,a,0x1B); } -template<> EIGEN_STRONG_INLINE Packet2d ei_preverse(const Packet2d& a) +template<> EIGEN_STRONG_INLINE Packet2d preverse(const Packet2d& a) { return _mm_shuffle_pd(a,a,0x1); } -template<> EIGEN_STRONG_INLINE Packet4i ei_preverse(const Packet4i& a) +template<> EIGEN_STRONG_INLINE Packet4i preverse(const Packet4i& a) { return _mm_shuffle_epi32(a,0x1B); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pabs(const Packet4f& a) +template<> EIGEN_STRONG_INLINE Packet4f pabs(const Packet4f& a) { const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF,0x7FFFFFFF)); return _mm_and_ps(a,mask); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pabs(const Packet2d& a) +template<> EIGEN_STRONG_INLINE Packet2d pabs(const Packet2d& a) { const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0xFFFFFFFF,0x7FFFFFFF,0xFFFFFFFF,0x7FFFFFFF)); return _mm_and_pd(a,mask); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pabs(const Packet4i& a) +template<> EIGEN_STRONG_INLINE Packet4i pabs(const Packet4i& a) { #ifdef EIGEN_VECTORIZE_SSSE3 return _mm_abs_epi32(a); @@ -330,7 +332,7 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_pabs(const Packet4i& a) #endif } -EIGEN_STRONG_INLINE void ei_punpackp(Packet4f* vecs) +EIGEN_STRONG_INLINE void punpackp(Packet4f* vecs) { vecs[1] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0x55)); vecs[2] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0xAA)); @@ -340,47 +342,47 @@ EIGEN_STRONG_INLINE void ei_punpackp(Packet4f* vecs) #ifdef EIGEN_VECTORIZE_SSE3 // TODO implement SSE2 versions as well as integer versions -template<> EIGEN_STRONG_INLINE Packet4f ei_preduxp(const Packet4f* vecs) +template<> EIGEN_STRONG_INLINE Packet4f preduxp(const Packet4f* vecs) { return _mm_hadd_ps(_mm_hadd_ps(vecs[0], vecs[1]),_mm_hadd_ps(vecs[2], vecs[3])); } -template<> EIGEN_STRONG_INLINE Packet2d ei_preduxp(const Packet2d* vecs) +template<> EIGEN_STRONG_INLINE Packet2d preduxp(const Packet2d* vecs) { return _mm_hadd_pd(vecs[0], vecs[1]); } // SSSE3 version: -// EIGEN_STRONG_INLINE Packet4i ei_preduxp(const Packet4i* vecs) +// EIGEN_STRONG_INLINE Packet4i preduxp(const Packet4i* vecs) // { // return _mm_hadd_epi32(_mm_hadd_epi32(vecs[0], vecs[1]),_mm_hadd_epi32(vecs[2], vecs[3])); // } -template<> EIGEN_STRONG_INLINE float ei_predux(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux(const Packet4f& a) { Packet4f tmp0 = _mm_hadd_ps(a,a); - return ei_pfirst(_mm_hadd_ps(tmp0, tmp0)); + return pfirst(_mm_hadd_ps(tmp0, tmp0)); } -template<> EIGEN_STRONG_INLINE double ei_predux(const Packet2d& a) { return ei_pfirst(_mm_hadd_pd(a, a)); } +template<> EIGEN_STRONG_INLINE double predux(const Packet2d& a) { return pfirst(_mm_hadd_pd(a, a)); } // SSSE3 version: -// EIGEN_STRONG_INLINE float ei_predux(const Packet4i& a) +// EIGEN_STRONG_INLINE float predux(const Packet4i& a) // { // Packet4i tmp0 = _mm_hadd_epi32(a,a); -// return ei_pfirst(_mm_hadd_epi32(tmp0, tmp0)); +// return pfirst(_mm_hadd_epi32(tmp0, tmp0)); // } #else // SSE2 versions -template<> EIGEN_STRONG_INLINE float ei_predux(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux(const Packet4f& a) { Packet4f tmp = _mm_add_ps(a, _mm_movehl_ps(a,a)); - return ei_pfirst(_mm_add_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1))); + return pfirst(_mm_add_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1))); } -template<> EIGEN_STRONG_INLINE double ei_predux(const Packet2d& a) +template<> EIGEN_STRONG_INLINE double predux(const Packet2d& a) { - return ei_pfirst(_mm_add_sd(a, _mm_unpackhi_pd(a,a))); + return pfirst(_mm_add_sd(a, _mm_unpackhi_pd(a,a))); } -template<> EIGEN_STRONG_INLINE Packet4f ei_preduxp(const Packet4f* vecs) +template<> EIGEN_STRONG_INLINE Packet4f preduxp(const Packet4f* vecs) { Packet4f tmp0, tmp1, tmp2; tmp0 = _mm_unpacklo_ps(vecs[0], vecs[1]); @@ -394,19 +396,19 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_preduxp(const Packet4f* vec return _mm_add_ps(tmp0, tmp2); } -template<> EIGEN_STRONG_INLINE Packet2d ei_preduxp(const Packet2d* vecs) +template<> EIGEN_STRONG_INLINE Packet2d preduxp(const Packet2d* vecs) { return _mm_add_pd(_mm_unpacklo_pd(vecs[0], vecs[1]), _mm_unpackhi_pd(vecs[0], vecs[1])); } #endif // SSE3 -template<> EIGEN_STRONG_INLINE int ei_predux(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux(const Packet4i& a) { Packet4i tmp = _mm_add_epi32(a, _mm_unpackhi_epi64(a,a)); - return ei_pfirst(tmp) + ei_pfirst(_mm_shuffle_epi32(tmp, 1)); + return pfirst(tmp) + pfirst(_mm_shuffle_epi32(tmp, 1)); } -template<> EIGEN_STRONG_INLINE Packet4i ei_preduxp(const Packet4i* vecs) +template<> EIGEN_STRONG_INLINE Packet4i preduxp(const Packet4i* vecs) { Packet4i tmp0, tmp1, tmp2; tmp0 = _mm_unpacklo_epi32(vecs[0], vecs[1]); @@ -423,69 +425,69 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_preduxp(const Packet4i* vec // Other reduction functions: // mul -template<> EIGEN_STRONG_INLINE float ei_predux_mul(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_mul(const Packet4f& a) { Packet4f tmp = _mm_mul_ps(a, _mm_movehl_ps(a,a)); - return ei_pfirst(_mm_mul_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1))); + return pfirst(_mm_mul_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1))); } -template<> EIGEN_STRONG_INLINE double ei_predux_mul(const Packet2d& a) +template<> EIGEN_STRONG_INLINE double predux_mul(const Packet2d& a) { - return ei_pfirst(_mm_mul_sd(a, _mm_unpackhi_pd(a,a))); + return pfirst(_mm_mul_sd(a, _mm_unpackhi_pd(a,a))); } -template<> EIGEN_STRONG_INLINE int ei_predux_mul(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_mul(const Packet4i& a) { // after some experiments, it is seems this is the fastest way to implement it - // for GCC (eg., reusing ei_pmul is very slow !) + // for GCC (eg., reusing pmul is very slow !) // TODO try to call _mm_mul_epu32 directly EIGEN_ALIGN16 int aux[4]; - ei_pstore(aux, a); + pstore(aux, a); return (aux[0] * aux[1]) * (aux[2] * aux[3]);; } // min -template<> EIGEN_STRONG_INLINE float ei_predux_min(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_min(const Packet4f& a) { Packet4f tmp = _mm_min_ps(a, _mm_movehl_ps(a,a)); - return ei_pfirst(_mm_min_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1))); + return pfirst(_mm_min_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1))); } -template<> EIGEN_STRONG_INLINE double ei_predux_min(const Packet2d& a) +template<> EIGEN_STRONG_INLINE double predux_min(const Packet2d& a) { - return ei_pfirst(_mm_min_sd(a, _mm_unpackhi_pd(a,a))); + return pfirst(_mm_min_sd(a, _mm_unpackhi_pd(a,a))); } -template<> EIGEN_STRONG_INLINE int ei_predux_min(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_min(const Packet4i& a) { // after some experiments, it is seems this is the fastest way to implement it - // for GCC (eg., it does not like using std::min after the ei_pstore !!) + // for GCC (eg., it does not like using std::min after the pstore !!) EIGEN_ALIGN16 int aux[4]; - ei_pstore(aux, a); + pstore(aux, a); register int aux0 = aux[0] EIGEN_STRONG_INLINE float ei_predux_max(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_max(const Packet4f& a) { Packet4f tmp = _mm_max_ps(a, _mm_movehl_ps(a,a)); - return ei_pfirst(_mm_max_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1))); + return pfirst(_mm_max_ss(tmp, _mm_shuffle_ps(tmp,tmp, 1))); } -template<> EIGEN_STRONG_INLINE double ei_predux_max(const Packet2d& a) +template<> EIGEN_STRONG_INLINE double predux_max(const Packet2d& a) { - return ei_pfirst(_mm_max_sd(a, _mm_unpackhi_pd(a,a))); + return pfirst(_mm_max_sd(a, _mm_unpackhi_pd(a,a))); } -template<> EIGEN_STRONG_INLINE int ei_predux_max(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_max(const Packet4i& a) { // after some experiments, it is seems this is the fastest way to implement it - // for GCC (eg., it does not like using std::min after the ei_pstore !!) + // for GCC (eg., it does not like using std::min after the pstore !!) EIGEN_ALIGN16 int aux[4]; - ei_pstore(aux, a); + pstore(aux, a); register int aux0 = aux[0]>aux[1] ? aux[0] : aux[1]; register int aux2 = aux[2]>aux[3] ? aux[2] : aux[3]; return aux0>aux2 ? aux0 : aux2; } #if (defined __GNUC__) -// template <> EIGEN_STRONG_INLINE Packet4f ei_pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) +// template <> EIGEN_STRONG_INLINE Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) // { // Packet4f res = b; // asm("mulps %[a], %[b] \n\taddps %[c], %[b]" : [b] "+x" (res) : [a] "x" (a), [c] "x" (c)); @@ -502,7 +504,7 @@ template<> EIGEN_STRONG_INLINE int ei_predux_max(const Packet4i& a) #ifdef EIGEN_VECTORIZE_SSSE3 // SSSE3 versions template -struct ei_palign_impl +struct palign_impl { EIGEN_STRONG_INLINE static void run(Packet4f& first, const Packet4f& second) { @@ -512,7 +514,7 @@ struct ei_palign_impl }; template -struct ei_palign_impl +struct palign_impl { EIGEN_STRONG_INLINE static void run(Packet4i& first, const Packet4i& second) { @@ -522,7 +524,7 @@ struct ei_palign_impl }; template -struct ei_palign_impl +struct palign_impl { EIGEN_STRONG_INLINE static void run(Packet2d& first, const Packet2d& second) { @@ -533,7 +535,7 @@ struct ei_palign_impl #else // SSE2 versions template -struct ei_palign_impl +struct palign_impl { EIGEN_STRONG_INLINE static void run(Packet4f& first, const Packet4f& second) { @@ -556,7 +558,7 @@ struct ei_palign_impl }; template -struct ei_palign_impl +struct palign_impl { EIGEN_STRONG_INLINE static void run(Packet4i& first, const Packet4i& second) { @@ -579,7 +581,7 @@ struct ei_palign_impl }; template -struct ei_palign_impl +struct palign_impl { EIGEN_STRONG_INLINE static void run(Packet2d& first, const Packet2d& second) { @@ -592,4 +594,6 @@ struct ei_palign_impl }; #endif +} // end namespace internal + #endif // EIGEN_PACKET_MATH_SSE_H diff --git a/Eigen/src/Core/products/CoeffBasedProduct.h b/Eigen/src/Core/products/CoeffBasedProduct.h index d2e693861..e1f19d787 100644 --- a/Eigen/src/Core/products/CoeffBasedProduct.h +++ b/Eigen/src/Core/products/CoeffBasedProduct.h @@ -26,6 +26,8 @@ #ifndef EIGEN_COEFFBASED_PRODUCT_H #define EIGEN_COEFFBASED_PRODUCT_H +namespace internal { + /********************************************************************************* * Coefficient based product implementation. * It is designed for the following use cases: @@ -40,22 +42,22 @@ */ template -struct ei_product_coeff_impl; +struct product_coeff_impl; template -struct ei_product_packet_impl; +struct product_packet_impl; template -struct ei_traits > +struct traits > { typedef MatrixXpr XprKind; - typedef typename ei_cleantype::type _LhsNested; - typedef typename ei_cleantype::type _RhsNested; - typedef typename ei_scalar_product_traits::ReturnType Scalar; - typedef typename ei_promote_storage_type::StorageKind, - typename ei_traits<_RhsNested>::StorageKind>::ret StorageKind; - typedef typename ei_promote_index_type::Index, - typename ei_traits<_RhsNested>::Index>::type Index; + typedef typename cleantype::type _LhsNested; + typedef typename cleantype::type _RhsNested; + typedef typename scalar_product_traits::ReturnType Scalar; + typedef typename promote_storage_type::StorageKind, + typename traits<_RhsNested>::StorageKind>::ret StorageKind; + typedef typename promote_index_type::Index, + typename traits<_RhsNested>::Index>::type Index; enum { LhsCoeffReadCost = _LhsNested::CoeffReadCost, @@ -73,18 +75,18 @@ struct ei_traits > LhsRowMajor = LhsFlags & RowMajorBit, RhsRowMajor = RhsFlags & RowMajorBit, - SameType = ei_is_same_type::ret, + SameType = is_same_type::ret, CanVectorizeRhs = RhsRowMajor && (RhsFlags & PacketAccessBit) && (ColsAtCompileTime == Dynamic - || ( (ColsAtCompileTime % ei_packet_traits::size) == 0 + || ( (ColsAtCompileTime % packet_traits::size) == 0 && (RhsFlags&AlignedBit) ) ), CanVectorizeLhs = (!LhsRowMajor) && (LhsFlags & PacketAccessBit) && (RowsAtCompileTime == Dynamic - || ( (RowsAtCompileTime % ei_packet_traits::size) == 0 + || ( (RowsAtCompileTime % packet_traits::size) == 0 && (LhsFlags&AlignedBit) ) ), @@ -113,13 +115,15 @@ struct ei_traits > && (!RhsRowMajor) && (LhsFlags & RhsFlags & ActualPacketAccessBit) && (LhsFlags & RhsFlags & AlignedBit) - && (InnerSize % ei_packet_traits::size == 0) + && (InnerSize % packet_traits::size == 0) }; }; +} // end namespace internal + template class CoeffBasedProduct - : ei_no_assignment_operator, + : internal::no_assignment_operator, public MatrixBase > { public: @@ -130,19 +134,19 @@ class CoeffBasedProduct private: - typedef typename ei_traits::_LhsNested _LhsNested; - typedef typename ei_traits::_RhsNested _RhsNested; + typedef typename internal::traits::_LhsNested _LhsNested; + typedef typename internal::traits::_RhsNested _RhsNested; enum { - PacketSize = ei_packet_traits::size, - InnerSize = ei_traits::InnerSize, + PacketSize = internal::packet_traits::size, + InnerSize = internal::traits::InnerSize, Unroll = CoeffReadCost != Dynamic && CoeffReadCost <= EIGEN_UNROLLING_LIMIT, - CanVectorizeInner = ei_traits::CanVectorizeInner + CanVectorizeInner = internal::traits::CanVectorizeInner }; - typedef ei_product_coeff_impl ScalarCoeffImpl; + typedef internal::product_coeff_impl ScalarCoeffImpl; typedef CoeffBasedProduct LazyCoeffBasedProductType; @@ -158,9 +162,9 @@ class CoeffBasedProduct { // we don't allow taking products of matrices of different real types, as that wouldn't be vectorizable. // We still allow to mix T and complex. - EIGEN_STATIC_ASSERT((ei_is_same_type::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type::ret), YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) - ei_assert(lhs.cols() == rhs.rows() + eigen_assert(lhs.cols() == rhs.rows() && "invalid matrix product" && "if you wanted a coeff-wise or a dot product use the respective explicit functions"); } @@ -191,9 +195,9 @@ class CoeffBasedProduct EIGEN_STRONG_INLINE const PacketScalar packet(Index row, Index col) const { PacketScalar res; - ei_product_packet_impl + internal::product_packet_impl ::run(row, col, m_lhs, m_rhs, res); return res; } @@ -225,10 +229,12 @@ class CoeffBasedProduct mutable PlainObject m_result; }; +namespace internal { + // here we need to overload the nested rule for products // such that the nested type is a const reference to a plain matrix template -struct ei_nested, N, PlainObject> +struct nested, N, PlainObject> { typedef PlainObject const& type; }; @@ -242,18 +248,18 @@ struct ei_nested -struct ei_product_coeff_impl +struct product_coeff_impl { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, RetScalar &res) { - ei_product_coeff_impl::run(row, col, lhs, rhs, res); + product_coeff_impl::run(row, col, lhs, rhs, res); res += lhs.coeff(row, UnrollingIndex) * rhs.coeff(UnrollingIndex, col); } }; template -struct ei_product_coeff_impl +struct product_coeff_impl { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, RetScalar &res) @@ -263,12 +269,12 @@ struct ei_product_coeff_impl }; template -struct ei_product_coeff_impl +struct product_coeff_impl { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, RetScalar& res) { - ei_assert(lhs.cols()>0 && "you are using a non initialized matrix"); + eigen_assert(lhs.cols()>0 && "you are using a non initialized matrix"); res = lhs.coeff(row, 0) * rhs.coeff(0, col); for(Index i = 1; i < lhs.cols(); ++i) res += lhs.coeff(row, i) * rhs.coeff(i, col); @@ -280,44 +286,44 @@ struct ei_product_coeff_impl *******************************************/ template -struct ei_product_coeff_vectorized_unroller +struct product_coeff_vectorized_unroller { typedef typename Lhs::Index Index; - enum { PacketSize = ei_packet_traits::size }; + enum { PacketSize = packet_traits::size }; EIGEN_STRONG_INLINE static void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, typename Lhs::PacketScalar &pres) { - ei_product_coeff_vectorized_unroller::run(row, col, lhs, rhs, pres); - pres = ei_padd(pres, ei_pmul( lhs.template packet(row, UnrollingIndex) , rhs.template packet(UnrollingIndex, col) )); + product_coeff_vectorized_unroller::run(row, col, lhs, rhs, pres); + pres = padd(pres, pmul( lhs.template packet(row, UnrollingIndex) , rhs.template packet(UnrollingIndex, col) )); } }; template -struct ei_product_coeff_vectorized_unroller<0, Lhs, Rhs, Packet> +struct product_coeff_vectorized_unroller<0, Lhs, Rhs, Packet> { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, typename Lhs::PacketScalar &pres) { - pres = ei_pmul(lhs.template packet(row, 0) , rhs.template packet(0, col)); + pres = pmul(lhs.template packet(row, 0) , rhs.template packet(0, col)); } }; template -struct ei_product_coeff_impl +struct product_coeff_impl { typedef typename Lhs::PacketScalar Packet; typedef typename Lhs::Index Index; - enum { PacketSize = ei_packet_traits::size }; + enum { PacketSize = packet_traits::size }; EIGEN_STRONG_INLINE static void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, RetScalar &res) { Packet pres; - ei_product_coeff_vectorized_unroller::run(row, col, lhs, rhs, pres); - ei_product_coeff_impl::run(row, col, lhs, rhs, res); - res = ei_predux(pres); + product_coeff_vectorized_unroller::run(row, col, lhs, rhs, pres); + product_coeff_impl::run(row, col, lhs, rhs, res); + res = predux(pres); } }; template -struct ei_product_coeff_vectorized_dyn_selector +struct product_coeff_vectorized_dyn_selector { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, typename Lhs::Scalar &res) @@ -329,7 +335,7 @@ struct ei_product_coeff_vectorized_dyn_selector // NOTE the 3 following specializations are because taking .col(0) on a vector is a bit slower // NOTE maybe they are now useless since we have a specialization for Block template -struct ei_product_coeff_vectorized_dyn_selector +struct product_coeff_vectorized_dyn_selector { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index /*row*/, Index col, const Lhs& lhs, const Rhs& rhs, typename Lhs::Scalar &res) @@ -339,7 +345,7 @@ struct ei_product_coeff_vectorized_dyn_selector }; template -struct ei_product_coeff_vectorized_dyn_selector +struct product_coeff_vectorized_dyn_selector { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index row, Index /*col*/, const Lhs& lhs, const Rhs& rhs, typename Lhs::Scalar &res) @@ -349,7 +355,7 @@ struct ei_product_coeff_vectorized_dyn_selector }; template -struct ei_product_coeff_vectorized_dyn_selector +struct product_coeff_vectorized_dyn_selector { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index /*row*/, Index /*col*/, const Lhs& lhs, const Rhs& rhs, typename Lhs::Scalar &res) @@ -359,12 +365,12 @@ struct ei_product_coeff_vectorized_dyn_selector }; template -struct ei_product_coeff_impl +struct product_coeff_impl { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, typename Lhs::Scalar &res) { - ei_product_coeff_vectorized_dyn_selector::run(row, col, lhs, rhs, res); + product_coeff_vectorized_dyn_selector::run(row, col, lhs, rhs, res); } }; @@ -373,71 +379,73 @@ struct ei_product_coeff_impl -struct ei_product_packet_impl +struct product_packet_impl { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Packet &res) { - ei_product_packet_impl::run(row, col, lhs, rhs, res); - res = ei_pmadd(ei_pset1(lhs.coeff(row, UnrollingIndex)), rhs.template packet(UnrollingIndex, col), res); + product_packet_impl::run(row, col, lhs, rhs, res); + res = pmadd(pset1(lhs.coeff(row, UnrollingIndex)), rhs.template packet(UnrollingIndex, col), res); } }; template -struct ei_product_packet_impl +struct product_packet_impl { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Packet &res) { - ei_product_packet_impl::run(row, col, lhs, rhs, res); - res = ei_pmadd(lhs.template packet(row, UnrollingIndex), ei_pset1(rhs.coeff(UnrollingIndex, col)), res); + product_packet_impl::run(row, col, lhs, rhs, res); + res = pmadd(lhs.template packet(row, UnrollingIndex), pset1(rhs.coeff(UnrollingIndex, col)), res); } }; template -struct ei_product_packet_impl +struct product_packet_impl { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Packet &res) { - res = ei_pmul(ei_pset1(lhs.coeff(row, 0)),rhs.template packet(0, col)); + res = pmul(pset1(lhs.coeff(row, 0)),rhs.template packet(0, col)); } }; template -struct ei_product_packet_impl +struct product_packet_impl { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Packet &res) { - res = ei_pmul(lhs.template packet(row, 0), ei_pset1(rhs.coeff(0, col))); + res = pmul(lhs.template packet(row, 0), pset1(rhs.coeff(0, col))); } }; template -struct ei_product_packet_impl +struct product_packet_impl { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Packet& res) { - ei_assert(lhs.cols()>0 && "you are using a non initialized matrix"); - res = ei_pmul(ei_pset1(lhs.coeff(row, 0)),rhs.template packet(0, col)); + eigen_assert(lhs.cols()>0 && "you are using a non initialized matrix"); + res = pmul(pset1(lhs.coeff(row, 0)),rhs.template packet(0, col)); for(Index i = 1; i < lhs.cols(); ++i) - res = ei_pmadd(ei_pset1(lhs.coeff(row, i)), rhs.template packet(i, col), res); + res = pmadd(pset1(lhs.coeff(row, i)), rhs.template packet(i, col), res); } }; template -struct ei_product_packet_impl +struct product_packet_impl { typedef typename Lhs::Index Index; EIGEN_STRONG_INLINE static void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Packet& res) { - ei_assert(lhs.cols()>0 && "you are using a non initialized matrix"); - res = ei_pmul(lhs.template packet(row, 0), ei_pset1(rhs.coeff(0, col))); + eigen_assert(lhs.cols()>0 && "you are using a non initialized matrix"); + res = pmul(lhs.template packet(row, 0), pset1(rhs.coeff(0, col))); for(Index i = 1; i < lhs.cols(); ++i) - res = ei_pmadd(lhs.template packet(row, i), ei_pset1(rhs.coeff(i, col)), res); + res = pmadd(lhs.template packet(row, i), pset1(rhs.coeff(i, col)), res); } }; +} // end namespace internal + #endif // EIGEN_COEFFBASED_PRODUCT_H diff --git a/Eigen/src/Core/products/GeneralBlockPanelKernel.h b/Eigen/src/Core/products/GeneralBlockPanelKernel.h index 7e2d496fe..94ed792f7 100644 --- a/Eigen/src/Core/products/GeneralBlockPanelKernel.h +++ b/Eigen/src/Core/products/GeneralBlockPanelKernel.h @@ -25,18 +25,20 @@ #ifndef EIGEN_GENERAL_BLOCK_PANEL_H #define EIGEN_GENERAL_BLOCK_PANEL_H +namespace internal { + template -class ei_gebp_traits; +class gebp_traits; /** \internal */ -inline void ei_manage_caching_sizes(Action action, std::ptrdiff_t* l1=0, std::ptrdiff_t* l2=0) +inline void manage_caching_sizes(Action action, std::ptrdiff_t* l1=0, std::ptrdiff_t* l2=0) { static std::ptrdiff_t m_l1CacheSize = 0; static std::ptrdiff_t m_l2CacheSize = 0; if(m_l1CacheSize==0) { - m_l1CacheSize = ei_queryL1CacheSize(); - m_l2CacheSize = ei_queryTopLevelCacheSize(); + m_l1CacheSize = queryL1CacheSize(); + m_l2CacheSize = queryTopLevelCacheSize(); if(m_l1CacheSize<=0) m_l1CacheSize = 8 * 1024; if(m_l2CacheSize<=0) m_l2CacheSize = 1 * 1024 * 1024; @@ -45,50 +47,22 @@ inline void ei_manage_caching_sizes(Action action, std::ptrdiff_t* l1=0, std::pt if(action==SetAction) { // set the cpu cache size and cache all block sizes from a global cache size in byte - ei_internal_assert(l1!=0 && l2!=0); + eigen_internal_assert(l1!=0 && l2!=0); m_l1CacheSize = *l1; m_l2CacheSize = *l2; } else if(action==GetAction) { - ei_internal_assert(l1!=0 && l2!=0); + eigen_internal_assert(l1!=0 && l2!=0); *l1 = m_l1CacheSize; *l2 = m_l2CacheSize; } else { - ei_internal_assert(false); + eigen_internal_assert(false); } } -/** \returns the currently set level 1 cpu cache size (in bytes) used to estimate the ideal blocking size parameters. - * \sa setCpuCacheSize */ -inline std::ptrdiff_t l1CacheSize() -{ - std::ptrdiff_t l1, l2; - ei_manage_caching_sizes(GetAction, &l1, &l2); - return l1; -} - -/** \returns the currently set level 2 cpu cache size (in bytes) used to estimate the ideal blocking size parameters. - * \sa setCpuCacheSize */ -inline std::ptrdiff_t l2CacheSize() -{ - std::ptrdiff_t l1, l2; - ei_manage_caching_sizes(GetAction, &l1, &l2); - return l2; -} - -/** Set the cpu L1 and L2 cache sizes (in bytes). - * These values are use to adjust the size of the blocks - * for the algorithms working per blocks. - * - * \sa computeProductBlockingSizes */ -inline void setCpuCacheSizes(std::ptrdiff_t l1, std::ptrdiff_t l2) -{ - ei_manage_caching_sizes(SetAction, &l1, &l2); -} - /** \brief Computes the blocking parameters for a m x k times k x n matrix product * * \param[in,out] k Input: the third dimension of the product. Output: the blocking size along the same dimension. @@ -100,7 +74,7 @@ inline void setCpuCacheSizes(std::ptrdiff_t l1, std::ptrdiff_t l2) * for matrix products and related algorithms. The blocking sizes depends on various * parameters: * - the L1 and L2 cache sizes, - * - the register level blocking sizes defined by ei_gebp_traits, + * - the register level blocking sizes defined by gebp_traits, * - the number of scalars that fit into a packet (when vectorization is enabled). * * \sa setCpuCacheSizes */ @@ -116,15 +90,15 @@ void computeProductBlockingSizes(std::ptrdiff_t& k, std::ptrdiff_t& m, std::ptrd // stay in L1 cache. std::ptrdiff_t l1, l2; - typedef ei_gebp_traits Traits; + typedef gebp_traits Traits; enum { kdiv = KcFactor * 2 * Traits::nr * Traits::RhsProgress * sizeof(RhsScalar), - mr = ei_gebp_traits::mr, + mr = gebp_traits::mr, mr_mask = (0xffffffff/mr)*mr }; - ei_manage_caching_sizes(GetAction, &l1, &l2); + manage_caching_sizes(GetAction, &l1, &l2); k = std::min(k, l1/kdiv); std::ptrdiff_t _m = k>0 ? l2/(4 * sizeof(LhsScalar) * k) : 0; if(_m struct ei_gebp_madd_selector { + template struct gebp_madd_selector { EIGEN_STRONG_INLINE EIGEN_ALWAYS_INLINE_ATTRIB static void run(const CJ& cj, A& a, B& b, C& c, T& /*t*/) { c = cj.pmadd(a,b,c); } }; - template struct ei_gebp_madd_selector { + template struct gebp_madd_selector { EIGEN_STRONG_INLINE EIGEN_ALWAYS_INLINE_ATTRIB static void run(const CJ& cj, T& a, T& b, T& c, T& t) { - t = b; t = cj.pmul(a,t); c = ei_padd(c,t); + t = b; t = cj.pmul(a,t); c = padd(c,t); } }; template - EIGEN_STRONG_INLINE void ei_gebp_madd(const CJ& cj, A& a, B& b, C& c, T& t) + EIGEN_STRONG_INLINE void gebp_madd(const CJ& cj, A& a, B& b, C& c, T& t) { - ei_gebp_madd_selector::run(cj,a,b,c,t); + gebp_madd_selector::run(cj,a,b,c,t); } - #define MADD(CJ,A,B,C,T) ei_gebp_madd(CJ,A,B,C,T); -// #define MADD(CJ,A,B,C,T) T = B; T = CJ.pmul(A,T); C = ei_padd(C,T); + #define MADD(CJ,A,B,C,T) gebp_madd(CJ,A,B,C,T); +// #define MADD(CJ,A,B,C,T) T = B; T = CJ.pmul(A,T); C = padd(C,T); #endif /* Vectorization logic @@ -178,20 +152,20 @@ inline void computeProductBlockingSizes(std::ptrdiff_t& k, std::ptrdiff_t& m, st * real*cplx : load lhs as (a0,a0,a1,a1), and mul as usual */ template -class ei_gebp_traits +class gebp_traits { public: typedef _LhsScalar LhsScalar; typedef _RhsScalar RhsScalar; - typedef typename ei_scalar_product_traits::ReturnType ResScalar; + typedef typename scalar_product_traits::ReturnType ResScalar; enum { ConjLhs = _ConjLhs, ConjRhs = _ConjRhs, - Vectorizable = ei_packet_traits::Vectorizable && ei_packet_traits::Vectorizable, - LhsPacketSize = Vectorizable ? ei_packet_traits::size : 1, - RhsPacketSize = Vectorizable ? ei_packet_traits::size : 1, - ResPacketSize = Vectorizable ? ei_packet_traits::size : 1, + Vectorizable = packet_traits::Vectorizable && packet_traits::Vectorizable, + LhsPacketSize = Vectorizable ? packet_traits::size : 1, + RhsPacketSize = Vectorizable ? packet_traits::size : 1, + ResPacketSize = Vectorizable ? packet_traits::size : 1, NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS, @@ -207,67 +181,67 @@ public: RhsProgress = RhsPacketSize }; - typedef typename ei_packet_traits::type _LhsPacket; - typedef typename ei_packet_traits::type _RhsPacket; - typedef typename ei_packet_traits::type _ResPacket; + typedef typename packet_traits::type _LhsPacket; + typedef typename packet_traits::type _RhsPacket; + typedef typename packet_traits::type _ResPacket; - typedef typename ei_meta_if::ret LhsPacket; - typedef typename ei_meta_if::ret RhsPacket; - typedef typename ei_meta_if::ret ResPacket; + typedef typename meta_if::ret LhsPacket; + typedef typename meta_if::ret RhsPacket; + typedef typename meta_if::ret ResPacket; typedef ResPacket AccPacket; EIGEN_STRONG_INLINE void initAcc(AccPacket& p) { - p = ei_pset1(ResScalar(0)); + p = pset1(ResScalar(0)); } EIGEN_STRONG_INLINE void unpackRhs(DenseIndex n, const RhsScalar* rhs, RhsScalar* b) { for(DenseIndex k=0; k(rhs[k])); + pstore(&b[k*RhsPacketSize], pset1(rhs[k])); } EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const { - dest = ei_pload(b); + dest = pload(b); } EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const { - dest = ei_pload(a); + dest = pload(a); } EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, AccPacket& c, AccPacket& tmp) const { - tmp = b; tmp = ei_pmul(a,tmp); c = ei_padd(c,tmp); + tmp = b; tmp = pmul(a,tmp); c = padd(c,tmp); } EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha, ResPacket& r) const { - r = ei_pmadd(c,alpha,r); + r = pmadd(c,alpha,r); } protected: -// ei_conj_helper cj; -// ei_conj_helper pcj; +// conj_helper cj; +// conj_helper pcj; }; template -class ei_gebp_traits, RealScalar, _ConjLhs, false> +class gebp_traits, RealScalar, _ConjLhs, false> { public: typedef std::complex LhsScalar; typedef RealScalar RhsScalar; - typedef typename ei_scalar_product_traits::ReturnType ResScalar; + typedef typename scalar_product_traits::ReturnType ResScalar; enum { ConjLhs = _ConjLhs, ConjRhs = false, - Vectorizable = ei_packet_traits::Vectorizable && ei_packet_traits::Vectorizable, - LhsPacketSize = Vectorizable ? ei_packet_traits::size : 1, - RhsPacketSize = Vectorizable ? ei_packet_traits::size : 1, - ResPacketSize = Vectorizable ? ei_packet_traits::size : 1, + Vectorizable = packet_traits::Vectorizable && packet_traits::Vectorizable, + LhsPacketSize = Vectorizable ? packet_traits::size : 1, + RhsPacketSize = Vectorizable ? packet_traits::size : 1, + ResPacketSize = Vectorizable ? packet_traits::size : 1, NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS, nr = NumberOfRegisters/4, @@ -278,48 +252,48 @@ public: RhsProgress = RhsPacketSize }; - typedef typename ei_packet_traits::type _LhsPacket; - typedef typename ei_packet_traits::type _RhsPacket; - typedef typename ei_packet_traits::type _ResPacket; + typedef typename packet_traits::type _LhsPacket; + typedef typename packet_traits::type _RhsPacket; + typedef typename packet_traits::type _ResPacket; - typedef typename ei_meta_if::ret LhsPacket; - typedef typename ei_meta_if::ret RhsPacket; - typedef typename ei_meta_if::ret ResPacket; + typedef typename meta_if::ret LhsPacket; + typedef typename meta_if::ret RhsPacket; + typedef typename meta_if::ret ResPacket; typedef ResPacket AccPacket; EIGEN_STRONG_INLINE void initAcc(AccPacket& p) { - p = ei_pset1(ResScalar(0)); + p = pset1(ResScalar(0)); } EIGEN_STRONG_INLINE void unpackRhs(DenseIndex n, const RhsScalar* rhs, RhsScalar* b) { for(DenseIndex k=0; k(rhs[k])); + pstore(&b[k*RhsPacketSize], pset1(rhs[k])); } EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const { - dest = ei_pload(b); + dest = pload(b); } EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const { - dest = ei_pload(a); + dest = pload(a); } EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& tmp) const { - madd_impl(a, b, c, tmp, typename ei_meta_if::ret()); + madd_impl(a, b, c, tmp, typename meta_if::ret()); } - EIGEN_STRONG_INLINE void madd_impl(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& tmp, const ei_meta_true&) const + EIGEN_STRONG_INLINE void madd_impl(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& tmp, const meta_true&) const { - tmp = b; tmp = ei_pmul(a.v,tmp); c.v = ei_padd(c.v,tmp); + tmp = b; tmp = pmul(a.v,tmp); c.v = padd(c.v,tmp); } - EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& b, ResScalar& c, RhsScalar& /*tmp*/, const ei_meta_false&) const + EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& b, ResScalar& c, RhsScalar& /*tmp*/, const meta_false&) const { c += a * b; } @@ -330,11 +304,11 @@ public: } protected: - ei_conj_helper cj; + conj_helper cj; }; template -class ei_gebp_traits, std::complex, _ConjLhs, _ConjRhs > +class gebp_traits, std::complex, _ConjLhs, _ConjRhs > { public: typedef std::complex Scalar; @@ -345,10 +319,10 @@ public: enum { ConjLhs = _ConjLhs, ConjRhs = _ConjRhs, - Vectorizable = ei_packet_traits::Vectorizable - && ei_packet_traits::Vectorizable, - RealPacketSize = Vectorizable ? ei_packet_traits::size : 1, - ResPacketSize = Vectorizable ? ei_packet_traits::size : 1, + Vectorizable = packet_traits::Vectorizable + && packet_traits::Vectorizable, + RealPacketSize = Vectorizable ? packet_traits::size : 1, + ResPacketSize = Vectorizable ? packet_traits::size : 1, nr = 2, mr = 2 * ResPacketSize, @@ -358,25 +332,25 @@ public: RhsProgress = Vectorizable ? 2*ResPacketSize : 1 }; - typedef typename ei_packet_traits::type RealPacket; - typedef typename ei_packet_traits::type ScalarPacket; + typedef typename packet_traits::type RealPacket; + typedef typename packet_traits::type ScalarPacket; struct DoublePacket { RealPacket first; RealPacket second; }; - typedef typename ei_meta_if::ret LhsPacket; - typedef typename ei_meta_if::ret RhsPacket; - typedef typename ei_meta_if::ret ResPacket; - typedef typename ei_meta_if::ret AccPacket; + typedef typename meta_if::ret LhsPacket; + typedef typename meta_if::ret RhsPacket; + typedef typename meta_if::ret ResPacket; + typedef typename meta_if::ret AccPacket; EIGEN_STRONG_INLINE void initAcc(Scalar& p) { p = Scalar(0); } EIGEN_STRONG_INLINE void initAcc(DoublePacket& p) { - p.first = ei_pset1(RealScalar(0)); - p.second = ei_pset1(RealScalar(0)); + p.first = pset1(RealScalar(0)); + p.second = pset1(RealScalar(0)); } /* Unpack the rhs coeff such that each complex coefficient is spread into @@ -389,8 +363,8 @@ public: { if(Vectorizable) { - ei_pstore((RealScalar*)&b[k*ResPacketSize*2+0], ei_pset1(ei_real(rhs[k]))); - ei_pstore((RealScalar*)&b[k*ResPacketSize*2+ResPacketSize], ei_pset1(ei_imag(rhs[k]))); + pstore((RealScalar*)&b[k*ResPacketSize*2+0], pset1(real(rhs[k]))); + pstore((RealScalar*)&b[k*ResPacketSize*2+ResPacketSize], pset1(imag(rhs[k]))); } else b[k] = rhs[k]; @@ -401,20 +375,20 @@ public: EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, DoublePacket& dest) const { - dest.first = ei_pload((const RealScalar*)b); - dest.second = ei_pload((const RealScalar*)(b+ResPacketSize)); + dest.first = pload((const RealScalar*)b); + dest.second = pload((const RealScalar*)(b+ResPacketSize)); } // nothing special here EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const { - dest = ei_pload((const typename ei_unpacket_traits::type*)(a)); + dest = pload((const typename unpacket_traits::type*)(a)); } EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, DoublePacket& c, RhsPacket& /*tmp*/) const { - c.first = ei_padd(ei_pmul(a,b.first), c.first); - c.second = ei_padd(ei_pmul(a,b.second),c.second); + c.first = padd(pmul(a,b.first), c.first); + c.second = padd(pmul(a,b.second),c.second); } EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, ResPacket& c, RhsPacket& /*tmp*/) const @@ -430,34 +404,34 @@ public: ResPacket tmp; if((!ConjLhs)&&(!ConjRhs)) { - tmp = ei_pcplxflip(ei_pconj(ResPacket(c.second))); - tmp = ei_padd(ResPacket(c.first),tmp); + tmp = pcplxflip(pconj(ResPacket(c.second))); + tmp = padd(ResPacket(c.first),tmp); } else if((!ConjLhs)&&(ConjRhs)) { - tmp = ei_pconj(ei_pcplxflip(ResPacket(c.second))); - tmp = ei_padd(ResPacket(c.first),tmp); + tmp = pconj(pcplxflip(ResPacket(c.second))); + tmp = padd(ResPacket(c.first),tmp); } else if((ConjLhs)&&(!ConjRhs)) { - tmp = ei_pcplxflip(ResPacket(c.second)); - tmp = ei_padd(ei_pconj(ResPacket(c.first)),tmp); + tmp = pcplxflip(ResPacket(c.second)); + tmp = padd(pconj(ResPacket(c.first)),tmp); } else if((ConjLhs)&&(ConjRhs)) { - tmp = ei_pcplxflip(ResPacket(c.second)); - tmp = ei_psub(ei_pconj(ResPacket(c.first)),tmp); + tmp = pcplxflip(ResPacket(c.second)); + tmp = psub(pconj(ResPacket(c.first)),tmp); } - r = ei_pmadd(tmp,alpha,r); + r = pmadd(tmp,alpha,r); } protected: - ei_conj_helper cj; + conj_helper cj; }; template -class ei_gebp_traits, false, _ConjRhs > +class gebp_traits, false, _ConjRhs > { public: typedef std::complex Scalar; @@ -468,11 +442,11 @@ public: enum { ConjLhs = false, ConjRhs = _ConjRhs, - Vectorizable = ei_packet_traits::Vectorizable - && ei_packet_traits::Vectorizable, - LhsPacketSize = Vectorizable ? ei_packet_traits::size : 1, - RhsPacketSize = Vectorizable ? ei_packet_traits::size : 1, - ResPacketSize = Vectorizable ? ei_packet_traits::size : 1, + Vectorizable = packet_traits::Vectorizable + && packet_traits::Vectorizable, + LhsPacketSize = Vectorizable ? packet_traits::size : 1, + RhsPacketSize = Vectorizable ? packet_traits::size : 1, + ResPacketSize = Vectorizable ? packet_traits::size : 1, NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS, nr = 4, @@ -483,48 +457,48 @@ public: RhsProgress = ResPacketSize }; - typedef typename ei_packet_traits::type _LhsPacket; - typedef typename ei_packet_traits::type _RhsPacket; - typedef typename ei_packet_traits::type _ResPacket; + typedef typename packet_traits::type _LhsPacket; + typedef typename packet_traits::type _RhsPacket; + typedef typename packet_traits::type _ResPacket; - typedef typename ei_meta_if::ret LhsPacket; - typedef typename ei_meta_if::ret RhsPacket; - typedef typename ei_meta_if::ret ResPacket; + typedef typename meta_if::ret LhsPacket; + typedef typename meta_if::ret RhsPacket; + typedef typename meta_if::ret ResPacket; typedef ResPacket AccPacket; EIGEN_STRONG_INLINE void initAcc(AccPacket& p) { - p = ei_pset1(ResScalar(0)); + p = pset1(ResScalar(0)); } EIGEN_STRONG_INLINE void unpackRhs(DenseIndex n, const RhsScalar* rhs, RhsScalar* b) { for(DenseIndex k=0; k(rhs[k])); + pstore(&b[k*RhsPacketSize], pset1(rhs[k])); } EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const { - dest = ei_pload(b); + dest = pload(b); } EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const { - dest = ei_ploaddup(a); + dest = ploaddup(a); } EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& tmp) const { - madd_impl(a, b, c, tmp, typename ei_meta_if::ret()); + madd_impl(a, b, c, tmp, typename meta_if::ret()); } - EIGEN_STRONG_INLINE void madd_impl(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& tmp, const ei_meta_true&) const + EIGEN_STRONG_INLINE void madd_impl(const LhsPacket& a, const RhsPacket& b, AccPacket& c, RhsPacket& tmp, const meta_true&) const { - tmp = b; tmp.v = ei_pmul(a,tmp.v); c = ei_padd(c,tmp); + tmp = b; tmp.v = pmul(a,tmp.v); c = padd(c,tmp); } - EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& b, ResScalar& c, RhsScalar& /*tmp*/, const ei_meta_false&) const + EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& b, ResScalar& c, RhsScalar& /*tmp*/, const meta_false&) const { c += a * b; } @@ -535,7 +509,7 @@ public: } protected: - ei_conj_helper cj; + conj_helper cj; }; /* optimized GEneral packed Block * packed Panel product kernel @@ -546,9 +520,9 @@ protected: * |cplx |real | easy vectorization */ template -struct ei_gebp_kernel +struct gebp_kernel { - typedef ei_gebp_traits Traits; + typedef gebp_traits Traits; typedef typename Traits::ResScalar ResScalar; typedef typename Traits::LhsPacket LhsPacket; typedef typename Traits::RhsPacket RhsPacket; @@ -570,8 +544,8 @@ struct ei_gebp_kernel if(strideA==-1) strideA = depth; if(strideB==-1) strideB = depth; - ei_conj_helper cj; -// ei_conj_helper pcj; + conj_helper cj; +// conj_helper pcj; Index packet_cols = (cols/nr) * nr; const Index peeled_mc = (rows/mr)*mr; // FIXME: @@ -592,7 +566,7 @@ struct ei_gebp_kernel for(Index i=0; i(alpha); + ResPacket alphav = pset1(alpha); - R0 = ei_ploadu(r0); - R1 = ei_ploadu(r1); - if(nr==4) R2 = ei_ploadu(r2); - if(nr==4) R3 = ei_ploadu(r3); - R4 = ei_ploadu(r0 + ResPacketSize); - R5 = ei_ploadu(r1 + ResPacketSize); - if(nr==4) R6 = ei_ploadu(r2 + ResPacketSize); - if(nr==4) R7 = ei_ploadu(r3 + ResPacketSize); + R0 = ploadu(r0); + R1 = ploadu(r1); + if(nr==4) R2 = ploadu(r2); + if(nr==4) R3 = ploadu(r3); + R4 = ploadu(r0 + ResPacketSize); + R5 = ploadu(r1 + ResPacketSize); + if(nr==4) R6 = ploadu(r2 + ResPacketSize); + if(nr==4) R7 = ploadu(r3 + ResPacketSize); traits.acc(C0, alphav, R0); traits.acc(C1, alphav, R1); @@ -801,21 +775,21 @@ EIGEN_ASM_COMMENT("mybegin4"); if(nr==4) traits.acc(C6, alphav, R6); if(nr==4) traits.acc(C7, alphav, R7); - ei_pstoreu(r0, R0); - ei_pstoreu(r1, R1); - if(nr==4) ei_pstoreu(r2, R2); - if(nr==4) ei_pstoreu(r3, R3); - ei_pstoreu(r0 + ResPacketSize, R4); - ei_pstoreu(r1 + ResPacketSize, R5); - if(nr==4) ei_pstoreu(r2 + ResPacketSize, R6); - if(nr==4) ei_pstoreu(r3 + ResPacketSize, R7); + pstoreu(r0, R0); + pstoreu(r1, R1); + if(nr==4) pstoreu(r2, R2); + if(nr==4) pstoreu(r3, R3); + pstoreu(r0 + ResPacketSize, R4); + pstoreu(r1 + ResPacketSize, R5); + if(nr==4) pstoreu(r2 + ResPacketSize, R6); + if(nr==4) pstoreu(r3 + ResPacketSize, R7); } if(rows-peeled_mc>=LhsProgress) { Index i = peeled_mc; const LhsScalar* blA = &blockA[i*strideA+offsetA*LhsProgress]; - ei_prefetch(&blA[0]); + prefetch(&blA[0]); // gets res block as register AccPacket C0, C1, C2, C3; @@ -939,32 +913,32 @@ EIGEN_ASM_COMMENT("mybegin4"); } ResPacket R0, R1, R2, R3; - ResPacket alphav = ei_pset1(alpha); + ResPacket alphav = pset1(alpha); ResScalar* r0 = &res[(j2+0)*resStride + i]; ResScalar* r1 = r0 + resStride; ResScalar* r2 = r1 + resStride; ResScalar* r3 = r2 + resStride; - R0 = ei_ploadu(r0); - R1 = ei_ploadu(r1); - if(nr==4) R2 = ei_ploadu(r2); - if(nr==4) R3 = ei_ploadu(r3); + R0 = ploadu(r0); + R1 = ploadu(r1); + if(nr==4) R2 = ploadu(r2); + if(nr==4) R3 = ploadu(r3); traits.acc(C0, alphav, R0); traits.acc(C1, alphav, R1); if(nr==4) traits.acc(C2, alphav, R2); if(nr==4) traits.acc(C3, alphav, R3); - ei_pstoreu(r0, R0); - ei_pstoreu(r1, R1); - if(nr==4) ei_pstoreu(r2, R2); - if(nr==4) ei_pstoreu(r3, R3); + pstoreu(r0, R0); + pstoreu(r1, R1); + if(nr==4) pstoreu(r2, R2); + if(nr==4) pstoreu(r3, R3); } for(Index i=peeled_mc2; i(blB[k])); +// pstore(&unpackedB[k*RhsPacketSize], pset1(blB[k])); } for(Index i=0; i(alpha); + ResPacket alphav = pset1(alpha); ResScalar* r0 = &res[(j2+0)*resStride + i]; - R0 = ei_ploadu(r0); - R4 = ei_ploadu(r0+ResPacketSize); + R0 = ploadu(r0); + R4 = ploadu(r0+ResPacketSize); traits.acc(C0, alphav, R0); traits.acc(C4, alphav, R4); - ei_pstoreu(r0, R0); - ei_pstoreu(r0+ResPacketSize, R4); + pstoreu(r0, R0); + pstoreu(r0+ResPacketSize, R4); } if(rows-peeled_mc>=LhsProgress) { Index i = peeled_mc; const LhsScalar* blA = &blockA[i*strideA+offsetA*LhsProgress]; - ei_prefetch(&blA[0]); + prefetch(&blA[0]); AccPacket C0; traits.initAcc(C0); @@ -1083,15 +1057,15 @@ EIGEN_ASM_COMMENT("mybegin4"); blA += LhsProgress; } - ResPacket alphav = ei_pset1(alpha); - ResPacket R0 = ei_ploadu(&res[(j2+0)*resStride + i]); + ResPacket alphav = pset1(alpha); + ResPacket R0 = ploadu(&res[(j2+0)*resStride + i]); traits.acc(C0, alphav, R0); - ei_pstoreu(&res[(j2+0)*resStride + i], R0); + pstoreu(&res[(j2+0)*resStride + i], R0); } for(Index i=peeled_mc2; i -struct ei_gemm_pack_lhs +struct gemm_pack_lhs { void operator()(Scalar* blockA, const Scalar* EIGEN_RESTRICT _lhs, Index lhsStride, Index depth, Index rows, Index stride=0, Index offset=0) { -// enum { PacketSize = ei_packet_traits::size }; - ei_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride)); - ei_conj_if::IsComplex && Conjugate> cj; - ei_const_blas_data_mapper lhs(_lhs,lhsStride); +// enum { PacketSize = packet_traits::size }; + eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride)); + conj_if::IsComplex && Conjugate> cj; + const_blas_data_mapper lhs(_lhs,lhsStride); Index count = 0; Index peeled_mc = (rows/Pack1)*Pack1; for(Index i=0; i -struct ei_gemm_pack_rhs +struct gemm_pack_rhs { - typedef typename ei_packet_traits::type Packet; - enum { PacketSize = ei_packet_traits::size }; + typedef typename packet_traits::type Packet; + enum { PacketSize = packet_traits::size }; void operator()(Scalar* blockB, const Scalar* rhs, Index rhsStride, Index depth, Index cols, Index stride=0, Index offset=0) { - ei_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride)); - ei_conj_if::IsComplex && Conjugate> cj; + eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride)); + conj_if::IsComplex && Conjugate> cj; Index packet_cols = (cols/nr) * nr; Index count = 0; for(Index j2=0; j2 // this version is optimized for row major matrices template -struct ei_gemm_pack_rhs +struct gemm_pack_rhs { - enum { PacketSize = ei_packet_traits::size }; + enum { PacketSize = packet_traits::size }; void operator()(Scalar* blockB, const Scalar* rhs, Index rhsStride, Index depth, Index cols, Index stride=0, Index offset=0) { - ei_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride)); - ei_conj_if::IsComplex && Conjugate> cj; + eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride)); + conj_if::IsComplex && Conjugate> cj; Index packet_cols = (cols/nr) * nr; Index count = 0; for(Index j2=0; j2 } }; +} // end namespace internal + +/** \returns the currently set level 1 cpu cache size (in bytes) used to estimate the ideal blocking size parameters. + * \sa setCpuCacheSize */ +inline std::ptrdiff_t l1CacheSize() +{ + std::ptrdiff_t l1, l2; + internal::manage_caching_sizes(GetAction, &l1, &l2); + return l1; +} + +/** \returns the currently set level 2 cpu cache size (in bytes) used to estimate the ideal blocking size parameters. + * \sa setCpuCacheSize */ +inline std::ptrdiff_t l2CacheSize() +{ + std::ptrdiff_t l1, l2; + internal::manage_caching_sizes(GetAction, &l1, &l2); + return l2; +} + +/** Set the cpu L1 and L2 cache sizes (in bytes). + * These values are use to adjust the size of the blocks + * for the algorithms working per blocks. + * + * \sa computeProductBlockingSizes */ +inline void setCpuCacheSizes(std::ptrdiff_t l1, std::ptrdiff_t l2) +{ + internal::manage_caching_sizes(SetAction, &l1, &l2); +} + #endif // EIGEN_GENERAL_BLOCK_PANEL_H diff --git a/Eigen/src/Core/products/GeneralMatrixMatrix.h b/Eigen/src/Core/products/GeneralMatrixMatrix.h index 1cdfb84d1..39e65599d 100644 --- a/Eigen/src/Core/products/GeneralMatrixMatrix.h +++ b/Eigen/src/Core/products/GeneralMatrixMatrix.h @@ -25,27 +25,29 @@ #ifndef EIGEN_GENERAL_MATRIX_MATRIX_H #define EIGEN_GENERAL_MATRIX_MATRIX_H -template class ei_level3_blocking; +namespace internal { + +template class level3_blocking; /* Specialization for a row-major destination matrix => simple transposition of the product */ template< typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs, typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs> -struct ei_general_matrix_matrix_product +struct general_matrix_matrix_product { - typedef typename ei_scalar_product_traits::ReturnType ResScalar; + typedef typename scalar_product_traits::ReturnType ResScalar; static EIGEN_STRONG_INLINE void run( Index rows, Index cols, Index depth, const LhsScalar* lhs, Index lhsStride, const RhsScalar* rhs, Index rhsStride, ResScalar* res, Index resStride, ResScalar alpha, - ei_level3_blocking& blocking, + level3_blocking& blocking, GemmParallelInfo* info = 0) { // transpose the product such that the result is column major - ei_general_matrix_matrix_product @@ -59,29 +61,29 @@ template< typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs, typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs> -struct ei_general_matrix_matrix_product +struct general_matrix_matrix_product { -typedef typename ei_scalar_product_traits::ReturnType ResScalar; +typedef typename scalar_product_traits::ReturnType ResScalar; static void run(Index rows, Index cols, Index depth, const LhsScalar* _lhs, Index lhsStride, const RhsScalar* _rhs, Index rhsStride, ResScalar* res, Index resStride, ResScalar alpha, - ei_level3_blocking& blocking, + level3_blocking& blocking, GemmParallelInfo* info = 0) { - ei_const_blas_data_mapper lhs(_lhs,lhsStride); - ei_const_blas_data_mapper rhs(_rhs,rhsStride); + const_blas_data_mapper lhs(_lhs,lhsStride); + const_blas_data_mapper rhs(_rhs,rhsStride); - typedef ei_gebp_traits Traits; + typedef gebp_traits Traits; Index kc = blocking.kc(); // cache block size along the K direction Index mc = std::min(rows,blocking.mc()); // cache block size along the M direction //Index nc = blocking.nc(); // cache block size along the N direction - ei_gemm_pack_lhs pack_lhs; - ei_gemm_pack_rhs pack_rhs; - ei_gebp_kernel gebp; + gemm_pack_lhs pack_lhs; + gemm_pack_rhs pack_rhs; + gebp_kernel gebp; #ifdef EIGEN_HAS_OPENMP if(info) @@ -94,7 +96,7 @@ static void run(Index rows, Index cols, Index depth, std::size_t sizeW = kc*Traits::WorkSpaceFactor; RhsScalar* w = ei_aligned_stack_new(RhsScalar, sizeW); RhsScalar* blockB = blocking.blockB(); - ei_internal_assert(blockB!=0); + eigen_internal_assert(blockB!=0); // For each horizontal panel of the rhs, and corresponding vertical panel of the lhs... for(Index k=0; k for "large" GEMM, i.e., -* implementation of the high level wrapper to ei_general_matrix_matrix_product +* implementation of the high level wrapper to general_matrix_matrix_product **********************************************************************************/ template -struct ei_traits > - : ei_traits, Lhs, Rhs> > +struct traits > + : traits, Lhs, Rhs> > {}; template -struct ei_gemm_functor +struct gemm_functor { - ei_gemm_functor(const Lhs& lhs, const Rhs& rhs, Dest& dest, Scalar actualAlpha, + gemm_functor(const Lhs& lhs, const Rhs& rhs, Dest& dest, Scalar actualAlpha, BlockingType& blocking) : m_lhs(lhs), m_rhs(rhs), m_dest(dest), m_actualAlpha(actualAlpha), m_blocking(blocking) {} @@ -250,10 +252,10 @@ struct ei_gemm_functor }; template class ei_gemm_blocking_space; +bool FiniteAtCompileTime = MaxRows!=Dynamic && MaxCols!=Dynamic && MaxDepth != Dynamic> class gemm_blocking_space; template -class ei_level3_blocking +class level3_blocking { typedef _LhsScalar LhsScalar; typedef _RhsScalar RhsScalar; @@ -269,7 +271,7 @@ class ei_level3_blocking public: - ei_level3_blocking() + level3_blocking() : m_blockA(0), m_blockB(0), m_blockW(0), m_mc(0), m_nc(0), m_kc(0) {} @@ -283,19 +285,19 @@ class ei_level3_blocking }; template -class ei_gemm_blocking_space - : public ei_level3_blocking< - typename ei_meta_if::ret, - typename ei_meta_if::ret> +class gemm_blocking_space + : public level3_blocking< + typename meta_if::ret, + typename meta_if::ret> { enum { Transpose = StorageOrder==RowMajor, ActualRows = Transpose ? MaxCols : MaxRows, ActualCols = Transpose ? MaxRows : MaxCols }; - typedef typename ei_meta_if::ret LhsScalar; - typedef typename ei_meta_if::ret RhsScalar; - typedef ei_gebp_traits Traits; + typedef typename meta_if::ret LhsScalar; + typedef typename meta_if::ret RhsScalar; + typedef gebp_traits Traits; enum { SizeA = ActualRows * MaxDepth, SizeB = ActualCols * MaxDepth, @@ -308,7 +310,7 @@ class ei_gemm_blocking_spacem_mc = ActualRows; this->m_nc = ActualCols; @@ -325,17 +327,17 @@ class ei_gemm_blocking_space -class ei_gemm_blocking_space - : public ei_level3_blocking< - typename ei_meta_if::ret, - typename ei_meta_if::ret> +class gemm_blocking_space + : public level3_blocking< + typename meta_if::ret, + typename meta_if::ret> { enum { Transpose = StorageOrder==RowMajor }; - typedef typename ei_meta_if::ret LhsScalar; - typedef typename ei_meta_if::ret RhsScalar; - typedef ei_gebp_traits Traits; + typedef typename meta_if::ret LhsScalar; + typedef typename meta_if::ret RhsScalar; + typedef gebp_traits Traits; DenseIndex m_sizeA; DenseIndex m_sizeB; @@ -343,7 +345,7 @@ class ei_gemm_blocking_spacem_mc = Transpose ? cols : rows; this->m_nc = Transpose ? rows : cols; @@ -358,19 +360,19 @@ class ei_gemm_blocking_spacem_blockA==0) - this->m_blockA = ei_aligned_new(m_sizeA); + this->m_blockA = aligned_new(m_sizeA); } void allocateB() { if(this->m_blockB==0) - this->m_blockB = ei_aligned_new(m_sizeB); + this->m_blockB = aligned_new(m_sizeB); } void allocateW() { if(this->m_blockW==0) - this->m_blockW = ei_aligned_new(m_sizeW); + this->m_blockW = aligned_new(m_sizeW); } void allocateAll() @@ -380,14 +382,16 @@ class ei_gemm_blocking_spacem_blockA, m_sizeA); - ei_aligned_delete(this->m_blockB, m_sizeB); - ei_aligned_delete(this->m_blockW, m_sizeW); + aligned_delete(this->m_blockA, m_sizeA); + aligned_delete(this->m_blockB, m_sizeB); + aligned_delete(this->m_blockW, m_sizeW); } }; +} // end namespace internal + template class GeneralProduct : public ProductBase, Lhs, Rhs> @@ -404,13 +408,13 @@ class GeneralProduct GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs) { - typedef ei_scalar_product_op BinOp; + typedef internal::scalar_product_op BinOp; EIGEN_CHECK_BINARY_COMPATIBILIY(BinOp,LhsScalar,RhsScalar); } template void scaleAndAddTo(Dest& dst, Scalar alpha) const { - ei_assert(dst.rows()==m_lhs.rows() && dst.cols()==m_rhs.cols()); + eigen_assert(dst.rows()==m_lhs.rows() && dst.cols()==m_rhs.cols()); const ActualLhsType lhs = LhsBlasTraits::extract(m_lhs); const ActualRhsType rhs = RhsBlasTraits::extract(m_rhs); @@ -418,12 +422,12 @@ class GeneralProduct Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(m_lhs) * RhsBlasTraits::extractScalarFactor(m_rhs); - typedef ei_gemm_blocking_space<(Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,LhsScalar,RhsScalar, + typedef internal::gemm_blocking_space<(Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,LhsScalar,RhsScalar, Dest::MaxRowsAtCompileTime,Dest::MaxColsAtCompileTime,MaxDepthAtCompileTime> BlockingType; - typedef ei_gemm_functor< + typedef internal::gemm_functor< Scalar, Index, - ei_general_matrix_matrix_product< + internal::general_matrix_matrix_product< Index, LhsScalar, (_ActualLhsType::Flags&RowMajorBit) ? RowMajor : ColMajor, bool(LhsBlasTraits::NeedToConjugate), RhsScalar, (_ActualRhsType::Flags&RowMajorBit) ? RowMajor : ColMajor, bool(RhsBlasTraits::NeedToConjugate), @@ -432,7 +436,7 @@ class GeneralProduct BlockingType blocking(dst.rows(), dst.cols(), lhs.cols()); - ei_parallelize_gemm<(Dest::MaxRowsAtCompileTime>32 || Dest::MaxRowsAtCompileTime==Dynamic)>(GemmFunctor(lhs, rhs, dst, actualAlpha, blocking), this->rows(), this->cols(), Dest::Flags&RowMajorBit); + internal::parallelize_gemm<(Dest::MaxRowsAtCompileTime>32 || Dest::MaxRowsAtCompileTime==Dynamic)>(GemmFunctor(lhs, rhs, dst, actualAlpha, blocking), this->rows(), this->cols(), Dest::Flags&RowMajorBit); } }; diff --git a/Eigen/src/Core/products/GeneralMatrixVector.h b/Eigen/src/Core/products/GeneralMatrixVector.h index 96a038b05..41df6170c 100644 --- a/Eigen/src/Core/products/GeneralMatrixVector.h +++ b/Eigen/src/Core/products/GeneralMatrixVector.h @@ -25,6 +25,8 @@ #ifndef EIGEN_GENERAL_MATRIX_VECTOR_H #define EIGEN_GENERAL_MATRIX_VECTOR_H +namespace internal { + /* Optimized col-major matrix * vector product: * This algorithm processes 4 columns at onces that allows to both reduce * the number of load/stores of the result by a factor 4 and to reduce @@ -39,25 +41,25 @@ * |cplx |real |real | optimal case, vectorization possible via real-cplx mul */ template -struct ei_general_matrix_vector_product +struct general_matrix_vector_product { -typedef typename ei_scalar_product_traits::ReturnType ResScalar; +typedef typename scalar_product_traits::ReturnType ResScalar; enum { - Vectorizable = ei_packet_traits::Vectorizable && ei_packet_traits::Vectorizable - && int(ei_packet_traits::size)==int(ei_packet_traits::size), - LhsPacketSize = Vectorizable ? ei_packet_traits::size : 1, - RhsPacketSize = Vectorizable ? ei_packet_traits::size : 1, - ResPacketSize = Vectorizable ? ei_packet_traits::size : 1 + Vectorizable = packet_traits::Vectorizable && packet_traits::Vectorizable + && int(packet_traits::size)==int(packet_traits::size), + LhsPacketSize = Vectorizable ? packet_traits::size : 1, + RhsPacketSize = Vectorizable ? packet_traits::size : 1, + ResPacketSize = Vectorizable ? packet_traits::size : 1 }; -typedef typename ei_packet_traits::type _LhsPacket; -typedef typename ei_packet_traits::type _RhsPacket; -typedef typename ei_packet_traits::type _ResPacket; +typedef typename packet_traits::type _LhsPacket; +typedef typename packet_traits::type _RhsPacket; +typedef typename packet_traits::type _ResPacket; -typedef typename ei_meta_if::ret LhsPacket; -typedef typename ei_meta_if::ret RhsPacket; -typedef typename ei_meta_if::ret ResPacket; +typedef typename meta_if::ret LhsPacket; +typedef typename meta_if::ret RhsPacket; +typedef typename meta_if::ret ResPacket; EIGEN_DONT_INLINE static void run( Index rows, Index cols, @@ -69,23 +71,23 @@ EIGEN_DONT_INLINE static void run( #endif , RhsScalar alpha) { - ei_internal_assert(resIncr==1); + eigen_internal_assert(resIncr==1); #ifdef _EIGEN_ACCUMULATE_PACKETS #error _EIGEN_ACCUMULATE_PACKETS has already been defined #endif #define _EIGEN_ACCUMULATE_PACKETS(A0,A13,A2) \ - ei_pstore(&res[j], \ - ei_padd(ei_pload(&res[j]), \ - ei_padd( \ - ei_padd(pcj.pmul(EIGEN_CAT(ei_ploa , A0)(&lhs0[j]), ptmp0), \ - pcj.pmul(EIGEN_CAT(ei_ploa , A13)(&lhs1[j]), ptmp1)), \ - ei_padd(pcj.pmul(EIGEN_CAT(ei_ploa , A2)(&lhs2[j]), ptmp2), \ - pcj.pmul(EIGEN_CAT(ei_ploa , A13)(&lhs3[j]), ptmp3)) ))) - - ei_conj_helper cj; - ei_conj_helper pcj; + pstore(&res[j], \ + padd(pload(&res[j]), \ + padd( \ + padd(pcj.pmul(EIGEN_CAT(ploa , A0)(&lhs0[j]), ptmp0), \ + pcj.pmul(EIGEN_CAT(ploa , A13)(&lhs1[j]), ptmp1)), \ + padd(pcj.pmul(EIGEN_CAT(ploa , A2)(&lhs2[j]), ptmp2), \ + pcj.pmul(EIGEN_CAT(ploa , A13)(&lhs3[j]), ptmp3)) ))) + + conj_helper cj; + conj_helper pcj; if(ConjugateRhs) - alpha = ei_conj(alpha); + alpha = conj(alpha); enum { AllAligned = 0, EvenAligned, FirstAligned, NoneAligned }; const Index columnsAtOnce = 4; @@ -97,7 +99,7 @@ EIGEN_DONT_INLINE static void run( // How many coeffs of the result do we have to skip to be aligned. // Here we assume data are at least aligned on the base scalar type. - Index alignedStart = ei_first_aligned(res,size); + Index alignedStart = first_aligned(res,size); Index alignedSize = ResPacketSize>1 ? alignedStart + ((size-alignedStart) & ~ResPacketAlignedMask) : 0; const Index peeledSize = peels>1 ? alignedStart + ((alignedSize-alignedStart) & ~PeelAlignedMask) : alignedStart; @@ -107,7 +109,7 @@ EIGEN_DONT_INLINE static void run( : FirstAligned; // we cannot assume the first element is aligned because of sub-matrices - const Index lhsAlignmentOffset = ei_first_aligned(lhs,size); + const Index lhsAlignmentOffset = first_aligned(lhs,size); // find how many columns do we have to skip to be aligned with the result (if possible) Index skipColumns = 0; @@ -119,7 +121,7 @@ EIGEN_DONT_INLINE static void run( } else if (LhsPacketSize>1) { - ei_internal_assert(size_t(lhs+lhsAlignmentOffset)%sizeof(LhsPacket)==0 || size= cols) || LhsPacketSize > size || (size_t(lhs+alignedStart+lhsStride*skipColumns)%sizeof(LhsPacket))==0); @@ -154,10 +156,10 @@ EIGEN_DONT_INLINE static void run( Index columnBound = ((cols-skipColumns)/columnsAtOnce)*columnsAtOnce + skipColumns; for (Index i=skipColumns; i(alpha*rhs[i*rhsIncr]), - ptmp1 = ei_pset1(alpha*rhs[(i+offset1)*rhsIncr]), - ptmp2 = ei_pset1(alpha*rhs[(i+2)*rhsIncr]), - ptmp3 = ei_pset1(alpha*rhs[(i+offset3)*rhsIncr]); + RhsPacket ptmp0 = pset1(alpha*rhs[i*rhsIncr]), + ptmp1 = pset1(alpha*rhs[(i+offset1)*rhsIncr]), + ptmp2 = pset1(alpha*rhs[(i+2)*rhsIncr]), + ptmp3 = pset1(alpha*rhs[(i+offset3)*rhsIncr]); // this helps a lot generating better binary code const LhsScalar *lhs0 = lhs + i*lhsStride, *lhs1 = lhs + (i+offset1)*lhsStride, @@ -169,10 +171,10 @@ EIGEN_DONT_INLINE static void run( // process initial unaligned coeffs for (Index j=0; jalignedStart) @@ -193,32 +195,32 @@ EIGEN_DONT_INLINE static void run( LhsPacket A00, A01, A02, A03, A10, A11, A12, A13; ResPacket T0, T1; - A01 = ei_pload(&lhs1[alignedStart-1]); - A02 = ei_pload(&lhs2[alignedStart-2]); - A03 = ei_pload(&lhs3[alignedStart-3]); + A01 = pload(&lhs1[alignedStart-1]); + A02 = pload(&lhs2[alignedStart-2]); + A03 = pload(&lhs3[alignedStart-3]); for (Index j = alignedStart; j(&lhs1[j-1+LhsPacketSize]); ei_palign<1>(A01,A11); - A12 = ei_pload(&lhs2[j-2+LhsPacketSize]); ei_palign<2>(A02,A12); - A13 = ei_pload(&lhs3[j-3+LhsPacketSize]); ei_palign<3>(A03,A13); + A11 = pload(&lhs1[j-1+LhsPacketSize]); palign<1>(A01,A11); + A12 = pload(&lhs2[j-2+LhsPacketSize]); palign<2>(A02,A12); + A13 = pload(&lhs3[j-3+LhsPacketSize]); palign<3>(A03,A13); - A00 = ei_pload(&lhs0[j]); - A10 = ei_pload(&lhs0[j+LhsPacketSize]); - T0 = pcj.pmadd(A00, ptmp0, ei_pload(&res[j])); - T1 = pcj.pmadd(A10, ptmp0, ei_pload(&res[j+ResPacketSize])); + A00 = pload(&lhs0[j]); + A10 = pload(&lhs0[j+LhsPacketSize]); + T0 = pcj.pmadd(A00, ptmp0, pload(&res[j])); + T1 = pcj.pmadd(A10, ptmp0, pload(&res[j+ResPacketSize])); T0 = pcj.pmadd(A01, ptmp1, T0); - A01 = ei_pload(&lhs1[j-1+2*LhsPacketSize]); ei_palign<1>(A11,A01); + A01 = pload(&lhs1[j-1+2*LhsPacketSize]); palign<1>(A11,A01); T0 = pcj.pmadd(A02, ptmp2, T0); - A02 = ei_pload(&lhs2[j-2+2*LhsPacketSize]); ei_palign<2>(A12,A02); + A02 = pload(&lhs2[j-2+2*LhsPacketSize]); palign<2>(A12,A02); T0 = pcj.pmadd(A03, ptmp3, T0); - ei_pstore(&res[j],T0); - A03 = ei_pload(&lhs3[j-3+2*LhsPacketSize]); ei_palign<3>(A13,A03); + pstore(&res[j],T0); + A03 = pload(&lhs3[j-3+2*LhsPacketSize]); palign<3>(A13,A03); T1 = pcj.pmadd(A11, ptmp1, T1); T1 = pcj.pmadd(A12, ptmp2, T1); T1 = pcj.pmadd(A13, ptmp3, T1); - ei_pstore(&res[j+ResPacketSize],T1); + pstore(&res[j+ResPacketSize],T1); } } for (Index j = peeledSize; j(alpha*rhs[k*rhsIncr]); + RhsPacket ptmp0 = pset1(alpha*rhs[k*rhsIncr]); const LhsScalar* lhs0 = lhs + k*lhsStride; if (Vectorizable) @@ -257,19 +259,19 @@ EIGEN_DONT_INLINE static void run( /* explicit vectorization */ // process first unaligned result's coeffs for (Index j=0; j(&lhs0[i]), ptmp0, ei_pload(&res[i]))); + pstore(&res[i], pcj.pmadd(ploadu(&lhs0[i]), ptmp0, pload(&res[i]))); else for (Index i = alignedStart;i(&lhs0[i]), ptmp0, ei_pload(&res[i]))); + pstore(&res[i], pcj.pmadd(ploadu(&lhs0[i]), ptmp0, pload(&res[i]))); } // process remaining scalars (or all if no explicit vectorization) for (Index i=alignedSize; i -struct ei_general_matrix_vector_product +struct general_matrix_vector_product { -typedef typename ei_scalar_product_traits::ReturnType ResScalar; +typedef typename scalar_product_traits::ReturnType ResScalar; enum { - Vectorizable = ei_packet_traits::Vectorizable && ei_packet_traits::Vectorizable - && int(ei_packet_traits::size)==int(ei_packet_traits::size), - LhsPacketSize = Vectorizable ? ei_packet_traits::size : 1, - RhsPacketSize = Vectorizable ? ei_packet_traits::size : 1, - ResPacketSize = Vectorizable ? ei_packet_traits::size : 1 + Vectorizable = packet_traits::Vectorizable && packet_traits::Vectorizable + && int(packet_traits::size)==int(packet_traits::size), + LhsPacketSize = Vectorizable ? packet_traits::size : 1, + RhsPacketSize = Vectorizable ? packet_traits::size : 1, + ResPacketSize = Vectorizable ? packet_traits::size : 1 }; -typedef typename ei_packet_traits::type _LhsPacket; -typedef typename ei_packet_traits::type _RhsPacket; -typedef typename ei_packet_traits::type _ResPacket; +typedef typename packet_traits::type _LhsPacket; +typedef typename packet_traits::type _RhsPacket; +typedef typename packet_traits::type _ResPacket; -typedef typename ei_meta_if::ret LhsPacket; -typedef typename ei_meta_if::ret RhsPacket; -typedef typename ei_meta_if::ret ResPacket; +typedef typename meta_if::ret LhsPacket; +typedef typename meta_if::ret RhsPacket; +typedef typename meta_if::ret ResPacket; EIGEN_DONT_INLINE static void run( Index rows, Index cols, @@ -323,20 +325,20 @@ EIGEN_DONT_INLINE static void run( ResScalar alpha) { EIGEN_UNUSED_VARIABLE(rhsIncr); - ei_internal_assert(rhsIncr==1); + eigen_internal_assert(rhsIncr==1); #ifdef _EIGEN_ACCUMULATE_PACKETS #error _EIGEN_ACCUMULATE_PACKETS has already been defined #endif #define _EIGEN_ACCUMULATE_PACKETS(A0,A13,A2) {\ - RhsPacket b = ei_pload(&rhs[j]); \ - ptmp0 = pcj.pmadd(EIGEN_CAT(ei_ploa,A0) (&lhs0[j]), b, ptmp0); \ - ptmp1 = pcj.pmadd(EIGEN_CAT(ei_ploa,A13)(&lhs1[j]), b, ptmp1); \ - ptmp2 = pcj.pmadd(EIGEN_CAT(ei_ploa,A2) (&lhs2[j]), b, ptmp2); \ - ptmp3 = pcj.pmadd(EIGEN_CAT(ei_ploa,A13)(&lhs3[j]), b, ptmp3); } + RhsPacket b = pload(&rhs[j]); \ + ptmp0 = pcj.pmadd(EIGEN_CAT(ploa,A0) (&lhs0[j]), b, ptmp0); \ + ptmp1 = pcj.pmadd(EIGEN_CAT(ploa,A13)(&lhs1[j]), b, ptmp1); \ + ptmp2 = pcj.pmadd(EIGEN_CAT(ploa,A2) (&lhs2[j]), b, ptmp2); \ + ptmp3 = pcj.pmadd(EIGEN_CAT(ploa,A13)(&lhs3[j]), b, ptmp3); } - ei_conj_helper cj; - ei_conj_helper pcj; + conj_helper cj; + conj_helper pcj; enum { AllAligned=0, EvenAligned=1, FirstAligned=2, NoneAligned=3 }; const Index rowsAtOnce = 4; @@ -349,7 +351,7 @@ EIGEN_DONT_INLINE static void run( // How many coeffs of the result do we have to skip to be aligned. // Here we assume data are at least aligned on the base scalar type // if that's not the case then vectorization is discarded, see below. - Index alignedStart = ei_first_aligned(rhs, depth); + Index alignedStart = first_aligned(rhs, depth); Index alignedSize = RhsPacketSize>1 ? alignedStart + ((depth-alignedStart) & ~RhsPacketAlignedMask) : 0; const Index peeledSize = peels>1 ? alignedStart + ((alignedSize-alignedStart) & ~PeelAlignedMask) : alignedStart; @@ -359,7 +361,7 @@ EIGEN_DONT_INLINE static void run( : FirstAligned; // we cannot assume the first element is aligned because of sub-matrices - const Index lhsAlignmentOffset = ei_first_aligned(lhs,depth); + const Index lhsAlignmentOffset = first_aligned(lhs,depth); // find how many rows do we have to skip to be aligned with rhs (if possible) Index skipRows = 0; @@ -371,7 +373,7 @@ EIGEN_DONT_INLINE static void run( } else if (LhsPacketSize>1) { - ei_internal_assert(size_t(lhs+lhsAlignmentOffset)%sizeof(LhsPacket)==0 || depth= rows) || LhsPacketSize > depth @@ -416,8 +418,8 @@ EIGEN_DONT_INLINE static void run( if (Vectorizable) { /* explicit vectorization */ - ResPacket ptmp0 = ei_pset1(ResScalar(0)), ptmp1 = ei_pset1(ResScalar(0)), - ptmp2 = ei_pset1(ResScalar(0)), ptmp3 = ei_pset1(ResScalar(0)); + ResPacket ptmp0 = pset1(ResScalar(0)), ptmp1 = pset1(ResScalar(0)), + ptmp2 = pset1(ResScalar(0)), ptmp3 = pset1(ResScalar(0)); // process initial unaligned coeffs // FIXME this loop get vectorized by the compiler ! @@ -450,27 +452,27 @@ EIGEN_DONT_INLINE static void run( * than basic unaligned loads. */ LhsPacket A01, A02, A03, A11, A12, A13; - A01 = ei_pload(&lhs1[alignedStart-1]); - A02 = ei_pload(&lhs2[alignedStart-2]); - A03 = ei_pload(&lhs3[alignedStart-3]); + A01 = pload(&lhs1[alignedStart-1]); + A02 = pload(&lhs2[alignedStart-2]); + A03 = pload(&lhs3[alignedStart-3]); for (Index j = alignedStart; j(&rhs[j]); - A11 = ei_pload(&lhs1[j-1+LhsPacketSize]); ei_palign<1>(A01,A11); - A12 = ei_pload(&lhs2[j-2+LhsPacketSize]); ei_palign<2>(A02,A12); - A13 = ei_pload(&lhs3[j-3+LhsPacketSize]); ei_palign<3>(A03,A13); + RhsPacket b = pload(&rhs[j]); + A11 = pload(&lhs1[j-1+LhsPacketSize]); palign<1>(A01,A11); + A12 = pload(&lhs2[j-2+LhsPacketSize]); palign<2>(A02,A12); + A13 = pload(&lhs3[j-3+LhsPacketSize]); palign<3>(A03,A13); - ptmp0 = pcj.pmadd(ei_pload(&lhs0[j]), b, ptmp0); + ptmp0 = pcj.pmadd(pload(&lhs0[j]), b, ptmp0); ptmp1 = pcj.pmadd(A01, b, ptmp1); - A01 = ei_pload(&lhs1[j-1+2*LhsPacketSize]); ei_palign<1>(A11,A01); + A01 = pload(&lhs1[j-1+2*LhsPacketSize]); palign<1>(A11,A01); ptmp2 = pcj.pmadd(A02, b, ptmp2); - A02 = ei_pload(&lhs2[j-2+2*LhsPacketSize]); ei_palign<2>(A12,A02); + A02 = pload(&lhs2[j-2+2*LhsPacketSize]); palign<2>(A12,A02); ptmp3 = pcj.pmadd(A03, b, ptmp3); - A03 = ei_pload(&lhs3[j-3+2*LhsPacketSize]); ei_palign<3>(A13,A03); + A03 = pload(&lhs3[j-3+2*LhsPacketSize]); palign<3>(A13,A03); - b = ei_pload(&rhs[j+RhsPacketSize]); - ptmp0 = pcj.pmadd(ei_pload(&lhs0[j+LhsPacketSize]), b, ptmp0); + b = pload(&rhs[j+RhsPacketSize]); + ptmp0 = pcj.pmadd(pload(&lhs0[j+LhsPacketSize]), b, ptmp0); ptmp1 = pcj.pmadd(A11, b, ptmp1); ptmp2 = pcj.pmadd(A12, b, ptmp2); ptmp3 = pcj.pmadd(A13, b, ptmp3); @@ -484,10 +486,10 @@ EIGEN_DONT_INLINE static void run( _EIGEN_ACCUMULATE_PACKETS(du,du,du); break; } - tmp0 += ei_predux(ptmp0); - tmp1 += ei_predux(ptmp1); - tmp2 += ei_predux(ptmp2); - tmp3 += ei_predux(ptmp3); + tmp0 += predux(ptmp0); + tmp1 += predux(ptmp1); + tmp2 += predux(ptmp2); + tmp3 += predux(ptmp3); } } // end explicit vectorization @@ -513,7 +515,7 @@ EIGEN_DONT_INLINE static void run( for (Index i=start; i(tmp0); + ResPacket ptmp0 = pset1(tmp0); const LhsScalar* lhs0 = lhs + i*lhsStride; // process first unaligned result's coeffs // FIXME this loop get vectorized by the compiler ! @@ -525,11 +527,11 @@ EIGEN_DONT_INLINE static void run( // process aligned rhs coeffs if ((size_t(lhs0+alignedStart)%sizeof(LhsPacket))==0) for (Index j = alignedStart;j(&lhs0[j]), ei_pload(&rhs[j]), ptmp0); + ptmp0 = pcj.pmadd(pload(&lhs0[j]), pload(&rhs[j]), ptmp0); else for (Index j = alignedStart;j(&lhs0[j]), ei_pload(&rhs[j]), ptmp0); - tmp0 += ei_predux(ptmp0); + ptmp0 = pcj.pmadd(ploadu(&lhs0[j]), pload(&rhs[j]), ptmp0); + tmp0 += predux(ptmp0); } // process remaining scalars @@ -552,4 +554,6 @@ EIGEN_DONT_INLINE static void run( } }; +} // end namespace internal + #endif // EIGEN_GENERAL_MATRIX_VECTOR_H diff --git a/Eigen/src/Core/products/Parallelizer.h b/Eigen/src/Core/products/Parallelizer.h index b13c0706e..677504ecc 100644 --- a/Eigen/src/Core/products/Parallelizer.h +++ b/Eigen/src/Core/products/Parallelizer.h @@ -25,19 +25,21 @@ #ifndef EIGEN_PARALLELIZER_H #define EIGEN_PARALLELIZER_H +namespace internal { + /** \internal */ -inline void ei_manage_multi_threading(Action action, int* v) +inline void manage_multi_threading(Action action, int* v) { static int m_maxThreads = -1; if(action==SetAction) { - ei_internal_assert(v!=0); + eigen_internal_assert(v!=0); m_maxThreads = *v; } else if(action==GetAction) { - ei_internal_assert(v!=0); + eigen_internal_assert(v!=0); #ifdef EIGEN_HAS_OPENMP if(m_maxThreads>0) *v = m_maxThreads; @@ -49,7 +51,7 @@ inline void ei_manage_multi_threading(Action action, int* v) } else { - ei_internal_assert(false); + eigen_internal_assert(false); } } @@ -58,7 +60,7 @@ inline void ei_manage_multi_threading(Action action, int* v) inline int nbThreads() { int ret; - ei_manage_multi_threading(GetAction, &ret); + manage_multi_threading(GetAction, &ret); return ret; } @@ -66,7 +68,7 @@ inline int nbThreads() * \sa nbThreads */ inline void setNbThreads(int v) { - ei_manage_multi_threading(SetAction, &v); + manage_multi_threading(SetAction, &v); } template struct GemmParallelInfo @@ -81,7 +83,7 @@ template struct GemmParallelInfo }; template -void ei_parallelize_gemm(const Functor& func, Index rows, Index cols, bool transpose) +void parallelize_gemm(const Functor& func, Index rows, Index cols, bool transpose) { #ifndef EIGEN_HAS_OPENMP // FIXME the transpose variable is only needed to properly split @@ -147,4 +149,6 @@ void ei_parallelize_gemm(const Functor& func, Index rows, Index cols, bool trans #endif } +} // end namespace internal + #endif // EIGEN_PARALLELIZER_H diff --git a/Eigen/src/Core/products/SelfadjointMatrixMatrix.h b/Eigen/src/Core/products/SelfadjointMatrixMatrix.h index ede8b77bf..741c5f630 100644 --- a/Eigen/src/Core/products/SelfadjointMatrixMatrix.h +++ b/Eigen/src/Core/products/SelfadjointMatrixMatrix.h @@ -25,12 +25,14 @@ #ifndef EIGEN_SELFADJOINT_MATRIX_MATRIX_H #define EIGEN_SELFADJOINT_MATRIX_MATRIX_H +namespace internal { + // pack a selfadjoint block diagonal for use with the gebp_kernel template -struct ei_symm_pack_lhs +struct symm_pack_lhs { template inline - void pack(Scalar* blockA, const ei_const_blas_data_mapper& lhs, Index cols, Index i, Index& count) + void pack(Scalar* blockA, const const_blas_data_mapper& lhs, Index cols, Index i, Index& count) { // normal copy for(Index k=0; k lhs(_lhs,lhsStride); + const_blas_data_mapper lhs(_lhs,lhsStride); Index count = 0; Index peeled_mc = (rows/Pack1)*Pack1; for(Index i=0; i -struct ei_symm_pack_rhs +struct symm_pack_rhs { - enum { PacketSize = ei_packet_traits::size }; + enum { PacketSize = packet_traits::size }; void operator()(Scalar* blockB, const Scalar* _rhs, Index rhsStride, Index rows, Index cols, Index k2) { Index end_k = k2 + rows; Index count = 0; - ei_const_blas_data_mapper rhs(_rhs,rhsStride); + const_blas_data_mapper rhs(_rhs,rhsStride); Index packet_cols = (cols/nr)*nr; // first part: normal case @@ -118,12 +120,12 @@ struct ei_symm_pack_rhs // transpose for(Index k=k2; k -struct ei_product_selfadjoint_matrix; +struct product_selfadjoint_matrix; template -struct ei_product_selfadjoint_matrix +struct product_selfadjoint_matrix { static EIGEN_STRONG_INLINE void run( @@ -224,7 +226,7 @@ struct ei_product_selfadjoint_matrix::IsComplex && EIGEN_LOGICAL_XOR(RhsSelfAdjoint,ConjugateRhs), EIGEN_LOGICAL_XOR(LhsSelfAdjoint,LhsStorageOrder==RowMajor) ? ColMajor : RowMajor, @@ -237,7 +239,7 @@ struct ei_product_selfadjoint_matrix -struct ei_product_selfadjoint_matrix +struct product_selfadjoint_matrix { static EIGEN_DONT_INLINE void run( @@ -249,10 +251,10 @@ struct ei_product_selfadjoint_matrix lhs(_lhs,lhsStride); - ei_const_blas_data_mapper rhs(_rhs,rhsStride); + const_blas_data_mapper lhs(_lhs,lhsStride); + const_blas_data_mapper rhs(_rhs,rhsStride); - typedef ei_gebp_traits Traits; + typedef gebp_traits Traits; Index kc = size; // cache block size along the K direction Index mc = rows; // cache block size along the M direction @@ -267,10 +269,10 @@ struct ei_product_selfadjoint_matrix gebp_kernel; - ei_symm_pack_lhs pack_lhs; - ei_gemm_pack_rhs pack_rhs; - ei_gemm_pack_lhs pack_lhs_transposed; + gebp_kernel gebp_kernel; + symm_pack_lhs pack_lhs; + gemm_pack_rhs pack_rhs; + gemm_pack_lhs pack_lhs_transposed; for(Index k2=0; k2() + gemm_pack_lhs() (blockA, &lhs(i2, k2), lhsStride, actual_kc, actual_mc); gebp_kernel(res+i2, resStride, blockA, blockB, actual_mc, actual_kc, cols, alpha); @@ -321,7 +323,7 @@ struct ei_product_selfadjoint_matrix -struct ei_product_selfadjoint_matrix +struct product_selfadjoint_matrix { static EIGEN_DONT_INLINE void run( @@ -333,9 +335,9 @@ struct ei_product_selfadjoint_matrix lhs(_lhs,lhsStride); + const_blas_data_mapper lhs(_lhs,lhsStride); - typedef ei_gebp_traits Traits; + typedef gebp_traits Traits; Index kc = size; // cache block size along the K direction Index mc = rows; // cache block size along the M direction @@ -348,9 +350,9 @@ struct ei_product_selfadjoint_matrix gebp_kernel; - ei_gemm_pack_lhs pack_lhs; - ei_symm_pack_rhs pack_rhs; + gebp_kernel gebp_kernel; + gemm_pack_lhs pack_lhs; + symm_pack_rhs pack_rhs; for(Index k2=0; k2 -struct ei_traits > - : ei_traits, Lhs, Rhs> > +struct traits > + : traits, Lhs, Rhs> > {}; +} template struct SelfadjointProductMatrix @@ -399,7 +405,7 @@ struct SelfadjointProductMatrix template void scaleAndAddTo(Dest& dst, Scalar alpha) const { - ei_assert(dst.rows()==m_lhs.rows() && dst.cols()==m_rhs.cols()); + eigen_assert(dst.rows()==m_lhs.rows() && dst.cols()==m_rhs.cols()); const ActualLhsType lhs = LhsBlasTraits::extract(m_lhs); const ActualRhsType rhs = RhsBlasTraits::extract(m_rhs); @@ -407,14 +413,14 @@ struct SelfadjointProductMatrix Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(m_lhs) * RhsBlasTraits::extractScalarFactor(m_rhs); - ei_product_selfadjoint_matrix::Flags &RowMajorBit) ? RowMajor : ColMajor, LhsIsSelfAdjoint, + internal::traits::Flags &RowMajorBit) ? RowMajor : ColMajor, LhsIsSelfAdjoint, NumTraits::IsComplex && EIGEN_LOGICAL_XOR(LhsIsUpper,bool(LhsBlasTraits::NeedToConjugate)), EIGEN_LOGICAL_XOR(RhsIsUpper, - ei_traits::Flags &RowMajorBit) ? RowMajor : ColMajor, RhsIsSelfAdjoint, + internal::traits::Flags &RowMajorBit) ? RowMajor : ColMajor, RhsIsSelfAdjoint, NumTraits::IsComplex && EIGEN_LOGICAL_XOR(RhsIsUpper,bool(RhsBlasTraits::NeedToConjugate)), - ei_traits::Flags&RowMajorBit ? RowMajor : ColMajor> + internal::traits::Flags&RowMajorBit ? RowMajor : ColMajor> ::run( lhs.rows(), rhs.cols(), // sizes &lhs.coeff(0,0), lhs.outerStride(), // lhs info diff --git a/Eigen/src/Core/products/SelfadjointMatrixVector.h b/Eigen/src/Core/products/SelfadjointMatrixVector.h index df7509f9a..57f4b7da3 100644 --- a/Eigen/src/Core/products/SelfadjointMatrixVector.h +++ b/Eigen/src/Core/products/SelfadjointMatrixVector.h @@ -25,19 +25,21 @@ #ifndef EIGEN_SELFADJOINT_MATRIX_VECTOR_H #define EIGEN_SELFADJOINT_MATRIX_VECTOR_H +namespace internal { + /* Optimized selfadjoint matrix * vector product: * This algorithm processes 2 columns at onces that allows to both reduce * the number of load/stores of the result by a factor 2 and to reduce * the instruction dependency. */ template -static EIGEN_DONT_INLINE void ei_product_selfadjoint_vector( +static EIGEN_DONT_INLINE void product_selfadjoint_vector( Index size, const Scalar* lhs, Index lhsStride, const Scalar* _rhs, Index rhsIncr, Scalar* res, Scalar alpha) { - typedef typename ei_packet_traits::type Packet; + typedef typename packet_traits::type Packet; const Index PacketSize = sizeof(Packet)/sizeof(Scalar); enum { @@ -46,13 +48,13 @@ static EIGEN_DONT_INLINE void ei_product_selfadjoint_vector( FirstTriangular = IsRowMajor == IsLower }; - ei_conj_helper::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, IsRowMajor), ConjugateRhs> cj0; - ei_conj_helper::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> cj1; + conj_helper::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, IsRowMajor), ConjugateRhs> cj0; + conj_helper::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> cj1; - ei_conj_helper::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, IsRowMajor), ConjugateRhs> pcj0; - ei_conj_helper::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> pcj1; + conj_helper::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, IsRowMajor), ConjugateRhs> pcj0; + conj_helper::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> pcj1; - Scalar cjAlpha = ConjugateRhs ? ei_conj(alpha) : alpha; + Scalar cjAlpha = ConjugateRhs ? conj(alpha) : alpha; // if the rhs is not sequentially stored in memory we copy it to a temporary buffer, // this is because we need to extract packets @@ -77,19 +79,19 @@ static EIGEN_DONT_INLINE void ei_product_selfadjoint_vector( register const Scalar* EIGEN_RESTRICT A1 = lhs + (j+1)*lhsStride; Scalar t0 = cjAlpha * rhs[j]; - Packet ptmp0 = ei_pset1(t0); + Packet ptmp0 = pset1(t0); Scalar t1 = cjAlpha * rhs[j+1]; - Packet ptmp1 = ei_pset1(t1); + Packet ptmp1 = pset1(t1); Scalar t2 = 0; - Packet ptmp2 = ei_pset1(t2); + Packet ptmp2 = pset1(t2); Scalar t3 = 0; - Packet ptmp3 = ei_pset1(t3); + Packet ptmp3 = pset1(t3); size_t starti = FirstTriangular ? 0 : j+2; size_t endi = FirstTriangular ? j : size; size_t alignedEnd = starti; - size_t alignedStart = (starti) + ei_first_aligned(&res[starti], endi-starti); + size_t alignedStart = (starti) + first_aligned(&res[starti], endi-starti); alignedEnd = alignedStart + ((endi-alignedStart)/(PacketSize))*(PacketSize); res[j] += cj0.pmul(A0[j], t0); @@ -108,8 +110,8 @@ static EIGEN_DONT_INLINE void ei_product_selfadjoint_vector( for (size_t i=starti; i huge speed up) // gcc 4.2 does this optimization automatically. @@ -119,15 +121,15 @@ static EIGEN_DONT_INLINE void ei_product_selfadjoint_vector( Scalar* EIGEN_RESTRICT resIt = res + alignedStart; for (size_t i=alignedStart; i(a0It); a0It += PacketSize; - Packet A1i = ei_ploadu(a1It); a1It += PacketSize; - Packet Bi = ei_ploadu(rhsIt); rhsIt += PacketSize; // FIXME should be aligned in most cases - Packet Xi = ei_pload (resIt); + Packet A0i = ploadu(a0It); a0It += PacketSize; + Packet A1i = ploadu(a1It); a1It += PacketSize; + Packet Bi = ploadu(rhsIt); rhsIt += PacketSize; // FIXME should be aligned in most cases + Packet Xi = pload (resIt); Xi = pcj0.pmadd(A0i,ptmp0, pcj0.pmadd(A1i,ptmp1,Xi)); ptmp2 = pcj1.pmadd(A0i, Bi, ptmp2); ptmp3 = pcj1.pmadd(A1i, Bi, ptmp3); - ei_pstore(resIt,Xi); resIt += PacketSize; + pstore(resIt,Xi); resIt += PacketSize; } for (size_t i=alignedEnd; i(rhs), size); } +} // end namespace internal + /*************************************************************************** -* Wrapper to ei_product_selfadjoint_vector +* Wrapper to product_selfadjoint_vector ***************************************************************************/ +namespace internal { template -struct ei_traits > - : ei_traits, Lhs, Rhs> > +struct traits > + : traits, Lhs, Rhs> > {}; +} template struct SelfadjointProductMatrix @@ -180,7 +186,7 @@ struct SelfadjointProductMatrix template void scaleAndAddTo(Dest& dst, Scalar alpha) const { - ei_assert(dst.rows()==m_lhs.rows() && dst.cols()==m_rhs.cols()); + eigen_assert(dst.rows()==m_lhs.rows() && dst.cols()==m_rhs.cols()); const ActualLhsType lhs = LhsBlasTraits::extract(m_lhs); const ActualRhsType rhs = RhsBlasTraits::extract(m_rhs); @@ -188,9 +194,9 @@ struct SelfadjointProductMatrix Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(m_lhs) * RhsBlasTraits::extractScalarFactor(m_rhs); - ei_assert(dst.innerStride()==1 && "not implemented yet"); + eigen_assert(dst.innerStride()==1 && "not implemented yet"); - ei_product_selfadjoint_vector::Flags&RowMajorBit) ? RowMajor : ColMajor, int(LhsUpLo), bool(LhsBlasTraits::NeedToConjugate), bool(RhsBlasTraits::NeedToConjugate)> + internal::product_selfadjoint_vector::Flags&RowMajorBit) ? RowMajor : ColMajor, int(LhsUpLo), bool(LhsBlasTraits::NeedToConjugate), bool(RhsBlasTraits::NeedToConjugate)> ( lhs.rows(), // size &lhs.coeff(0,0), lhs.outerStride(), // lhs info @@ -201,10 +207,12 @@ struct SelfadjointProductMatrix } }; +namespace internal { template -struct ei_traits > - : ei_traits, Lhs, Rhs> > +struct traits > + : traits, Lhs, Rhs> > {}; +} template struct SelfadjointProductMatrix @@ -220,7 +228,7 @@ struct SelfadjointProductMatrix template void scaleAndAddTo(Dest& dst, Scalar alpha) const { - ei_assert(dst.rows()==m_lhs.rows() && dst.cols()==m_rhs.cols()); + eigen_assert(dst.rows()==m_lhs.rows() && dst.cols()==m_rhs.cols()); const ActualLhsType lhs = LhsBlasTraits::extract(m_lhs); const ActualRhsType rhs = RhsBlasTraits::extract(m_rhs); @@ -228,10 +236,10 @@ struct SelfadjointProductMatrix Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(m_lhs) * RhsBlasTraits::extractScalarFactor(m_rhs); - ei_assert(dst.innerStride()==1 && "not implemented yet"); + eigen_assert(dst.innerStride()==1 && "not implemented yet"); // transpose the product - ei_product_selfadjoint_vector::Flags&RowMajorBit) ? ColMajor : RowMajor, int(RhsUpLo)==Upper ? Lower : Upper, + internal::product_selfadjoint_vector::Flags&RowMajorBit) ? ColMajor : RowMajor, int(RhsUpLo)==Upper ? Lower : Upper, bool(RhsBlasTraits::NeedToConjugate), bool(LhsBlasTraits::NeedToConjugate)> ( rhs.rows(), // size diff --git a/Eigen/src/Core/products/SelfadjointProduct.h b/Eigen/src/Core/products/SelfadjointProduct.h index 8f431c2e4..26aa65cca 100644 --- a/Eigen/src/Core/products/SelfadjointProduct.h +++ b/Eigen/src/Core/products/SelfadjointProduct.h @@ -25,6 +25,8 @@ #ifndef EIGEN_SELFADJOINT_PRODUCT_H #define EIGEN_SELFADJOINT_PRODUCT_H +namespace internal { + /********************************************************************** * This file implements a self adjoint product: C += A A^T updating only * half of the selfadjoint matrix C. @@ -33,28 +35,28 @@ // forward declarations (defined at the end of this file) template -struct ei_sybb_kernel; +struct sybb_kernel; /* Optimized selfadjoint product (_SYRK) */ template -struct ei_selfadjoint_product; +struct selfadjoint_product; // as usual if the result is row major => we transpose the product template -struct ei_selfadjoint_product +struct selfadjoint_product { static EIGEN_STRONG_INLINE void run(Index size, Index depth, const Scalar* mat, Index matStride, Scalar* res, Index resStride, Scalar alpha) { - ei_selfadjoint_product + selfadjoint_product ::run(size, depth, mat, matStride, res, resStride, alpha); } }; template -struct ei_selfadjoint_product +struct selfadjoint_product { static EIGEN_DONT_INLINE void run( @@ -63,12 +65,12 @@ struct ei_selfadjoint_product mat(_mat,matStride); + const_blas_data_mapper mat(_mat,matStride); // if(AAT) -// alpha = ei_conj(alpha); +// alpha = conj(alpha); - typedef ei_gebp_traits Traits; + typedef gebp_traits Traits; Index kc = depth; // cache block size along the K direction Index mc = size; // cache block size along the M direction @@ -90,10 +92,10 @@ struct ei_selfadjoint_product::IsComplex && AAT }; - ei_gebp_kernel gebp_kernel; - ei_gemm_pack_rhs pack_rhs; - ei_gemm_pack_lhs pack_lhs; - ei_sybb_kernel sybb; + gebp_kernel gebp_kernel; + gemm_pack_rhs pack_rhs; + gemm_pack_lhs pack_lhs; + sybb_kernel sybb; for(Index k2=0; k2 -template -SelfAdjointView& SelfAdjointView -::rankUpdate(const MatrixBase& u, Scalar alpha) -{ - typedef ei_blas_traits UBlasTraits; - typedef typename UBlasTraits::DirectLinearAccessType ActualUType; - typedef typename ei_cleantype::type _ActualUType; - const ActualUType actualU = UBlasTraits::extract(u.derived()); - - Scalar actualAlpha = alpha * UBlasTraits::extractScalarFactor(u.derived()); - - enum { IsRowMajor = (ei_traits::Flags&RowMajorBit) ? 1 : 0 }; - - ei_selfadjoint_product - ::run(_expression().cols(), actualU.cols(), &actualU.coeff(0,0), actualU.outerStride(), - const_cast(_expression().data()), _expression().outerStride(), actualAlpha); - - return *this; -} - - // Optimized SYmmetric packed Block * packed Block product kernel. // This kernel is built on top of the gebp kernel: // - the current selfadjoint block (res) is processed per panel of actual_mc x BlockSize @@ -168,15 +143,15 @@ SelfAdjointView& SelfAdjointView // small temporary buffer which is then accumulated into the result using a // triangular traversal. template -struct ei_sybb_kernel +struct sybb_kernel { enum { - PacketSize = ei_packet_traits::size, + PacketSize = packet_traits::size, BlockSize = EIGEN_PLAIN_ENUM_MAX(mr,nr) }; void operator()(Scalar* res, Index resStride, const Scalar* blockA, const Scalar* blockB, Index size, Index depth, Scalar alpha, Scalar* workspace) { - ei_gebp_kernel gebp_kernel; + gebp_kernel gebp_kernel; Matrix buffer; // let's process the block per panel of actual_mc x BlockSize, @@ -217,4 +192,32 @@ struct ei_sybb_kernel } }; +} // end namespace internal + +// high level API + +template +template +SelfAdjointView& SelfAdjointView +::rankUpdate(const MatrixBase& u, Scalar alpha) +{ + typedef internal::blas_traits UBlasTraits; + typedef typename UBlasTraits::DirectLinearAccessType ActualUType; + typedef typename internal::cleantype::type _ActualUType; + const ActualUType actualU = UBlasTraits::extract(u.derived()); + + Scalar actualAlpha = alpha * UBlasTraits::extractScalarFactor(u.derived()); + + enum { IsRowMajor = (internal::traits::Flags&RowMajorBit) ? 1 : 0 }; + + internal::selfadjoint_product + ::run(_expression().cols(), actualU.cols(), &actualU.coeff(0,0), actualU.outerStride(), + const_cast(_expression().data()), _expression().outerStride(), actualAlpha); + + return *this; +} + #endif // EIGEN_SELFADJOINT_PRODUCT_H diff --git a/Eigen/src/Core/products/SelfadjointRank2Update.h b/Eigen/src/Core/products/SelfadjointRank2Update.h index a617f1cc6..13b088031 100644 --- a/Eigen/src/Core/products/SelfadjointRank2Update.h +++ b/Eigen/src/Core/products/SelfadjointRank2Update.h @@ -25,15 +25,17 @@ #ifndef EIGEN_SELFADJOINTRANK2UPTADE_H #define EIGEN_SELFADJOINTRANK2UPTADE_H +namespace internal { + /* Optimized selfadjoint matrix += alpha * uv' + vu' * It corresponds to the Level2 syr2 BLAS routine */ template -struct ei_selfadjoint_rank2_update_selector; +struct selfadjoint_rank2_update_selector; template -struct ei_selfadjoint_rank2_update_selector +struct selfadjoint_rank2_update_selector { static void run(Scalar* mat, Index stride, const UType& u, const VType& v, Scalar alpha) { @@ -41,52 +43,53 @@ struct ei_selfadjoint_rank2_update_selector for (Index i=0; i >(mat+stride*i+i, size-i) += - (alpha * ei_conj(u.coeff(i))) * v.tail(size-i) - + (alpha * ei_conj(v.coeff(i))) * u.tail(size-i); + (alpha * conj(u.coeff(i))) * v.tail(size-i) + + (alpha * conj(v.coeff(i))) * u.tail(size-i); } } }; template -struct ei_selfadjoint_rank2_update_selector +struct selfadjoint_rank2_update_selector { static void run(Scalar* mat, Index stride, const UType& u, const VType& v, Scalar alpha) { const Index size = u.size(); for (Index i=0; i >(mat+stride*i, i+1) += - (alpha * ei_conj(u.coeff(i))) * v.head(i+1) - + (alpha * ei_conj(v.coeff(i))) * u.head(i+1); + (alpha * conj(u.coeff(i))) * v.head(i+1) + + (alpha * conj(v.coeff(i))) * u.head(i+1); } }; -template struct ei_conj_expr_if - : ei_meta_if::Scalar>,T> > {}; +template struct conj_expr_if + : meta_if::Scalar>,T> > {}; +} // end namespace internal template template SelfAdjointView& SelfAdjointView ::rankUpdate(const MatrixBase& u, const MatrixBase& v, Scalar alpha) { - typedef ei_blas_traits UBlasTraits; + typedef internal::blas_traits UBlasTraits; typedef typename UBlasTraits::DirectLinearAccessType ActualUType; - typedef typename ei_cleantype::type _ActualUType; + typedef typename internal::cleantype::type _ActualUType; const ActualUType actualU = UBlasTraits::extract(u.derived()); - typedef ei_blas_traits VBlasTraits; + typedef internal::blas_traits VBlasTraits; typedef typename VBlasTraits::DirectLinearAccessType ActualVType; - typedef typename ei_cleantype::type _ActualVType; + typedef typename internal::cleantype::type _ActualVType; const ActualVType actualV = VBlasTraits::extract(v.derived()); Scalar actualAlpha = alpha * UBlasTraits::extractScalarFactor(u.derived()) * VBlasTraits::extractScalarFactor(v.derived()); - enum { IsRowMajor = (ei_traits::Flags&RowMajorBit) ? 1 : 0 }; - ei_selfadjoint_rank2_update_selector::ret>::type, - typename ei_cleantype::ret>::type, + enum { IsRowMajor = (internal::traits::Flags&RowMajorBit) ? 1 : 0 }; + internal::selfadjoint_rank2_update_selector::ret>::type, + typename internal::cleantype::ret>::type, (IsRowMajor ? int(UpLo==Upper ? Lower : Upper) : UpLo)> ::run(const_cast(_expression().data()),_expression().outerStride(),actualU,actualV,actualAlpha); diff --git a/Eigen/src/Core/products/TriangularMatrixMatrix.h b/Eigen/src/Core/products/TriangularMatrixMatrix.h index cef5eeba1..e35399243 100644 --- a/Eigen/src/Core/products/TriangularMatrixMatrix.h +++ b/Eigen/src/Core/products/TriangularMatrixMatrix.h @@ -25,14 +25,16 @@ #ifndef EIGEN_TRIANGULAR_MATRIX_MATRIX_H #define EIGEN_TRIANGULAR_MATRIX_MATRIX_H +namespace internal { + // template -// struct ei_gemm_pack_lhs_triangular +// struct gemm_pack_lhs_triangular // { // Matrix::IsComplex && Conjugate> cj; -// ei_const_blas_data_mapper lhs(_lhs,lhsStride); +// conj_if::IsComplex && Conjugate> cj; +// const_blas_data_mapper lhs(_lhs,lhsStride); // int count = 0; // const int peeled_mc = (rows/mr)*mr; // for(int i=0; i -struct ei_product_triangular_matrix_matrix; +struct product_triangular_matrix_matrix; template -struct ei_product_triangular_matrix_matrix { @@ -74,7 +76,7 @@ struct ei_product_triangular_matrix_matrix -struct ei_product_triangular_matrix_matrix { @@ -102,10 +104,10 @@ struct ei_product_triangular_matrix_matrix lhs(_lhs,lhsStride); - ei_const_blas_data_mapper rhs(_rhs,rhsStride); + const_blas_data_mapper lhs(_lhs,lhsStride); + const_blas_data_mapper rhs(_rhs,rhsStride); - typedef ei_gebp_traits Traits; + typedef gebp_traits Traits; enum { SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr), IsLower = (Mode&Lower) == Lower, @@ -130,9 +132,9 @@ struct ei_product_triangular_matrix_matrix gebp_kernel; - ei_gemm_pack_lhs pack_lhs; - ei_gemm_pack_rhs pack_rhs; + gebp_kernel gebp_kernel; + gemm_pack_lhs pack_lhs; + gemm_pack_rhs pack_rhs; for(Index k2=IsLower ? depth : 0; IsLower ? k2>0 : k2() + gemm_pack_lhs() (blockA, &lhs(i2, actual_k2), lhsStride, actual_kc, actual_mc); gebp_kernel(res+i2, resStride, blockA, blockB, actual_mc, actual_kc, cols, alpha); @@ -217,7 +219,7 @@ struct ei_product_triangular_matrix_matrix -struct ei_product_triangular_matrix_matrix { @@ -229,10 +231,10 @@ struct ei_product_triangular_matrix_matrix lhs(_lhs,lhsStride); - ei_const_blas_data_mapper rhs(_rhs,rhsStride); + const_blas_data_mapper lhs(_lhs,lhsStride); + const_blas_data_mapper rhs(_rhs,rhsStride); - typedef ei_gebp_traits Traits; + typedef gebp_traits Traits; enum { SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr), IsLower = (Mode&Lower) == Lower, @@ -257,10 +259,10 @@ struct ei_product_triangular_matrix_matrix gebp_kernel; - ei_gemm_pack_lhs pack_lhs; - ei_gemm_pack_rhs pack_rhs; - ei_gemm_pack_rhs pack_rhs_panel; + gebp_kernel gebp_kernel; + gemm_pack_lhs pack_lhs; + gemm_pack_rhs pack_rhs; + gemm_pack_rhs pack_rhs_panel; for(Index k2=IsLower ? 0 : depth; IsLower ? k20; @@ -352,14 +354,16 @@ struct ei_product_triangular_matrix_matrix -struct ei_traits > - : ei_traits, Lhs, Rhs> > +struct traits > + : traits, Lhs, Rhs> > {}; +} // end namespace internal + template struct TriangularProduct : public ProductBase, Lhs, Rhs > @@ -376,11 +380,11 @@ struct TriangularProduct Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(m_lhs) * RhsBlasTraits::extractScalarFactor(m_rhs); - ei_product_triangular_matrix_matrix::Flags&RowMajorBit) ? RowMajor : ColMajor, LhsBlasTraits::NeedToConjugate, - (ei_traits<_ActualRhsType>::Flags&RowMajorBit) ? RowMajor : ColMajor, RhsBlasTraits::NeedToConjugate, - (ei_traits::Flags&RowMajorBit) ? RowMajor : ColMajor> + (internal::traits<_ActualLhsType>::Flags&RowMajorBit) ? RowMajor : ColMajor, LhsBlasTraits::NeedToConjugate, + (internal::traits<_ActualRhsType>::Flags&RowMajorBit) ? RowMajor : ColMajor, RhsBlasTraits::NeedToConjugate, + (internal::traits::Flags&RowMajorBit) ? RowMajor : ColMajor> ::run( lhs.rows(), rhs.cols(), lhs.cols(),// LhsIsTriangular ? rhs.cols() : lhs.rows(), // sizes &lhs.coeff(0,0), lhs.outerStride(), // lhs info @@ -391,4 +395,5 @@ struct TriangularProduct } }; + #endif // EIGEN_TRIANGULAR_MATRIX_MATRIX_H diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h index 67c131ab2..4c1cfc492 100644 --- a/Eigen/src/Core/products/TriangularMatrixVector.h +++ b/Eigen/src/Core/products/TriangularMatrixVector.h @@ -25,26 +25,28 @@ #ifndef EIGEN_TRIANGULARMATRIXVECTOR_H #define EIGEN_TRIANGULARMATRIXVECTOR_H +namespace internal { + template -struct ei_product_triangular_vector_selector; +struct product_triangular_vector_selector; template -struct ei_product_triangular_vector_selector +struct product_triangular_vector_selector { - static EIGEN_DONT_INLINE void run(const Lhs& lhs, const Rhs& rhs, Result& res, typename ei_traits::Scalar alpha) + static EIGEN_DONT_INLINE void run(const Lhs& lhs, const Rhs& rhs, Result& res, typename traits::Scalar alpha) { typedef Transpose TrRhs; TrRhs trRhs(rhs); typedef Transpose TrLhs; TrLhs trLhs(lhs); typedef Transpose TrRes; TrRes trRes(res); - ei_product_triangular_vector_selector ::run(trRhs,trLhs,trRes,alpha); } }; template -struct ei_product_triangular_vector_selector +struct product_triangular_vector_selector { typedef typename Rhs::Scalar Scalar; typedef typename Rhs::Index Index; @@ -52,11 +54,11 @@ struct ei_product_triangular_vector_selector::Scalar alpha) + static EIGEN_DONT_INLINE void run(const Lhs& lhs, const Rhs& rhs, Result& res, typename traits::Scalar alpha) { static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH; - typename ei_conj_expr_if::ret cjLhs(lhs); - typename ei_conj_expr_if::ret cjRhs(rhs); + typename conj_expr_if::ret cjLhs(lhs); + typename conj_expr_if::ret cjRhs(rhs); Index size = lhs.cols(); for (Index pi=0; pi0) { Index s = IsLower ? pi+actualPanelWidth : 0; - ei_general_matrix_vector_product::run( + general_matrix_vector_product::run( r, actualPanelWidth, &(lhs.const_cast_derived().coeffRef(s,pi)), lhs.outerStride(), &rhs.coeff(pi), rhs.innerStride(), @@ -87,7 +89,7 @@ struct ei_product_triangular_vector_selector -struct ei_product_triangular_vector_selector +struct product_triangular_vector_selector { typedef typename Rhs::Scalar Scalar; typedef typename Rhs::Index Index; @@ -95,11 +97,11 @@ struct ei_product_triangular_vector_selector::Scalar alpha) + static void run(const Lhs& lhs, const Rhs& rhs, Result& res, typename traits::Scalar alpha) { static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH; - typename ei_conj_expr_if::ret cjLhs(lhs); - typename ei_conj_expr_if::ret cjRhs(rhs); + typename conj_expr_if::ret cjLhs(lhs); + typename conj_expr_if::ret cjRhs(rhs); Index size = lhs.cols(); for (Index pi=0; pi0) { Index s = IsLower ? 0 : pi + actualPanelWidth; - ei_general_matrix_vector_product::run( + general_matrix_vector_product::run( actualPanelWidth, r, &(lhs.const_cast_derived().coeffRef(pi,s)), lhs.outerStride(), &(rhs.const_cast_derived().coeffRef(s)), 1, @@ -129,19 +131,21 @@ struct ei_product_triangular_vector_selector -struct ei_traits > - : ei_traits, Lhs, Rhs> > +struct traits > + : traits, Lhs, Rhs> > {}; template -struct ei_traits > - : ei_traits, Lhs, Rhs> > +struct traits > + : traits, Lhs, Rhs> > {}; +} // end namespace internal + template struct TriangularProduct : public ProductBase, Lhs, Rhs > @@ -152,7 +156,7 @@ struct TriangularProduct template void scaleAndAddTo(Dest& dst, Scalar alpha) const { - ei_assert(dst.rows()==m_lhs.rows() && dst.cols()==m_rhs.cols()); + eigen_assert(dst.rows()==m_lhs.rows() && dst.cols()==m_rhs.cols()); const ActualLhsType lhs = LhsBlasTraits::extract(m_lhs); const ActualRhsType rhs = RhsBlasTraits::extract(m_rhs); @@ -160,12 +164,12 @@ struct TriangularProduct Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(m_lhs) * RhsBlasTraits::extractScalarFactor(m_rhs); - ei_product_triangular_vector_selector + internal::product_triangular_vector_selector ::Flags)&RowMajorBit) ? RowMajor : ColMajor> + (int(internal::traits::Flags)&RowMajorBit) ? RowMajor : ColMajor> ::run(lhs,rhs,dst,actualAlpha); } }; @@ -181,7 +185,7 @@ struct TriangularProduct template void scaleAndAddTo(Dest& dst, Scalar alpha) const { - ei_assert(dst.rows()==m_lhs.rows() && dst.cols()==m_rhs.cols()); + eigen_assert(dst.rows()==m_lhs.rows() && dst.cols()==m_rhs.cols()); const ActualLhsType lhs = LhsBlasTraits::extract(m_lhs); const ActualRhsType rhs = RhsBlasTraits::extract(m_rhs); @@ -189,12 +193,12 @@ struct TriangularProduct Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(m_lhs) * RhsBlasTraits::extractScalarFactor(m_rhs); - ei_product_triangular_vector_selector + internal::product_triangular_vector_selector ::Flags)&RowMajorBit) ? RowMajor : ColMajor> + (int(internal::traits::Flags)&RowMajorBit) ? RowMajor : ColMajor> ::run(lhs,rhs,dst,actualAlpha); } }; diff --git a/Eigen/src/Core/products/TriangularSolverMatrix.h b/Eigen/src/Core/products/TriangularSolverMatrix.h index 7163a800a..8b9143c2b 100644 --- a/Eigen/src/Core/products/TriangularSolverMatrix.h +++ b/Eigen/src/Core/products/TriangularSolverMatrix.h @@ -25,16 +25,18 @@ #ifndef EIGEN_TRIANGULAR_SOLVER_MATRIX_H #define EIGEN_TRIANGULAR_SOLVER_MATRIX_H +namespace internal { + // if the rhs is row major, let's transpose the product template -struct ei_triangular_solve_matrix +struct triangular_solve_matrix { static EIGEN_DONT_INLINE void run( Index size, Index cols, const Scalar* tri, Index triStride, Scalar* _other, Index otherStride) { - ei_triangular_solve_matrix< + triangular_solve_matrix< Scalar, Index, Side==OnTheLeft?OnTheRight:OnTheLeft, (Mode&UnitDiag) | ((Mode&Upper) ? Lower : Upper), NumTraits::IsComplex && Conjugate, @@ -46,7 +48,7 @@ struct ei_triangular_solve_matrix -struct ei_triangular_solve_matrix +struct triangular_solve_matrix { static EIGEN_DONT_INLINE void run( Index size, Index otherSize, @@ -54,10 +56,10 @@ struct ei_triangular_solve_matrix tri(_tri,triStride); - ei_blas_data_mapper other(_other,otherStride); + const_blas_data_mapper tri(_tri,triStride); + blas_data_mapper other(_other,otherStride); - typedef ei_gebp_traits Traits; + typedef gebp_traits Traits; enum { SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr), IsLower = (Mode&Lower) == Lower @@ -74,10 +76,10 @@ struct ei_triangular_solve_matrix conj; - ei_gebp_kernel gebp_kernel; - ei_gemm_pack_lhs pack_lhs; - ei_gemm_pack_rhs pack_rhs; + conj_if conj; + gebp_kernel gebp_kernel; + gemm_pack_lhs pack_lhs; + gemm_pack_rhs pack_rhs; for(Index k2=IsLower ? 0 : size; IsLower ? k20; @@ -181,7 +183,7 @@ struct ei_triangular_solve_matrix -struct ei_triangular_solve_matrix +struct triangular_solve_matrix { static EIGEN_DONT_INLINE void run( Index size, Index otherSize, @@ -189,10 +191,10 @@ struct ei_triangular_solve_matrix rhs(_tri,triStride); - ei_blas_data_mapper lhs(_other,otherStride); + const_blas_data_mapper rhs(_tri,triStride); + blas_data_mapper lhs(_other,otherStride); - typedef ei_gebp_traits Traits; + typedef gebp_traits Traits; enum { RhsStorageOrder = TriStorageOrder, SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr), @@ -213,11 +215,11 @@ struct ei_triangular_solve_matrix conj; - ei_gebp_kernel gebp_kernel; - ei_gemm_pack_rhs pack_rhs; - ei_gemm_pack_rhs pack_rhs_panel; - ei_gemm_pack_lhs pack_lhs_panel; + conj_if conj; + gebp_kernel gebp_kernel; + gemm_pack_rhs pack_rhs; + gemm_pack_rhs pack_rhs_panel; + gemm_pack_lhs pack_lhs_panel; for(Index k2=IsLower ? size : 0; IsLower ? k2>0 : k2 -struct ei_gebp_kernel; +struct gebp_kernel; template -struct ei_gemm_pack_rhs; +struct gemm_pack_rhs; template -struct ei_gemm_pack_lhs; +struct gemm_pack_lhs; template< typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs, typename RhsScalar, int RhsStorageOrder, bool ConjugateRhs, int ResStorageOrder> -struct ei_general_matrix_matrix_product; +struct general_matrix_matrix_product; template -struct ei_general_matrix_vector_product; +struct general_matrix_vector_product; -template struct ei_conj_if; +template struct conj_if; -template<> struct ei_conj_if { +template<> struct conj_if { template - inline T operator()(const T& x) { return ei_conj(x); } + inline T operator()(const T& x) { return conj(x); } }; -template<> struct ei_conj_if { +template<> struct conj_if { template inline const T& operator()(const T& x) { return x; } }; -template struct ei_conj_helper +template struct conj_helper { - EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const Scalar& c) const { return ei_pmadd(x,y,c); } - EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const { return ei_pmul(x,y); } + EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const Scalar& c) const { return internal::pmadd(x,y,c); } + EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const { return internal::pmul(x,y); } }; -template struct ei_conj_helper, std::complex, false,true> +template struct conj_helper, std::complex, false,true> { typedef std::complex Scalar; EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const Scalar& c) const { return c + pmul(x,y); } EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const - { return Scalar(ei_real(x)*ei_real(y) + ei_imag(x)*ei_imag(y), ei_imag(x)*ei_real(y) - ei_real(x)*ei_imag(y)); } + { return Scalar(real(x)*real(y) + imag(x)*imag(y), imag(x)*real(y) - real(x)*imag(y)); } }; -template struct ei_conj_helper, std::complex, true,false> +template struct conj_helper, std::complex, true,false> { typedef std::complex Scalar; EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const Scalar& c) const { return c + pmul(x,y); } EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const - { return Scalar(ei_real(x)*ei_real(y) + ei_imag(x)*ei_imag(y), ei_real(x)*ei_imag(y) - ei_imag(x)*ei_real(y)); } + { return Scalar(real(x)*real(y) + imag(x)*imag(y), real(x)*imag(y) - imag(x)*real(y)); } }; -template struct ei_conj_helper, std::complex, true,true> +template struct conj_helper, std::complex, true,true> { typedef std::complex Scalar; EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const Scalar& c) const { return c + pmul(x,y); } EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const - { return Scalar(ei_real(x)*ei_real(y) - ei_imag(x)*ei_imag(y), - ei_real(x)*ei_imag(y) - ei_imag(x)*ei_real(y)); } + { return Scalar(real(x)*real(y) - imag(x)*imag(y), - real(x)*imag(y) - imag(x)*real(y)); } }; -template struct ei_conj_helper, RealScalar, Conj,false> +template struct conj_helper, RealScalar, Conj,false> { typedef std::complex Scalar; EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const RealScalar& y, const Scalar& c) const - { return ei_padd(c, pmul(x,y)); } + { return padd(c, pmul(x,y)); } EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const RealScalar& y) const - { return ei_conj_if()(x)*y; } + { return conj_if()(x)*y; } }; -template struct ei_conj_helper, false,Conj> +template struct conj_helper, false,Conj> { typedef std::complex Scalar; EIGEN_STRONG_INLINE Scalar pmadd(const RealScalar& x, const Scalar& y, const Scalar& c) const - { return ei_padd(c, pmul(x,y)); } + { return padd(c, pmul(x,y)); } EIGEN_STRONG_INLINE Scalar pmul(const RealScalar& x, const Scalar& y) const - { return x*ei_conj_if()(y); } + { return x*conj_if()(y); } }; -template struct ei_get_factor { +template struct get_factor { EIGEN_STRONG_INLINE static To run(const From& x) { return x; } }; -template struct ei_get_factor::Real> { - EIGEN_STRONG_INLINE static typename NumTraits::Real run(const Scalar& x) { return ei_real(x); } +template struct get_factor::Real> { + EIGEN_STRONG_INLINE static typename NumTraits::Real run(const Scalar& x) { return real(x); } }; // Lightweight helper class to access matrix coefficients. // Yes, this is somehow redundant with Map<>, but this version is much much lighter, // and so I hope better compilation performance (time and code quality). template -class ei_blas_data_mapper +class blas_data_mapper { public: - ei_blas_data_mapper(Scalar* data, Index stride) : m_data(data), m_stride(stride) {} + blas_data_mapper(Scalar* data, Index stride) : m_data(data), m_stride(stride) {} EIGEN_STRONG_INLINE Scalar& operator()(Index i, Index j) { return m_data[StorageOrder==RowMajor ? j + i*m_stride : i + j*m_stride]; } protected: @@ -140,10 +142,10 @@ class ei_blas_data_mapper // lightweight helper class to access matrix coefficients (const version) template -class ei_const_blas_data_mapper +class const_blas_data_mapper { public: - ei_const_blas_data_mapper(const Scalar* data, Index stride) : m_data(data), m_stride(stride) {} + const_blas_data_mapper(const Scalar* data, Index stride) : m_data(data), m_stride(stride) {} EIGEN_STRONG_INLINE const Scalar& operator()(Index i, Index j) const { return m_data[StorageOrder==RowMajor ? j + i*m_stride : i + j*m_stride]; } protected: @@ -155,9 +157,9 @@ class ei_const_blas_data_mapper /* Helper class to analyze the factors of a Product expression. * In particular it allows to pop out operator-, scalar multiples, * and conjugate */ -template struct ei_blas_traits +template struct blas_traits { - typedef typename ei_traits::Scalar Scalar; + typedef typename traits::Scalar Scalar; typedef const XprType& ExtractType; typedef XprType _ExtractType; enum { @@ -168,10 +170,10 @@ template struct ei_blas_traits && ( /* Uncomment this when the low-level matrix-vector product functions support strided vectors bool(XprType::IsVectorAtCompileTime) || */ - int(ei_inner_stride_at_compile_time::ret) == 1) + int(inner_stride_at_compile_time::ret) == 1) ) ? 1 : 0 }; - typedef typename ei_meta_if::ret DirectLinearAccessType; @@ -181,11 +183,11 @@ template struct ei_blas_traits // pop conjugate template -struct ei_blas_traits, NestedXpr> > - : ei_blas_traits +struct blas_traits, NestedXpr> > + : blas_traits { - typedef ei_blas_traits Base; - typedef CwiseUnaryOp, NestedXpr> XprType; + typedef blas_traits Base; + typedef CwiseUnaryOp, NestedXpr> XprType; typedef typename Base::ExtractType ExtractType; enum { @@ -193,16 +195,16 @@ struct ei_blas_traits, NestedXpr> > NeedToConjugate = Base::NeedToConjugate ? 0 : IsComplex }; static inline ExtractType extract(const XprType& x) { return Base::extract(x.nestedExpression()); } - static inline Scalar extractScalarFactor(const XprType& x) { return ei_conj(Base::extractScalarFactor(x.nestedExpression())); } + static inline Scalar extractScalarFactor(const XprType& x) { return conj(Base::extractScalarFactor(x.nestedExpression())); } }; // pop scalar multiple template -struct ei_blas_traits, NestedXpr> > - : ei_blas_traits +struct blas_traits, NestedXpr> > + : blas_traits { - typedef ei_blas_traits Base; - typedef CwiseUnaryOp, NestedXpr> XprType; + typedef blas_traits Base; + typedef CwiseUnaryOp, NestedXpr> XprType; typedef typename Base::ExtractType ExtractType; static inline ExtractType extract(const XprType& x) { return Base::extract(x.nestedExpression()); } static inline Scalar extractScalarFactor(const XprType& x) @@ -211,11 +213,11 @@ struct ei_blas_traits, NestedXpr> > // pop opposite template -struct ei_blas_traits, NestedXpr> > - : ei_blas_traits +struct blas_traits, NestedXpr> > + : blas_traits { - typedef ei_blas_traits Base; - typedef CwiseUnaryOp, NestedXpr> XprType; + typedef blas_traits Base; + typedef CwiseUnaryOp, NestedXpr> XprType; typedef typename Base::ExtractType ExtractType; static inline ExtractType extract(const XprType& x) { return Base::extract(x.nestedExpression()); } static inline Scalar extractScalarFactor(const XprType& x) @@ -224,15 +226,15 @@ struct ei_blas_traits, NestedXpr> > // pop/push transpose template -struct ei_blas_traits > - : ei_blas_traits +struct blas_traits > + : blas_traits { typedef typename NestedXpr::Scalar Scalar; - typedef ei_blas_traits Base; + typedef blas_traits Base; typedef Transpose XprType; typedef Transpose ExtractType; typedef Transpose _ExtractType; - typedef typename ei_meta_if::ret DirectLinearAccessType; @@ -243,22 +245,24 @@ struct ei_blas_traits > static inline Scalar extractScalarFactor(const XprType& x) { return Base::extractScalarFactor(x.nestedExpression()); } }; -template::HasUsableDirectAccess> -struct ei_extract_data_selector { +template::HasUsableDirectAccess> +struct extract_data_selector { static const typename T::Scalar* run(const T& m) { - return &ei_blas_traits::extract(m).const_cast_derived().coeffRef(0,0); // FIXME this should be .data() + return &blas_traits::extract(m).const_cast_derived().coeffRef(0,0); // FIXME this should be .data() } }; template -struct ei_extract_data_selector { +struct extract_data_selector { static typename T::Scalar* run(const T&) { return 0; } }; -template const typename T::Scalar* ei_extract_data(const T& m) +template const typename T::Scalar* extract_data(const T& m) { - return ei_extract_data_selector::run(m); + return extract_data_selector::run(m); } +} // end namespace internal + #endif // EIGEN_BLASUTIL_H diff --git a/Eigen/src/Core/util/ForwardDeclarations.h b/Eigen/src/Core/util/ForwardDeclarations.h index 4b1740c82..0d0b905ea 100644 --- a/Eigen/src/Core/util/ForwardDeclarations.h +++ b/Eigen/src/Core/util/ForwardDeclarations.h @@ -26,19 +26,22 @@ #ifndef EIGEN_FORWARDDECLARATIONS_H #define EIGEN_FORWARDDECLARATIONS_H -template struct ei_traits; -template struct NumTraits; +namespace internal { +template struct traits; -template struct ei_has_direct_access +template struct has_direct_access { - enum { ret = (ei_traits::Flags & DirectAccessBit) ? 1 : 0 }; + enum { ret = (traits::Flags & DirectAccessBit) ? 1 : 0 }; }; +} // end namespace internal + +template struct NumTraits; template struct EigenBase; template class DenseBase; template::Flags & DirectAccessBit) ? DirectAccessors - : (ei_traits::Flags & LvalueBit) ? WriteAccessors + AccessorLevels Level = (internal::traits::Flags & DirectAccessBit) ? DirectAccessors + : (internal::traits::Flags & LvalueBit) ? WriteAccessors : ReadOnlyAccessors> class DenseCoeffsBase; @@ -61,7 +64,7 @@ template class ForceAlignedAccess; template class SwapWrapper; template::ret> class Block; + bool HasDirectAccess = internal::has_direct_access::ret> class Block; template class VectorBlock; template class Transpose; @@ -95,58 +98,67 @@ template struct CommaInitializer; template class ReturnByValue; template class ArrayWrapper; -template struct ei_solve_retval_base; -template struct ei_solve_retval; -template struct ei_kernel_retval_base; -template struct ei_kernel_retval; -template struct ei_image_retval_base; -template struct ei_image_retval; +namespace internal { +template struct solve_retval_base; +template struct solve_retval; +template struct kernel_retval_base; +template struct kernel_retval; +template struct image_retval_base; +template struct image_retval; +} // end namespace internal template class BandMatrix; -template struct ei_product_type; +namespace internal { +template struct product_type; +} + template::value> + int ProductType = internal::product_type::value> struct ProductReturnType; // this is a workaround for sun CC template struct LazyProductReturnType; +namespace internal { + // Provides scalar/packet-wise product and product with accumulation // with optional conjugation of the arguments. -template struct ei_conj_helper; - -template struct ei_scalar_sum_op; -template struct ei_scalar_difference_op; -template struct ei_scalar_conj_product_op; -template struct ei_scalar_quotient_op; -template struct ei_scalar_opposite_op; -template struct ei_scalar_conjugate_op; -template struct ei_scalar_real_op; -template struct ei_scalar_imag_op; -template struct ei_scalar_abs_op; -template struct ei_scalar_abs2_op; -template struct ei_scalar_sqrt_op; -template struct ei_scalar_exp_op; -template struct ei_scalar_log_op; -template struct ei_scalar_cos_op; -template struct ei_scalar_sin_op; -template struct ei_scalar_pow_op; -template struct ei_scalar_inverse_op; -template struct ei_scalar_square_op; -template struct ei_scalar_cube_op; -template struct ei_scalar_cast_op; -template struct ei_scalar_multiple_op; -template struct ei_scalar_quotient1_op; -template struct ei_scalar_min_op; -template struct ei_scalar_max_op; -template struct ei_scalar_random_op; -template struct ei_scalar_add_op; -template struct ei_scalar_constant_op; -template struct ei_scalar_identity_op; - -template struct ei_scalar_product_op; -template struct ei_scalar_multiple2_op; +template struct conj_helper; + +template struct scalar_sum_op; +template struct scalar_difference_op; +template struct scalar_conj_product_op; +template struct scalar_quotient_op; +template struct scalar_opposite_op; +template struct scalar_conjugate_op; +template struct scalar_real_op; +template struct scalar_imag_op; +template struct scalar_abs_op; +template struct scalar_abs2_op; +template struct scalar_sqrt_op; +template struct scalar_exp_op; +template struct scalar_log_op; +template struct scalar_cos_op; +template struct scalar_sin_op; +template struct scalar_pow_op; +template struct scalar_inverse_op; +template struct scalar_square_op; +template struct scalar_cube_op; +template struct scalar_cast_op; +template struct scalar_multiple_op; +template struct scalar_quotient1_op; +template struct scalar_min_op; +template struct scalar_max_op; +template struct scalar_random_op; +template struct scalar_add_op; +template struct scalar_constant_op; +template struct scalar_identity_op; + +template struct scalar_product_op; +template struct scalar_multiple2_op; + +} // end namespace internal struct IOFormat; @@ -165,7 +177,9 @@ template class Reverse; template class FullPivLU; template class PartialPivLU; -template struct ei_inverse_impl; +namespace internal { +template struct inverse_impl; +} template class HouseholderQR; template class ColPivHouseholderQR; template class FullPivHouseholderQR; @@ -192,12 +206,15 @@ template class Homogeneous; // MatrixFunctions module template struct MatrixExponentialReturnValue; template class MatrixFunctionReturnValue; + +namespace internal { template -struct ei_stem_function +struct stem_function { typedef std::complex::Real> ComplexScalar; typedef ComplexScalar type(ComplexScalar, int); }; +} #ifdef EIGEN2_SUPPORT diff --git a/Eigen/src/Core/util/Macros.h b/Eigen/src/Core/util/Macros.h index 2bf509f8f..0cea94852 100644 --- a/Eigen/src/Core/util/Macros.h +++ b/Eigen/src/Core/util/Macros.h @@ -128,18 +128,18 @@ # endif #endif -#ifndef ei_assert +#ifndef eigen_assert #ifdef EIGEN_NO_DEBUG -#define ei_assert(x) +#define eigen_assert(x) #else -#define ei_assert(x) assert(x) +#define eigen_assert(x) assert(x) #endif #endif #ifdef EIGEN_INTERNAL_DEBUGGING -#define ei_internal_assert(x) ei_assert(x) +#define eigen_internal_assert(x) eigen_assert(x) #else -#define ei_internal_assert(x) +#define eigen_internal_assert(x) #endif #ifdef EIGEN_NO_DEBUG @@ -295,35 +295,35 @@ **/ #define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \ - typedef typename Eigen::ei_traits::Scalar Scalar; /*!< \brief Numeric type, e.g. float, double, int or std::complex. */ \ + typedef typename Eigen::internal::traits::Scalar Scalar; /*!< \brief Numeric type, e.g. float, double, int or std::complex. */ \ typedef typename Eigen::NumTraits::Real RealScalar; /*!< \brief The underlying numeric type for composed scalar types. \details In cases where Scalar is e.g. std::complex, T were corresponding to RealScalar. */ \ typedef typename Base::CoeffReturnType CoeffReturnType; /*!< \brief The return type for coefficient access. \details Depending on whether the object allows direct coefficient access (e.g. for a MatrixXd), this type is either 'const Scalar&' or simply 'Scalar' for objects that do not allow direct coefficient access. */ \ - typedef typename Eigen::ei_nested::type Nested; \ - typedef typename Eigen::ei_traits::StorageKind StorageKind; \ - typedef typename Eigen::ei_traits::Index Index; \ - enum { RowsAtCompileTime = Eigen::ei_traits::RowsAtCompileTime, \ - ColsAtCompileTime = Eigen::ei_traits::ColsAtCompileTime, \ - Flags = Eigen::ei_traits::Flags, \ - CoeffReadCost = Eigen::ei_traits::CoeffReadCost, \ + typedef typename Eigen::internal::nested::type Nested; \ + typedef typename Eigen::internal::traits::StorageKind StorageKind; \ + typedef typename Eigen::internal::traits::Index Index; \ + enum { RowsAtCompileTime = Eigen::internal::traits::RowsAtCompileTime, \ + ColsAtCompileTime = Eigen::internal::traits::ColsAtCompileTime, \ + Flags = Eigen::internal::traits::Flags, \ + CoeffReadCost = Eigen::internal::traits::CoeffReadCost, \ SizeAtCompileTime = Base::SizeAtCompileTime, \ MaxSizeAtCompileTime = Base::MaxSizeAtCompileTime, \ IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; #define EIGEN_DENSE_PUBLIC_INTERFACE(Derived) \ - typedef typename Eigen::ei_traits::Scalar Scalar; /*!< \brief Numeric type, e.g. float, double, int or std::complex. */ \ + typedef typename Eigen::internal::traits::Scalar Scalar; /*!< \brief Numeric type, e.g. float, double, int or std::complex. */ \ typedef typename Eigen::NumTraits::Real RealScalar; /*!< \brief The underlying numeric type for composed scalar types. \details In cases where Scalar is e.g. std::complex, T were corresponding to RealScalar. */ \ typedef typename Base::PacketScalar PacketScalar; \ typedef typename Base::CoeffReturnType CoeffReturnType; /*!< \brief The return type for coefficient access. \details Depending on whether the object allows direct coefficient access (e.g. for a MatrixXd), this type is either 'const Scalar&' or simply 'Scalar' for objects that do not allow direct coefficient access. */ \ - typedef typename Eigen::ei_nested::type Nested; \ - typedef typename Eigen::ei_traits::StorageKind StorageKind; \ - typedef typename Eigen::ei_traits::Index Index; \ - enum { RowsAtCompileTime = Eigen::ei_traits::RowsAtCompileTime, \ - ColsAtCompileTime = Eigen::ei_traits::ColsAtCompileTime, \ - MaxRowsAtCompileTime = Eigen::ei_traits::MaxRowsAtCompileTime, \ - MaxColsAtCompileTime = Eigen::ei_traits::MaxColsAtCompileTime, \ - Flags = Eigen::ei_traits::Flags, \ - CoeffReadCost = Eigen::ei_traits::CoeffReadCost, \ + typedef typename Eigen::internal::nested::type Nested; \ + typedef typename Eigen::internal::traits::StorageKind StorageKind; \ + typedef typename Eigen::internal::traits::Index Index; \ + enum { RowsAtCompileTime = Eigen::internal::traits::RowsAtCompileTime, \ + ColsAtCompileTime = Eigen::internal::traits::ColsAtCompileTime, \ + MaxRowsAtCompileTime = Eigen::internal::traits::MaxRowsAtCompileTime, \ + MaxColsAtCompileTime = Eigen::internal::traits::MaxColsAtCompileTime, \ + Flags = Eigen::internal::traits::Flags, \ + CoeffReadCost = Eigen::internal::traits::CoeffReadCost, \ SizeAtCompileTime = Base::SizeAtCompileTime, \ MaxSizeAtCompileTime = Base::MaxSizeAtCompileTime, \ IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; \ @@ -371,9 +371,9 @@ // the expression type of a cwise product #define EIGEN_CWISE_PRODUCT_RETURN_TYPE(LHS,RHS) \ CwiseBinaryOp< \ - ei_scalar_product_op< \ - typename ei_traits::Scalar, \ - typename ei_traits::Scalar \ + internal::scalar_product_op< \ + typename internal::traits::Scalar, \ + typename internal::traits::Scalar \ >, \ LHS, \ RHS \ diff --git a/Eigen/src/Core/util/Memory.h b/Eigen/src/Core/util/Memory.h index 362ccf18e..51ec78f1a 100644 --- a/Eigen/src/Core/util/Memory.h +++ b/Eigen/src/Core/util/Memory.h @@ -80,6 +80,8 @@ #define EIGEN_HAS_MM_MALLOC 0 #endif +namespace internal { + /***************************************************************************** *** Implementation of handmade aligned functions *** *****************************************************************************/ @@ -89,7 +91,7 @@ /** \internal Like malloc, but the returned pointer is guaranteed to be 16-byte aligned. * Fast, but wastes 16 additional bytes of memory. Does not throw any exception. */ -inline void* ei_handmade_aligned_malloc(size_t size) +inline void* handmade_aligned_malloc(size_t size) { void *original = std::malloc(size+16); if (original == 0) return 0; @@ -98,8 +100,8 @@ inline void* ei_handmade_aligned_malloc(size_t size) return aligned; } -/** \internal Frees memory allocated with ei_handmade_aligned_malloc */ -inline void ei_handmade_aligned_free(void *ptr) +/** \internal Frees memory allocated with handmade_aligned_malloc */ +inline void handmade_aligned_free(void *ptr) { if (ptr) std::free(*(reinterpret_cast(ptr) - 1)); } @@ -109,9 +111,9 @@ inline void ei_handmade_aligned_free(void *ptr) * Since we know that our handmade version is based on std::realloc * we can use std::realloc to implement efficient reallocation. */ -inline void* ei_handmade_aligned_realloc(void* ptr, size_t size, size_t = 0) +inline void* handmade_aligned_realloc(void* ptr, size_t size, size_t = 0) { - if (ptr == 0) return ei_handmade_aligned_malloc(size); + if (ptr == 0) return handmade_aligned_malloc(size); void *original = *(reinterpret_cast(ptr) - 1); original = std::realloc(original,size+16); if (original == 0) return 0; @@ -124,26 +126,26 @@ inline void* ei_handmade_aligned_realloc(void* ptr, size_t size, size_t = 0) *** Implementation of generic aligned realloc (when no realloc can be used)*** *****************************************************************************/ -void* ei_aligned_malloc(size_t size); -void ei_aligned_free(void *ptr); +void* aligned_malloc(size_t size); +void aligned_free(void *ptr); /** \internal * \brief Reallocates aligned memory. * Allows reallocation with aligned ptr types. This implementation will * always create a new memory chunk and copy the old data. */ -inline void* ei_generic_aligned_realloc(void* ptr, size_t size, size_t old_size) +inline void* generic_aligned_realloc(void* ptr, size_t size, size_t old_size) { if (ptr==0) - return ei_aligned_malloc(size); + return aligned_malloc(size); if (size==0) { - ei_aligned_free(ptr); + aligned_free(ptr); return 0; } - void* newptr = ei_aligned_malloc(size); + void* newptr = aligned_malloc(size); if (newptr == 0) { #ifdef EIGEN_HAS_ERRNO @@ -155,7 +157,7 @@ inline void* ei_generic_aligned_realloc(void* ptr, size_t size, size_t old_size) if (ptr != 0) { std::memcpy(newptr, ptr, std::min(size,old_size)); - ei_aligned_free(ptr); + aligned_free(ptr); } return newptr; @@ -168,10 +170,10 @@ inline void* ei_generic_aligned_realloc(void* ptr, size_t size, size_t old_size) /** \internal Allocates \a size bytes. The returned pointer is guaranteed to have 16 bytes alignment. * On allocation error, the returned pointer is null, and if exceptions are enabled then a std::bad_alloc is thrown. */ -inline void* ei_aligned_malloc(size_t size) +inline void* aligned_malloc(size_t size) { #ifdef EIGEN_NO_MALLOC - ei_assert(false && "heap allocation is forbidden (EIGEN_NO_MALLOC is defined)"); + eigen_assert(false && "heap allocation is forbidden (EIGEN_NO_MALLOC is defined)"); #endif void *result; @@ -186,7 +188,7 @@ inline void* ei_aligned_malloc(size_t size) #elif (defined _MSC_VER) result = _aligned_malloc(size, 16); #else - result = ei_handmade_aligned_malloc(size); + result = handmade_aligned_malloc(size); #endif #ifdef EIGEN_EXCEPTIONS @@ -196,8 +198,8 @@ inline void* ei_aligned_malloc(size_t size) return result; } -/** \internal Frees memory allocated with ei_aligned_malloc. */ -inline void ei_aligned_free(void *ptr) +/** \internal Frees memory allocated with aligned_malloc. */ +inline void aligned_free(void *ptr) { #if !EIGEN_ALIGN std::free(ptr); @@ -210,7 +212,7 @@ inline void ei_aligned_free(void *ptr) #elif defined(_MSC_VER) _aligned_free(ptr); #else - ei_handmade_aligned_free(ptr); + handmade_aligned_free(ptr); #endif } @@ -219,7 +221,7 @@ inline void ei_aligned_free(void *ptr) * \brief Reallocates an aligned block of memory. * \throws std::bad_alloc if EIGEN_EXCEPTIONS are defined. **/ -inline void* ei_aligned_realloc(void *ptr, size_t new_size, size_t old_size) +inline void* aligned_realloc(void *ptr, size_t new_size, size_t old_size) { EIGEN_UNUSED_VARIABLE(old_size); @@ -229,7 +231,7 @@ inline void* ei_aligned_realloc(void *ptr, size_t new_size, size_t old_size) #elif EIGEN_MALLOC_ALREADY_ALIGNED result = std::realloc(ptr,new_size); #elif EIGEN_HAS_POSIX_MEMALIGN - result = ei_generic_aligned_realloc(ptr,new_size,old_size); + result = generic_aligned_realloc(ptr,new_size,old_size); #elif EIGEN_HAS_MM_MALLOC // The defined(_mm_free) is just here to verify that this MSVC version // implements _mm_malloc/_mm_free based on the corresponding _aligned_ @@ -237,12 +239,12 @@ inline void* ei_aligned_realloc(void *ptr, size_t new_size, size_t old_size) #if defined(_MSC_VER) && defined(_mm_free) result = _aligned_realloc(ptr,new_size,16); #else - result = ei_generic_aligned_realloc(ptr,new_size,old_size); + result = generic_aligned_realloc(ptr,new_size,old_size); #endif #elif defined(_MSC_VER) result = _aligned_realloc(ptr,new_size,16); #else - result = ei_handmade_aligned_realloc(ptr,new_size,old_size); + result = handmade_aligned_realloc(ptr,new_size,old_size); #endif #ifdef EIGEN_EXCEPTIONS @@ -259,15 +261,15 @@ inline void* ei_aligned_realloc(void *ptr, size_t new_size, size_t old_size) /** \internal Allocates \a size bytes. If Align is true, then the returned ptr is 16-byte-aligned. * On allocation error, the returned pointer is null, and if exceptions are enabled then a std::bad_alloc is thrown. */ -template inline void* ei_conditional_aligned_malloc(size_t size) +template inline void* conditional_aligned_malloc(size_t size) { - return ei_aligned_malloc(size); + return aligned_malloc(size); } -template<> inline void* ei_conditional_aligned_malloc(size_t size) +template<> inline void* conditional_aligned_malloc(size_t size) { #ifdef EIGEN_NO_MALLOC - ei_assert(false && "heap allocation is forbidden (EIGEN_NO_MALLOC is defined)"); + eigen_assert(false && "heap allocation is forbidden (EIGEN_NO_MALLOC is defined)"); #endif void *result = std::malloc(size); @@ -277,23 +279,23 @@ template<> inline void* ei_conditional_aligned_malloc(size_t size) return result; } -/** \internal Frees memory allocated with ei_conditional_aligned_malloc */ -template inline void ei_conditional_aligned_free(void *ptr) +/** \internal Frees memory allocated with conditional_aligned_malloc */ +template inline void conditional_aligned_free(void *ptr) { - ei_aligned_free(ptr); + aligned_free(ptr); } -template<> inline void ei_conditional_aligned_free(void *ptr) +template<> inline void conditional_aligned_free(void *ptr) { std::free(ptr); } -template inline void* ei_conditional_aligned_realloc(void* ptr, size_t new_size, size_t old_size) +template inline void* conditional_aligned_realloc(void* ptr, size_t new_size, size_t old_size) { - return ei_aligned_realloc(ptr, new_size, old_size); + return aligned_realloc(ptr, new_size, old_size); } -template<> inline void* ei_conditional_aligned_realloc(void* ptr, size_t new_size, size_t) +template<> inline void* conditional_aligned_realloc(void* ptr, size_t new_size, size_t) { return std::realloc(ptr, new_size); } @@ -305,7 +307,7 @@ template<> inline void* ei_conditional_aligned_realloc(void* ptr, size_t /** \internal Constructs the elements of an array. * The \a size parameter tells on how many objects to call the constructor of T. */ -template inline T* ei_construct_elements_of_array(T *ptr, size_t size) +template inline T* construct_elements_of_array(T *ptr, size_t size) { for (size_t i=0; i < size; ++i) ::new (ptr + i) T; return ptr; @@ -314,7 +316,7 @@ template inline T* ei_construct_elements_of_array(T *ptr, size_t siz /** \internal Destructs the elements of an array. * The \a size parameters tells on how many objects to call the destructor of T. */ -template inline void ei_destruct_elements_of_array(T *ptr, size_t size) +template inline void destruct_elements_of_array(T *ptr, size_t size) { // always destruct an array starting from the end. if(ptr) @@ -329,41 +331,41 @@ template inline void ei_destruct_elements_of_array(T *ptr, size_t si * On allocation error, the returned pointer is undefined, but if exceptions are enabled then a std::bad_alloc is thrown. * The default constructor of T is called. */ -template inline T* ei_aligned_new(size_t size) +template inline T* aligned_new(size_t size) { - T *result = reinterpret_cast(ei_aligned_malloc(sizeof(T)*size)); - return ei_construct_elements_of_array(result, size); + T *result = reinterpret_cast(aligned_malloc(sizeof(T)*size)); + return construct_elements_of_array(result, size); } -template inline T* ei_conditional_aligned_new(size_t size) +template inline T* conditional_aligned_new(size_t size) { - T *result = reinterpret_cast(ei_conditional_aligned_malloc(sizeof(T)*size)); - return ei_construct_elements_of_array(result, size); + T *result = reinterpret_cast(conditional_aligned_malloc(sizeof(T)*size)); + return construct_elements_of_array(result, size); } -/** \internal Deletes objects constructed with ei_aligned_new +/** \internal Deletes objects constructed with aligned_new * The \a size parameters tells on how many objects to call the destructor of T. */ -template inline void ei_aligned_delete(T *ptr, size_t size) +template inline void aligned_delete(T *ptr, size_t size) { - ei_destruct_elements_of_array(ptr, size); - ei_aligned_free(ptr); + destruct_elements_of_array(ptr, size); + aligned_free(ptr); } -/** \internal Deletes objects constructed with ei_conditional_aligned_new +/** \internal Deletes objects constructed with conditional_aligned_new * The \a size parameters tells on how many objects to call the destructor of T. */ -template inline void ei_conditional_aligned_delete(T *ptr, size_t size) +template inline void conditional_aligned_delete(T *ptr, size_t size) { - ei_destruct_elements_of_array(ptr, size); - ei_conditional_aligned_free(ptr); + destruct_elements_of_array(ptr, size); + conditional_aligned_free(ptr); } -template inline T* ei_conditional_aligned_realloc_new(T* pts, size_t new_size, size_t old_size) +template inline T* conditional_aligned_realloc_new(T* pts, size_t new_size, size_t old_size) { - T *result = reinterpret_cast(ei_conditional_aligned_realloc(reinterpret_cast(pts), sizeof(T)*new_size, sizeof(T)*old_size)); + T *result = reinterpret_cast(conditional_aligned_realloc(reinterpret_cast(pts), sizeof(T)*new_size, sizeof(T)*old_size)); if (new_size > old_size) - ei_construct_elements_of_array(result+old_size, new_size-old_size); + construct_elements_of_array(result+old_size, new_size-old_size); return result; } @@ -383,13 +385,13 @@ template inline T* ei_conditional_aligned_realloc_new(T* * other hand, we do not assume that the array address is a multiple of sizeof(Scalar), as that fails for * example with Scalar=double on certain 32-bit platforms, see bug #79. * - * There is also the variant ei_first_aligned(const MatrixBase&) defined in DenseCoeffsBase.h. + * There is also the variant first_aligned(const MatrixBase&) defined in DenseCoeffsBase.h. */ template -inline static Index ei_first_aligned(const Scalar* array, Index size) +inline static Index first_aligned(const Scalar* array, Index size) { - typedef typename ei_packet_traits::type Packet; - enum { PacketSize = ei_packet_traits::size, + typedef typename packet_traits::type Packet; + enum { PacketSize = packet_traits::size, PacketAlignedMask = PacketSize-1 }; @@ -412,6 +414,8 @@ inline static Index ei_first_aligned(const Scalar* array, Index size) } } +} // end namespace internal + /***************************************************************************** *** Implementation of runtime stack allocation (falling back to malloc) *** *****************************************************************************/ @@ -431,20 +435,20 @@ inline static Index ei_first_aligned(const Scalar* array, Index size) #if (defined __linux__) #define ei_aligned_stack_alloc(SIZE) (SIZE<=EIGEN_STACK_ALLOCATION_LIMIT) \ ? alloca(SIZE) \ - : ei_aligned_malloc(SIZE) - #define ei_aligned_stack_free(PTR,SIZE) if(SIZE>EIGEN_STACK_ALLOCATION_LIMIT) ei_aligned_free(PTR) + : Eigen::internal::aligned_malloc(SIZE) + #define ei_aligned_stack_free(PTR,SIZE) if(SIZE>EIGEN_STACK_ALLOCATION_LIMIT) Eigen::internal::aligned_free(PTR) #elif defined(_MSC_VER) #define ei_aligned_stack_alloc(SIZE) (SIZE<=EIGEN_STACK_ALLOCATION_LIMIT) \ ? _alloca(SIZE) \ - : ei_aligned_malloc(SIZE) - #define ei_aligned_stack_free(PTR,SIZE) if(SIZE>EIGEN_STACK_ALLOCATION_LIMIT) ei_aligned_free(PTR) + : Eigen::internal::aligned_malloc(SIZE) + #define ei_aligned_stack_free(PTR,SIZE) if(SIZE>EIGEN_STACK_ALLOCATION_LIMIT) Eigen::internal::aligned_free(PTR) #else - #define ei_aligned_stack_alloc(SIZE) ei_aligned_malloc(SIZE) - #define ei_aligned_stack_free(PTR,SIZE) ei_aligned_free(PTR) + #define ei_aligned_stack_alloc(SIZE) Eigen::internal::aligned_malloc(SIZE) + #define ei_aligned_stack_free(PTR,SIZE) Eigen::internal::aligned_free(PTR) #endif -#define ei_aligned_stack_new(TYPE,SIZE) ei_construct_elements_of_array(reinterpret_cast(ei_aligned_stack_alloc(sizeof(TYPE)*SIZE)), SIZE) -#define ei_aligned_stack_delete(TYPE,PTR,SIZE) do {ei_destruct_elements_of_array(PTR, SIZE); \ +#define ei_aligned_stack_new(TYPE,SIZE) Eigen::internal::construct_elements_of_array(reinterpret_cast(ei_aligned_stack_alloc(sizeof(TYPE)*SIZE)), SIZE) +#define ei_aligned_stack_delete(TYPE,PTR,SIZE) do {Eigen::internal::destruct_elements_of_array(PTR, SIZE); \ ei_aligned_stack_free(PTR,sizeof(TYPE)*SIZE);} while(0) @@ -456,26 +460,26 @@ inline static Index ei_first_aligned(const Scalar* array, Index size) #ifdef EIGEN_EXCEPTIONS #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \ void* operator new(size_t size, const std::nothrow_t&) throw() { \ - try { return Eigen::ei_conditional_aligned_malloc(size); } \ + try { return Eigen::internal::conditional_aligned_malloc(size); } \ catch (...) { return 0; } \ return 0; \ } #else #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \ void* operator new(size_t size, const std::nothrow_t&) throw() { \ - return Eigen::ei_conditional_aligned_malloc(size); \ + return Eigen::internal::conditional_aligned_malloc(size); \ } #endif #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign) \ void *operator new(size_t size) { \ - return Eigen::ei_conditional_aligned_malloc(size); \ + return Eigen::internal::conditional_aligned_malloc(size); \ } \ void *operator new[](size_t size) { \ - return Eigen::ei_conditional_aligned_malloc(size); \ + return Eigen::internal::conditional_aligned_malloc(size); \ } \ - void operator delete(void * ptr) throw() { Eigen::ei_conditional_aligned_free(ptr); } \ - void operator delete[](void * ptr) throw() { Eigen::ei_conditional_aligned_free(ptr); } \ + void operator delete(void * ptr) throw() { Eigen::internal::conditional_aligned_free(ptr); } \ + void operator delete[](void * ptr) throw() { Eigen::internal::conditional_aligned_free(ptr); } \ /* in-place new and delete. since (at least afaik) there is no actual */ \ /* memory allocated we can safely let the default implementation handle */ \ /* this particular case. */ \ @@ -484,9 +488,9 @@ inline static Index ei_first_aligned(const Scalar* array, Index size) /* nothrow-new (returns zero instead of std::bad_alloc) */ \ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \ void operator delete(void *ptr, const std::nothrow_t&) throw() { \ - Eigen::ei_conditional_aligned_free(ptr); \ + Eigen::internal::conditional_aligned_free(ptr); \ } \ - typedef void ei_operator_new_marker_type; + typedef void eigen_aligned_operator_new_marker_type; #else #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign) #endif @@ -564,7 +568,7 @@ public: pointer allocate( size_type num, const_pointer* hint = 0 ) { static_cast( hint ); // suppress unused variable warning - return static_cast( ei_aligned_malloc( num * sizeof(T) ) ); + return static_cast( internal::aligned_malloc( num * sizeof(T) ) ); } void construct( pointer p, const T& value ) @@ -579,7 +583,7 @@ public: void deallocate( pointer p, size_type /*num*/ ) { - ei_aligned_free( p ); + internal::aligned_free( p ); } bool operator!=(const aligned_allocator& ) const @@ -605,13 +609,16 @@ public: # endif #endif +namespace internal { + #ifdef EIGEN_CPUID -inline bool ei_cpuid_is_vendor(int abcd[4], const char* vendor) + +inline bool cpuid_is_vendor(int abcd[4], const char* vendor) { return abcd[1]==((int*)(vendor))[0] && abcd[3]==((int*)(vendor))[1] && abcd[2]==((int*)(vendor))[2]; } -inline void ei_queryCacheSizes_intel_direct(int& l1, int& l2, int& l3) +inline void queryCacheSizes_intel_direct(int& l1, int& l2, int& l3) { int abcd[4]; l1 = l2 = l3 = 0; @@ -643,7 +650,7 @@ inline void ei_queryCacheSizes_intel_direct(int& l1, int& l2, int& l3) } while(cache_type>0 && cache_id<16); } -inline void ei_queryCacheSizes_intel_codes(int& l1, int& l2, int& l3) +inline void queryCacheSizes_intel_codes(int& l1, int& l2, int& l3) { int abcd[4]; abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0; @@ -723,15 +730,15 @@ inline void ei_queryCacheSizes_intel_codes(int& l1, int& l2, int& l3) l3 *= 1024; } -inline void ei_queryCacheSizes_intel(int& l1, int& l2, int& l3, int max_std_funcs) +inline void queryCacheSizes_intel(int& l1, int& l2, int& l3, int max_std_funcs) { if(max_std_funcs>=4) - ei_queryCacheSizes_intel_direct(l1,l2,l3); + queryCacheSizes_intel_direct(l1,l2,l3); else - ei_queryCacheSizes_intel_codes(l1,l2,l3); + queryCacheSizes_intel_codes(l1,l2,l3); } -inline void ei_queryCacheSizes_amd(int& l1, int& l2, int& l3) +inline void queryCacheSizes_amd(int& l1, int& l2, int& l3) { int abcd[4]; abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0; @@ -746,7 +753,7 @@ inline void ei_queryCacheSizes_amd(int& l1, int& l2, int& l3) /** \internal * Queries and returns the cache sizes in Bytes of the L1, L2, and L3 data caches respectively */ -inline void ei_queryCacheSizes(int& l1, int& l2, int& l3) +inline void queryCacheSizes(int& l1, int& l2, int& l3) { #ifdef EIGEN_CPUID int abcd[4]; @@ -754,27 +761,27 @@ inline void ei_queryCacheSizes(int& l1, int& l2, int& l3) // identify the CPU vendor EIGEN_CPUID(abcd,0x0,0); int max_std_funcs = abcd[1]; - if(ei_cpuid_is_vendor(abcd,"GenuineIntel")) - ei_queryCacheSizes_intel(l1,l2,l3,max_std_funcs); - else if(ei_cpuid_is_vendor(abcd,"AuthenticAMD") || ei_cpuid_is_vendor(abcd,"AMDisbetter!")) - ei_queryCacheSizes_amd(l1,l2,l3); + if(cpuid_is_vendor(abcd,"GenuineIntel")) + queryCacheSizes_intel(l1,l2,l3,max_std_funcs); + else if(cpuid_is_vendor(abcd,"AuthenticAMD") || cpuid_is_vendor(abcd,"AMDisbetter!")) + queryCacheSizes_amd(l1,l2,l3); else // by default let's use Intel's API - ei_queryCacheSizes_intel(l1,l2,l3,max_std_funcs); + queryCacheSizes_intel(l1,l2,l3,max_std_funcs); // here is the list of other vendors: -// ||ei_cpuid_is_vendor(abcd,"VIA VIA VIA ") -// ||ei_cpuid_is_vendor(abcd,"CyrixInstead") -// ||ei_cpuid_is_vendor(abcd,"CentaurHauls") -// ||ei_cpuid_is_vendor(abcd,"GenuineTMx86") -// ||ei_cpuid_is_vendor(abcd,"TransmetaCPU") -// ||ei_cpuid_is_vendor(abcd,"RiseRiseRise") -// ||ei_cpuid_is_vendor(abcd,"Geode by NSC") -// ||ei_cpuid_is_vendor(abcd,"SiS SiS SiS ") -// ||ei_cpuid_is_vendor(abcd,"UMC UMC UMC ") -// ||ei_cpuid_is_vendor(abcd,"NexGenDriven") -// ||ei_cpuid_is_vendor(abcd,"CentaurHauls") -// ||ei_cpuid_is_vendor(abcd,"CentaurHauls") +// ||cpuid_is_vendor(abcd,"VIA VIA VIA ") +// ||cpuid_is_vendor(abcd,"CyrixInstead") +// ||cpuid_is_vendor(abcd,"CentaurHauls") +// ||cpuid_is_vendor(abcd,"GenuineTMx86") +// ||cpuid_is_vendor(abcd,"TransmetaCPU") +// ||cpuid_is_vendor(abcd,"RiseRiseRise") +// ||cpuid_is_vendor(abcd,"Geode by NSC") +// ||cpuid_is_vendor(abcd,"SiS SiS SiS ") +// ||cpuid_is_vendor(abcd,"UMC UMC UMC ") +// ||cpuid_is_vendor(abcd,"NexGenDriven") +// ||cpuid_is_vendor(abcd,"CentaurHauls") +// ||cpuid_is_vendor(abcd,"CentaurHauls") #else l1 = l2 = l3 = -1; #endif @@ -782,20 +789,22 @@ inline void ei_queryCacheSizes(int& l1, int& l2, int& l3) /** \internal * \returns the size in Bytes of the L1 data cache */ -inline int ei_queryL1CacheSize() +inline int queryL1CacheSize() { int l1(-1), l2, l3; - ei_queryCacheSizes(l1,l2,l3); + queryCacheSizes(l1,l2,l3); return l1; } /** \internal * \returns the size in Bytes of the L2 or L3 cache if this later is present */ -inline int ei_queryTopLevelCacheSize() +inline int queryTopLevelCacheSize() { int l1, l2(-1), l3(-1); - ei_queryCacheSizes(l1,l2,l3); + queryCacheSizes(l1,l2,l3); return std::max(l2,l3); } +} // end namespace internal + #endif // EIGEN_MEMORY_H diff --git a/Eigen/src/Core/util/Meta.h b/Eigen/src/Core/util/Meta.h index 3d28680b6..56330db9b 100644 --- a/Eigen/src/Core/util/Meta.h +++ b/Eigen/src/Core/util/Meta.h @@ -26,6 +26,8 @@ #ifndef EIGEN_META_H #define EIGEN_META_H +namespace internal { + /** \internal * \file Meta.h * This file contains generic metaprogramming classes which are not specifically related to Eigen. @@ -33,72 +35,72 @@ * we however don't want to add a dependency to Boost. */ -struct ei_meta_true { enum { ret = 1 }; }; -struct ei_meta_false { enum { ret = 0 }; }; +struct meta_true { enum { ret = 1 }; }; +struct meta_false { enum { ret = 0 }; }; template -struct ei_meta_if { typedef Then ret; }; +struct meta_if { typedef Then ret; }; template -struct ei_meta_if { typedef Else ret; }; - -template struct ei_is_same_type { enum { ret = 0 }; }; -template struct ei_is_same_type { enum { ret = 1 }; }; - -template struct ei_unref { typedef T type; }; -template struct ei_unref { typedef T type; }; - -template struct ei_unpointer { typedef T type; }; -template struct ei_unpointer { typedef T type; }; -template struct ei_unpointer { typedef T type; }; - -template struct ei_unconst { typedef T type; }; -template struct ei_unconst { typedef T type; }; -template struct ei_unconst { typedef T & type; }; -template struct ei_unconst { typedef T * type; }; - -template struct ei_cleantype { typedef T type; }; -template struct ei_cleantype { typedef typename ei_cleantype::type type; }; -template struct ei_cleantype { typedef typename ei_cleantype::type type; }; -template struct ei_cleantype { typedef typename ei_cleantype::type type; }; -template struct ei_cleantype { typedef typename ei_cleantype::type type; }; -template struct ei_cleantype { typedef typename ei_cleantype::type type; }; - -template struct ei_is_arithmetic { enum { ret = false }; }; -template<> struct ei_is_arithmetic { enum { ret = true }; }; -template<> struct ei_is_arithmetic { enum { ret = true }; }; -template<> struct ei_is_arithmetic { enum { ret = true }; }; -template<> struct ei_is_arithmetic { enum { ret = true }; }; -template<> struct ei_is_arithmetic { enum { ret = true }; }; -template<> struct ei_is_arithmetic { enum { ret = true }; }; -template<> struct ei_is_arithmetic { enum { ret = true }; }; -template<> struct ei_is_arithmetic { enum { ret = true }; }; -template<> struct ei_is_arithmetic{ enum { ret = true }; }; -template<> struct ei_is_arithmetic { enum { ret = true }; }; -template<> struct ei_is_arithmetic { enum { ret = true }; }; -template<> struct ei_is_arithmetic { enum { ret = true }; }; -template<> struct ei_is_arithmetic { enum { ret = true }; }; -template<> struct ei_is_arithmetic { enum { ret = true }; }; -template<> struct ei_is_arithmetic { enum { ret = true }; }; - -template struct ei_makeconst { typedef const T type; }; -template struct ei_makeconst { typedef const T type; }; -template struct ei_makeconst { typedef const T& type; }; -template struct ei_makeconst { typedef const T& type; }; -template struct ei_makeconst { typedef const T* type; }; -template struct ei_makeconst { typedef const T* type; }; - -template struct ei_makeconst_return_type +struct meta_if { typedef Else ret; }; + +template struct is_same_type { enum { ret = 0 }; }; +template struct is_same_type { enum { ret = 1 }; }; + +template struct unref { typedef T type; }; +template struct unref { typedef T type; }; + +template struct unpointer { typedef T type; }; +template struct unpointer { typedef T type; }; +template struct unpointer { typedef T type; }; + +template struct unconst { typedef T type; }; +template struct unconst { typedef T type; }; +template struct unconst { typedef T & type; }; +template struct unconst { typedef T * type; }; + +template struct cleantype { typedef T type; }; +template struct cleantype { typedef typename cleantype::type type; }; +template struct cleantype { typedef typename cleantype::type type; }; +template struct cleantype { typedef typename cleantype::type type; }; +template struct cleantype { typedef typename cleantype::type type; }; +template struct cleantype { typedef typename cleantype::type type; }; + +template struct is_arithmetic { enum { ret = false }; }; +template<> struct is_arithmetic { enum { ret = true }; }; +template<> struct is_arithmetic { enum { ret = true }; }; +template<> struct is_arithmetic { enum { ret = true }; }; +template<> struct is_arithmetic { enum { ret = true }; }; +template<> struct is_arithmetic { enum { ret = true }; }; +template<> struct is_arithmetic { enum { ret = true }; }; +template<> struct is_arithmetic { enum { ret = true }; }; +template<> struct is_arithmetic { enum { ret = true }; }; +template<> struct is_arithmetic{ enum { ret = true }; }; +template<> struct is_arithmetic { enum { ret = true }; }; +template<> struct is_arithmetic { enum { ret = true }; }; +template<> struct is_arithmetic { enum { ret = true }; }; +template<> struct is_arithmetic { enum { ret = true }; }; +template<> struct is_arithmetic { enum { ret = true }; }; +template<> struct is_arithmetic { enum { ret = true }; }; + +template struct makeconst { typedef const T type; }; +template struct makeconst { typedef const T type; }; +template struct makeconst { typedef const T& type; }; +template struct makeconst { typedef const T& type; }; +template struct makeconst { typedef const T* type; }; +template struct makeconst { typedef const T* type; }; + +template struct makeconst_return_type { - typedef typename ei_meta_if::ret, T, typename ei_makeconst::type>::ret type; + typedef typename meta_if::ret, T, typename makeconst::type>::ret type; }; /** \internal Allows to enable/disable an overload * according to a compile time condition. */ -template struct ei_enable_if; +template struct enable_if; -template struct ei_enable_if +template struct enable_if { typedef T type; }; /** \internal @@ -108,67 +110,67 @@ template struct ei_enable_if * upcoming next STL generation (using a templated result member). * If none of these members is provided, then the type of the first argument is returned. FIXME, that behavior is a pretty bad hack. */ -template struct ei_result_of {}; +template struct result_of {}; -struct ei_has_none {int a[1];}; -struct ei_has_std_result_type {int a[2];}; -struct ei_has_tr1_result {int a[3];}; +struct has_none {int a[1];}; +struct has_std_result_type {int a[2];}; +struct has_tr1_result {int a[3];}; -template -struct ei_unary_result_of_select {typedef ArgType type;}; +template +struct unary_result_of_select {typedef ArgType type;}; template -struct ei_unary_result_of_select {typedef typename Func::result_type type;}; +struct unary_result_of_select {typedef typename Func::result_type type;}; template -struct ei_unary_result_of_select {typedef typename Func::template result::type type;}; +struct unary_result_of_select {typedef typename Func::template result::type type;}; template -struct ei_result_of { +struct result_of { template - static ei_has_std_result_type testFunctor(T const *, typename T::result_type const * = 0); + static has_std_result_type testFunctor(T const *, typename T::result_type const * = 0); template - static ei_has_tr1_result testFunctor(T const *, typename T::template result::type const * = 0); - static ei_has_none testFunctor(...); + static has_tr1_result testFunctor(T const *, typename T::template result::type const * = 0); + static has_none testFunctor(...); // note that the following indirection is needed for gcc-3.3 enum {FunctorType = sizeof(testFunctor(static_cast(0)))}; - typedef typename ei_unary_result_of_select::type type; + typedef typename unary_result_of_select::type type; }; -template -struct ei_binary_result_of_select {typedef ArgType0 type;}; +template +struct binary_result_of_select {typedef ArgType0 type;}; template -struct ei_binary_result_of_select +struct binary_result_of_select {typedef typename Func::result_type type;}; template -struct ei_binary_result_of_select +struct binary_result_of_select {typedef typename Func::template result::type type;}; template -struct ei_result_of { +struct result_of { template - static ei_has_std_result_type testFunctor(T const *, typename T::result_type const * = 0); + static has_std_result_type testFunctor(T const *, typename T::result_type const * = 0); template - static ei_has_tr1_result testFunctor(T const *, typename T::template result::type const * = 0); - static ei_has_none testFunctor(...); + static has_tr1_result testFunctor(T const *, typename T::template result::type const * = 0); + static has_none testFunctor(...); // note that the following indirection is needed for gcc-3.3 enum {FunctorType = sizeof(testFunctor(static_cast(0)))}; - typedef typename ei_binary_result_of_select::type type; + typedef typename binary_result_of_select::type type; }; /** \internal In short, it computes int(sqrt(\a Y)) with \a Y an integer. - * Usage example: \code ei_meta_sqrt<1023>::ret \endcode + * Usage example: \code meta_sqrt<1023>::ret \endcode */ template Y))) > // use ?: instead of || just to shut up a stupid gcc 4.3 warning -class ei_meta_sqrt +class meta_sqrt { enum { MidX = (InfX+SupX)/2, @@ -177,49 +179,51 @@ class ei_meta_sqrt NewSup = int(TakeInf) ? int(MidX) : SupX }; public: - enum { ret = ei_meta_sqrt::ret }; + enum { ret = meta_sqrt::ret }; }; template -class ei_meta_sqrt { public: enum { ret = (SupX*SupX <= Y) ? SupX : InfX }; }; +class meta_sqrt { public: enum { ret = (SupX*SupX <= Y) ? SupX : InfX }; }; /** \internal determines whether the product of two numeric types is allowed and what the return type is */ -template struct ei_scalar_product_traits; +template struct scalar_product_traits; -template struct ei_scalar_product_traits +template struct scalar_product_traits { //enum { Cost = NumTraits::MulCost }; typedef T ReturnType; }; -template struct ei_scalar_product_traits > +template struct scalar_product_traits > { //enum { Cost = 2*NumTraits::MulCost }; typedef std::complex ReturnType; }; -template struct ei_scalar_product_traits, T> +template struct scalar_product_traits, T> { //enum { Cost = 2*NumTraits::MulCost }; typedef std::complex ReturnType; }; -// FIXME quick workaround around current limitation of ei_result_of +// FIXME quick workaround around current limitation of result_of // template -// struct ei_result_of(ArgType0,ArgType1)> { -// typedef typename ei_scalar_product_traits::type, typename ei_cleantype::type>::ReturnType type; +// struct result_of(ArgType0,ArgType1)> { +// typedef typename scalar_product_traits::type, typename cleantype::type>::ReturnType type; // }; -template struct ei_is_diagonal +template struct is_diagonal { enum { ret = false }; }; -template struct ei_is_diagonal > +template struct is_diagonal > { enum { ret = true }; }; -template struct ei_is_diagonal > +template struct is_diagonal > { enum { ret = true }; }; -template struct ei_is_diagonal > +template struct is_diagonal > { enum { ret = true }; }; +} // end namespace internal + #endif // EIGEN_META_H diff --git a/Eigen/src/Core/util/StaticAssert.h b/Eigen/src/Core/util/StaticAssert.h index 323273e6a..71e8eef1b 100644 --- a/Eigen/src/Core/util/StaticAssert.h +++ b/Eigen/src/Core/util/StaticAssert.h @@ -29,11 +29,11 @@ /* Some notes on Eigen's static assertion mechanism: * * - in EIGEN_STATIC_ASSERT(CONDITION,MSG) the parameter CONDITION must be a compile time boolean - * expression, and MSG an enum listed in struct ei_static_assert + * expression, and MSG an enum listed in struct internal::static_assertion * * - define EIGEN_NO_STATIC_ASSERT to disable them (and save compilation time) * in that case, the static assertion is converted to the following runtime assert: - * ei_assert(CONDITION && "MSG") + * eigen_assert(CONDITION && "MSG") * * - currently EIGEN_STATIC_ASSERT can only be used in function scope * @@ -48,11 +48,13 @@ #else // not CXX0X + namespace internal { + template - struct ei_static_assert {}; + struct static_assertion {}; template<> - struct ei_static_assert + struct static_assertion { enum { YOU_TRIED_CALLING_A_VECTOR_METHOD_ON_A_MATRIX, @@ -94,18 +96,20 @@ }; }; + } // end namespace internal + // Specialized implementation for MSVC to avoid "conditional // expression is constant" warnings. This implementation doesn't // appear to work under GCC, hence the multiple implementations. #ifdef _MSC_VER #define EIGEN_STATIC_ASSERT(CONDITION,MSG) \ - {Eigen::ei_static_assert<(CONDITION)>::MSG;} + {Eigen::internal::static_assertion<(CONDITION)>::MSG;} #else #define EIGEN_STATIC_ASSERT(CONDITION,MSG) \ - if (Eigen::ei_static_assert<(CONDITION)>::MSG) {} + if (Eigen::internal::static_assertion<(CONDITION)>::MSG) {} #endif @@ -113,7 +117,7 @@ #else // EIGEN_NO_STATIC_ASSERT - #define EIGEN_STATIC_ASSERT(CONDITION,MSG) ei_assert((CONDITION) && #MSG); + #define EIGEN_STATIC_ASSERT(CONDITION,MSG) eigen_assert((CONDITION) && #MSG); #endif // EIGEN_NO_STATIC_ASSERT diff --git a/Eigen/src/Core/util/XprHelper.h b/Eigen/src/Core/util/XprHelper.h index 7232fa0f8..9f5bd7d71 100644 --- a/Eigen/src/Core/util/XprHelper.h +++ b/Eigen/src/Core/util/XprHelper.h @@ -1,4 +1,4 @@ -// // This file is part of Eigen, a lightweight C++ template library +// This file is part of Eigen, a lightweight C++ template library // for linear algebra. // // Copyright (C) 2008 Gael Guennebaud @@ -37,46 +37,48 @@ #define EIGEN_EMPTY_STRUCT_CTOR(X) #endif -//classes inheriting ei_no_assignment_operator don't generate a default operator=. -class ei_no_assignment_operator +typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE DenseIndex; + +namespace internal { + +//classes inheriting no_assignment_operator don't generate a default operator=. +class no_assignment_operator { private: - ei_no_assignment_operator& operator=(const ei_no_assignment_operator&); + no_assignment_operator& operator=(const no_assignment_operator&); }; -typedef EIGEN_DEFAULT_DENSE_INDEX_TYPE DenseIndex; - /** \internal return the index type with the largest number of bits */ template -struct ei_promote_index_type +struct promote_index_type { - typedef typename ei_meta_if<(sizeof(I1)::ret type; + typedef typename meta_if<(sizeof(I1)::ret type; }; /** \internal If the template parameter Value is Dynamic, this class is just a wrapper around a T variable that * can be accessed using value() and setValue(). * Otherwise, this class is an empty structure and value() just returns the template parameter Value. */ -template class ei_variable_if_dynamic +template class variable_if_dynamic { public: - EIGEN_EMPTY_STRUCT_CTOR(ei_variable_if_dynamic) - explicit ei_variable_if_dynamic(T v) { EIGEN_ONLY_USED_FOR_DEBUG(v); ei_assert(v == T(Value)); } + EIGEN_EMPTY_STRUCT_CTOR(variable_if_dynamic) + explicit variable_if_dynamic(T v) { EIGEN_ONLY_USED_FOR_DEBUG(v); assert(v == T(Value)); } static T value() { return T(Value); } void setValue(T) {} }; -template class ei_variable_if_dynamic +template class variable_if_dynamic { T m_value; - ei_variable_if_dynamic() { ei_assert(false); } + variable_if_dynamic() { assert(false); } public: - explicit ei_variable_if_dynamic(T value) : m_value(value) {} + explicit variable_if_dynamic(T value) : m_value(value) {} T value() const { return m_value; } void setValue(T value) { m_value = value; } }; -template struct ei_functor_traits +template struct functor_traits { enum { @@ -85,9 +87,9 @@ template struct ei_functor_traits }; }; -template struct ei_packet_traits; +template struct packet_traits; -template struct ei_unpacket_traits +template struct unpacket_traits { typedef T type; enum {size=1}; @@ -100,7 +102,7 @@ template class ei_make_proper_matrix_type +> class make_proper_matrix_type { enum { IsColVector = _Cols==1 && _Rows!=1, @@ -114,7 +116,7 @@ template -class ei_compute_matrix_flags +class compute_matrix_flags { enum { row_major_bit = Options&RowMajor ? RowMajorBit : 0, @@ -123,10 +125,10 @@ class ei_compute_matrix_flags aligned_bit = ( ((Options&DontAlign)==0) - && ei_packet_traits::Vectorizable + && packet_traits::Vectorizable && ( #if EIGEN_ALIGN_STATICALLY - ((!is_dynamic_size_storage) && (((MaxCols*MaxRows) % ei_packet_traits::size) == 0)) + ((!is_dynamic_size_storage) && (((MaxCols*MaxRows) % packet_traits::size) == 0)) #else 0 #endif @@ -141,95 +143,95 @@ class ei_compute_matrix_flags ) ) ? AlignedBit : 0, - packet_access_bit = ei_packet_traits::Vectorizable && aligned_bit ? PacketAccessBit : 0 + packet_access_bit = packet_traits::Vectorizable && aligned_bit ? PacketAccessBit : 0 }; public: enum { ret = LinearAccessBit | LvalueBit | DirectAccessBit | NestByRefBit | packet_access_bit | row_major_bit | aligned_bit }; }; -template struct ei_size_at_compile_time +template struct size_at_compile_time { enum { ret = (_Rows==Dynamic || _Cols==Dynamic) ? Dynamic : _Rows * _Cols }; }; -/* ei_plain_matrix_type : the difference from ei_eval is that ei_plain_matrix_type is always a plain matrix type, - * whereas ei_eval is a const reference in the case of a matrix +/* plain_matrix_type : the difference from eval is that plain_matrix_type is always a plain matrix type, + * whereas eval is a const reference in the case of a matrix */ -template::StorageKind> struct ei_plain_matrix_type; -template struct ei_plain_matrix_type_dense; -template struct ei_plain_matrix_type +template::StorageKind> struct plain_matrix_type; +template struct plain_matrix_type_dense; +template struct plain_matrix_type { - typedef typename ei_plain_matrix_type_dense::XprKind>::type type; + typedef typename plain_matrix_type_dense::XprKind>::type type; }; -template struct ei_plain_matrix_type_dense +template struct plain_matrix_type_dense { - typedef Matrix::Scalar, - ei_traits::RowsAtCompileTime, - ei_traits::ColsAtCompileTime, - AutoAlign | (ei_traits::Flags&RowMajorBit ? RowMajor : ColMajor), - ei_traits::MaxRowsAtCompileTime, - ei_traits::MaxColsAtCompileTime + typedef Matrix::Scalar, + traits::RowsAtCompileTime, + traits::ColsAtCompileTime, + AutoAlign | (traits::Flags&RowMajorBit ? RowMajor : ColMajor), + traits::MaxRowsAtCompileTime, + traits::MaxColsAtCompileTime > type; }; -template struct ei_plain_matrix_type_dense +template struct plain_matrix_type_dense { - typedef Array::Scalar, - ei_traits::RowsAtCompileTime, - ei_traits::ColsAtCompileTime, - AutoAlign | (ei_traits::Flags&RowMajorBit ? RowMajor : ColMajor), - ei_traits::MaxRowsAtCompileTime, - ei_traits::MaxColsAtCompileTime + typedef Array::Scalar, + traits::RowsAtCompileTime, + traits::ColsAtCompileTime, + AutoAlign | (traits::Flags&RowMajorBit ? RowMajor : ColMajor), + traits::MaxRowsAtCompileTime, + traits::MaxColsAtCompileTime > type; }; -/* ei_eval : the return type of eval(). For matrices, this is just a const reference +/* eval : the return type of eval(). For matrices, this is just a const reference * in order to avoid a useless copy */ -template::StorageKind> struct ei_eval; +template::StorageKind> struct eval; -template struct ei_eval +template struct eval { - typedef typename ei_plain_matrix_type::type type; + typedef typename plain_matrix_type::type type; // typedef typename T::PlainObject type; -// typedef T::Matrix::Scalar, -// ei_traits::RowsAtCompileTime, -// ei_traits::ColsAtCompileTime, -// AutoAlign | (ei_traits::Flags&RowMajorBit ? RowMajor : ColMajor), -// ei_traits::MaxRowsAtCompileTime, -// ei_traits::MaxColsAtCompileTime +// typedef T::Matrix::Scalar, +// traits::RowsAtCompileTime, +// traits::ColsAtCompileTime, +// AutoAlign | (traits::Flags&RowMajorBit ? RowMajor : ColMajor), +// traits::MaxRowsAtCompileTime, +// traits::MaxColsAtCompileTime // > type; }; // for matrices, no need to evaluate, just use a const reference to avoid a useless copy template -struct ei_eval, Dense> +struct eval, Dense> { typedef const Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& type; }; template -struct ei_eval, Dense> +struct eval, Dense> { typedef const Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& type; }; -/* ei_plain_matrix_type_column_major : same as ei_plain_matrix_type but guaranteed to be column-major +/* plain_matrix_type_column_major : same as plain_matrix_type but guaranteed to be column-major */ -template struct ei_plain_matrix_type_column_major +template struct plain_matrix_type_column_major { - enum { Rows = ei_traits::RowsAtCompileTime, - Cols = ei_traits::ColsAtCompileTime, - MaxRows = ei_traits::MaxRowsAtCompileTime, - MaxCols = ei_traits::MaxColsAtCompileTime + enum { Rows = traits::RowsAtCompileTime, + Cols = traits::ColsAtCompileTime, + MaxRows = traits::MaxRowsAtCompileTime, + MaxCols = traits::MaxColsAtCompileTime }; - typedef Matrix::Scalar, + typedef Matrix::Scalar, Rows, Cols, (MaxRows==1&&MaxCols!=1) ? RowMajor : ColMajor, @@ -238,16 +240,16 @@ template struct ei_plain_matrix_type_column_major > type; }; -/* ei_plain_matrix_type_row_major : same as ei_plain_matrix_type but guaranteed to be row-major +/* plain_matrix_type_row_major : same as plain_matrix_type but guaranteed to be row-major */ -template struct ei_plain_matrix_type_row_major +template struct plain_matrix_type_row_major { - enum { Rows = ei_traits::RowsAtCompileTime, - Cols = ei_traits::ColsAtCompileTime, - MaxRows = ei_traits::MaxRowsAtCompileTime, - MaxCols = ei_traits::MaxColsAtCompileTime + enum { Rows = traits::RowsAtCompileTime, + Cols = traits::ColsAtCompileTime, + MaxRows = traits::MaxRowsAtCompileTime, + MaxCols = traits::MaxColsAtCompileTime }; - typedef Matrix::Scalar, + typedef Matrix::Scalar, Rows, Cols, (MaxCols==1&&MaxRows!=1) ? RowMajor : ColMajor, @@ -257,16 +259,16 @@ template struct ei_plain_matrix_type_row_major }; // we should be able to get rid of this one too -template struct ei_must_nest_by_value { enum { ret = false }; }; +template struct must_nest_by_value { enum { ret = false }; }; template -struct ei_is_reference +struct is_reference { enum { ret = false }; }; template -struct ei_is_reference +struct is_reference { enum { ret = true }; }; @@ -277,10 +279,10 @@ struct ei_is_reference * objects which should generate no copying overhead. **/ template -struct ei_ref_selector +struct ref_selector { - typedef typename ei_meta_if< - bool(ei_traits::Flags & NestByRefBit), + typedef typename meta_if< + bool(traits::Flags & NestByRefBit), T const&, T >::ret type; @@ -298,70 +300,70 @@ struct ei_ref_selector * * Example. Suppose that a, b, and c are of type Matrix3d. The user forms the expression a*(b+c). * b+c is an expression "sum of matrices", which we will denote by S. In order to determine how to nest it, - * the Product expression uses: ei_nested::ret, which turns out to be Matrix3d because the internal logic of - * ei_nested determined that in this case it was better to evaluate the expression b+c into a temporary. On the other hand, - * since a is of type Matrix3d, the Product expression nests it as ei_nested::ret, which turns out to be - * const Matrix3d&, because the internal logic of ei_nested determined that since a was already a matrix, there was no point + * the Product expression uses: nested::ret, which turns out to be Matrix3d because the internal logic of + * nested determined that in this case it was better to evaluate the expression b+c into a temporary. On the other hand, + * since a is of type Matrix3d, the Product expression nests it as nested::ret, which turns out to be + * const Matrix3d&, because the internal logic of nested determined that since a was already a matrix, there was no point * in copying it into another matrix. */ -template::type> struct ei_nested +template::type> struct nested { // this is a direct port of the logic used when Dynamic was 33331, to make an atomic commit. enum { - _ScalarReadCost = NumTraits::Scalar>::ReadCost, + _ScalarReadCost = NumTraits::Scalar>::ReadCost, ScalarReadCost = _ScalarReadCost == Dynamic ? 33331 : int(_ScalarReadCost), - _CoeffReadCost = int(ei_traits::CoeffReadCost), + _CoeffReadCost = int(traits::CoeffReadCost), CoeffReadCost = _CoeffReadCost == Dynamic ? 33331 : int(_CoeffReadCost), N = n == Dynamic ? 33331 : n, CostEval = (N+1) * int(ScalarReadCost), CostNoEval = (N-1) * int(CoeffReadCost) }; - typedef typename ei_meta_if< - ( int(ei_traits::Flags) & EvalBeforeNestingBit ) || + typedef typename meta_if< + ( int(traits::Flags) & EvalBeforeNestingBit ) || ( int(CostEval) <= int(CostNoEval) ), PlainObject, - typename ei_ref_selector::type + typename ref_selector::type >::ret type; /* this is what the above logic should be updated to look like: enum { - ScalarReadCost = NumTraits::Scalar>::ReadCost, - CoeffReadCost = ei_traits::CoeffReadCost, + ScalarReadCost = NumTraits::Scalar>::ReadCost, + CoeffReadCost = traits::CoeffReadCost, CostEval = n == Dynamic || ScalarReadCost == Dynamic ? int(Dynamic) : (n+1) * int(ScalarReadCost), CostNoEval = n == Dynamic || (CoeffReadCost == Dynamic && n>1) ? int(Dynamic) : (n-1) * int(CoeffReadCost) }; - typedef typename ei_meta_if< - ( int(ei_traits::Flags) & EvalBeforeNestingBit ) || + typedef typename meta_if< + ( int(traits::Flags) & EvalBeforeNestingBit ) || ( int(CostNoEval) == Dynamic ? true : int(CostEval) == Dynamic ? false : int(CostEval) <= int(CostNoEval) ), PlainObject, - typename ei_ref_selector::type + typename ref_selector::type >::ret type; */ }; -template struct ei_are_flags_consistent +template struct are_flags_consistent { enum { ret = EIGEN_IMPLIES(bool(Flags&DirectAccessBit), bool(Flags&LvalueBit)) }; }; -template::XprKind> -struct ei_dense_xpr_base +template::XprKind> +struct dense_xpr_base { - /* ei_dense_xpr_base should only ever be used on dense expressions, thus falling either into the MatrixXpr or into the ArrayXpr cases */ + /* dense_xpr_base should only ever be used on dense expressions, thus falling either into the MatrixXpr or into the ArrayXpr cases */ }; template -struct ei_dense_xpr_base +struct dense_xpr_base { typedef MatrixBase type; }; template -struct ei_dense_xpr_base +struct dense_xpr_base { typedef ArrayBase type; }; @@ -369,27 +371,27 @@ struct ei_dense_xpr_base /** \internal Helper base class to add a scalar multiple operator * overloads for complex types */ template::ret > -struct ei_special_scalar_op_base : public DenseCoeffsBase + bool EnableIt = !is_same_type::ret > +struct special_scalar_op_base : public DenseCoeffsBase { // dummy operator* so that the - // "using ei_special_scalar_op_base::operator*" compiles + // "using special_scalar_op_base::operator*" compiles void operator*() const; }; template -struct ei_special_scalar_op_base : public DenseCoeffsBase +struct special_scalar_op_base : public DenseCoeffsBase { - const CwiseUnaryOp, Derived> + const CwiseUnaryOp, Derived> operator*(const OtherScalar& scalar) const { - return CwiseUnaryOp, Derived> - (*static_cast(this), ei_scalar_multiple2_op(scalar)); + return CwiseUnaryOp, Derived> + (*static_cast(this), scalar_multiple2_op(scalar)); } - inline friend const CwiseUnaryOp, Derived> + inline friend const CwiseUnaryOp, Derived> operator*(const OtherScalar& scalar, const Derived& matrix) - { return static_cast(matrix).operator*(scalar); } + { return static_cast(matrix).operator*(scalar); } }; template struct HNormalizedReturnType { @@ -399,24 +401,24 @@ template struct HNormalizedReturnType { SizeMinusOne = SizeAtCompileTime==Dynamic ? Dynamic : SizeAtCompileTime-1 }; typedef Block::ColsAtCompileTime==1 ? SizeMinusOne : 1, - ei_traits::ColsAtCompileTime==1 ? 1 : SizeMinusOne> StartMinusOne; - typedef CwiseUnaryOp::Scalar>, + traits::ColsAtCompileTime==1 ? SizeMinusOne : 1, + traits::ColsAtCompileTime==1 ? 1 : SizeMinusOne> StartMinusOne; + typedef CwiseUnaryOp::Scalar>, StartMinusOne > Type; }; -template struct ei_cast_return_type +template struct cast_return_type { typedef typename XprType::Scalar CurrentScalarType; - typedef typename ei_cleantype::type _CastType; + typedef typename cleantype::type _CastType; typedef typename _CastType::Scalar NewScalarType; - typedef typename ei_meta_if::ret, + typedef typename meta_if::ret, const XprType&,CastType>::ret type; }; -template struct ei_promote_storage_type; +template struct promote_storage_type; -template struct ei_promote_storage_type +template struct promote_storage_type { typedef A ret; }; @@ -425,37 +427,37 @@ template struct ei_promote_storage_type * \param Scalar optional parameter allowing to pass a different scalar type than the one of the MatrixType. */ template -struct ei_plain_row_type +struct plain_row_type { typedef Matrix MatrixRowType; typedef Array ArrayRowType; - typedef typename ei_meta_if< - ei_is_same_type< typename ei_traits::XprKind, MatrixXpr >::ret, + typedef typename meta_if< + is_same_type< typename traits::XprKind, MatrixXpr >::ret, MatrixRowType, ArrayRowType >::ret type; }; template -struct ei_plain_col_type +struct plain_col_type { typedef Matrix MatrixColType; typedef Array ArrayColType; - typedef typename ei_meta_if< - ei_is_same_type< typename ei_traits::XprKind, MatrixXpr >::ret, + typedef typename meta_if< + is_same_type< typename traits::XprKind, MatrixXpr >::ret, MatrixColType, ArrayColType >::ret type; }; template -struct ei_plain_diag_type +struct plain_diag_type { enum { diag_size = EIGEN_SIZE_MIN_PREFER_DYNAMIC(ExpressionType::RowsAtCompileTime, ExpressionType::ColsAtCompileTime), max_diag_size = EIGEN_SIZE_MIN_PREFER_FIXED(ExpressionType::MaxRowsAtCompileTime, ExpressionType::MaxColsAtCompileTime) @@ -463,11 +465,13 @@ struct ei_plain_diag_type typedef Matrix MatrixDiagType; typedef Array ArrayDiagType; - typedef typename ei_meta_if< - ei_is_same_type< typename ei_traits::XprKind, MatrixXpr >::ret, + typedef typename meta_if< + is_same_type< typename traits::XprKind, MatrixXpr >::ret, MatrixDiagType, ArrayDiagType >::ret type; }; +} // end namespace internal + #endif // EIGEN_XPRHELPER_H diff --git a/Eigen/src/Eigen2Support/Block.h b/Eigen/src/Eigen2Support/Block.h index ba0e39650..bc28051e0 100644 --- a/Eigen/src/Eigen2Support/Block.h +++ b/Eigen/src/Eigen2Support/Block.h @@ -49,7 +49,7 @@ inline Block DenseBase switch(type) { default: - ei_assert(false && "Bad corner type."); + eigen_assert(false && "Bad corner type."); case TopLeft: return Block(derived(), 0, 0, cRows, cCols); case TopRight: @@ -69,7 +69,7 @@ DenseBase::corner(CornerType type, Index cRows, Index cCols) const switch(type) { default: - ei_assert(false && "Bad corner type."); + eigen_assert(false && "Bad corner type."); case TopLeft: return Block(derived(), 0, 0, cRows, cCols); case TopRight: @@ -101,7 +101,7 @@ DenseBase::corner(CornerType type) switch(type) { default: - ei_assert(false && "Bad corner type."); + eigen_assert(false && "Bad corner type."); case TopLeft: return Block(derived(), 0, 0); case TopRight: @@ -122,7 +122,7 @@ DenseBase::corner(CornerType type) const switch(type) { default: - ei_assert(false && "Bad corner type."); + eigen_assert(false && "Bad corner type."); case TopLeft: return Block(derived(), 0, 0); case TopRight: diff --git a/Eigen/src/Eigen2Support/Cwise.h b/Eigen/src/Eigen2Support/Cwise.h index 1489f8f79..74fa63aaa 100644 --- a/Eigen/src/Eigen2Support/Cwise.h +++ b/Eigen/src/Eigen2Support/Cwise.h @@ -29,17 +29,17 @@ /** \internal * convenient macro to defined the return type of a cwise binary operation */ #define EIGEN_CWISE_BINOP_RETURN_TYPE(OP) \ - CwiseBinaryOp::Scalar>, ExpressionType, OtherDerived> + CwiseBinaryOp::Scalar>, ExpressionType, OtherDerived> /** \internal * convenient macro to defined the return type of a cwise unary operation */ #define EIGEN_CWISE_UNOP_RETURN_TYPE(OP) \ - CwiseUnaryOp::Scalar>, ExpressionType> + CwiseUnaryOp::Scalar>, ExpressionType> /** \internal * convenient macro to defined the return type of a cwise comparison to a scalar */ #define EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(OP) \ - CwiseBinaryOp::Scalar>, ExpressionType, \ + CwiseBinaryOp::Scalar>, ExpressionType, \ typename ExpressionType::ConstantReturnType > /** \class Cwise @@ -61,10 +61,10 @@ template class Cwise { public: - typedef typename ei_traits::Scalar Scalar; - typedef typename ei_meta_if::ret, + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::meta_if::ret, ExpressionType, const ExpressionType&>::ret ExpressionTypeNested; - typedef CwiseUnaryOp, ExpressionType> ScalarAddReturnType; + typedef CwiseUnaryOp, ExpressionType> ScalarAddReturnType; inline Cwise(const ExpressionType& matrix) : m_matrix(matrix) {} @@ -76,28 +76,28 @@ template class Cwise operator*(const MatrixBase &other) const; template - const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op) + const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_quotient_op) operator/(const MatrixBase &other) const; template - const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_min_op) + const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_min_op) min(const MatrixBase &other) const; template - const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_max_op) + const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_max_op) max(const MatrixBase &other) const; - const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_abs_op) abs() const; - const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_abs2_op) abs2() const; - const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_square_op) square() const; - const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cube_op) cube() const; - const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_inverse_op) inverse() const; - const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sqrt_op) sqrt() const; - const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_exp_op) exp() const; - const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_log_op) log() const; - const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cos_op) cos() const; - const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sin_op) sin() const; - const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_pow_op) pow(const Scalar& exponent) const; + const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_abs_op) abs() const; + const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_abs2_op) abs2() const; + const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_square_op) square() const; + const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_cube_op) cube() const; + const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_inverse_op) inverse() const; + const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_sqrt_op) sqrt() const; + const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_exp_op) exp() const; + const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_log_op) log() const; + const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_cos_op) cos() const; + const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_sin_op) sin() const; + const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_pow_op) pow(const Scalar& exponent) const; const ScalarAddReturnType operator+(const Scalar& scalar) const; diff --git a/Eigen/src/Eigen2Support/CwiseOperators.h b/Eigen/src/Eigen2Support/CwiseOperators.h index 74feee4a0..0c7e9db6d 100644 --- a/Eigen/src/Eigen2Support/CwiseOperators.h +++ b/Eigen/src/Eigen2Support/CwiseOperators.h @@ -32,7 +32,7 @@ /** \deprecated ArrayBase::abs() */ template -EIGEN_STRONG_INLINE const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_abs_op) +EIGEN_STRONG_INLINE const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_abs_op) Cwise::abs() const { return _expression(); @@ -40,7 +40,7 @@ Cwise::abs() const /** \deprecated ArrayBase::abs2() */ template -EIGEN_STRONG_INLINE const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_abs2_op) +EIGEN_STRONG_INLINE const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_abs2_op) Cwise::abs2() const { return _expression(); @@ -48,7 +48,7 @@ Cwise::abs2() const /** \deprecated ArrayBase::exp() */ template -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_exp_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_exp_op) Cwise::exp() const { return _expression(); @@ -56,7 +56,7 @@ Cwise::exp() const /** \deprecated ArrayBase::log() */ template -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_log_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_log_op) Cwise::log() const { return _expression(); @@ -74,10 +74,10 @@ Cwise::operator*(const MatrixBase &other) const /** \deprecated ArrayBase::operator/() */ template template -EIGEN_STRONG_INLINE const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op) +EIGEN_STRONG_INLINE const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_quotient_op) Cwise::operator/(const MatrixBase &other) const { - return EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op)(_expression(), other.derived()); + return EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_quotient_op)(_expression(), other.derived()); } /** \deprecated ArrayBase::operator*=() */ @@ -99,19 +99,19 @@ inline ExpressionType& Cwise::operator/=(const MatrixBase template -EIGEN_STRONG_INLINE const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_min_op) +EIGEN_STRONG_INLINE const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_min_op) Cwise::min(const MatrixBase &other) const { - return EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_min_op)(_expression(), other.derived()); + return EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_min_op)(_expression(), other.derived()); } /** \deprecated ArrayBase::max() */ template template -EIGEN_STRONG_INLINE const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_max_op) +EIGEN_STRONG_INLINE const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_max_op) Cwise::max(const MatrixBase &other) const { - return EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_max_op)(_expression(), other.derived()); + return EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_max_op)(_expression(), other.derived()); } /*************************************************************************** @@ -122,7 +122,7 @@ Cwise::max(const MatrixBase &other) const /** \deprecated ArrayBase::sqrt() */ template -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sqrt_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_sqrt_op) Cwise::sqrt() const { return _expression(); @@ -130,7 +130,7 @@ Cwise::sqrt() const /** \deprecated ArrayBase::cos() */ template -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cos_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_cos_op) Cwise::cos() const { return _expression(); @@ -139,7 +139,7 @@ Cwise::cos() const /** \deprecated ArrayBase::sin() */ template -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sin_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_sin_op) Cwise::sin() const { return _expression(); @@ -148,16 +148,16 @@ Cwise::sin() const /** \deprecated ArrayBase::log() */ template -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_pow_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_pow_op) Cwise::pow(const Scalar& exponent) const { - return EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_pow_op)(_expression(), ei_scalar_pow_op(exponent)); + return EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_pow_op)(_expression(), internal::scalar_pow_op(exponent)); } /** \deprecated ArrayBase::inverse() */ template -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_inverse_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_inverse_op) Cwise::inverse() const { return _expression(); @@ -165,7 +165,7 @@ Cwise::inverse() const /** \deprecated ArrayBase::square() */ template -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_square_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_square_op) Cwise::square() const { return _expression(); @@ -173,7 +173,7 @@ Cwise::square() const /** \deprecated ArrayBase::cube() */ template -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cube_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_cube_op) Cwise::cube() const { return _expression(); @@ -299,7 +299,7 @@ template inline const typename Cwise::ScalarAddReturnType Cwise::operator+(const Scalar& scalar) const { - return typename Cwise::ScalarAddReturnType(m_matrix, ei_scalar_add_op(scalar)); + return typename Cwise::ScalarAddReturnType(m_matrix, internal::scalar_add_op(scalar)); } /** \deprecated ArrayBase::operator+=(Scalar) */ diff --git a/Eigen/src/Eigen2Support/Minor.h b/Eigen/src/Eigen2Support/Minor.h index 555d1d7f5..a058ac1e0 100644 --- a/Eigen/src/Eigen2Support/Minor.h +++ b/Eigen/src/Eigen2Support/Minor.h @@ -38,12 +38,14 @@ * * \sa MatrixBase::minor() */ + +namespace internal { template -struct ei_traits > - : ei_traits +struct traits > + : traits { - typedef typename ei_nested::type MatrixTypeNested; - typedef typename ei_unref::type _MatrixTypeNested; + typedef typename nested::type MatrixTypeNested; + typedef typename unref::type _MatrixTypeNested; typedef typename MatrixType::StorageKind StorageKind; enum { RowsAtCompileTime = (MatrixType::RowsAtCompileTime != Dynamic) ? @@ -59,6 +61,7 @@ struct ei_traits > // where loops are unrolled and the 'if' evaluates at compile time }; }; +} template class Minor : public MatrixBase > @@ -72,7 +75,7 @@ template class Minor Index row, Index col) : m_matrix(matrix), m_row(row), m_col(col) { - ei_assert(row >= 0 && row < matrix.rows() + eigen_assert(row >= 0 && row < matrix.rows() && col >= 0 && col < matrix.cols()); } diff --git a/Eigen/src/Eigenvalues/ComplexEigenSolver.h b/Eigen/src/Eigenvalues/ComplexEigenSolver.h index 7bf1d140e..d737d4cf0 100644 --- a/Eigen/src/Eigenvalues/ComplexEigenSolver.h +++ b/Eigen/src/Eigenvalues/ComplexEigenSolver.h @@ -169,8 +169,8 @@ template class ComplexEigenSolver */ const EigenvectorType& eigenvectors() const { - ei_assert(m_isInitialized && "ComplexEigenSolver is not initialized."); - ei_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues."); + eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized."); + eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues."); return m_eivec; } @@ -193,7 +193,7 @@ template class ComplexEigenSolver */ const EigenvalueType& eigenvalues() const { - ei_assert(m_isInitialized && "ComplexEigenSolver is not initialized."); + eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized."); return m_eivalues; } @@ -229,7 +229,7 @@ template class ComplexEigenSolver */ ComputationInfo info() const { - ei_assert(m_isInitialized && "ComplexEigenSolver is not initialized."); + eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized."); return m_schur.info(); } @@ -293,7 +293,7 @@ void ComplexEigenSolver::doComputeEigenvectors(RealScalar matrixnorm { // If the i-th and k-th eigenvalue are equal, then z equals 0. // Use a small value instead, to prevent division by zero. - ei_real_ref(z) = NumTraits::epsilon() * matrixnorm; + internal::real_ref(z) = NumTraits::epsilon() * matrixnorm; } m_matX.coeffRef(i,k) = m_matX.coeff(i,k) / z; } diff --git a/Eigen/src/Eigenvalues/ComplexSchur.h b/Eigen/src/Eigenvalues/ComplexSchur.h index 612573895..b1830f642 100644 --- a/Eigen/src/Eigenvalues/ComplexSchur.h +++ b/Eigen/src/Eigenvalues/ComplexSchur.h @@ -30,7 +30,9 @@ #include "./EigenvaluesCommon.h" #include "./HessenbergDecomposition.h" -template struct ei_complex_schur_reduce_to_hessenberg; +namespace internal { +template struct complex_schur_reduce_to_hessenberg; +} /** \eigenvalues_module \ingroup Eigenvalues_Module * @@ -146,8 +148,8 @@ template class ComplexSchur */ const ComplexMatrixType& matrixU() const { - ei_assert(m_isInitialized && "ComplexSchur is not initialized."); - ei_assert(m_matUisUptodate && "The matrix U has not been computed during the ComplexSchur decomposition."); + eigen_assert(m_isInitialized && "ComplexSchur is not initialized."); + eigen_assert(m_matUisUptodate && "The matrix U has not been computed during the ComplexSchur decomposition."); return m_matU; } @@ -170,7 +172,7 @@ template class ComplexSchur */ const ComplexMatrixType& matrixT() const { - ei_assert(m_isInitialized && "ComplexSchur is not initialized."); + eigen_assert(m_isInitialized && "ComplexSchur is not initialized."); return m_matT; } @@ -201,7 +203,7 @@ template class ComplexSchur */ ComputationInfo info() const { - ei_assert(m_isInitialized && "RealSchur is not initialized."); + eigen_assert(m_isInitialized && "RealSchur is not initialized."); return m_info; } @@ -222,22 +224,24 @@ template class ComplexSchur bool subdiagonalEntryIsNeglegible(Index i); ComplexScalar computeShift(Index iu, Index iter); void reduceToTriangularForm(bool computeU); - friend struct ei_complex_schur_reduce_to_hessenberg::IsComplex>; + friend struct internal::complex_schur_reduce_to_hessenberg::IsComplex>; }; +namespace internal { + /** Computes the principal value of the square root of the complex \a z. */ template -std::complex ei_sqrt(const std::complex &z) +std::complex sqrt(const std::complex &z) { RealScalar t, tre, tim; - t = ei_abs(z); + t = abs(z); - if (ei_abs(ei_real(z)) <= ei_abs(ei_imag(z))) + if (abs(real(z)) <= abs(imag(z))) { // No cancellation in these formulas - tre = ei_sqrt(RealScalar(0.5)*(t + ei_real(z))); - tim = ei_sqrt(RealScalar(0.5)*(t - ei_real(z))); + tre = sqrt(RealScalar(0.5)*(t + real(z))); + tim = sqrt(RealScalar(0.5)*(t - real(z))); } else { @@ -245,14 +249,14 @@ std::complex ei_sqrt(const std::complex &z) if (z.real() > RealScalar(0)) { tre = t + z.real(); - tim = ei_abs(ei_imag(z))*ei_sqrt(RealScalar(0.5)/tre); - tre = ei_sqrt(RealScalar(0.5)*tre); + tim = abs(imag(z))*sqrt(RealScalar(0.5)/tre); + tre = sqrt(RealScalar(0.5)*tre); } else { tim = t - z.real(); - tre = ei_abs(ei_imag(z))*ei_sqrt(RealScalar(0.5)/tim); - tim = ei_sqrt(RealScalar(0.5)*tim); + tre = abs(imag(z))*sqrt(RealScalar(0.5)/tim); + tim = sqrt(RealScalar(0.5)*tim); } } if(z.imag() < RealScalar(0)) @@ -260,6 +264,7 @@ std::complex ei_sqrt(const std::complex &z) return (std::complex(tre,tim)); } +} // end namespace internal /** If m_matT(i+1,i) is neglegible in floating point arithmetic @@ -268,9 +273,9 @@ std::complex ei_sqrt(const std::complex &z) template inline bool ComplexSchur::subdiagonalEntryIsNeglegible(Index i) { - RealScalar d = ei_norm1(m_matT.coeff(i,i)) + ei_norm1(m_matT.coeff(i+1,i+1)); - RealScalar sd = ei_norm1(m_matT.coeff(i+1,i)); - if (ei_isMuchSmallerThan(sd, d, NumTraits::epsilon())) + RealScalar d = internal::norm1(m_matT.coeff(i,i)) + internal::norm1(m_matT.coeff(i+1,i+1)); + RealScalar sd = internal::norm1(m_matT.coeff(i+1,i)); + if (internal::isMuchSmallerThan(sd, d, NumTraits::epsilon())) { m_matT.coeffRef(i+1,i) = ComplexScalar(0); return true; @@ -286,7 +291,7 @@ typename ComplexSchur::ComplexScalar ComplexSchur::compu if (iter == 10 || iter == 20) { // exceptional shift, taken from http://www.netlib.org/eispack/comqr.f - return ei_abs(ei_real(m_matT.coeff(iu,iu-1))) + ei_abs(ei_real(m_matT.coeff(iu-1,iu-2))); + return internal::abs(internal::real(m_matT.coeff(iu,iu-1))) + internal::abs(internal::real(m_matT.coeff(iu-1,iu-2))); } // compute the shift as one of the eigenvalues of t, the 2x2 @@ -297,19 +302,19 @@ typename ComplexSchur::ComplexScalar ComplexSchur::compu ComplexScalar b = t.coeff(0,1) * t.coeff(1,0); ComplexScalar c = t.coeff(0,0) - t.coeff(1,1); - ComplexScalar disc = ei_sqrt(c*c + RealScalar(4)*b); + ComplexScalar disc = internal::sqrt(c*c + RealScalar(4)*b); ComplexScalar det = t.coeff(0,0) * t.coeff(1,1) - b; ComplexScalar trace = t.coeff(0,0) + t.coeff(1,1); ComplexScalar eival1 = (trace + disc) / RealScalar(2); ComplexScalar eival2 = (trace - disc) / RealScalar(2); - if(ei_norm1(eival1) > ei_norm1(eival2)) + if(internal::norm1(eival1) > internal::norm1(eival2)) eival2 = det / eival1; else eival1 = det / eival2; // choose the eigenvalue closest to the bottom entry of the diagonal - if(ei_norm1(eival1-t.coeff(1,1)) < ei_norm1(eival2-t.coeff(1,1))) + if(internal::norm1(eival1-t.coeff(1,1)) < internal::norm1(eival2-t.coeff(1,1))) return normt * eival1; else return normt * eival2; @@ -320,7 +325,7 @@ template ComplexSchur& ComplexSchur::compute(const MatrixType& matrix, bool computeU) { m_matUisUptodate = false; - ei_assert(matrix.cols() == matrix.rows()); + eigen_assert(matrix.cols() == matrix.rows()); if(matrix.cols() == 1) { @@ -332,14 +337,16 @@ ComplexSchur& ComplexSchur::compute(const MatrixType& ma return *this; } - ei_complex_schur_reduce_to_hessenberg::IsComplex>::run(*this, matrix, computeU); + internal::complex_schur_reduce_to_hessenberg::IsComplex>::run(*this, matrix, computeU); reduceToTriangularForm(computeU); return *this; } +namespace internal { + /* Reduce given matrix to Hessenberg form */ template -struct ei_complex_schur_reduce_to_hessenberg +struct complex_schur_reduce_to_hessenberg { // this is the implementation for the case IsComplex = true static void run(ComplexSchur& _this, const MatrixType& matrix, bool computeU) @@ -351,7 +358,7 @@ struct ei_complex_schur_reduce_to_hessenberg }; template -struct ei_complex_schur_reduce_to_hessenberg +struct complex_schur_reduce_to_hessenberg { static void run(ComplexSchur& _this, const MatrixType& matrix, bool computeU) { @@ -370,6 +377,8 @@ struct ei_complex_schur_reduce_to_hessenberg } }; +} // end namespace internal + // Reduce the Hessenberg matrix m_matT to triangular form by QR iteration. template void ComplexSchur::reduceToTriangularForm(bool computeU) diff --git a/Eigen/src/Eigenvalues/EigenSolver.h b/Eigen/src/Eigenvalues/EigenSolver.h index 0a5faec52..5a59ccbd4 100644 --- a/Eigen/src/Eigenvalues/EigenSolver.h +++ b/Eigen/src/Eigenvalues/EigenSolver.h @@ -211,8 +211,8 @@ template class EigenSolver */ const MatrixType& pseudoEigenvectors() const { - ei_assert(m_isInitialized && "EigenSolver is not initialized."); - ei_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues."); + eigen_assert(m_isInitialized && "EigenSolver is not initialized."); + eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues."); return m_eivec; } @@ -254,7 +254,7 @@ template class EigenSolver */ const EigenvalueType& eigenvalues() const { - ei_assert(m_isInitialized && "EigenSolver is not initialized."); + eigen_assert(m_isInitialized && "EigenSolver is not initialized."); return m_eivalues; } @@ -289,7 +289,7 @@ template class EigenSolver ComputationInfo info() const { - ei_assert(m_isInitialized && "ComplexEigenSolver is not initialized."); + eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized."); return m_realSchur.info(); } @@ -311,17 +311,17 @@ template class EigenSolver template MatrixType EigenSolver::pseudoEigenvalueMatrix() const { - ei_assert(m_isInitialized && "EigenSolver is not initialized."); + eigen_assert(m_isInitialized && "EigenSolver is not initialized."); Index n = m_eivalues.rows(); MatrixType matD = MatrixType::Zero(n,n); for (Index i=0; i(i,i) << ei_real(m_eivalues.coeff(i)), ei_imag(m_eivalues.coeff(i)), - -ei_imag(m_eivalues.coeff(i)), ei_real(m_eivalues.coeff(i)); + matD.template block<2,2>(i,i) << internal::real(m_eivalues.coeff(i)), internal::imag(m_eivalues.coeff(i)), + -internal::imag(m_eivalues.coeff(i)), internal::real(m_eivalues.coeff(i)); ++i; } } @@ -331,13 +331,13 @@ MatrixType EigenSolver::pseudoEigenvalueMatrix() const template typename EigenSolver::EigenvectorsType EigenSolver::eigenvectors() const { - ei_assert(m_isInitialized && "EigenSolver is not initialized."); - ei_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues."); + eigen_assert(m_isInitialized && "EigenSolver is not initialized."); + eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues."); Index n = m_eivec.cols(); EigenvectorsType matV(n,n); for (Index j=0; j(); @@ -384,7 +384,7 @@ EigenSolver& EigenSolver::compute(const MatrixType& matr else { Scalar p = Scalar(0.5) * (m_matT.coeff(i, i) - m_matT.coeff(i+1, i+1)); - Scalar z = ei_sqrt(ei_abs(p * p + m_matT.coeff(i+1, i) * m_matT.coeff(i, i+1))); + Scalar z = internal::sqrt(internal::abs(p * p + m_matT.coeff(i+1, i) * m_matT.coeff(i, i+1))); m_eivalues.coeffRef(i) = ComplexScalar(m_matT.coeff(i+1, i+1) + p, z); m_eivalues.coeffRef(i+1) = ComplexScalar(m_matT.coeff(i+1, i+1) + p, -z); i += 2; @@ -407,7 +407,7 @@ template std::complex cdiv(Scalar xr, Scalar xi, Scalar yr, Scalar yi) { Scalar r,d; - if (ei_abs(yr) > ei_abs(yi)) + if (internal::abs(yr) > internal::abs(yi)) { r = yi/yr; d = yr + r*yi; @@ -480,14 +480,14 @@ void EigenSolver::doComputeEigenvectors() Scalar denom = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) + m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag(); Scalar t = (x * lastr - lastw * r) / denom; m_matT.coeffRef(i,n) = t; - if (ei_abs(x) > ei_abs(lastw)) + if (internal::abs(x) > internal::abs(lastw)) m_matT.coeffRef(i+1,n) = (-r - w * t) / x; else m_matT.coeffRef(i+1,n) = (-lastr - y * t) / lastw; } // Overflow control - Scalar t = ei_abs(m_matT.coeff(i,n)); + Scalar t = internal::abs(m_matT.coeff(i,n)); if ((eps * t) * t > 1) m_matT.col(n).tail(size-i) /= t; } @@ -499,16 +499,16 @@ void EigenSolver::doComputeEigenvectors() Index l = n-1; // Last vector component imaginary so matrix is triangular - if (ei_abs(m_matT.coeff(n,n-1)) > ei_abs(m_matT.coeff(n-1,n))) + if (internal::abs(m_matT.coeff(n,n-1)) > internal::abs(m_matT.coeff(n-1,n))) { m_matT.coeffRef(n-1,n-1) = q / m_matT.coeff(n,n-1); m_matT.coeffRef(n-1,n) = -(m_matT.coeff(n,n) - p) / m_matT.coeff(n,n-1); } else { - std::complex cc = cdiv(0.0,-m_matT.coeff(n-1,n),m_matT.coeff(n-1,n-1)-p,q); - m_matT.coeffRef(n-1,n-1) = ei_real(cc); - m_matT.coeffRef(n-1,n) = ei_imag(cc); + std::complex cc = cdiv(0.0,-m_matT.coeff(n-1,n),m_matT.coeff(n-1,n-1)-p,q); + m_matT.coeffRef(n-1,n-1) = internal::real(cc); + m_matT.coeffRef(n-1,n) = internal::imag(cc); } m_matT.coeffRef(n,n-1) = 0.0; m_matT.coeffRef(n,n) = 1.0; @@ -530,8 +530,8 @@ void EigenSolver::doComputeEigenvectors() if (m_eivalues.coeff(i).imag() == 0) { std::complex cc = cdiv(-ra,-sa,w,q); - m_matT.coeffRef(i,n-1) = ei_real(cc); - m_matT.coeffRef(i,n) = ei_imag(cc); + m_matT.coeffRef(i,n-1) = internal::real(cc); + m_matT.coeffRef(i,n) = internal::imag(cc); } else { @@ -541,12 +541,12 @@ void EigenSolver::doComputeEigenvectors() Scalar vr = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) + m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag() - q * q; Scalar vi = (m_eivalues.coeff(i).real() - p) * Scalar(2) * q; if ((vr == 0.0) && (vi == 0.0)) - vr = eps * norm * (ei_abs(w) + ei_abs(q) + ei_abs(x) + ei_abs(y) + ei_abs(lastw)); + vr = eps * norm * (internal::abs(w) + internal::abs(q) + internal::abs(x) + internal::abs(y) + internal::abs(lastw)); std::complex cc = cdiv(x*lastra-lastw*ra+q*sa,x*lastsa-lastw*sa-q*ra,vr,vi); - m_matT.coeffRef(i,n-1) = ei_real(cc); - m_matT.coeffRef(i,n) = ei_imag(cc); - if (ei_abs(x) > (ei_abs(lastw) + ei_abs(q))) + m_matT.coeffRef(i,n-1) = internal::real(cc); + m_matT.coeffRef(i,n) = internal::imag(cc); + if (internal::abs(x) > (internal::abs(lastw) + internal::abs(q))) { m_matT.coeffRef(i+1,n-1) = (-ra - w * m_matT.coeff(i,n-1) + q * m_matT.coeff(i,n)) / x; m_matT.coeffRef(i+1,n) = (-sa - w * m_matT.coeff(i,n) - q * m_matT.coeff(i,n-1)) / x; @@ -554,13 +554,13 @@ void EigenSolver::doComputeEigenvectors() else { cc = cdiv(-lastra-y*m_matT.coeff(i,n-1),-lastsa-y*m_matT.coeff(i,n),lastw,q); - m_matT.coeffRef(i+1,n-1) = ei_real(cc); - m_matT.coeffRef(i+1,n) = ei_imag(cc); + m_matT.coeffRef(i+1,n-1) = internal::real(cc); + m_matT.coeffRef(i+1,n) = internal::imag(cc); } } // Overflow control - Scalar t = std::max(ei_abs(m_matT.coeff(i,n-1)),ei_abs(m_matT.coeff(i,n))); + Scalar t = std::max(internal::abs(m_matT.coeff(i,n-1)),internal::abs(m_matT.coeff(i,n))); if ((eps * t) * t > 1) m_matT.block(i, n-1, size-i, 2) /= t; diff --git a/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h b/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h index a47a3dc2e..a19e8cf24 100644 --- a/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h +++ b/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h @@ -182,8 +182,8 @@ template GeneralizedSelfAdjointEigenSolver& GeneralizedSelfAdjointEigenSolver:: compute(const MatrixType& matA, const MatrixType& matB, int options) { - ei_assert(matA.cols()==matA.rows() && matB.rows()==matA.rows() && matB.cols()==matB.rows()); - ei_assert((options&~(EigVecMask|GenEigMask))==0 + eigen_assert(matA.cols()==matA.rows() && matB.rows()==matA.rows() && matB.cols()==matB.rows()); + eigen_assert((options&~(EigVecMask|GenEigMask))==0 && (options&EigVecMask)!=EigVecMask && ((options&GenEigMask)==0 || (options&GenEigMask)==Ax_lBx || (options&GenEigMask)==ABx_lx || (options&GenEigMask)==BAx_lx) diff --git a/Eigen/src/Eigenvalues/HessenbergDecomposition.h b/Eigen/src/Eigenvalues/HessenbergDecomposition.h index 79554187a..b7da136a8 100644 --- a/Eigen/src/Eigenvalues/HessenbergDecomposition.h +++ b/Eigen/src/Eigenvalues/HessenbergDecomposition.h @@ -28,11 +28,13 @@ template struct HessenbergDecompositionMatrixHReturnType; +namespace internal { template -struct ei_traits > +struct traits > { typedef MatrixType ReturnType; }; +} /** \eigenvalues_module \ingroup Eigenvalues_Module * @@ -184,7 +186,7 @@ template class HessenbergDecomposition */ const CoeffVectorType& householderCoefficients() const { - ei_assert(m_isInitialized && "HessenbergDecomposition is not initialized."); + eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized."); return m_hCoeffs; } @@ -219,7 +221,7 @@ template class HessenbergDecomposition */ const MatrixType& packedMatrix() const { - ei_assert(m_isInitialized && "HessenbergDecomposition is not initialized."); + eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized."); return m_matrix; } @@ -239,7 +241,7 @@ template class HessenbergDecomposition */ HouseholderSequenceType matrixQ() const { - ei_assert(m_isInitialized && "HessenbergDecomposition is not initialized."); + eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized."); return HouseholderSequenceType(m_matrix, m_hCoeffs.conjugate(), false, m_matrix.rows() - 1, 1); } @@ -265,7 +267,7 @@ template class HessenbergDecomposition */ HessenbergDecompositionMatrixHReturnType matrixH() const { - ei_assert(m_isInitialized && "HessenbergDecomposition is not initialized."); + eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized."); return HessenbergDecompositionMatrixHReturnType(*this); } @@ -319,7 +321,7 @@ void HessenbergDecomposition::_compute(MatrixType& matA, CoeffVector // A = A H' matA.rightCols(remainingSize) - .applyHouseholderOnTheRight(matA.col(i).tail(remainingSize-1).conjugate(), ei_conj(h), &temp.coeffRef(0)); + .applyHouseholderOnTheRight(matA.col(i).tail(remainingSize-1).conjugate(), internal::conj(h), &temp.coeffRef(0)); } } diff --git a/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h b/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h index e517b6e5a..5591519fb 100644 --- a/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h +++ b/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h @@ -26,10 +26,10 @@ #ifndef EIGEN_MATRIXBASEEIGENVALUES_H #define EIGEN_MATRIXBASEEIGENVALUES_H - +namespace internal { template -struct ei_eigenvalues_selector +struct eigenvalues_selector { // this is the implementation for the case IsComplex = true static inline typename MatrixBase::EigenvaluesReturnType const @@ -42,7 +42,7 @@ struct ei_eigenvalues_selector }; template -struct ei_eigenvalues_selector +struct eigenvalues_selector { static inline typename MatrixBase::EigenvaluesReturnType const run(const MatrixBase& m) @@ -53,6 +53,8 @@ struct ei_eigenvalues_selector } }; +} // end namespace internal + /** \brief Computes the eigenvalues of a matrix * \returns Column vector containing the eigenvalues. * @@ -77,8 +79,8 @@ template inline typename MatrixBase::EigenvaluesReturnType MatrixBase::eigenvalues() const { - typedef typename ei_traits::Scalar Scalar; - return ei_eigenvalues_selector::IsComplex>::run(derived()); + typedef typename internal::traits::Scalar Scalar; + return internal::eigenvalues_selector::IsComplex>::run(derived()); } /** \brief Computes the eigenvalues of a matrix @@ -135,7 +137,7 @@ MatrixBase::operatorNorm() const typename Derived::PlainObject m_eval(derived()); // FIXME if it is really guaranteed that the eigenvalues are already sorted, // then we don't need to compute a maxCoeff() here, comparing the 1st and last ones is enough. - return ei_sqrt((m_eval*m_eval.adjoint()) + return internal::sqrt((m_eval*m_eval.adjoint()) .eval() .template selfadjointView() .eigenvalues() diff --git a/Eigen/src/Eigenvalues/RealSchur.h b/Eigen/src/Eigenvalues/RealSchur.h index 1d299d5f6..e250d9a86 100644 --- a/Eigen/src/Eigenvalues/RealSchur.h +++ b/Eigen/src/Eigenvalues/RealSchur.h @@ -137,8 +137,8 @@ template class RealSchur */ const MatrixType& matrixU() const { - ei_assert(m_isInitialized && "RealSchur is not initialized."); - ei_assert(m_matUisUptodate && "The matrix U has not been computed during the RealSchur decomposition."); + eigen_assert(m_isInitialized && "RealSchur is not initialized."); + eigen_assert(m_matUisUptodate && "The matrix U has not been computed during the RealSchur decomposition."); return m_matU; } @@ -154,7 +154,7 @@ template class RealSchur */ const MatrixType& matrixT() const { - ei_assert(m_isInitialized && "RealSchur is not initialized."); + eigen_assert(m_isInitialized && "RealSchur is not initialized."); return m_matT; } @@ -183,7 +183,7 @@ template class RealSchur */ ComputationInfo info() const { - ei_assert(m_isInitialized && "RealSchur is not initialized."); + eigen_assert(m_isInitialized && "RealSchur is not initialized."); return m_info; } @@ -300,10 +300,10 @@ inline typename MatrixType::Index RealSchur::findSmallSubdiagEntry(I Index res = iu; while (res > 0) { - Scalar s = ei_abs(m_matT.coeff(res-1,res-1)) + ei_abs(m_matT.coeff(res,res)); + Scalar s = internal::abs(m_matT.coeff(res-1,res-1)) + internal::abs(m_matT.coeff(res,res)); if (s == 0.0) s = norm; - if (ei_abs(m_matT.coeff(res,res-1)) < NumTraits::epsilon() * s) + if (internal::abs(m_matT.coeff(res,res-1)) < NumTraits::epsilon() * s) break; res--; } @@ -325,7 +325,7 @@ inline void RealSchur::splitOffTwoRows(Index iu, bool computeU, Scal if (q >= 0) // Two real eigenvalues { - Scalar z = ei_sqrt(ei_abs(q)); + Scalar z = internal::sqrt(internal::abs(q)); JacobiRotation rot; if (p >= 0) rot.makeGivens(p + z, m_matT.coeff(iu, iu-1)); @@ -357,7 +357,7 @@ inline void RealSchur::computeShift(Index iu, Index iter, Scalar& ex exshift += shiftInfo.coeff(0); for (Index i = 0; i <= iu; ++i) m_matT.coeffRef(i,i) -= shiftInfo.coeff(0); - Scalar s = ei_abs(m_matT.coeff(iu,iu-1)) + ei_abs(m_matT.coeff(iu-1,iu-2)); + Scalar s = internal::abs(m_matT.coeff(iu,iu-1)) + internal::abs(m_matT.coeff(iu-1,iu-2)); shiftInfo.coeffRef(0) = Scalar(0.75) * s; shiftInfo.coeffRef(1) = Scalar(0.75) * s; shiftInfo.coeffRef(2) = Scalar(-0.4375) * s * s; @@ -370,7 +370,7 @@ inline void RealSchur::computeShift(Index iu, Index iter, Scalar& ex s = s * s + shiftInfo.coeff(2); if (s > 0) { - s = ei_sqrt(s); + s = internal::sqrt(s); if (shiftInfo.coeff(1) < shiftInfo.coeff(0)) s = -s; s = s + (shiftInfo.coeff(1) - shiftInfo.coeff(0)) / Scalar(2.0); @@ -400,9 +400,9 @@ inline void RealSchur::initFrancisQRStep(Index il, Index iu, const V if (im == il) { break; } - const Scalar lhs = m_matT.coeff(im,im-1) * (ei_abs(v.coeff(1)) + ei_abs(v.coeff(2))); - const Scalar rhs = v.coeff(0) * (ei_abs(m_matT.coeff(im-1,im-1)) + ei_abs(Tmm) + ei_abs(m_matT.coeff(im+1,im+1))); - if (ei_abs(lhs) < NumTraits::epsilon() * rhs) + const Scalar lhs = m_matT.coeff(im,im-1) * (internal::abs(v.coeff(1)) + internal::abs(v.coeff(2))); + const Scalar rhs = v.coeff(0) * (internal::abs(m_matT.coeff(im-1,im-1)) + internal::abs(Tmm) + internal::abs(m_matT.coeff(im+1,im+1))); + if (internal::abs(lhs) < NumTraits::epsilon() * rhs) { break; } diff --git a/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h b/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h index d32e223fb..7cef9e529 100644 --- a/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h +++ b/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h @@ -101,7 +101,7 @@ template class SelfAdjointEigenSolver * This is a column vector with entries of type #RealScalar. * The length of the vector is the size of \p _MatrixType. */ - typedef typename ei_plain_col_type::type RealVectorType; + typedef typename internal::plain_col_type::type RealVectorType; typedef Tridiagonalization TridiagonalizationType; /** \brief Default constructor for fixed-size matrices. @@ -219,8 +219,8 @@ template class SelfAdjointEigenSolver */ const MatrixType& eigenvectors() const { - ei_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized."); - ei_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues."); + eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized."); + eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues."); return m_eivec; } @@ -240,7 +240,7 @@ template class SelfAdjointEigenSolver */ const RealVectorType& eigenvalues() const { - ei_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized."); + eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized."); return m_eivalues; } @@ -264,8 +264,8 @@ template class SelfAdjointEigenSolver */ MatrixType operatorSqrt() const { - ei_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized."); - ei_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues."); + eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized."); + eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues."); return m_eivec * m_eivalues.cwiseSqrt().asDiagonal() * m_eivec.adjoint(); } @@ -289,8 +289,8 @@ template class SelfAdjointEigenSolver */ MatrixType operatorInverseSqrt() const { - ei_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized."); - ei_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues."); + eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized."); + eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues."); return m_eivec * m_eivalues.cwiseInverse().cwiseSqrt().asDiagonal() * m_eivec.adjoint(); } @@ -300,7 +300,7 @@ template class SelfAdjointEigenSolver */ ComputationInfo info() const { - ei_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized."); + eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized."); return m_info; } @@ -335,15 +335,17 @@ template class SelfAdjointEigenSolver * Implemented from Golub's "Matrix Computations", algorithm 8.3.2: * "implicit symmetric QR step with Wilkinson shift" */ +namespace internal { template -static void ei_tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n); +static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n); +} template SelfAdjointEigenSolver& SelfAdjointEigenSolver ::compute(const MatrixType& matrix, int options) { - ei_assert(matrix.cols() == matrix.rows()); - ei_assert((options&~(EigVecMask|GenEigMask))==0 + eigen_assert(matrix.cols() == matrix.rows()); + eigen_assert((options&~(EigVecMask|GenEigMask))==0 && (options&EigVecMask)!=EigVecMask && "invalid option parameter"); bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors; @@ -352,7 +354,7 @@ SelfAdjointEigenSolver& SelfAdjointEigenSolver if(n==1) { - m_eivalues.coeffRef(0,0) = ei_real(matrix.coeff(0,0)); + m_eivalues.coeffRef(0,0) = internal::real(matrix.coeff(0,0)); if(computeEigenvectors) m_eivec.setOnes(); m_info = Success; @@ -367,7 +369,7 @@ SelfAdjointEigenSolver& SelfAdjointEigenSolver mat = matrix; m_subdiag.resize(n-1); - ei_tridiagonalization_inplace(mat, diag, m_subdiag, computeEigenvectors); + internal::tridiagonalization_inplace(mat, diag, m_subdiag, computeEigenvectors); Index end = n-1; Index start = 0; @@ -376,7 +378,7 @@ SelfAdjointEigenSolver& SelfAdjointEigenSolver while (end>0) { for (Index i = start; i& SelfAdjointEigenSolver while (start>0 && m_subdiag[start-1]!=0) start--; - ei_tridiagonal_qr_step(diag.data(), m_subdiag.data(), start, end, computeEigenvectors ? m_eivec.data() : (Scalar*)0, n); + internal::tridiagonal_qr_step(diag.data(), m_subdiag.data(), start, end, computeEigenvectors ? m_eivec.data() : (Scalar*)0, n); } if (iter <= m_maxIterations) @@ -427,12 +429,13 @@ SelfAdjointEigenSolver& SelfAdjointEigenSolver return *this; } +namespace internal { template -static void ei_tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n) +static void tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n) { RealScalar td = (diag[end-1] - diag[end])*RealScalar(0.5); - RealScalar e2 = ei_abs2(subdiag[end-1]); - RealScalar mu = diag[end] - e2 / (td + (td>0 ? 1 : -1) * ei_sqrt(td*td + e2)); + RealScalar e2 = abs2(subdiag[end-1]); + RealScalar mu = diag[end] - e2 / (td + (td>0 ? 1 : -1) * sqrt(td*td + e2)); RealScalar x = diag[start] - mu; RealScalar z = subdiag[start]; @@ -468,5 +471,6 @@ static void ei_tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index } } } +} // end namespace internal #endif // EIGEN_SELFADJOINTEIGENSOLVER_H diff --git a/Eigen/src/Eigenvalues/Tridiagonalization.h b/Eigen/src/Eigenvalues/Tridiagonalization.h index 23ae748d4..fac79cf96 100644 --- a/Eigen/src/Eigenvalues/Tridiagonalization.h +++ b/Eigen/src/Eigenvalues/Tridiagonalization.h @@ -26,6 +26,11 @@ #ifndef EIGEN_TRIDIAGONALIZATION_H #define EIGEN_TRIDIAGONALIZATION_H +namespace internal { +template +void tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs); +} + /** \eigenvalues_module \ingroup Eigenvalues_Module * * @@ -78,15 +83,15 @@ template class Tridiagonalization }; typedef Matrix CoeffVectorType; - typedef typename ei_plain_col_type::type DiagonalType; + typedef typename internal::plain_col_type::type DiagonalType; typedef Matrix SubDiagonalType; - typedef typename ei_meta_if::IsComplex, + typedef typename internal::meta_if::IsComplex, typename Diagonal::RealReturnType, Diagonal >::ret DiagonalReturnType; - typedef typename ei_meta_if::IsComplex, + typedef typename internal::meta_if::IsComplex, typename Diagonal< Block,0 >::RealReturnType, Diagonal< @@ -129,7 +134,7 @@ template class Tridiagonalization m_hCoeffs(matrix.cols() > 1 ? matrix.cols()-1 : 1), m_isInitialized(false) { - ei_tridiagonalization_inplace(m_matrix, m_hCoeffs); + internal::tridiagonalization_inplace(m_matrix, m_hCoeffs); m_isInitialized = true; } @@ -154,7 +159,7 @@ template class Tridiagonalization { m_matrix = matrix; m_hCoeffs.resize(matrix.rows()-1, 1); - ei_tridiagonalization_inplace(m_matrix, m_hCoeffs); + internal::tridiagonalization_inplace(m_matrix, m_hCoeffs); m_isInitialized = true; return *this; } @@ -177,7 +182,7 @@ template class Tridiagonalization */ inline CoeffVectorType householderCoefficients() const { - ei_assert(m_isInitialized && "Tridiagonalization is not initialized."); + eigen_assert(m_isInitialized && "Tridiagonalization is not initialized."); return m_hCoeffs; } @@ -214,7 +219,7 @@ template class Tridiagonalization */ inline const MatrixType& packedMatrix() const { - ei_assert(m_isInitialized && "Tridiagonalization is not initialized."); + eigen_assert(m_isInitialized && "Tridiagonalization is not initialized."); return m_matrix; } @@ -235,7 +240,7 @@ template class Tridiagonalization */ HouseholderSequenceType matrixQ() const { - ei_assert(m_isInitialized && "Tridiagonalization is not initialized."); + eigen_assert(m_isInitialized && "Tridiagonalization is not initialized."); return HouseholderSequenceType(m_matrix, m_hCoeffs.conjugate(), false, m_matrix.rows() - 1, 1); } @@ -296,7 +301,7 @@ template const typename Tridiagonalization::DiagonalReturnType Tridiagonalization::diagonal() const { - ei_assert(m_isInitialized && "Tridiagonalization is not initialized."); + eigen_assert(m_isInitialized && "Tridiagonalization is not initialized."); return m_matrix.diagonal(); } @@ -304,7 +309,7 @@ template const typename Tridiagonalization::SubDiagonalReturnType Tridiagonalization::subDiagonal() const { - ei_assert(m_isInitialized && "Tridiagonalization is not initialized."); + eigen_assert(m_isInitialized && "Tridiagonalization is not initialized."); Index n = m_matrix.rows(); return Block(m_matrix, 1, 0, n-1,n-1).diagonal(); } @@ -315,7 +320,7 @@ Tridiagonalization::matrixT() const { // FIXME should this function (and other similar ones) rather take a matrix as argument // and fill it ? (to avoid temporaries) - ei_assert(m_isInitialized && "Tridiagonalization is not initialized."); + eigen_assert(m_isInitialized && "Tridiagonalization is not initialized."); Index n = m_matrix.rows(); MatrixType matT = m_matrix; matT.topRightCorner(n-1, n-1).diagonal() = subDiagonal().template cast().conjugate(); @@ -327,6 +332,8 @@ Tridiagonalization::matrixT() const return matT; } +namespace internal { + /** \internal * Performs a tridiagonal decomposition of the selfadjoint matrix \a matA in-place. * @@ -351,10 +358,10 @@ Tridiagonalization::matrixT() const * \sa Tridiagonalization::packedMatrix() */ template -void ei_tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs) +void tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs) { - ei_assert(matA.rows()==matA.cols()); - ei_assert(matA.rows()==hCoeffs.size()+1); + eigen_assert(matA.rows()==matA.cols()); + eigen_assert(matA.rows()==hCoeffs.size()+1); typedef typename MatrixType::Index Index; typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::RealScalar RealScalar; @@ -371,9 +378,9 @@ void ei_tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs) matA.col(i).coeffRef(i+1) = 1; hCoeffs.tail(n-i-1).noalias() = (matA.bottomRightCorner(remainingSize,remainingSize).template selfadjointView() - * (ei_conj(h) * matA.col(i).tail(remainingSize))); + * (conj(h) * matA.col(i).tail(remainingSize))); - hCoeffs.tail(n-i-1) += (ei_conj(h)*Scalar(-0.5)*(hCoeffs.tail(remainingSize).dot(matA.col(i).tail(remainingSize)))) * matA.col(i).tail(n-i-1); + hCoeffs.tail(n-i-1) += (conj(h)*Scalar(-0.5)*(hCoeffs.tail(remainingSize).dot(matA.col(i).tail(remainingSize)))) * matA.col(i).tail(n-i-1); matA.bottomRightCorner(remainingSize, remainingSize).template selfadjointView() .rankUpdate(matA.col(i).tail(remainingSize), hCoeffs.tail(remainingSize), -1); @@ -387,7 +394,7 @@ void ei_tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs) template::IsComplex> -struct ei_tridiagonalization_inplace_selector; +struct tridiagonalization_inplace_selector; /** \brief Performs a full tridiagonalization in place * @@ -430,19 +437,19 @@ struct ei_tridiagonalization_inplace_selector; * \sa class Tridiagonalization */ template -void ei_tridiagonalization_inplace(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, bool extractQ) +void tridiagonalization_inplace(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, bool extractQ) { typedef typename MatrixType::Index Index; //Index n = mat.rows(); - ei_assert(mat.cols()==mat.rows() && diag.size()==mat.rows() && subdiag.size()==mat.rows()-1); - ei_tridiagonalization_inplace_selector::run(mat, diag, subdiag, extractQ); + eigen_assert(mat.cols()==mat.rows() && diag.size()==mat.rows() && subdiag.size()==mat.rows()-1); + tridiagonalization_inplace_selector::run(mat, diag, subdiag, extractQ); } /** \internal * General full tridiagonalization */ template -struct ei_tridiagonalization_inplace_selector +struct tridiagonalization_inplace_selector { typedef typename Tridiagonalization::CoeffVectorType CoeffVectorType; typedef typename Tridiagonalization::HouseholderSequenceType HouseholderSequenceType; @@ -451,7 +458,7 @@ struct ei_tridiagonalization_inplace_selector static void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, bool extractQ) { CoeffVectorType hCoeffs(mat.cols()-1); - ei_tridiagonalization_inplace(mat,hCoeffs); + tridiagonalization_inplace(mat,hCoeffs); diag = mat.diagonal().real(); subdiag = mat.template diagonal<-1>().real(); if(extractQ) @@ -464,7 +471,7 @@ struct ei_tridiagonalization_inplace_selector * Especially useful for plane fitting. */ template -struct ei_tridiagonalization_inplace_selector +struct tridiagonalization_inplace_selector { typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::RealScalar RealScalar; @@ -473,7 +480,7 @@ struct ei_tridiagonalization_inplace_selector static void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, bool extractQ) { diag[0] = mat(0,0); - RealScalar v1norm2 = ei_abs2(mat(2,0)); + RealScalar v1norm2 = abs2(mat(2,0)); if(v1norm2 == RealScalar(0)) { diag[1] = mat(1,1); @@ -485,7 +492,7 @@ struct ei_tridiagonalization_inplace_selector } else { - RealScalar beta = ei_sqrt(ei_abs2(mat(1,0)) + v1norm2); + RealScalar beta = sqrt(abs2(mat(1,0)) + v1norm2); RealScalar invBeta = RealScalar(1)/beta; Scalar m01 = mat(1,0) * invBeta; Scalar m02 = mat(2,0) * invBeta; @@ -508,16 +515,19 @@ struct ei_tridiagonalization_inplace_selector * Trivial specialization for 1x1 matrices */ template -struct ei_tridiagonalization_inplace_selector +struct tridiagonalization_inplace_selector { typedef typename MatrixType::Scalar Scalar; template static void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType&, bool extractQ) { - diag(0,0) = ei_real(mat(0,0)); + diag(0,0) = real(mat(0,0)); if(extractQ) mat(0,0) = Scalar(1); } }; + +} // end namespace internal + #endif // EIGEN_TRIDIAGONALIZATION_H diff --git a/Eigen/src/Geometry/AlignedBox.h b/Eigen/src/Geometry/AlignedBox.h index 196a4fc72..0497eb301 100644 --- a/Eigen/src/Geometry/AlignedBox.h +++ b/Eigen/src/Geometry/AlignedBox.h @@ -84,7 +84,7 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim) template inline explicit AlignedBox(const MatrixBase& a_p) { - const typename ei_nested::type p(a_p.derived()); + const typename internal::nested::type p(a_p.derived()); m_min = p; m_max = p; } @@ -120,8 +120,8 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim) inline VectorType& max() { return m_max; } /** \returns the center of the box */ - inline const CwiseUnaryOp, - CwiseBinaryOp, VectorType, VectorType> > + inline const CwiseUnaryOp, + CwiseBinaryOp, VectorType, VectorType> > center() const { return (m_min+m_max)/2; } @@ -129,7 +129,7 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim) * Note that this function does not get the same * result for integral or floating scalar types: see */ - inline const CwiseBinaryOp< ei_scalar_difference_op, VectorType, VectorType> sizes() const + inline const CwiseBinaryOp< internal::scalar_difference_op, VectorType, VectorType> sizes() const { return m_max - m_min; } /** \returns the volume of the bounding box */ @@ -140,7 +140,7 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim) * if the length of the diagonal is needed: diagonal().norm() * will provide it. */ - inline CwiseBinaryOp< ei_scalar_difference_op, VectorType, VectorType> diagonal() const + inline CwiseBinaryOp< internal::scalar_difference_op, VectorType, VectorType> diagonal() const { return sizes(); } /** \returns the vertex of the bounding box at the corner defined by @@ -178,10 +178,10 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim) if(!ScalarTraits::IsInteger) { r[d] = m_min[d] + (m_max[d]-m_min[d]) - * ei_random(Scalar(0), Scalar(1)); + * internal::random(Scalar(0), Scalar(1)); } else - r[d] = ei_random(m_min[d], m_max[d]); + r[d] = internal::random(m_min[d], m_max[d]); } return r; } @@ -190,7 +190,7 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim) template inline bool contains(const MatrixBase& a_p) const { - const typename ei_nested::type p(a_p.derived()); + const typename internal::nested::type p(a_p.derived()); return (m_min.array()<=p.array()).all() && (p.array()<=m_max.array()).all(); } @@ -202,7 +202,7 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim) template inline AlignedBox& extend(const MatrixBase& a_p) { - const typename ei_nested::type p(a_p.derived()); + const typename internal::nested::type p(a_p.derived()); m_min = m_min.cwiseMin(p); m_max = m_max.cwiseMax(p); return *this; @@ -236,7 +236,7 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim) template inline AlignedBox& translate(const MatrixBase& a_t) { - const typename ei_nested::type t(a_t.derived()); + const typename internal::nested::type t(a_t.derived()); m_min += t; m_max += t; return *this; @@ -261,14 +261,14 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim) */ template inline NonInteger exteriorDistance(const MatrixBase& p) const - { return ei_sqrt(NonInteger(squaredExteriorDistance(p))); } + { return internal::sqrt(NonInteger(squaredExteriorDistance(p))); } /** \returns the distance between the boxes \a b and \c *this, * and zero if the boxes intersect. * \sa squaredExteriorDistance() */ inline NonInteger exteriorDistance(const AlignedBox& b) const - { return ei_sqrt(NonInteger(squaredExteriorDistance(b))); } + { return internal::sqrt(NonInteger(squaredExteriorDistance(b))); } /** \returns \c *this with scalar type casted to \a NewScalarType * @@ -276,10 +276,10 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim) * then this function smartly returns a const reference to \c *this. */ template - inline typename ei_cast_return_type >::type cast() const { - return typename ei_cast_return_type >::type(*this); } @@ -309,7 +309,7 @@ template template inline Scalar AlignedBox::squaredExteriorDistance(const MatrixBase& a_p) const { - const typename ei_nested::type p(a_p.derived()); + const typename internal::nested::type p(a_p.derived()); Scalar dist2 = 0.; Scalar aux; for (Index k=0; k struct ei_traits > +namespace internal { +template struct traits > { typedef _Scalar Scalar; }; +} template class AngleAxis : public RotationBase,3> @@ -131,8 +133,8 @@ public: * then this function smartly returns a const reference to \c *this. */ template - inline typename ei_cast_return_type >::type cast() const - { return typename ei_cast_return_type >::type(*this); } + inline typename internal::cast_return_type >::type cast() const + { return typename internal::cast_return_type >::type(*this); } /** Copy constructor with scalar type conversion */ template @@ -149,7 +151,7 @@ public: * * \sa MatrixBase::isApprox() */ bool isApprox(const AngleAxis& other, typename NumTraits::Real prec = NumTraits::dummy_precision()) const - { return m_axis.isApprox(other.m_axis, prec) && ei_isApprox(m_angle,other.m_angle, prec); } + { return m_axis.isApprox(other.m_axis, prec) && internal::isApprox(m_angle,other.m_angle, prec); } }; /** \ingroup Geometry_Module @@ -175,7 +177,7 @@ AngleAxis& AngleAxis::operator=(const QuaternionBase::Matrix3 AngleAxis::toRotationMatrix(void) const { Matrix3 res; - Vector3 sin_axis = ei_sin(m_angle) * m_axis; - Scalar c = ei_cos(m_angle); + Vector3 sin_axis = internal::sin(m_angle) * m_axis; + Scalar c = internal::cos(m_angle); Vector3 cos1_axis = (Scalar(1)-c) * m_axis; Scalar tmp; diff --git a/Eigen/src/Geometry/EulerAngles.h b/Eigen/src/Geometry/EulerAngles.h index f2b3f129e..d246a6ebf 100644 --- a/Eigen/src/Geometry/EulerAngles.h +++ b/Eigen/src/Geometry/EulerAngles.h @@ -60,31 +60,31 @@ MatrixBase::eulerAngles(Index a0, Index a1, Index a2) const if (a0==a2) { Scalar s = Vector2(coeff(j,i) , coeff(k,i)).norm(); - res[1] = ei_atan2(s, coeff(i,i)); + res[1] = internal::atan2(s, coeff(i,i)); if (s > epsilon) { - res[0] = ei_atan2(coeff(j,i), coeff(k,i)); - res[2] = ei_atan2(coeff(i,j),-coeff(i,k)); + res[0] = internal::atan2(coeff(j,i), coeff(k,i)); + res[2] = internal::atan2(coeff(i,j),-coeff(i,k)); } else { res[0] = Scalar(0); - res[2] = (coeff(i,i)>0?1:-1)*ei_atan2(-coeff(k,j), coeff(j,j)); + res[2] = (coeff(i,i)>0?1:-1)*internal::atan2(-coeff(k,j), coeff(j,j)); } } else { Scalar c = Vector2(coeff(i,i) , coeff(i,j)).norm(); - res[1] = ei_atan2(-coeff(i,k), c); + res[1] = internal::atan2(-coeff(i,k), c); if (c > epsilon) { - res[0] = ei_atan2(coeff(j,k), coeff(k,k)); - res[2] = ei_atan2(coeff(i,j), coeff(i,i)); + res[0] = internal::atan2(coeff(j,k), coeff(k,k)); + res[2] = internal::atan2(coeff(i,j), coeff(i,i)); } else { res[0] = Scalar(0); - res[2] = (coeff(i,k)>0?1:-1)*ei_atan2(-coeff(k,j), coeff(j,j)); + res[2] = (coeff(i,k)>0?1:-1)*internal::atan2(-coeff(k,j), coeff(j,j)); } } if (!odd) diff --git a/Eigen/src/Geometry/Homogeneous.h b/Eigen/src/Geometry/Homogeneous.h index f05899dc8..c6b387b5b 100644 --- a/Eigen/src/Geometry/Homogeneous.h +++ b/Eigen/src/Geometry/Homogeneous.h @@ -39,13 +39,16 @@ * * \sa MatrixBase::homogeneous() */ + +namespace internal { + template -struct ei_traits > - : ei_traits +struct traits > + : traits { - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_nested::type MatrixTypeNested; - typedef typename ei_unref::type _MatrixTypeNested; + typedef typename traits::StorageKind StorageKind; + typedef typename nested::type MatrixTypeNested; + typedef typename unref::type _MatrixTypeNested; enum { RowsPlusOne = (MatrixType::RowsAtCompileTime != Dynamic) ? int(MatrixType::RowsAtCompileTime) + 1 : Dynamic, @@ -63,8 +66,10 @@ struct ei_traits > }; }; -template struct ei_homogeneous_left_product_impl; -template struct ei_homogeneous_right_product_impl; +template struct homogeneous_left_product_impl; +template struct homogeneous_right_product_impl; + +} // end namespace internal template class Homogeneous : public MatrixBase > @@ -92,38 +97,38 @@ template class Homogeneous } template - inline const ei_homogeneous_right_product_impl + inline const internal::homogeneous_right_product_impl operator* (const MatrixBase& rhs) const { - ei_assert(int(Direction)==Horizontal); - return ei_homogeneous_right_product_impl(m_matrix,rhs.derived()); + eigen_assert(int(Direction)==Horizontal); + return internal::homogeneous_right_product_impl(m_matrix,rhs.derived()); } template friend - inline const ei_homogeneous_left_product_impl + inline const internal::homogeneous_left_product_impl operator* (const MatrixBase& lhs, const Homogeneous& rhs) { - ei_assert(int(Direction)==Vertical); - return ei_homogeneous_left_product_impl(lhs.derived(),rhs.m_matrix); + eigen_assert(int(Direction)==Vertical); + return internal::homogeneous_left_product_impl(lhs.derived(),rhs.m_matrix); } template friend - inline const ei_homogeneous_left_product_impl::AffinePartNested> operator* (const Transform& tr, const Homogeneous& rhs) { - ei_assert(int(Direction)==Vertical); - return ei_homogeneous_left_product_impl::AffinePartNested > + eigen_assert(int(Direction)==Vertical); + return internal::homogeneous_left_product_impl::AffinePartNested > (tr.affine(),rhs.m_matrix); } template friend - inline const ei_homogeneous_left_product_impl::MatrixType> operator* (const Transform& tr, const Homogeneous& rhs) { - ei_assert(int(Direction)==Vertical); - return ei_homogeneous_left_product_impl::MatrixType> + eigen_assert(int(Direction)==Vertical); + return internal::homogeneous_left_product_impl::MatrixType> (tr.matrix(),rhs.m_matrix); } @@ -210,11 +215,13 @@ VectorwiseOp::hnormalized() const Direction==Horizontal ? _expression().cols()-1 : 1)); } +namespace internal { + template -struct ei_traits,Lhs> > +struct traits,Lhs> > { - typedef typename ei_make_proper_matrix_type< - typename ei_traits::Scalar, + typedef typename make_proper_matrix_type< + typename traits::Scalar, Lhs::RowsAtCompileTime, MatrixType::ColsAtCompileTime, MatrixType::PlainObject::Options, @@ -223,12 +230,12 @@ struct ei_traits -struct ei_homogeneous_left_product_impl,Lhs> - : public ReturnByValue,Lhs> > +struct homogeneous_left_product_impl,Lhs> + : public ReturnByValue,Lhs> > { - typedef typename ei_cleantype::type LhsNested; + typedef typename cleantype::type LhsNested; typedef typename MatrixType::Index Index; - ei_homogeneous_left_product_impl(const Lhs& lhs, const MatrixType& rhs) + homogeneous_left_product_impl(const Lhs& lhs, const MatrixType& rhs) : m_lhs(lhs), m_rhs(rhs) {} @@ -251,9 +258,9 @@ struct ei_homogeneous_left_product_impl,Lhs> }; template -struct ei_traits,Rhs> > +struct traits,Rhs> > { - typedef typename ei_make_proper_matrix_type::Scalar, + typedef typename make_proper_matrix_type::Scalar, MatrixType::RowsAtCompileTime, Rhs::ColsAtCompileTime, MatrixType::PlainObject::Options, @@ -262,12 +269,12 @@ struct ei_traits -struct ei_homogeneous_right_product_impl,Rhs> - : public ReturnByValue,Rhs> > +struct homogeneous_right_product_impl,Rhs> + : public ReturnByValue,Rhs> > { - typedef typename ei_cleantype::type RhsNested; + typedef typename cleantype::type RhsNested; typedef typename MatrixType::Index Index; - ei_homogeneous_right_product_impl(const MatrixType& lhs, const Rhs& rhs) + homogeneous_right_product_impl(const MatrixType& lhs, const Rhs& rhs) : m_lhs(lhs), m_rhs(rhs) {} @@ -289,4 +296,6 @@ struct ei_homogeneous_right_product_impl,Rhs> const typename Rhs::Nested m_rhs; }; +} // end namespace internal + #endif // EIGEN_HOMOGENEOUS_H diff --git a/Eigen/src/Geometry/Hyperplane.h b/Eigen/src/Geometry/Hyperplane.h index 7b7d33a92..852aef185 100644 --- a/Eigen/src/Geometry/Hyperplane.h +++ b/Eigen/src/Geometry/Hyperplane.h @@ -139,7 +139,7 @@ public: /** \returns the absolute distance between the plane \c *this and a point \a p. * \sa signedDistance() */ - inline Scalar absDistance(const VectorType& p) const { return ei_abs(signedDistance(p)); } + inline Scalar absDistance(const VectorType& p) const { return internal::abs(signedDistance(p)); } /** \returns the projection of a point \a p onto the plane \c *this. */ @@ -186,9 +186,9 @@ public: Scalar det = coeffs().coeff(0) * other.coeffs().coeff(1) - coeffs().coeff(1) * other.coeffs().coeff(0); // since the line equations ax+by=c are normalized with a^2+b^2=1, the following tests // whether the two lines are approximately parallel. - if(ei_isMuchSmallerThan(det, Scalar(1))) + if(internal::isMuchSmallerThan(det, Scalar(1))) { // special case where the two lines are approximately parallel. Pick any point on the first line. - if(ei_abs(coeffs().coeff(1))>ei_abs(coeffs().coeff(0))) + if(internal::abs(coeffs().coeff(1))>internal::abs(coeffs().coeff(0))) return VectorType(coeffs().coeff(1), -coeffs().coeff(2)/coeffs().coeff(1)-coeffs().coeff(0)); else return VectorType(-coeffs().coeff(2)/coeffs().coeff(0)-coeffs().coeff(1), coeffs().coeff(0)); @@ -216,7 +216,7 @@ public: normal() = mat * normal(); else { - ei_assert("invalid traits value in Hyperplane::transform()"); + eigen_assert("invalid traits value in Hyperplane::transform()"); } return *this; } @@ -242,10 +242,10 @@ public: * then this function smartly returns a const reference to \c *this. */ template - inline typename ei_cast_return_type >::type cast() const { - return typename ei_cast_return_type >::type(*this); } diff --git a/Eigen/src/Geometry/OrthoMethods.h b/Eigen/src/Geometry/OrthoMethods.h index d03d85beb..f4695827d 100644 --- a/Eigen/src/Geometry/OrthoMethods.h +++ b/Eigen/src/Geometry/OrthoMethods.h @@ -43,23 +43,25 @@ MatrixBase::cross(const MatrixBase& other) const // Note that there is no need for an expression here since the compiler // optimize such a small temporary very well (even within a complex expression) - const typename ei_nested::type lhs(derived()); - const typename ei_nested::type rhs(other.derived()); - return typename ei_plain_matrix_type::type( + const typename internal::nested::type lhs(derived()); + const typename internal::nested::type rhs(other.derived()); + return typename internal::plain_matrix_type::type( lhs.coeff(1) * rhs.coeff(2) - lhs.coeff(2) * rhs.coeff(1), lhs.coeff(2) * rhs.coeff(0) - lhs.coeff(0) * rhs.coeff(2), lhs.coeff(0) * rhs.coeff(1) - lhs.coeff(1) * rhs.coeff(0) ); } +namespace internal { + template< int Arch,typename VectorLhs,typename VectorRhs, typename Scalar = typename VectorLhs::Scalar, bool Vectorizable = (VectorLhs::Flags&VectorRhs::Flags)&PacketAccessBit> -struct ei_cross3_impl { - inline static typename ei_plain_matrix_type::type +struct cross3_impl { + inline static typename internal::plain_matrix_type::type run(const VectorLhs& lhs, const VectorRhs& rhs) { - return typename ei_plain_matrix_type::type( + return typename internal::plain_matrix_type::type( lhs.coeff(1) * rhs.coeff(2) - lhs.coeff(2) * rhs.coeff(1), lhs.coeff(2) * rhs.coeff(0) - lhs.coeff(0) * rhs.coeff(2), lhs.coeff(0) * rhs.coeff(1) - lhs.coeff(1) * rhs.coeff(0), @@ -68,6 +70,8 @@ struct ei_cross3_impl { } }; +} + /** \geometry_module * * \returns the cross product of \c *this and \a other using only the x, y, and z coefficients @@ -85,14 +89,14 @@ MatrixBase::cross3(const MatrixBase& other) const EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Derived,4) EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,4) - typedef typename ei_nested::type DerivedNested; - typedef typename ei_nested::type OtherDerivedNested; + typedef typename internal::nested::type DerivedNested; + typedef typename internal::nested::type OtherDerivedNested; const DerivedNested lhs(derived()); const OtherDerivedNested rhs(other.derived()); - return ei_cross3_impl::type, - typename ei_cleantype::type>::run(lhs,rhs); + return internal::cross3_impl::type, + typename internal::cleantype::type>::run(lhs,rhs); } /** \returns a matrix expression of the cross product of each column or row @@ -110,20 +114,20 @@ const typename VectorwiseOp::CrossReturnType VectorwiseOp::cross(const MatrixBase& other) const { EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,3) - EIGEN_STATIC_ASSERT((ei_is_same_type::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type::ret), YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) CrossReturnType res(_expression().rows(),_expression().cols()); if(Direction==Vertical) { - ei_assert(CrossReturnType::RowsAtCompileTime==3 && "the matrix must have exactly 3 rows"); + eigen_assert(CrossReturnType::RowsAtCompileTime==3 && "the matrix must have exactly 3 rows"); res.row(0) = _expression().row(1) * other.coeff(2) - _expression().row(2) * other.coeff(1); res.row(1) = _expression().row(2) * other.coeff(0) - _expression().row(0) * other.coeff(2); res.row(2) = _expression().row(0) * other.coeff(1) - _expression().row(1) * other.coeff(0); } else { - ei_assert(CrossReturnType::ColsAtCompileTime==3 && "the matrix must have exactly 3 columns"); + eigen_assert(CrossReturnType::ColsAtCompileTime==3 && "the matrix must have exactly 3 columns"); res.col(0) = _expression().col(1) * other.coeff(2) - _expression().col(2) * other.coeff(1); res.col(1) = _expression().col(2) * other.coeff(0) - _expression().col(0) * other.coeff(2); res.col(2) = _expression().col(0) * other.coeff(1) - _expression().col(1) * other.coeff(0); @@ -131,11 +135,13 @@ VectorwiseOp::cross(const MatrixBase& ot return res; } +namespace internal { + template -struct ei_unitOrthogonal_selector +struct unitOrthogonal_selector { - typedef typename ei_plain_matrix_type::type VectorType; - typedef typename ei_traits::Scalar Scalar; + typedef typename plain_matrix_type::type VectorType; + typedef typename traits::Scalar Scalar; typedef typename NumTraits::Real RealScalar; typedef typename Derived::Index Index; typedef Matrix Vector2; @@ -148,18 +154,18 @@ struct ei_unitOrthogonal_selector if (maxi==0) sndi = 1; RealScalar invnm = RealScalar(1)/(Vector2() << src.coeff(sndi),src.coeff(maxi)).finished().norm(); - perp.coeffRef(maxi) = -ei_conj(src.coeff(sndi)) * invnm; - perp.coeffRef(sndi) = ei_conj(src.coeff(maxi)) * invnm; + perp.coeffRef(maxi) = -conj(src.coeff(sndi)) * invnm; + perp.coeffRef(sndi) = conj(src.coeff(maxi)) * invnm; return perp; } }; template -struct ei_unitOrthogonal_selector +struct unitOrthogonal_selector { - typedef typename ei_plain_matrix_type::type VectorType; - typedef typename ei_traits::Scalar Scalar; + typedef typename plain_matrix_type::type VectorType; + typedef typename traits::Scalar Scalar; typedef typename NumTraits::Real RealScalar; inline static VectorType run(const Derived& src) { @@ -171,12 +177,12 @@ struct ei_unitOrthogonal_selector /* unless the x and y coords are both close to zero, we can * simply take ( -y, x, 0 ) and normalize it. */ - if((!ei_isMuchSmallerThan(src.x(), src.z())) - || (!ei_isMuchSmallerThan(src.y(), src.z()))) + if((!isMuchSmallerThan(src.x(), src.z())) + || (!isMuchSmallerThan(src.y(), src.z()))) { RealScalar invnm = RealScalar(1)/src.template head<2>().norm(); - perp.coeffRef(0) = -ei_conj(src.y())*invnm; - perp.coeffRef(1) = ei_conj(src.x())*invnm; + perp.coeffRef(0) = -conj(src.y())*invnm; + perp.coeffRef(1) = conj(src.x())*invnm; perp.coeffRef(2) = 0; } /* if both x and y are close to zero, then the vector is close @@ -187,8 +193,8 @@ struct ei_unitOrthogonal_selector { RealScalar invnm = RealScalar(1)/src.template tail<2>().norm(); perp.coeffRef(0) = 0; - perp.coeffRef(1) = -ei_conj(src.z())*invnm; - perp.coeffRef(2) = ei_conj(src.y())*invnm; + perp.coeffRef(1) = -conj(src.z())*invnm; + perp.coeffRef(2) = conj(src.y())*invnm; } return perp; @@ -196,13 +202,15 @@ struct ei_unitOrthogonal_selector }; template -struct ei_unitOrthogonal_selector +struct unitOrthogonal_selector { - typedef typename ei_plain_matrix_type::type VectorType; + typedef typename plain_matrix_type::type VectorType; inline static VectorType run(const Derived& src) - { return VectorType(-ei_conj(src.y()), ei_conj(src.x())).normalized(); } + { return VectorType(-conj(src.y()), conj(src.x())).normalized(); } }; +} // end namespace internal + /** \returns a unit vector which is orthogonal to \c *this * * The size of \c *this must be at least 2. If the size is exactly 2, @@ -215,7 +223,7 @@ typename MatrixBase::PlainObject MatrixBase::unitOrthogonal() const { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) - return ei_unitOrthogonal_selector::run(derived()); + return internal::unitOrthogonal_selector::run(derived()); } #endif // EIGEN_ORTHOMETHODS_H diff --git a/Eigen/src/Geometry/ParametrizedLine.h b/Eigen/src/Geometry/ParametrizedLine.h index 3de23f53b..858cdf6a8 100644 --- a/Eigen/src/Geometry/ParametrizedLine.h +++ b/Eigen/src/Geometry/ParametrizedLine.h @@ -91,7 +91,7 @@ public: /** \returns the distance of a point \a p to its projection onto the line \c *this. * \sa squaredDistance() */ - RealScalar distance(const VectorType& p) const { return ei_sqrt(squaredDistance(p)); } + RealScalar distance(const VectorType& p) const { return internal::sqrt(squaredDistance(p)); } /** \returns the projection of a point \a p onto the line \c *this. */ VectorType projection(const VectorType& p) const @@ -105,10 +105,10 @@ public: * then this function smartly returns a const reference to \c *this. */ template - inline typename ei_cast_return_type >::type cast() const { - return typename ei_cast_return_type >::type(*this); } diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h index c0845653d..ebc720b6c 100644 --- a/Eigen/src/Geometry/Quaternion.h +++ b/Eigen/src/Geometry/Quaternion.h @@ -31,10 +31,12 @@ * The implementation is at the end of the file ***************************************************************************/ +namespace internal { template -struct ei_quaternionbase_assign_impl; +struct quaternionbase_assign_impl; +} template class QuaternionBase : public RotationBase @@ -44,9 +46,9 @@ public: using Base::operator*; using Base::derived; - typedef typename ei_traits::Scalar Scalar; + typedef typename internal::traits::Scalar Scalar; typedef typename NumTraits::Real RealScalar; - typedef typename ei_traits::Coefficients Coefficients; + typedef typename internal::traits::Coefficients Coefficients; // typedef typename Matrix Coefficients; /** the type of a 3D vector */ @@ -83,10 +85,10 @@ public: inline VectorBlock vec() { return coeffs().template head<3>(); } /** \returns a read-only vector expression of the coefficients (x,y,z,w) */ - inline const typename ei_traits::Coefficients& coeffs() const { return derived().coeffs(); } + inline const typename internal::traits::Coefficients& coeffs() const { return derived().coeffs(); } /** \returns a vector expression of the coefficients (x,y,z,w) */ - inline typename ei_traits::Coefficients& coeffs() { return derived().coeffs(); } + inline typename internal::traits::Coefficients& coeffs() { return derived().coeffs(); } EIGEN_STRONG_INLINE QuaternionBase& operator=(const QuaternionBase& other); template EIGEN_STRONG_INLINE Derived& operator=(const QuaternionBase& other); @@ -175,9 +177,9 @@ public: * then this function smartly returns a const reference to \c *this. */ template - inline typename ei_cast_return_type >::type cast() const + inline typename internal::cast_return_type >::type cast() const { - return typename ei_cast_return_type >::type( + return typename internal::cast_return_type >::type( coeffs().template cast()); } @@ -212,8 +214,9 @@ public: * \sa class AngleAxis, class Transform */ +namespace internal { template -struct ei_traits > +struct traits > { typedef Quaternion<_Scalar> PlainObject; typedef _Scalar Scalar; @@ -222,6 +225,7 @@ struct ei_traits > PacketAccess = Aligned }; }; +} template class Quaternion : public QuaternionBase >{ @@ -232,7 +236,7 @@ public: EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Quaternion) using Base::operator*=; - typedef typename ei_traits >::Coefficients Coefficients; + typedef typename internal::traits >::Coefficients Coefficients; typedef typename Base::AngleAxisType AngleAxisType; /** Default constructor leaving the quaternion uninitialized. */ @@ -281,9 +285,10 @@ typedef Quaternion Quaterniond; * Specialization of Map> ***************************************************************************/ +namespace internal { template -struct ei_traits, _PacketAccess> >: -ei_traits > +struct traits, _PacketAccess> >: +traits > { typedef _Scalar Scalar; typedef Map, _PacketAccess> Coefficients; @@ -291,6 +296,7 @@ ei_traits > PacketAccess = _PacketAccess }; }; +} /** \brief Expression of a quaternion from a memory buffer * @@ -310,7 +316,7 @@ class Map, PacketAccess > public: typedef _Scalar Scalar; - typedef typename ei_traits::Coefficients Coefficients; + typedef typename internal::traits::Coefficients Coefficients; EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Map) using Base::operator*=; @@ -348,7 +354,8 @@ typedef Map, Aligned> QuaternionMapAlignedd; // Generic Quaternion * Quaternion product // This product can be specialized for a given architecture via the Arch template argument. -template struct ei_quat_product +namespace internal { +template struct quat_product { EIGEN_STRONG_INLINE static Quaternion run(const QuaternionBase& a, const QuaternionBase& b){ return Quaternion @@ -360,18 +367,19 @@ template template -EIGEN_STRONG_INLINE Quaternion::Scalar> +EIGEN_STRONG_INLINE Quaternion::Scalar> QuaternionBase::operator* (const QuaternionBase& other) const { - EIGEN_STATIC_ASSERT((ei_is_same_type::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type::ret), YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) - return ei_quat_product::Scalar, - ei_traits::PacketAccess && ei_traits::PacketAccess>::run(*this, other); + return internal::quat_product::Scalar, + internal::traits::PacketAccess && internal::traits::PacketAccess>::run(*this, other); } /** \sa operator*(Quaternion) */ @@ -425,8 +433,8 @@ template EIGEN_STRONG_INLINE Derived& QuaternionBase::operator=(const AngleAxisType& aa) { Scalar ha = Scalar(0.5)*aa.angle(); // Scalar(0.5) to suppress precision loss warnings - this->w() = ei_cos(ha); - this->vec() = ei_sin(ha) * aa.axis(); + this->w() = internal::cos(ha); + this->vec() = internal::sin(ha) * aa.axis(); return derived(); } @@ -440,9 +448,9 @@ template template inline Derived& QuaternionBase::operator=(const MatrixBase& xpr) { - EIGEN_STATIC_ASSERT((ei_is_same_type::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type::ret), YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) - ei_quaternionbase_assign_impl::run(*this, xpr.derived()); + internal::quaternionbase_assign_impl::run(*this, xpr.derived()); return derived(); } @@ -519,12 +527,12 @@ inline Derived& QuaternionBase::setFromTwoVectors(const MatrixBasew() = ei_sqrt(w2); - this->vec() = axis * ei_sqrt(Scalar(1) - w2); + this->w() = internal::sqrt(w2); + this->vec() = axis * internal::sqrt(Scalar(1) - w2); return derived(); } Vector3 axis = v0.cross(v1); - Scalar s = ei_sqrt((Scalar(1)+c)*Scalar(2)); + Scalar s = internal::sqrt((Scalar(1)+c)*Scalar(2)); Scalar invs = Scalar(1)/s; this->vec() = axis * invs; this->w() = s * Scalar(0.5); @@ -539,7 +547,7 @@ inline Derived& QuaternionBase::setFromTwoVectors(const MatrixBase -inline Quaternion::Scalar> QuaternionBase::inverse() const +inline Quaternion::Scalar> QuaternionBase::inverse() const { // FIXME should this function be called multiplicativeInverse and conjugate() be called inverse() or opposite() ?? Scalar n2 = this->squaredNorm(); @@ -559,7 +567,7 @@ inline Quaternion::Scalar> QuaternionBase:: * \sa Quaternion2::inverse() */ template -inline Quaternion::Scalar> +inline Quaternion::Scalar> QuaternionBase::conjugate() const { return Quaternion(this->w(),-this->x(),-this->y(),-this->z()); @@ -570,10 +578,10 @@ QuaternionBase::conjugate() const */ template template -inline typename ei_traits::Scalar +inline typename internal::traits::Scalar QuaternionBase::angularDistance(const QuaternionBase& other) const { - double d = ei_abs(this->dot(other)); + double d = internal::abs(this->dot(other)); if (d>=1.0) return Scalar(0); return static_cast(2 * std::acos(d)); @@ -584,12 +592,12 @@ QuaternionBase::angularDistance(const QuaternionBase& oth */ template template -Quaternion::Scalar> +Quaternion::Scalar> QuaternionBase::slerp(Scalar t, const QuaternionBase& other) const { static const Scalar one = Scalar(1) - NumTraits::epsilon(); Scalar d = this->dot(other); - Scalar absD = ei_abs(d); + Scalar absD = internal::abs(d); Scalar scale0; Scalar scale1; @@ -603,10 +611,10 @@ QuaternionBase::slerp(Scalar t, const QuaternionBase& oth { // theta is the angle between the 2 quaternions Scalar theta = std::acos(absD); - Scalar sinTheta = ei_sin(theta); + Scalar sinTheta = internal::sin(theta); - scale0 = ei_sin( ( Scalar(1) - t ) * theta) / sinTheta; - scale1 = ei_sin( ( t * theta) ) / sinTheta; + scale0 = internal::sin( ( Scalar(1) - t ) * theta) / sinTheta; + scale1 = internal::sin( ( t * theta) ) / sinTheta; if (d<0) scale1 = -scale1; } @@ -614,9 +622,11 @@ QuaternionBase::slerp(Scalar t, const QuaternionBase& oth return Quaternion(scale0 * coeffs() + scale1 * other.coeffs()); } +namespace internal { + // set from a rotation matrix template -struct ei_quaternionbase_assign_impl +struct quaternionbase_assign_impl { typedef typename Other::Scalar Scalar; typedef DenseIndex Index; @@ -627,7 +637,7 @@ struct ei_quaternionbase_assign_impl Scalar t = mat.trace(); if (t > Scalar(0)) { - t = ei_sqrt(t + Scalar(1.0)); + t = sqrt(t + Scalar(1.0)); q.w() = Scalar(0.5)*t; t = Scalar(0.5)/t; q.x() = (mat.coeff(2,1) - mat.coeff(1,2)) * t; @@ -644,7 +654,7 @@ struct ei_quaternionbase_assign_impl DenseIndex j = (i+1)%3; DenseIndex k = (j+1)%3; - t = ei_sqrt(mat.coeff(i,i)-mat.coeff(j,j)-mat.coeff(k,k) + Scalar(1.0)); + t = sqrt(mat.coeff(i,i)-mat.coeff(j,j)-mat.coeff(k,k) + Scalar(1.0)); q.coeffs().coeffRef(i) = Scalar(0.5) * t; t = Scalar(0.5)/t; q.w() = (mat.coeff(k,j)-mat.coeff(j,k))*t; @@ -656,7 +666,7 @@ struct ei_quaternionbase_assign_impl // set from a vector of coefficients assumed to be a quaternion template -struct ei_quaternionbase_assign_impl +struct quaternionbase_assign_impl { typedef typename Other::Scalar Scalar; template inline static void run(QuaternionBase& q, const Other& vec) @@ -665,5 +675,6 @@ struct ei_quaternionbase_assign_impl } }; +} // end namespace internal #endif // EIGEN_QUATERNION_H diff --git a/Eigen/src/Geometry/Rotation2D.h b/Eigen/src/Geometry/Rotation2D.h index c65b4b6e0..e1214bd3e 100644 --- a/Eigen/src/Geometry/Rotation2D.h +++ b/Eigen/src/Geometry/Rotation2D.h @@ -41,10 +41,14 @@ * * \sa class Quaternion, class Transform */ -template struct ei_traits > + +namespace internal { + +template struct traits > { typedef _Scalar Scalar; }; +} // end namespace internal template class Rotation2D : public RotationBase,2> @@ -107,8 +111,8 @@ public: * then this function smartly returns a const reference to \c *this. */ template - inline typename ei_cast_return_type >::type cast() const - { return typename ei_cast_return_type >::type(*this); } + inline typename internal::cast_return_type >::type cast() const + { return typename internal::cast_return_type >::type(*this); } /** Copy constructor with scalar type conversion */ template @@ -124,7 +128,7 @@ public: * * \sa MatrixBase::isApprox() */ bool isApprox(const Rotation2D& other, typename NumTraits::Real prec = NumTraits::dummy_precision()) const - { return ei_isApprox(m_angle,other.m_angle, prec); } + { return internal::isApprox(m_angle,other.m_angle, prec); } }; /** \ingroup Geometry_Module @@ -143,7 +147,7 @@ template Rotation2D& Rotation2D::fromRotationMatrix(const MatrixBase& mat) { EIGEN_STATIC_ASSERT(Derived::RowsAtCompileTime==2 && Derived::ColsAtCompileTime==2,YOU_MADE_A_PROGRAMMING_MISTAKE) - m_angle = ei_atan2(mat.coeff(1,0), mat.coeff(0,0)); + m_angle = internal::atan2(mat.coeff(1,0), mat.coeff(0,0)); return *this; } @@ -153,8 +157,8 @@ template typename Rotation2D::Matrix2 Rotation2D::toRotationMatrix(void) const { - Scalar sinA = ei_sin(m_angle); - Scalar cosA = ei_cos(m_angle); + Scalar sinA = internal::sin(m_angle); + Scalar cosA = internal::cos(m_angle); return (Matrix2() << cosA, -sinA, sinA, cosA).finished(); } diff --git a/Eigen/src/Geometry/RotationBase.h b/Eigen/src/Geometry/RotationBase.h index 181e65be9..65b9cd834 100644 --- a/Eigen/src/Geometry/RotationBase.h +++ b/Eigen/src/Geometry/RotationBase.h @@ -26,8 +26,10 @@ #define EIGEN_ROTATIONBASE_H // forward declaration +namespace internal { template -struct ei_rotation_base_generic_product_selector; +struct rotation_base_generic_product_selector; +} /** \class RotationBase * @@ -42,7 +44,7 @@ class RotationBase public: enum { Dim = _Dim }; /** the scalar type of the coefficients */ - typedef typename ei_traits::Scalar Scalar; + typedef typename internal::traits::Scalar Scalar; /** corresponding linear transformation matrix type */ typedef Matrix RotationMatrixType; @@ -78,9 +80,9 @@ class RotationBase * - a vector of size Dim */ template - EIGEN_STRONG_INLINE typename ei_rotation_base_generic_product_selector::ReturnType + EIGEN_STRONG_INLINE typename internal::rotation_base_generic_product_selector::ReturnType operator*(const EigenBase& e) const - { return ei_rotation_base_generic_product_selector::run(derived(), e.derived()); } + { return internal::rotation_base_generic_product_selector::run(derived(), e.derived()); } /** \returns the concatenation of a linear transformation \a l with the rotation \a r */ template friend @@ -105,9 +107,11 @@ class RotationBase { return toRotationMatrix() * v; } }; +namespace internal { + // implementation of the generic product rotation * matrix template -struct ei_rotation_base_generic_product_selector +struct rotation_base_generic_product_selector { enum { Dim = RotationDerived::Dim }; typedef Matrix ReturnType; @@ -116,7 +120,7 @@ struct ei_rotation_base_generic_product_selector -struct ei_rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix, false > +struct rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix, false > { typedef Transform ReturnType; inline static ReturnType run(const RotationDerived& r, const DiagonalMatrix& m) @@ -128,7 +132,7 @@ struct ei_rotation_base_generic_product_selector< RotationDerived, DiagonalMatri }; template -struct ei_rotation_base_generic_product_selector +struct rotation_base_generic_product_selector { enum { Dim = RotationDerived::Dim }; typedef Matrix ReturnType; @@ -138,6 +142,8 @@ struct ei_rotation_base_generic_product_selector return *this = r.toRotationMatrix(); } +namespace internal { + /** \internal * * Helper function to return an arbitrary rotation object to a rotation matrix. @@ -179,29 +187,31 @@ Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols> * - any matrix expression, * - any type based on RotationBase (e.g., Quaternion, AngleAxis, Rotation2D) * - * Currently ei_toRotationMatrix is only used by Transform. + * Currently toRotationMatrix is only used by Transform. * * \sa class Transform, class Rotation2D, class Quaternion, class AngleAxis */ template -inline static Matrix ei_toRotationMatrix(const Scalar& s) +inline static Matrix toRotationMatrix(const Scalar& s) { EIGEN_STATIC_ASSERT(Dim==2,YOU_MADE_A_PROGRAMMING_MISTAKE) return Rotation2D(s).toRotationMatrix(); } template -inline static Matrix ei_toRotationMatrix(const RotationBase& r) +inline static Matrix toRotationMatrix(const RotationBase& r) { return r.toRotationMatrix(); } template -inline static const MatrixBase& ei_toRotationMatrix(const MatrixBase& mat) +inline static const MatrixBase& toRotationMatrix(const MatrixBase& mat) { EIGEN_STATIC_ASSERT(OtherDerived::RowsAtCompileTime==Dim && OtherDerived::ColsAtCompileTime==Dim, YOU_MADE_A_PROGRAMMING_MISTAKE) return mat; } +} // end namespace internal + #endif // EIGEN_ROTATIONBASE_H diff --git a/Eigen/src/Geometry/Scaling.h b/Eigen/src/Geometry/Scaling.h index 8fdbdb102..2d2871d19 100644 --- a/Eigen/src/Geometry/Scaling.h +++ b/Eigen/src/Geometry/Scaling.h @@ -78,7 +78,7 @@ public: /** Concatenates a uniform scaling and a linear transformation matrix */ // TODO returns an expression template - inline typename ei_plain_matrix_type::type operator* (const MatrixBase& other) const + inline typename internal::plain_matrix_type::type operator* (const MatrixBase& other) const { return other * m_factor; } template @@ -108,7 +108,7 @@ public: * * \sa MatrixBase::isApprox() */ bool isApprox(const UniformScaling& other, typename NumTraits::Real prec = NumTraits::dummy_precision()) const - { return ei_isApprox(m_factor, other.factor(), prec); } + { return internal::isApprox(m_factor, other.factor(), prec); } }; diff --git a/Eigen/src/Geometry/Transform.h b/Eigen/src/Geometry/Transform.h index e8099495d..b2ed121b6 100644 --- a/Eigen/src/Geometry/Transform.h +++ b/Eigen/src/Geometry/Transform.h @@ -27,8 +27,10 @@ #ifndef EIGEN_TRANSFORM_H #define EIGEN_TRANSFORM_H +namespace internal { + template -struct ei_transform_traits +struct transform_traits { enum { @@ -41,8 +43,8 @@ struct ei_transform_traits template< typename TransformType, typename MatrixType, - bool IsProjective = ei_transform_traits::IsProjective> -struct ei_transform_right_product_impl; + bool IsProjective = transform_traits::IsProjective> +struct transform_right_product_impl; template< typename Other, int Mode, @@ -50,14 +52,14 @@ template< typename Other, int HDim, int OtherRows=Other::RowsAtCompileTime, int OtherCols=Other::ColsAtCompileTime> -struct ei_transform_left_product_impl; +struct transform_left_product_impl; template< typename Lhs, typename Rhs, bool AnyProjective = - ei_transform_traits::IsProjective || - ei_transform_traits::IsProjective> -struct ei_transform_transform_product_impl; + transform_traits::IsProjective || + transform_traits::IsProjective> +struct transform_transform_product_impl; template< typename Other, int Mode, @@ -65,9 +67,11 @@ template< typename Other, int HDim, int OtherRows=Other::RowsAtCompileTime, int OtherCols=Other::ColsAtCompileTime> -struct ei_transform_construct_from_matrix; +struct transform_construct_from_matrix; + +template struct transform_take_affine_part; -template struct ei_transform_take_affine_part; +} // end namespace internal /** \geometry_module \ingroup Geometry_Module * @@ -194,11 +198,11 @@ public: /** type of read/write reference to the linear part of the transformation */ typedef Block LinearPart; /** type of read/write reference to the affine part of the transformation */ - typedef typename ei_meta_if >::ret AffinePart; /** type of read/write reference to the affine part of the transformation */ - typedef typename ei_meta_if >::ret AffinePartNested; /** type of a vector */ @@ -235,20 +239,20 @@ public: inline Transform& operator=(const Transform& other) { m_matrix = other.m_matrix; return *this; } - typedef ei_transform_take_affine_part take_affine_part; + typedef internal::transform_take_affine_part take_affine_part; /** Constructs and initializes a transformation from a Dim^2 or a (Dim+1)^2 matrix. */ template inline explicit Transform(const EigenBase& other) { - ei_transform_construct_from_matrix::run(this, other.derived()); + internal::transform_construct_from_matrix::run(this, other.derived()); } /** Set \c *this from a Dim^2 or (Dim+1)^2 matrix. */ template inline Transform& operator=(const EigenBase& other) { - ei_transform_construct_from_matrix::run(this, other.derived()); + internal::transform_construct_from_matrix::run(this, other.derived()); return *this; } @@ -280,7 +284,7 @@ public: else if(OtherModeIsAffineCompact) { typedef typename Transform::MatrixType OtherMatrixType; - ei_transform_construct_from_matrix::run(this, other.matrix()); + internal::transform_construct_from_matrix::run(this, other.matrix()); } else { @@ -354,9 +358,9 @@ public: */ // note: this function is defined here because some compilers cannot find the respective declaration template - EIGEN_STRONG_INLINE const typename ei_transform_right_product_impl::ResultType + EIGEN_STRONG_INLINE const typename internal::transform_right_product_impl::ResultType operator * (const EigenBase &other) const - { return ei_transform_right_product_impl::run(*this,other.derived()); } + { return internal::transform_right_product_impl::run(*this,other.derived()); } /** \returns the product expression of a transformation matrix \a a times a transform \a b * @@ -366,9 +370,9 @@ public: * \li a general transformation matrix of size Dim+1 x Dim+1. */ template friend - inline const typename ei_transform_left_product_impl::ResultType + inline const typename internal::transform_left_product_impl::ResultType operator * (const EigenBase &a, const Transform &b) - { return ei_transform_left_product_impl::run(a.derived(),b); } + { return internal::transform_left_product_impl::run(a.derived(),b); } /** \returns The product expression of a transform \a a times a diagonal matrix \a b * @@ -407,16 +411,16 @@ public: /** Concatenates two transformations */ inline const Transform operator * (const Transform& other) const { - return ei_transform_transform_product_impl::run(*this,other); + return internal::transform_transform_product_impl::run(*this,other); } /** Concatenates two different transformations */ template - inline const typename ei_transform_transform_product_impl< + inline const typename internal::transform_transform_product_impl< Transform,Transform >::ResultType operator * (const Transform& other) const { - return ei_transform_transform_product_impl >::run(*this,other); + return internal::transform_transform_product_impl >::run(*this,other); } /** \sa MatrixBase::setIdentity() */ @@ -495,8 +499,8 @@ public: * then this function smartly returns a const reference to \c *this. */ template - inline typename ei_cast_return_type >::type cast() const - { return typename ei_cast_return_type >::type(*this); } + inline typename internal::cast_return_type >::type cast() const + { return typename internal::cast_return_type >::type(*this); } /** Copy constructor with scalar type conversion */ template @@ -765,7 +769,7 @@ Transform::pretranslate(const MatrixBase &other) * to \c *this and returns a reference to \c *this. * * The template parameter \a RotationType is the type of the rotation which - * must be known by ei_toRotationMatrix<>. + * must be known by internal::toRotationMatrix<>. * * Natively supported types includes: * - any scalar (2D), @@ -783,7 +787,7 @@ template Transform& Transform::rotate(const RotationType& rotation) { - linearExt() *= ei_toRotationMatrix(rotation); + linearExt() *= internal::toRotationMatrix(rotation); return *this; } @@ -799,7 +803,7 @@ template Transform& Transform::prerotate(const RotationType& rotation) { - m_matrix.template block(0,0) = ei_toRotationMatrix(rotation) + m_matrix.template block(0,0) = internal::toRotationMatrix(rotation) * m_matrix.template block(0,0); return *this; } @@ -877,7 +881,7 @@ template template inline Transform& Transform::operator=(const RotationBase& r) { - linear() = ei_toRotationMatrix(r); + linear() = internal::toRotationMatrix(r); translation().setZero(); makeAffine(); return *this; @@ -980,23 +984,25 @@ Transform& Transform::fromPositionOrientationScale(const MatrixBase &position, const OrientationType& orientation, const MatrixBase &scale) { - linear() = ei_toRotationMatrix(orientation); + linear() = internal::toRotationMatrix(orientation); linear() *= scale.asDiagonal(); translation() = position; makeAffine(); return *this; } +namespace internal { + // selector needed to avoid taking the inverse of a 3x4 matrix template -struct ei_projective_transform_inverse +struct projective_transform_inverse { static inline void run(const TransformType&, TransformType&) {} }; template -struct ei_projective_transform_inverse +struct projective_transform_inverse { static inline void run(const TransformType& m, TransformType& res) { @@ -1004,6 +1010,8 @@ struct ei_projective_transform_inverse } }; +} // end namespace internal + /** * @@ -1031,7 +1039,7 @@ Transform::inverse(TransformTraits hint) const Transform res; if (hint == Projective) { - ei_projective_transform_inverse::run(*this, res); + internal::projective_transform_inverse::run(*this, res); } else { @@ -1045,7 +1053,7 @@ Transform::inverse(TransformTraits hint) const } else { - ei_assert(false && "Invalid transform traits in Transform::Inverse"); + eigen_assert(false && "Invalid transform traits in Transform::Inverse"); } // translation and remaining parts res.matrix().template topRightCorner() @@ -1055,11 +1063,13 @@ Transform::inverse(TransformTraits hint) const return res; } +namespace internal { + /***************************************************** *** Specializations of take affine part *** *****************************************************/ -template struct ei_transform_take_affine_part { +template struct transform_take_affine_part { typedef typename TransformType::MatrixType MatrixType; typedef typename TransformType::AffinePart AffinePart; static inline AffinePart run(MatrixType& m) @@ -1069,7 +1079,7 @@ template struct ei_transform_take_affine_part { }; template -struct ei_transform_take_affine_part > { +struct transform_take_affine_part > { typedef typename Transform::MatrixType MatrixType; static inline MatrixType& run(MatrixType& m) { return m; } static inline const MatrixType& run(const MatrixType& m) { return m; } @@ -1080,7 +1090,7 @@ struct ei_transform_take_affine_part > { *****************************************************/ template -struct ei_transform_construct_from_matrix +struct transform_construct_from_matrix { static inline void run(Transform *transform, const Other& other) { @@ -1091,7 +1101,7 @@ struct ei_transform_construct_from_matrix }; template -struct ei_transform_construct_from_matrix +struct transform_construct_from_matrix { static inline void run(Transform *transform, const Other& other) { @@ -1101,14 +1111,14 @@ struct ei_transform_construct_from_matrix }; template -struct ei_transform_construct_from_matrix +struct transform_construct_from_matrix { static inline void run(Transform *transform, const Other& other) { transform->matrix() = other; } }; template -struct ei_transform_construct_from_matrix +struct transform_construct_from_matrix { static inline void run(Transform *transform, const Other& other) { transform->matrix() = other.template block(0,0); } @@ -1119,7 +1129,7 @@ struct ei_transform_construct_from_matrix -struct ei_transform_product_result +struct transform_product_result { enum { @@ -1132,7 +1142,7 @@ struct ei_transform_product_result }; template< typename TransformType, typename MatrixType > -struct ei_transform_right_product_impl< TransformType, MatrixType, true > +struct transform_right_product_impl< TransformType, MatrixType, true > { typedef typename MatrixType::PlainObject ResultType; @@ -1143,7 +1153,7 @@ struct ei_transform_right_product_impl< TransformType, MatrixType, true > }; template< typename TransformType, typename MatrixType > -struct ei_transform_right_product_impl< TransformType, MatrixType, false > +struct transform_right_product_impl< TransformType, MatrixType, false > { enum { Dim = TransformType::Dim, @@ -1181,7 +1191,7 @@ struct ei_transform_right_product_impl< TransformType, MatrixType, false > // generic HDim x HDim matrix * T => Projective template -struct ei_transform_left_product_impl +struct transform_left_product_impl { typedef Transform TransformType; typedef typename TransformType::MatrixType MatrixType; @@ -1192,7 +1202,7 @@ struct ei_transform_left_product_impl // generic HDim x HDim matrix * AffineCompact => Projective template -struct ei_transform_left_product_impl +struct transform_left_product_impl { typedef Transform TransformType; typedef typename TransformType::MatrixType MatrixType; @@ -1208,7 +1218,7 @@ struct ei_transform_left_product_impl // affine matrix * T template -struct ei_transform_left_product_impl +struct transform_left_product_impl { typedef Transform TransformType; typedef typename TransformType::MatrixType MatrixType; @@ -1224,7 +1234,7 @@ struct ei_transform_left_product_impl // affine matrix * AffineCompact template -struct ei_transform_left_product_impl +struct transform_left_product_impl { typedef Transform TransformType; typedef typename TransformType::MatrixType MatrixType; @@ -1240,7 +1250,7 @@ struct ei_transform_left_product_impl // linear matrix * T template -struct ei_transform_left_product_impl +struct transform_left_product_impl { typedef Transform TransformType; typedef typename TransformType::MatrixType MatrixType; @@ -1261,9 +1271,9 @@ struct ei_transform_left_product_impl **********************************************************/ template -struct ei_transform_transform_product_impl,Transform,false > +struct transform_transform_product_impl,Transform,false > { - enum { ResultMode = ei_transform_product_result::Mode }; + enum { ResultMode = transform_product_result::Mode }; typedef Transform Lhs; typedef Transform Rhs; typedef Transform ResultType; @@ -1278,7 +1288,7 @@ struct ei_transform_transform_product_impl,Transfo }; template -struct ei_transform_transform_product_impl,Transform,true > +struct transform_transform_product_impl,Transform,true > { typedef Transform Lhs; typedef Transform Rhs; @@ -1289,4 +1299,6 @@ struct ei_transform_transform_product_impl,Transfo } }; +} // end namespace internal + #endif // EIGEN_TRANSFORM_H diff --git a/Eigen/src/Geometry/Translation.h b/Eigen/src/Geometry/Translation.h index 59d3e4a41..f442d825e 100644 --- a/Eigen/src/Geometry/Translation.h +++ b/Eigen/src/Geometry/Translation.h @@ -66,14 +66,14 @@ public: /** */ inline Translation(const Scalar& sx, const Scalar& sy) { - ei_assert(Dim==2); + eigen_assert(Dim==2); m_coeffs.x() = sx; m_coeffs.y() = sy; } /** */ inline Translation(const Scalar& sx, const Scalar& sy, const Scalar& sz) { - ei_assert(Dim==3); + eigen_assert(Dim==3); m_coeffs.x() = sx; m_coeffs.y() = sy; m_coeffs.z() = sz; @@ -161,8 +161,8 @@ public: * then this function smartly returns a const reference to \c *this. */ template - inline typename ei_cast_return_type >::type cast() const - { return typename ei_cast_return_type >::type(*this); } + inline typename internal::cast_return_type >::type cast() const + { return typename internal::cast_return_type >::type(*this); } /** Copy constructor with scalar type conversion */ template diff --git a/Eigen/src/Geometry/Umeyama.h b/Eigen/src/Geometry/Umeyama.h index 04449f623..c34eb1a98 100644 --- a/Eigen/src/Geometry/Umeyama.h +++ b/Eigen/src/Geometry/Umeyama.h @@ -36,30 +36,31 @@ // These helpers are required since it allows to use mixed types as parameters // for the Umeyama. The problem with mixed parameters is that the return type // cannot trivially be deduced when float and double types are mixed. -namespace +namespace internal { + +// Compile time return type deduction for different MatrixBase types. +// Different means here different alignment and parameters but the same underlying +// real scalar type. +template +struct umeyama_transform_matrix_type { - // Compile time return type deduction for different MatrixBase types. - // Different means here different alignment and parameters but the same underlying - // real scalar type. - template - struct ei_umeyama_transform_matrix_type - { - enum { - MinRowsAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(MatrixType::RowsAtCompileTime, OtherMatrixType::RowsAtCompileTime), - - // When possible we want to choose some small fixed size value since the result - // is likely to fit on the stack. So here, EIGEN_SIZE_MIN_PREFER_DYNAMIC is not what we want. - HomogeneousDimension = int(MinRowsAtCompileTime) == Dynamic ? Dynamic : int(MinRowsAtCompileTime)+1 - }; - - typedef Matrix::Scalar, - HomogeneousDimension, - HomogeneousDimension, - AutoAlign | (ei_traits::Flags & RowMajorBit ? RowMajor : ColMajor), - HomogeneousDimension, - HomogeneousDimension - > type; + enum { + MinRowsAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(MatrixType::RowsAtCompileTime, OtherMatrixType::RowsAtCompileTime), + + // When possible we want to choose some small fixed size value since the result + // is likely to fit on the stack. So here, EIGEN_SIZE_MIN_PREFER_DYNAMIC is not what we want. + HomogeneousDimension = int(MinRowsAtCompileTime) == Dynamic ? Dynamic : int(MinRowsAtCompileTime)+1 }; + + typedef Matrix::Scalar, + HomogeneousDimension, + HomogeneousDimension, + AutoAlign | (traits::Flags & RowMajorBit ? RowMajor : ColMajor), + HomogeneousDimension, + HomogeneousDimension + > type; +}; + } #endif @@ -103,23 +104,23 @@ namespace * Eigen::Matrix. */ template -typename ei_umeyama_transform_matrix_type::type +typename internal::umeyama_transform_matrix_type::type umeyama(const MatrixBase& src, const MatrixBase& dst, bool with_scaling = true) { - typedef typename ei_umeyama_transform_matrix_type::type TransformationMatrixType; - typedef typename ei_traits::Scalar Scalar; + typedef typename internal::umeyama_transform_matrix_type::type TransformationMatrixType; + typedef typename internal::traits::Scalar Scalar; typedef typename NumTraits::Real RealScalar; typedef typename Derived::Index Index; EIGEN_STATIC_ASSERT(!NumTraits::IsComplex, NUMERIC_TYPE_MUST_BE_REAL) - EIGEN_STATIC_ASSERT((ei_is_same_type::Scalar>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type::Scalar>::ret), YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) enum { Dimension = EIGEN_SIZE_MIN_PREFER_DYNAMIC(Derived::RowsAtCompileTime, OtherDerived::RowsAtCompileTime) }; typedef Matrix VectorType; typedef Matrix MatrixType; - typedef typename ei_plain_matrix_type_row_major::type RowMajorMatrixType; + typedef typename internal::plain_matrix_type_row_major::type RowMajorMatrixType; const Index m = src.rows(); // dimension const Index n = src.cols(); // number of measurements @@ -152,7 +153,7 @@ umeyama(const MatrixBase& src, const MatrixBase& dst, boo // Eq. (40) and (43) const VectorType& d = svd.singularValues(); - Index rank = 0; for (Index i=0; i 0 ) { Rt.block(0,0,m,m).noalias() = svd.matrixU()*svd.matrixV().transpose(); diff --git a/Eigen/src/Geometry/arch/Geometry_SSE.h b/Eigen/src/Geometry/arch/Geometry_SSE.h index 7d82be694..cbe695c72 100644 --- a/Eigen/src/Geometry/arch/Geometry_SSE.h +++ b/Eigen/src/Geometry/arch/Geometry_SSE.h @@ -26,8 +26,10 @@ #ifndef EIGEN_GEOMETRY_SSE_H #define EIGEN_GEOMETRY_SSE_H +namespace internal { + template -struct ei_quat_product +struct quat_product { inline static Quaternion run(const QuaternionBase& _a, const QuaternionBase& _b) { @@ -35,31 +37,31 @@ struct ei_quat_product Quaternion res; __m128 a = _a.coeffs().template packet(0); __m128 b = _b.coeffs().template packet(0); - __m128 flip1 = _mm_xor_ps(_mm_mul_ps(ei_vec4f_swizzle1(a,1,2,0,2), - ei_vec4f_swizzle1(b,2,0,1,2)),mask); - __m128 flip2 = _mm_xor_ps(_mm_mul_ps(ei_vec4f_swizzle1(a,3,3,3,1), - ei_vec4f_swizzle1(b,0,1,2,1)),mask); - ei_pstore(&res.x(), - _mm_add_ps(_mm_sub_ps(_mm_mul_ps(a,ei_vec4f_swizzle1(b,3,3,3,3)), - _mm_mul_ps(ei_vec4f_swizzle1(a,2,0,1,0), - ei_vec4f_swizzle1(b,1,2,0,0))), + __m128 flip1 = _mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a,1,2,0,2), + vec4f_swizzle1(b,2,0,1,2)),mask); + __m128 flip2 = _mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a,3,3,3,1), + vec4f_swizzle1(b,0,1,2,1)),mask); + pstore(&res.x(), + _mm_add_ps(_mm_sub_ps(_mm_mul_ps(a,vec4f_swizzle1(b,3,3,3,3)), + _mm_mul_ps(vec4f_swizzle1(a,2,0,1,0), + vec4f_swizzle1(b,1,2,0,0))), _mm_add_ps(flip1,flip2))); return res; } }; template -struct ei_cross3_impl +struct cross3_impl { - inline static typename ei_plain_matrix_type::type + inline static typename plain_matrix_type::type run(const VectorLhs& lhs, const VectorRhs& rhs) { __m128 a = lhs.template packet(0); __m128 b = rhs.template packet(0); - __m128 mul1=_mm_mul_ps(ei_vec4f_swizzle1(a,1,2,0,3),ei_vec4f_swizzle1(b,2,0,1,3)); - __m128 mul2=_mm_mul_ps(ei_vec4f_swizzle1(a,2,0,1,3),ei_vec4f_swizzle1(b,1,2,0,3)); - typename ei_plain_matrix_type::type res; - ei_pstore(&res.x(),_mm_sub_ps(mul1,mul2)); + __m128 mul1=_mm_mul_ps(vec4f_swizzle1(a,1,2,0,3),vec4f_swizzle1(b,2,0,1,3)); + __m128 mul2=_mm_mul_ps(vec4f_swizzle1(a,2,0,1,3),vec4f_swizzle1(b,1,2,0,3)); + typename plain_matrix_type::type res; + pstore(&res.x(),_mm_sub_ps(mul1,mul2)); return res; } }; @@ -68,7 +70,7 @@ struct ei_cross3_impl template -struct ei_quat_product +struct quat_product { inline static Quaternion run(const QuaternionBase& _a, const QuaternionBase& _b) { @@ -79,10 +81,10 @@ struct ei_quat_product(0); Packet2d b_zw = _b.coeffs().template packet(2); - Packet2d a_xx = ei_pset1(a[0]); - Packet2d a_yy = ei_pset1(a[1]); - Packet2d a_zz = ei_pset1(a[2]); - Packet2d a_ww = ei_pset1(a[3]); + Packet2d a_xx = pset1(a[0]); + Packet2d a_yy = pset1(a[1]); + Packet2d a_zz = pset1(a[2]); + Packet2d a_ww = pset1(a[3]); // two temporaries: Packet2d t1, t2; @@ -92,13 +94,13 @@ struct ei_quat_product -void ei_make_block_householder_triangular_factor(TriangularFactorType& triFactor, const VectorsType& vectors, const CoeffsType& hCoeffs) +void make_block_householder_triangular_factor(TriangularFactorType& triFactor, const VectorsType& vectors, const CoeffsType& hCoeffs) { typedef typename TriangularFactorType::Index Index; typedef typename VectorsType::Scalar Scalar; const Index nbVecs = vectors.cols(); - ei_assert(triFactor.rows() == nbVecs && triFactor.cols() == nbVecs && vectors.rows()>=nbVecs); + eigen_assert(triFactor.rows() == nbVecs && triFactor.cols() == nbVecs && vectors.rows()>=nbVecs); for(Index i = 0; i < nbVecs; i++) { @@ -54,13 +56,13 @@ void ei_make_block_householder_triangular_factor(TriangularFactorType& triFactor /** \internal */ template -void ei_apply_block_householder_on_the_left(MatrixType& mat, const VectorsType& vectors, const CoeffsType& hCoeffs) +void apply_block_householder_on_the_left(MatrixType& mat, const VectorsType& vectors, const CoeffsType& hCoeffs) { typedef typename MatrixType::Index Index; enum { TFactorSize = MatrixType::ColsAtCompileTime }; Index nbVecs = vectors.cols(); Matrix T(nbVecs,nbVecs); - ei_make_block_householder_triangular_factor(T, vectors, hCoeffs); + make_block_householder_triangular_factor(T, vectors, hCoeffs); const TriangularView& V(vectors); @@ -72,5 +74,6 @@ void ei_apply_block_householder_on_the_left(MatrixType& mat, const VectorsType& mat.noalias() -= V * tmp; } +} // end namespace internal #endif // EIGEN_BLOCK_HOUSEHOLDER_H diff --git a/Eigen/src/Householder/Householder.h b/Eigen/src/Householder/Householder.h index c45e6469d..7d77cd6e6 100644 --- a/Eigen/src/Householder/Householder.h +++ b/Eigen/src/Householder/Householder.h @@ -26,17 +26,19 @@ #ifndef EIGEN_HOUSEHOLDER_H #define EIGEN_HOUSEHOLDER_H -template struct ei_decrement_size +namespace internal { +template struct decrement_size { enum { ret = n==Dynamic ? n : n-1 }; }; +} template void MatrixBase::makeHouseholderInPlace(Scalar& tau, RealScalar& beta) { - VectorBlock::ret> essentialPart(derived(), 1, size()-1); + VectorBlock::ret> essentialPart(derived(), 1, size()-1); makeHouseholder(essentialPart, tau, beta); } @@ -68,18 +70,18 @@ void MatrixBase::makeHouseholder( RealScalar tailSqNorm = size()==1 ? RealScalar(0) : tail.squaredNorm(); Scalar c0 = coeff(0); - if(tailSqNorm == RealScalar(0) && ei_imag(c0)==RealScalar(0)) + if(tailSqNorm == RealScalar(0) && internal::imag(c0)==RealScalar(0)) { tau = 0; - beta = ei_real(c0); + beta = internal::real(c0); } else { - beta = ei_sqrt(ei_abs2(c0) + tailSqNorm); - if (ei_real(c0)>=RealScalar(0)) + beta = internal::sqrt(internal::abs2(c0) + tailSqNorm); + if (internal::real(c0)>=RealScalar(0)) beta = -beta; essential = tail / (c0 - beta); - tau = ei_conj((beta - c0) / beta); + tau = internal::conj((beta - c0) / beta); } } @@ -96,7 +98,7 @@ void MatrixBase::applyHouseholderOnTheLeft( } else { - Map::type> tmp(workspace,cols()); + Map::type> tmp(workspace,cols()); Block bottom(derived(), 1, 0, rows()-1, cols()); tmp.noalias() = essential.adjoint() * bottom; tmp += this->row(0); @@ -118,7 +120,7 @@ void MatrixBase::applyHouseholderOnTheRight( } else { - Map::type> tmp(workspace,rows()); + Map::type> tmp(workspace,rows()); Block right(derived(), 0, 1, rows(), cols()-1); tmp.noalias() = right * essential.conjugate(); tmp += this->col(0); diff --git a/Eigen/src/Householder/HouseholderSequence.h b/Eigen/src/Householder/HouseholderSequence.h index 0e9e85553..b9be94093 100644 --- a/Eigen/src/Householder/HouseholderSequence.h +++ b/Eigen/src/Householder/HouseholderSequence.h @@ -49,25 +49,27 @@ * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight() */ +namespace internal { + template -struct ei_traits > +struct traits > { typedef typename VectorsType::Scalar Scalar; typedef typename VectorsType::Index Index; typedef typename VectorsType::StorageKind StorageKind; enum { - RowsAtCompileTime = Side==OnTheLeft ? ei_traits::RowsAtCompileTime - : ei_traits::ColsAtCompileTime, + RowsAtCompileTime = Side==OnTheLeft ? traits::RowsAtCompileTime + : traits::ColsAtCompileTime, ColsAtCompileTime = RowsAtCompileTime, - MaxRowsAtCompileTime = Side==OnTheLeft ? ei_traits::MaxRowsAtCompileTime - : ei_traits::MaxColsAtCompileTime, + MaxRowsAtCompileTime = Side==OnTheLeft ? traits::MaxRowsAtCompileTime + : traits::MaxColsAtCompileTime, MaxColsAtCompileTime = MaxRowsAtCompileTime, Flags = 0 }; }; template -struct ei_hseq_side_dependent_impl +struct hseq_side_dependent_impl { typedef Block EssentialVectorType; typedef HouseholderSequence HouseholderSequenceType; @@ -80,7 +82,7 @@ struct ei_hseq_side_dependent_impl }; template -struct ei_hseq_side_dependent_impl +struct hseq_side_dependent_impl { typedef Transpose > EssentialVectorType; typedef HouseholderSequence HouseholderSequenceType; @@ -92,35 +94,37 @@ struct ei_hseq_side_dependent_impl } }; -template struct ei_matrix_type_times_scalar_type +template struct matrix_type_times_scalar_type { - typedef typename ei_scalar_product_traits::ReturnType + typedef typename scalar_product_traits::ReturnType ResultScalar; typedef Matrix Type; }; +} // end namespace internal + template class HouseholderSequence : public EigenBase > { enum { - RowsAtCompileTime = ei_traits::RowsAtCompileTime, - ColsAtCompileTime = ei_traits::ColsAtCompileTime, - MaxRowsAtCompileTime = ei_traits::MaxRowsAtCompileTime, - MaxColsAtCompileTime = ei_traits::MaxColsAtCompileTime + RowsAtCompileTime = internal::traits::RowsAtCompileTime, + ColsAtCompileTime = internal::traits::ColsAtCompileTime, + MaxRowsAtCompileTime = internal::traits::MaxRowsAtCompileTime, + MaxColsAtCompileTime = internal::traits::MaxColsAtCompileTime }; - typedef typename ei_traits::Scalar Scalar; + typedef typename internal::traits::Scalar Scalar; typedef typename VectorsType::Index Index; - typedef typename ei_hseq_side_dependent_impl::EssentialVectorType + typedef typename internal::hseq_side_dependent_impl::EssentialVectorType EssentialVectorType; public: typedef HouseholderSequence< VectorsType, - typename ei_meta_if::IsComplex, - typename ei_cleantype::type, + typename internal::meta_if::IsComplex, + typename internal::cleantype::type, CoeffsType>::ret, Side > ConjugateReturnType; @@ -141,8 +145,8 @@ template class HouseholderS const EssentialVectorType essentialVector(Index k) const { - ei_assert(k >= 0 && k < m_actualVectors); - return ei_hseq_side_dependent_impl::essentialVector(*this, k); + eigen_assert(k >= 0 && k < m_actualVectors); + return internal::hseq_side_dependent_impl::essentialVector(*this, k); } HouseholderSequence transpose() const @@ -163,8 +167,8 @@ template class HouseholderS // FIXME find a way to pass this temporary if the user want to Matrix temp(rows()); - if( ei_is_same_type::type,DestType>::ret - && ei_extract_data(dst) == ei_extract_data(m_vectors)) + if( internal::is_same_type::type,DestType>::ret + && internal::extract_data(dst) == internal::extract_data(m_vectors)) { // in-place dst.diagonal().setOnes(); @@ -227,24 +231,24 @@ template class HouseholderS } template - typename ei_matrix_type_times_scalar_type::Type operator*(const MatrixBase& other) const + typename internal::matrix_type_times_scalar_type::Type operator*(const MatrixBase& other) const { - typename ei_matrix_type_times_scalar_type::Type - res(other.template cast::ResultScalar>()); + typename internal::matrix_type_times_scalar_type::Type + res(other.template cast::ResultScalar>()); applyThisOnTheLeft(res); return res; } template friend - typename ei_matrix_type_times_scalar_type::Type operator*(const MatrixBase& other, const HouseholderSequence& h) + typename internal::matrix_type_times_scalar_type::Type operator*(const MatrixBase& other, const HouseholderSequence& h) { - typename ei_matrix_type_times_scalar_type::Type - res(other.template cast::ResultScalar>()); + typename internal::matrix_type_times_scalar_type::Type + res(other.template cast::ResultScalar>()); h.applyThisOnTheRight(res); return res; } - template friend struct ei_hseq_side_dependent_impl; + template friend struct internal::hseq_side_dependent_impl; protected: typename VectorsType::Nested m_vectors; diff --git a/Eigen/src/Jacobi/Jacobi.h b/Eigen/src/Jacobi/Jacobi.h index 39420bf42..58f6c98fb 100644 --- a/Eigen/src/Jacobi/Jacobi.h +++ b/Eigen/src/Jacobi/Jacobi.h @@ -29,7 +29,7 @@ /** \ingroup Jacobi_Module * \jacobi_module * \class JacobiRotation - * \brief Represents a rotation given by a cosine-sine pair. + * \brief Rotation given by a cosine-sine pair. * * This class represents a Jacobi or Givens rotation. * This is a 2D rotation in the plane \c J of angle \f$ \theta \f$ defined by @@ -63,15 +63,15 @@ template class JacobiRotation /** Concatenates two planar rotation */ JacobiRotation operator*(const JacobiRotation& other) { - return JacobiRotation(m_c * other.m_c - ei_conj(m_s) * other.m_s, - ei_conj(m_c * ei_conj(other.m_s) + ei_conj(m_s) * ei_conj(other.m_c))); + return JacobiRotation(m_c * other.m_c - internal::conj(m_s) * other.m_s, + internal::conj(m_c * internal::conj(other.m_s) + internal::conj(m_s) * internal::conj(other.m_c))); } /** Returns the transposed transformation */ - JacobiRotation transpose() const { return JacobiRotation(m_c, -ei_conj(m_s)); } + JacobiRotation transpose() const { return JacobiRotation(m_c, -internal::conj(m_s)); } /** Returns the adjoint transformation */ - JacobiRotation adjoint() const { return JacobiRotation(ei_conj(m_c), -m_s); } + JacobiRotation adjoint() const { return JacobiRotation(internal::conj(m_c), -m_s); } template bool makeJacobi(const MatrixBase&, typename Derived::Index p, typename Derived::Index q); @@ -80,8 +80,8 @@ template class JacobiRotation void makeGivens(const Scalar& p, const Scalar& q, Scalar* z=0); protected: - void makeGivens(const Scalar& p, const Scalar& q, Scalar* z, ei_meta_true); - void makeGivens(const Scalar& p, const Scalar& q, Scalar* z, ei_meta_false); + void makeGivens(const Scalar& p, const Scalar& q, Scalar* z, internal::meta_true); + void makeGivens(const Scalar& p, const Scalar& q, Scalar* z, internal::meta_false); Scalar m_c, m_s; }; @@ -103,8 +103,8 @@ bool JacobiRotation::makeJacobi(RealScalar x, Scalar y, RealScalar z) } else { - RealScalar tau = (x-z)/(RealScalar(2)*ei_abs(y)); - RealScalar w = ei_sqrt(ei_abs2(tau) + 1); + RealScalar tau = (x-z)/(RealScalar(2)*internal::abs(y)); + RealScalar w = internal::sqrt(internal::abs2(tau) + 1); RealScalar t; if(tau>0) { @@ -115,8 +115,8 @@ bool JacobiRotation::makeJacobi(RealScalar x, Scalar y, RealScalar z) t = RealScalar(1) / (tau - w); } RealScalar sign_t = t > 0 ? 1 : -1; - RealScalar n = RealScalar(1) / ei_sqrt(ei_abs2(t)+1); - m_s = - sign_t * (ei_conj(y) / ei_abs(y)) * ei_abs(t) * n; + RealScalar n = RealScalar(1) / internal::sqrt(internal::abs2(t)+1); + m_s = - sign_t * (internal::conj(y) / internal::abs(y)) * internal::abs(t) * n; m_c = n; return true; } @@ -135,7 +135,7 @@ template template inline bool JacobiRotation::makeJacobi(const MatrixBase& m, typename Derived::Index p, typename Derived::Index q) { - return makeJacobi(ei_real(m.coeff(p,p)), m.coeff(p,q), ei_real(m.coeff(q,q))); + return makeJacobi(internal::real(m.coeff(p,p)), m.coeff(p,q), internal::real(m.coeff(q,q))); } /** Makes \c *this as a Givens rotation \c G such that applying \f$ G^* \f$ to the left of the vector @@ -157,60 +157,60 @@ inline bool JacobiRotation::makeJacobi(const MatrixBase& m, typ template void JacobiRotation::makeGivens(const Scalar& p, const Scalar& q, Scalar* z) { - makeGivens(p, q, z, typename ei_meta_if::IsComplex, ei_meta_true, ei_meta_false>::ret()); + makeGivens(p, q, z, typename internal::meta_if::IsComplex, internal::meta_true, internal::meta_false>::ret()); } // specialization for complexes template -void JacobiRotation::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, ei_meta_true) +void JacobiRotation::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::meta_true) { if(q==Scalar(0)) { - m_c = ei_real(p)<0 ? Scalar(-1) : Scalar(1); + m_c = internal::real(p)<0 ? Scalar(-1) : Scalar(1); m_s = 0; if(r) *r = m_c * p; } else if(p==Scalar(0)) { m_c = 0; - m_s = -q/ei_abs(q); - if(r) *r = ei_abs(q); + m_s = -q/internal::abs(q); + if(r) *r = internal::abs(q); } else { - RealScalar p1 = ei_norm1(p); - RealScalar q1 = ei_norm1(q); + RealScalar p1 = internal::norm1(p); + RealScalar q1 = internal::norm1(q); if(p1>=q1) { Scalar ps = p / p1; - RealScalar p2 = ei_abs2(ps); + RealScalar p2 = internal::abs2(ps); Scalar qs = q / p1; - RealScalar q2 = ei_abs2(qs); + RealScalar q2 = internal::abs2(qs); - RealScalar u = ei_sqrt(RealScalar(1) + q2/p2); - if(ei_real(p)::makeGivens(const Scalar& p, const Scalar& q, Scalar // specialization for reals template -void JacobiRotation::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, ei_meta_false) +void JacobiRotation::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::meta_false) { if(q==0) { m_c = p ei_abs(q)) + else if(internal::abs(p) > internal::abs(q)) { Scalar t = q/p; - Scalar u = ei_sqrt(Scalar(1) + ei_abs2(t)); + Scalar u = internal::sqrt(Scalar(1) + internal::abs2(t)); if(p::makeGivens(const Scalar& p, const Scalar& q, Scalar else { Scalar t = p/q; - Scalar u = ei_sqrt(Scalar(1) + ei_abs2(t)); + Scalar u = internal::sqrt(Scalar(1) + internal::abs2(t)); if(q::makeGivens(const Scalar& p, const Scalar& q, Scalar * * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight() */ +namespace internal { template -void ei_apply_rotation_in_the_plane(VectorX& _x, VectorY& _y, const JacobiRotation& j); +void apply_rotation_in_the_plane(VectorX& _x, VectorY& _y, const JacobiRotation& j); +} /** \jacobi_module * Applies the rotation in the plane \a j to the rows \a p and \a q of \c *this, i.e., it computes B = J * B, * with \f$ B = \left ( \begin{array}{cc} \text{*this.row}(p) \\ \text{*this.row}(q) \end{array} \right ) \f$. * - * \sa class JacobiRotation, MatrixBase::applyOnTheRight(), ei_apply_rotation_in_the_plane() + * \sa class JacobiRotation, MatrixBase::applyOnTheRight(), internal::apply_rotation_in_the_plane() */ template template @@ -281,14 +283,14 @@ inline void MatrixBase::applyOnTheLeft(Index p, Index q, const JacobiRo { RowXpr x(this->row(p)); RowXpr y(this->row(q)); - ei_apply_rotation_in_the_plane(x, y, j); + internal::apply_rotation_in_the_plane(x, y, j); } /** \ingroup Jacobi_Module * Applies the rotation in the plane \a j to the columns \a p and \a q of \c *this, i.e., it computes B = B * J * with \f$ B = \left ( \begin{array}{cc} \text{*this.col}(p) & \text{*this.col}(q) \end{array} \right ) \f$. * - * \sa class JacobiRotation, MatrixBase::applyOnTheLeft(), ei_apply_rotation_in_the_plane() + * \sa class JacobiRotation, MatrixBase::applyOnTheLeft(), internal::apply_rotation_in_the_plane() */ template template @@ -296,18 +298,18 @@ inline void MatrixBase::applyOnTheRight(Index p, Index q, const JacobiR { ColXpr x(this->col(p)); ColXpr y(this->col(q)); - ei_apply_rotation_in_the_plane(x, y, j.transpose()); + internal::apply_rotation_in_the_plane(x, y, j.transpose()); } - +namespace internal { template -void /*EIGEN_DONT_INLINE*/ ei_apply_rotation_in_the_plane(VectorX& _x, VectorY& _y, const JacobiRotation& j) +void /*EIGEN_DONT_INLINE*/ apply_rotation_in_the_plane(VectorX& _x, VectorY& _y, const JacobiRotation& j) { typedef typename VectorX::Index Index; typedef typename VectorX::Scalar Scalar; - enum { PacketSize = ei_packet_traits::size }; - typedef typename ei_packet_traits::type Packet; - ei_assert(_x.size() == _y.size()); + enum { PacketSize = packet_traits::size }; + typedef typename packet_traits::type Packet; + eigen_assert(_x.size() == _y.size()); Index size = _x.size(); Index incrx = _x.innerStride(); Index incry = _y.innerStride(); @@ -324,32 +326,32 @@ void /*EIGEN_DONT_INLINE*/ ei_apply_rotation_in_the_plane(VectorX& _x, VectorY& // both vectors are sequentially stored in memory => vectorization enum { Peeling = 2 }; - Index alignedStart = ei_first_aligned(y, size); + Index alignedStart = first_aligned(y, size); Index alignedEnd = alignedStart + ((size-alignedStart)/PacketSize)*PacketSize; - const Packet pc = ei_pset1(j.c()); - const Packet ps = ei_pset1(j.s()); - ei_conj_helper::IsComplex,false> pcj; + const Packet pc = pset1(j.c()); + const Packet ps = pset1(j.s()); + conj_helper::IsComplex,false> pcj; for(Index i=0; i(px); - Packet yi = ei_pload(py); - ei_pstore(px, ei_padd(ei_pmul(pc,xi),pcj.pmul(ps,yi))); - ei_pstore(py, ei_psub(pcj.pmul(pc,yi),ei_pmul(ps,xi))); + Packet xi = pload(px); + Packet yi = pload(py); + pstore(px, padd(pmul(pc,xi),pcj.pmul(ps,yi))); + pstore(py, psub(pcj.pmul(pc,yi),pmul(ps,xi))); px += PacketSize; py += PacketSize; } @@ -359,23 +361,23 @@ void /*EIGEN_DONT_INLINE*/ ei_apply_rotation_in_the_plane(VectorX& _x, VectorY& Index peelingEnd = alignedStart + ((size-alignedStart)/(Peeling*PacketSize))*(Peeling*PacketSize); for(Index i=alignedStart; i(px); - Packet xi1 = ei_ploadu(px+PacketSize); - Packet yi = ei_pload (py); - Packet yi1 = ei_pload (py+PacketSize); - ei_pstoreu(px, ei_padd(ei_pmul(pc,xi),pcj.pmul(ps,yi))); - ei_pstoreu(px+PacketSize, ei_padd(ei_pmul(pc,xi1),pcj.pmul(ps,yi1))); - ei_pstore (py, ei_psub(pcj.pmul(pc,yi),ei_pmul(ps,xi))); - ei_pstore (py+PacketSize, ei_psub(pcj.pmul(pc,yi1),ei_pmul(ps,xi1))); + Packet xi = ploadu(px); + Packet xi1 = ploadu(px+PacketSize); + Packet yi = pload (py); + Packet yi1 = pload (py+PacketSize); + pstoreu(px, padd(pmul(pc,xi),pcj.pmul(ps,yi))); + pstoreu(px+PacketSize, padd(pmul(pc,xi1),pcj.pmul(ps,yi1))); + pstore (py, psub(pcj.pmul(pc,yi),pmul(ps,xi))); + pstore (py+PacketSize, psub(pcj.pmul(pc,yi1),pmul(ps,xi1))); px += Peeling*PacketSize; py += Peeling*PacketSize; } if(alignedEnd!=peelingEnd) { - Packet xi = ei_ploadu(x+peelingEnd); - Packet yi = ei_pload (y+peelingEnd); - ei_pstoreu(x+peelingEnd, ei_padd(ei_pmul(pc,xi),pcj.pmul(ps,yi))); - ei_pstore (y+peelingEnd, ei_psub(pcj.pmul(pc,yi),ei_pmul(ps,xi))); + Packet xi = ploadu(x+peelingEnd); + Packet yi = pload (y+peelingEnd); + pstoreu(x+peelingEnd, padd(pmul(pc,xi),pcj.pmul(ps,yi))); + pstore (y+peelingEnd, psub(pcj.pmul(pc,yi),pmul(ps,xi))); } } @@ -383,8 +385,8 @@ void /*EIGEN_DONT_INLINE*/ ei_apply_rotation_in_the_plane(VectorX& _x, VectorY& { Scalar xi = x[i]; Scalar yi = y[i]; - x[i] = j.c() * xi + ei_conj(j.s()) * yi; - y[i] = -j.s() * xi + ei_conj(j.c()) * yi; + x[i] = j.c() * xi + conj(j.s()) * yi; + y[i] = -j.s() * xi + conj(j.c()) * yi; } } @@ -393,17 +395,17 @@ void /*EIGEN_DONT_INLINE*/ ei_apply_rotation_in_the_plane(VectorX& _x, VectorY& (VectorX::Flags & VectorY::Flags & PacketAccessBit) && (VectorX::Flags & VectorY::Flags & AlignedBit)) { - const Packet pc = ei_pset1(j.c()); - const Packet ps = ei_pset1(j.s()); - ei_conj_helper::IsComplex,false> pcj; + const Packet pc = pset1(j.c()); + const Packet ps = pset1(j.s()); + conj_helper::IsComplex,false> pcj; Scalar* EIGEN_RESTRICT px = x; Scalar* EIGEN_RESTRICT py = y; for(Index i=0; i(px); - Packet yi = ei_pload(py); - ei_pstore(px, ei_padd(ei_pmul(pc,xi),pcj.pmul(ps,yi))); - ei_pstore(py, ei_psub(pcj.pmul(pc,yi),ei_pmul(ps,xi))); + Packet xi = pload(px); + Packet yi = pload(py); + pstore(px, padd(pmul(pc,xi),pcj.pmul(ps,yi))); + pstore(py, psub(pcj.pmul(pc,yi),pmul(ps,xi))); px += PacketSize; py += PacketSize; } @@ -416,12 +418,13 @@ void /*EIGEN_DONT_INLINE*/ ei_apply_rotation_in_the_plane(VectorX& _x, VectorY& { Scalar xi = *x; Scalar yi = *y; - *x = j.c() * xi + ei_conj(j.s()) * yi; - *y = -j.s() * xi + ei_conj(j.c()) * yi; + *x = j.c() * xi + conj(j.s()) * yi; + *y = -j.s() * xi + conj(j.c()) * yi; x += incrx; y += incry; } } } +} #endif // EIGEN_JACOBI_H diff --git a/Eigen/src/LU/Determinant.h b/Eigen/src/LU/Determinant.h index ea7db9c0f..b274f5958 100644 --- a/Eigen/src/LU/Determinant.h +++ b/Eigen/src/LU/Determinant.h @@ -25,8 +25,10 @@ #ifndef EIGEN_DETERMINANT_H #define EIGEN_DETERMINANT_H +namespace internal { + template -inline const typename Derived::Scalar ei_bruteforce_det3_helper +inline const typename Derived::Scalar bruteforce_det3_helper (const MatrixBase& matrix, int a, int b, int c) { return matrix.coeff(0,a) @@ -34,7 +36,7 @@ inline const typename Derived::Scalar ei_bruteforce_det3_helper } template -const typename Derived::Scalar ei_bruteforce_det4_helper +const typename Derived::Scalar bruteforce_det4_helper (const MatrixBase& matrix, int j, int k, int m, int n) { return (matrix.coeff(j,0) * matrix.coeff(k,1) - matrix.coeff(k,0) * matrix.coeff(j,1)) @@ -43,66 +45,68 @@ const typename Derived::Scalar ei_bruteforce_det4_helper template struct ei_determinant_impl +> struct determinant_impl { - static inline typename ei_traits::Scalar run(const Derived& m) + static inline typename traits::Scalar run(const Derived& m) { if(Derived::ColsAtCompileTime==Dynamic && m.rows()==0) - return typename ei_traits::Scalar(1); + return typename traits::Scalar(1); return m.partialPivLu().determinant(); } }; -template struct ei_determinant_impl +template struct determinant_impl { - static inline typename ei_traits::Scalar run(const Derived& m) + static inline typename traits::Scalar run(const Derived& m) { return m.coeff(0,0); } }; -template struct ei_determinant_impl +template struct determinant_impl { - static inline typename ei_traits::Scalar run(const Derived& m) + static inline typename traits::Scalar run(const Derived& m) { return m.coeff(0,0) * m.coeff(1,1) - m.coeff(1,0) * m.coeff(0,1); } }; -template struct ei_determinant_impl +template struct determinant_impl { - static inline typename ei_traits::Scalar run(const Derived& m) + static inline typename traits::Scalar run(const Derived& m) { - return ei_bruteforce_det3_helper(m,0,1,2) - - ei_bruteforce_det3_helper(m,1,0,2) - + ei_bruteforce_det3_helper(m,2,0,1); + return bruteforce_det3_helper(m,0,1,2) + - bruteforce_det3_helper(m,1,0,2) + + bruteforce_det3_helper(m,2,0,1); } }; -template struct ei_determinant_impl +template struct determinant_impl { - static typename ei_traits::Scalar run(const Derived& m) + static typename traits::Scalar run(const Derived& m) { // trick by Martin Costabel to compute 4x4 det with only 30 muls - return ei_bruteforce_det4_helper(m,0,1,2,3) - - ei_bruteforce_det4_helper(m,0,2,1,3) - + ei_bruteforce_det4_helper(m,0,3,1,2) - + ei_bruteforce_det4_helper(m,1,2,0,3) - - ei_bruteforce_det4_helper(m,1,3,0,2) - + ei_bruteforce_det4_helper(m,2,3,0,1); + return bruteforce_det4_helper(m,0,1,2,3) + - bruteforce_det4_helper(m,0,2,1,3) + + bruteforce_det4_helper(m,0,3,1,2) + + bruteforce_det4_helper(m,1,2,0,3) + - bruteforce_det4_helper(m,1,3,0,2) + + bruteforce_det4_helper(m,2,3,0,1); } }; +} // end namespace internal + /** \lu_module * * \returns the determinant of this matrix */ template -inline typename ei_traits::Scalar MatrixBase::determinant() const +inline typename internal::traits::Scalar MatrixBase::determinant() const { assert(rows() == cols()); - typedef typename ei_nested::type Nested; - return ei_determinant_impl::type>::run(derived()); + typedef typename internal::nested::type Nested; + return internal::determinant_impl::type>::run(derived()); } #endif // EIGEN_DETERMINANT_H diff --git a/Eigen/src/LU/FullPivLU.h b/Eigen/src/LU/FullPivLU.h index 558b1bd90..339d7845c 100644 --- a/Eigen/src/LU/FullPivLU.h +++ b/Eigen/src/LU/FullPivLU.h @@ -68,10 +68,10 @@ template class FullPivLU }; typedef typename MatrixType::Scalar Scalar; typedef typename NumTraits::Real RealScalar; - typedef typename ei_traits::StorageKind StorageKind; + typedef typename internal::traits::StorageKind StorageKind; typedef typename MatrixType::Index Index; - typedef typename ei_plain_row_type::type IntRowVectorType; - typedef typename ei_plain_col_type::type IntColVectorType; + typedef typename internal::plain_row_type::type IntRowVectorType; + typedef typename internal::plain_col_type::type IntColVectorType; typedef PermutationMatrix PermutationQType; typedef PermutationMatrix PermutationPType; @@ -115,7 +115,7 @@ template class FullPivLU */ inline const MatrixType& matrixLU() const { - ei_assert(m_isInitialized && "LU is not initialized."); + eigen_assert(m_isInitialized && "LU is not initialized."); return m_lu; } @@ -128,7 +128,7 @@ template class FullPivLU */ inline Index nonzeroPivots() const { - ei_assert(m_isInitialized && "LU is not initialized."); + eigen_assert(m_isInitialized && "LU is not initialized."); return m_nonzero_pivots; } @@ -143,7 +143,7 @@ template class FullPivLU */ inline const PermutationPType& permutationP() const { - ei_assert(m_isInitialized && "LU is not initialized."); + eigen_assert(m_isInitialized && "LU is not initialized."); return m_p; } @@ -153,7 +153,7 @@ template class FullPivLU */ inline const PermutationQType& permutationQ() const { - ei_assert(m_isInitialized && "LU is not initialized."); + eigen_assert(m_isInitialized && "LU is not initialized."); return m_q; } @@ -171,10 +171,10 @@ template class FullPivLU * * \sa image() */ - inline const ei_kernel_retval kernel() const + inline const internal::kernel_retval kernel() const { - ei_assert(m_isInitialized && "LU is not initialized."); - return ei_kernel_retval(*this); + eigen_assert(m_isInitialized && "LU is not initialized."); + return internal::kernel_retval(*this); } /** \returns the image of the matrix, also called its column-space. The columns of the returned matrix @@ -196,11 +196,11 @@ template class FullPivLU * * \sa kernel() */ - inline const ei_image_retval + inline const internal::image_retval image(const MatrixType& originalMatrix) const { - ei_assert(m_isInitialized && "LU is not initialized."); - return ei_image_retval(*this, originalMatrix); + eigen_assert(m_isInitialized && "LU is not initialized."); + return internal::image_retval(*this, originalMatrix); } /** \return a solution x to the equation Ax=b, where A is the matrix of which @@ -223,11 +223,11 @@ template class FullPivLU * \sa TriangularView::solve(), kernel(), inverse() */ template - inline const ei_solve_retval + inline const internal::solve_retval solve(const MatrixBase& b) const { - ei_assert(m_isInitialized && "LU is not initialized."); - return ei_solve_retval(*this, b.derived()); + eigen_assert(m_isInitialized && "LU is not initialized."); + return internal::solve_retval(*this, b.derived()); } /** \returns the determinant of the matrix of which @@ -245,7 +245,7 @@ template class FullPivLU * * \sa MatrixBase::determinant() */ - typename ei_traits::Scalar determinant() const; + typename internal::traits::Scalar determinant() const; /** Allows to prescribe a threshold to be used by certain methods, such as rank(), * who need to determine when pivots are to be considered nonzero. This is not used for the @@ -290,7 +290,7 @@ template class FullPivLU */ RealScalar threshold() const { - ei_assert(m_isInitialized || m_usePrescribedThreshold); + eigen_assert(m_isInitialized || m_usePrescribedThreshold); return m_usePrescribedThreshold ? m_prescribedThreshold // this formula comes from experimenting (see "LU precision tuning" thread on the list) // and turns out to be identical to Higham's formula used already in LDLt. @@ -305,11 +305,11 @@ template class FullPivLU */ inline Index rank() const { - ei_assert(m_isInitialized && "LU is not initialized."); - RealScalar premultiplied_threshold = ei_abs(m_maxpivot) * threshold(); + eigen_assert(m_isInitialized && "LU is not initialized."); + RealScalar premultiplied_threshold = internal::abs(m_maxpivot) * threshold(); Index result = 0; for(Index i = 0; i < m_nonzero_pivots; ++i) - result += (ei_abs(m_lu.coeff(i,i)) > premultiplied_threshold); + result += (internal::abs(m_lu.coeff(i,i)) > premultiplied_threshold); return result; } @@ -321,7 +321,7 @@ template class FullPivLU */ inline Index dimensionOfKernel() const { - ei_assert(m_isInitialized && "LU is not initialized."); + eigen_assert(m_isInitialized && "LU is not initialized."); return cols() - rank(); } @@ -334,7 +334,7 @@ template class FullPivLU */ inline bool isInjective() const { - ei_assert(m_isInitialized && "LU is not initialized."); + eigen_assert(m_isInitialized && "LU is not initialized."); return rank() == cols(); } @@ -347,7 +347,7 @@ template class FullPivLU */ inline bool isSurjective() const { - ei_assert(m_isInitialized && "LU is not initialized."); + eigen_assert(m_isInitialized && "LU is not initialized."); return rank() == rows(); } @@ -359,7 +359,7 @@ template class FullPivLU */ inline bool isInvertible() const { - ei_assert(m_isInitialized && "LU is not initialized."); + eigen_assert(m_isInitialized && "LU is not initialized."); return isInjective() && (m_lu.rows() == m_lu.cols()); } @@ -370,11 +370,11 @@ template class FullPivLU * * \sa MatrixBase::inverse() */ - inline const ei_solve_retval inverse() const + inline const internal::solve_retval inverse() const { - ei_assert(m_isInitialized && "LU is not initialized."); - ei_assert(m_lu.rows() == m_lu.cols() && "You can't take the inverse of a non-square matrix!"); - return ei_solve_retval + eigen_assert(m_isInitialized && "LU is not initialized."); + eigen_assert(m_lu.rows() == m_lu.cols() && "You can't take the inverse of a non-square matrix!"); + return internal::solve_retval (*this, MatrixType::Identity(m_lu.rows(), m_lu.cols())); } @@ -519,10 +519,10 @@ FullPivLU& FullPivLU::compute(const MatrixType& matrix) } template -typename ei_traits::Scalar FullPivLU::determinant() const +typename internal::traits::Scalar FullPivLU::determinant() const { - ei_assert(m_isInitialized && "LU is not initialized."); - ei_assert(m_lu.rows() == m_lu.cols() && "You can't take the determinant of a non-square matrix!"); + eigen_assert(m_isInitialized && "LU is not initialized."); + eigen_assert(m_lu.rows() == m_lu.cols() && "You can't take the determinant of a non-square matrix!"); return Scalar(m_det_pq) * Scalar(m_lu.diagonal().prod()); } @@ -532,7 +532,7 @@ typename ei_traits::Scalar FullPivLU::determinant() cons template MatrixType FullPivLU::reconstructedMatrix() const { - ei_assert(m_isInitialized && "LU is not initialized."); + eigen_assert(m_isInitialized && "LU is not initialized."); const Index smalldim = std::min(m_lu.rows(), m_lu.cols()); // LU MatrixType res(m_lu.rows(),m_lu.cols()); @@ -553,9 +553,10 @@ MatrixType FullPivLU::reconstructedMatrix() const /********* Implementation of kernel() **************************************************/ +namespace internal { template -struct ei_kernel_retval > - : ei_kernel_retval_base > +struct kernel_retval > + : kernel_retval_base > { EIGEN_MAKE_KERNEL_HELPERS(FullPivLU<_MatrixType>) @@ -596,9 +597,9 @@ struct ei_kernel_retval > RealScalar premultiplied_threshold = dec().maxPivot() * dec().threshold(); Index p = 0; for(Index i = 0; i < dec().nonzeroPivots(); ++i) - if(ei_abs(dec().matrixLU().coeff(i,i)) > premultiplied_threshold) + if(abs(dec().matrixLU().coeff(i,i)) > premultiplied_threshold) pivots.coeffRef(p++) = i; - ei_internal_assert(p == rank()); + eigen_internal_assert(p == rank()); // we construct a temporaty trapezoid matrix m, by taking the U matrix and // permuting the rows and cols to bring the nonnegligible pivots to the top of @@ -639,8 +640,8 @@ struct ei_kernel_retval > /***** Implementation of image() *****************************************************/ template -struct ei_image_retval > - : ei_image_retval_base > +struct image_retval > + : image_retval_base > { EIGEN_MAKE_IMAGE_HELPERS(FullPivLU<_MatrixType>) @@ -664,9 +665,9 @@ struct ei_image_retval > RealScalar premultiplied_threshold = dec().maxPivot() * dec().threshold(); Index p = 0; for(Index i = 0; i < dec().nonzeroPivots(); ++i) - if(ei_abs(dec().matrixLU().coeff(i,i)) > premultiplied_threshold) + if(abs(dec().matrixLU().coeff(i,i)) > premultiplied_threshold) pivots.coeffRef(p++) = i; - ei_internal_assert(p == rank()); + eigen_internal_assert(p == rank()); for(Index i = 0; i < rank(); ++i) dst.col(i) = originalMatrix().col(dec().permutationQ().indices().coeff(pivots.coeff(i))); @@ -676,8 +677,8 @@ struct ei_image_retval > /***** Implementation of solve() *****************************************************/ template -struct ei_solve_retval, Rhs> - : ei_solve_retval_base, Rhs> +struct solve_retval, Rhs> + : solve_retval_base, Rhs> { EIGEN_MAKE_SOLVE_HELPERS(FullPivLU<_MatrixType>,Rhs) @@ -693,7 +694,7 @@ struct ei_solve_retval, Rhs> const Index rows = dec().rows(), cols = dec().cols(), nonzero_pivots = dec().nonzeroPivots(); - ei_assert(rhs().rows() == rows); + eigen_assert(rhs().rows() == rows); const Index smalldim = std::min(rows, cols); if(nonzero_pivots == 0) @@ -733,6 +734,8 @@ struct ei_solve_retval, Rhs> } }; +} // end namespace internal + /******* MatrixBase methods *****************************************************************/ /** \lu_module diff --git a/Eigen/src/LU/Inverse.h b/Eigen/src/LU/Inverse.h index b587e3309..99286523a 100644 --- a/Eigen/src/LU/Inverse.h +++ b/Eigen/src/LU/Inverse.h @@ -25,12 +25,14 @@ #ifndef EIGEN_INVERSE_H #define EIGEN_INVERSE_H +namespace internal { + /********************************** *** General case implementation *** **********************************/ template -struct ei_compute_inverse +struct compute_inverse { static inline void run(const MatrixType& matrix, ResultType& result) { @@ -39,14 +41,14 @@ struct ei_compute_inverse }; template -struct ei_compute_inverse_and_det_with_check { /* nothing! general case not supported. */ }; +struct compute_inverse_and_det_with_check { /* nothing! general case not supported. */ }; /**************************** *** Size 1 implementation *** ****************************/ template -struct ei_compute_inverse +struct compute_inverse { static inline void run(const MatrixType& matrix, ResultType& result) { @@ -56,7 +58,7 @@ struct ei_compute_inverse }; template -struct ei_compute_inverse_and_det_with_check +struct compute_inverse_and_det_with_check { static inline void run( const MatrixType& matrix, @@ -67,7 +69,7 @@ struct ei_compute_inverse_and_det_with_check ) { determinant = matrix.coeff(0,0); - invertible = ei_abs(determinant) > absDeterminantThreshold; + invertible = abs(determinant) > absDeterminantThreshold; if(invertible) result.coeffRef(0,0) = typename ResultType::Scalar(1) / determinant; } }; @@ -77,7 +79,7 @@ struct ei_compute_inverse_and_det_with_check ****************************/ template -inline void ei_compute_inverse_size2_helper( +inline void compute_inverse_size2_helper( const MatrixType& matrix, const typename ResultType::Scalar& invdet, ResultType& result) { @@ -88,18 +90,18 @@ inline void ei_compute_inverse_size2_helper( } template -struct ei_compute_inverse +struct compute_inverse { static inline void run(const MatrixType& matrix, ResultType& result) { typedef typename ResultType::Scalar Scalar; const Scalar invdet = typename MatrixType::Scalar(1) / matrix.determinant(); - ei_compute_inverse_size2_helper(matrix, invdet, result); + compute_inverse_size2_helper(matrix, invdet, result); } }; template -struct ei_compute_inverse_and_det_with_check +struct compute_inverse_and_det_with_check { static inline void run( const MatrixType& matrix, @@ -111,10 +113,10 @@ struct ei_compute_inverse_and_det_with_check { typedef typename ResultType::Scalar Scalar; determinant = matrix.determinant(); - invertible = ei_abs(determinant) > absDeterminantThreshold; + invertible = abs(determinant) > absDeterminantThreshold; if(!invertible) return; const Scalar invdet = Scalar(1) / determinant; - ei_compute_inverse_size2_helper(matrix, invdet, inverse); + compute_inverse_size2_helper(matrix, invdet, inverse); } }; @@ -123,7 +125,7 @@ struct ei_compute_inverse_and_det_with_check ****************************/ template -inline typename MatrixType::Scalar ei_3x3_cofactor(const MatrixType& m) +inline typename MatrixType::Scalar cofactor_3x3(const MatrixType& m) { enum { i1 = (i+1) % 3, @@ -136,39 +138,39 @@ inline typename MatrixType::Scalar ei_3x3_cofactor(const MatrixType& m) } template -inline void ei_compute_inverse_size3_helper( +inline void compute_inverse_size3_helper( const MatrixType& matrix, const typename ResultType::Scalar& invdet, const Matrix& cofactors_col0, ResultType& result) { result.row(0) = cofactors_col0 * invdet; - result.coeffRef(1,0) = ei_3x3_cofactor(matrix) * invdet; - result.coeffRef(1,1) = ei_3x3_cofactor(matrix) * invdet; - result.coeffRef(1,2) = ei_3x3_cofactor(matrix) * invdet; - result.coeffRef(2,0) = ei_3x3_cofactor(matrix) * invdet; - result.coeffRef(2,1) = ei_3x3_cofactor(matrix) * invdet; - result.coeffRef(2,2) = ei_3x3_cofactor(matrix) * invdet; + result.coeffRef(1,0) = cofactor_3x3(matrix) * invdet; + result.coeffRef(1,1) = cofactor_3x3(matrix) * invdet; + result.coeffRef(1,2) = cofactor_3x3(matrix) * invdet; + result.coeffRef(2,0) = cofactor_3x3(matrix) * invdet; + result.coeffRef(2,1) = cofactor_3x3(matrix) * invdet; + result.coeffRef(2,2) = cofactor_3x3(matrix) * invdet; } template -struct ei_compute_inverse +struct compute_inverse { static inline void run(const MatrixType& matrix, ResultType& result) { typedef typename ResultType::Scalar Scalar; Matrix cofactors_col0; - cofactors_col0.coeffRef(0) = ei_3x3_cofactor(matrix); - cofactors_col0.coeffRef(1) = ei_3x3_cofactor(matrix); - cofactors_col0.coeffRef(2) = ei_3x3_cofactor(matrix); + cofactors_col0.coeffRef(0) = cofactor_3x3(matrix); + cofactors_col0.coeffRef(1) = cofactor_3x3(matrix); + cofactors_col0.coeffRef(2) = cofactor_3x3(matrix); const Scalar det = (cofactors_col0.cwiseProduct(matrix.col(0))).sum(); const Scalar invdet = Scalar(1) / det; - ei_compute_inverse_size3_helper(matrix, invdet, cofactors_col0, result); + compute_inverse_size3_helper(matrix, invdet, cofactors_col0, result); } }; template -struct ei_compute_inverse_and_det_with_check +struct compute_inverse_and_det_with_check { static inline void run( const MatrixType& matrix, @@ -180,14 +182,14 @@ struct ei_compute_inverse_and_det_with_check { typedef typename ResultType::Scalar Scalar; Matrix cofactors_col0; - cofactors_col0.coeffRef(0) = ei_3x3_cofactor(matrix); - cofactors_col0.coeffRef(1) = ei_3x3_cofactor(matrix); - cofactors_col0.coeffRef(2) = ei_3x3_cofactor(matrix); + cofactors_col0.coeffRef(0) = cofactor_3x3(matrix); + cofactors_col0.coeffRef(1) = cofactor_3x3(matrix); + cofactors_col0.coeffRef(2) = cofactor_3x3(matrix); determinant = (cofactors_col0.cwiseProduct(matrix.col(0))).sum(); - invertible = ei_abs(determinant) > absDeterminantThreshold; + invertible = abs(determinant) > absDeterminantThreshold; if(!invertible) return; const Scalar invdet = Scalar(1) / determinant; - ei_compute_inverse_size3_helper(matrix, invdet, cofactors_col0, inverse); + compute_inverse_size3_helper(matrix, invdet, cofactors_col0, inverse); } }; @@ -196,7 +198,7 @@ struct ei_compute_inverse_and_det_with_check ****************************/ template -inline const typename Derived::Scalar ei_general_det3_helper +inline const typename Derived::Scalar general_det3_helper (const MatrixBase& matrix, int i1, int i2, int i3, int j1, int j2, int j3) { return matrix.coeff(i1,j1) @@ -204,7 +206,7 @@ inline const typename Derived::Scalar ei_general_det3_helper } template -inline typename MatrixType::Scalar ei_4x4_cofactor(const MatrixType& matrix) +inline typename MatrixType::Scalar cofactor_4x4(const MatrixType& matrix) { enum { i1 = (i+1) % 4, @@ -214,45 +216,45 @@ inline typename MatrixType::Scalar ei_4x4_cofactor(const MatrixType& matrix) j2 = (j+2) % 4, j3 = (j+3) % 4 }; - return ei_general_det3_helper(matrix, i1, i2, i3, j1, j2, j3) - + ei_general_det3_helper(matrix, i2, i3, i1, j1, j2, j3) - + ei_general_det3_helper(matrix, i3, i1, i2, j1, j2, j3); + return general_det3_helper(matrix, i1, i2, i3, j1, j2, j3) + + general_det3_helper(matrix, i2, i3, i1, j1, j2, j3) + + general_det3_helper(matrix, i3, i1, i2, j1, j2, j3); } template -struct ei_compute_inverse_size4 +struct compute_inverse_size4 { static void run(const MatrixType& matrix, ResultType& result) { - result.coeffRef(0,0) = ei_4x4_cofactor(matrix); - result.coeffRef(1,0) = -ei_4x4_cofactor(matrix); - result.coeffRef(2,0) = ei_4x4_cofactor(matrix); - result.coeffRef(3,0) = -ei_4x4_cofactor(matrix); - result.coeffRef(0,2) = ei_4x4_cofactor(matrix); - result.coeffRef(1,2) = -ei_4x4_cofactor(matrix); - result.coeffRef(2,2) = ei_4x4_cofactor(matrix); - result.coeffRef(3,2) = -ei_4x4_cofactor(matrix); - result.coeffRef(0,1) = -ei_4x4_cofactor(matrix); - result.coeffRef(1,1) = ei_4x4_cofactor(matrix); - result.coeffRef(2,1) = -ei_4x4_cofactor(matrix); - result.coeffRef(3,1) = ei_4x4_cofactor(matrix); - result.coeffRef(0,3) = -ei_4x4_cofactor(matrix); - result.coeffRef(1,3) = ei_4x4_cofactor(matrix); - result.coeffRef(2,3) = -ei_4x4_cofactor(matrix); - result.coeffRef(3,3) = ei_4x4_cofactor(matrix); + result.coeffRef(0,0) = cofactor_4x4(matrix); + result.coeffRef(1,0) = -cofactor_4x4(matrix); + result.coeffRef(2,0) = cofactor_4x4(matrix); + result.coeffRef(3,0) = -cofactor_4x4(matrix); + result.coeffRef(0,2) = cofactor_4x4(matrix); + result.coeffRef(1,2) = -cofactor_4x4(matrix); + result.coeffRef(2,2) = cofactor_4x4(matrix); + result.coeffRef(3,2) = -cofactor_4x4(matrix); + result.coeffRef(0,1) = -cofactor_4x4(matrix); + result.coeffRef(1,1) = cofactor_4x4(matrix); + result.coeffRef(2,1) = -cofactor_4x4(matrix); + result.coeffRef(3,1) = cofactor_4x4(matrix); + result.coeffRef(0,3) = -cofactor_4x4(matrix); + result.coeffRef(1,3) = cofactor_4x4(matrix); + result.coeffRef(2,3) = -cofactor_4x4(matrix); + result.coeffRef(3,3) = cofactor_4x4(matrix); result /= (matrix.col(0).cwiseProduct(result.row(0).transpose())).sum(); } }; template -struct ei_compute_inverse - : ei_compute_inverse_size4 + : compute_inverse_size4 { }; template -struct ei_compute_inverse_and_det_with_check +struct compute_inverse_and_det_with_check { static inline void run( const MatrixType& matrix, @@ -263,8 +265,8 @@ struct ei_compute_inverse_and_det_with_check ) { determinant = matrix.determinant(); - invertible = ei_abs(determinant) > absDeterminantThreshold; - if(invertible) ei_compute_inverse::run(matrix, inverse); + invertible = abs(determinant) > absDeterminantThreshold; + if(invertible) compute_inverse::run(matrix, inverse); } }; @@ -273,20 +275,20 @@ struct ei_compute_inverse_and_det_with_check *************************/ template -struct ei_traits > +struct traits > { typedef typename MatrixType::PlainObject ReturnType; }; template -struct ei_inverse_impl : public ReturnByValue > +struct inverse_impl : public ReturnByValue > { typedef typename MatrixType::Index Index; - typedef typename ei_eval::type MatrixTypeNested; - typedef typename ei_cleantype::type MatrixTypeNestedCleaned; + typedef typename eval::type MatrixTypeNested; + typedef typename cleantype::type MatrixTypeNestedCleaned; const MatrixTypeNested m_matrix; - ei_inverse_impl(const MatrixType& matrix) + inverse_impl(const MatrixType& matrix) : m_matrix(matrix) {} @@ -297,13 +299,15 @@ struct ei_inverse_impl : public ReturnByValue > { const int Size = EIGEN_PLAIN_ENUM_MIN(MatrixType::ColsAtCompileTime,Dest::ColsAtCompileTime); EIGEN_ONLY_USED_FOR_DEBUG(Size); - ei_assert(( (Size<=1) || (Size>4) || (ei_extract_data(m_matrix)!=ei_extract_data(dst))) + eigen_assert(( (Size<=1) || (Size>4) || (extract_data(m_matrix)!=extract_data(dst))) && "Aliasing problem detected in inverse(), you need to do inverse().eval() here."); - ei_compute_inverse::run(m_matrix, dst); + compute_inverse::run(m_matrix, dst); } }; +} // end namespace internal + /** \lu_module * * \returns the matrix inverse of this matrix. @@ -322,11 +326,11 @@ struct ei_inverse_impl : public ReturnByValue > * \sa computeInverseAndDetWithCheck() */ template -inline const ei_inverse_impl MatrixBase::inverse() const +inline const internal::inverse_impl MatrixBase::inverse() const { EIGEN_STATIC_ASSERT(!NumTraits::IsInteger,THIS_FUNCTION_IS_NOT_FOR_INTEGER_NUMERIC_TYPES) - ei_assert(rows() == cols()); - return ei_inverse_impl(derived()); + eigen_assert(rows() == cols()); + return internal::inverse_impl(derived()); } /** \lu_module @@ -357,15 +361,15 @@ inline void MatrixBase::computeInverseAndDetWithCheck( ) const { // i'd love to put some static assertions there, but SFINAE means that they have no effect... - ei_assert(rows() == cols()); + eigen_assert(rows() == cols()); // for 2x2, it's worth giving a chance to avoid evaluating. // for larger sizes, evaluating has negligible cost and limits code size. - typedef typename ei_meta_if< + typedef typename internal::meta_if< RowsAtCompileTime == 2, - typename ei_cleantype::type>::type, + typename internal::cleantype::type>::type, PlainObject >::ret MatrixType; - ei_compute_inverse_and_det_with_check::run + internal::compute_inverse_and_det_with_check::run (derived(), absDeterminantThreshold, inverse, determinant, invertible); } @@ -396,7 +400,7 @@ inline void MatrixBase::computeInverseWithCheck( { RealScalar determinant; // i'd love to put some static assertions there, but SFINAE means that they have no effect... - ei_assert(rows() == cols()); + eigen_assert(rows() == cols()); computeInverseAndDetWithCheck(inverse,determinant,invertible,absDeterminantThreshold); } diff --git a/Eigen/src/LU/PartialPivLU.h b/Eigen/src/LU/PartialPivLU.h index fe91ecd3f..908c00c5c 100644 --- a/Eigen/src/LU/PartialPivLU.h +++ b/Eigen/src/LU/PartialPivLU.h @@ -71,7 +71,7 @@ template class PartialPivLU }; typedef typename MatrixType::Scalar Scalar; typedef typename NumTraits::Real RealScalar; - typedef typename ei_traits::StorageKind StorageKind; + typedef typename internal::traits::StorageKind StorageKind; typedef typename MatrixType::Index Index; typedef PermutationMatrix PermutationType; typedef Transpositions TranspositionType; @@ -112,7 +112,7 @@ template class PartialPivLU */ inline const MatrixType& matrixLU() const { - ei_assert(m_isInitialized && "PartialPivLU is not initialized."); + eigen_assert(m_isInitialized && "PartialPivLU is not initialized."); return m_lu; } @@ -120,7 +120,7 @@ template class PartialPivLU */ inline const PermutationType& permutationP() const { - ei_assert(m_isInitialized && "PartialPivLU is not initialized."); + eigen_assert(m_isInitialized && "PartialPivLU is not initialized."); return m_p; } @@ -142,11 +142,11 @@ template class PartialPivLU * \sa TriangularView::solve(), inverse(), computeInverse() */ template - inline const ei_solve_retval + inline const internal::solve_retval solve(const MatrixBase& b) const { - ei_assert(m_isInitialized && "PartialPivLU is not initialized."); - return ei_solve_retval(*this, b.derived()); + eigen_assert(m_isInitialized && "PartialPivLU is not initialized."); + return internal::solve_retval(*this, b.derived()); } /** \returns the inverse of the matrix of which *this is the LU decomposition. @@ -156,10 +156,10 @@ template class PartialPivLU * * \sa MatrixBase::inverse(), LU::inverse() */ - inline const ei_solve_retval inverse() const + inline const internal::solve_retval inverse() const { - ei_assert(m_isInitialized && "PartialPivLU is not initialized."); - return ei_solve_retval + eigen_assert(m_isInitialized && "PartialPivLU is not initialized."); + return internal::solve_retval (*this, MatrixType::Identity(m_lu.rows(), m_lu.cols())); } @@ -176,7 +176,7 @@ template class PartialPivLU * * \sa MatrixBase::determinant() */ - typename ei_traits::Scalar determinant() const; + typename internal::traits::Scalar determinant() const; MatrixType reconstructedMatrix() const; @@ -222,9 +222,11 @@ PartialPivLU::PartialPivLU(const MatrixType& matrix) compute(matrix); } -/** \internal This is the blocked version of ei_fullpivlu_unblocked() */ +namespace internal { + +/** \internal This is the blocked version of fullpivlu_unblocked() */ template -struct ei_partial_lu_impl +struct partial_lu_impl { // FIXME add a stride to Map, so that the following mapping becomes easier, // another option would be to create an expression being able to automatically @@ -390,28 +392,30 @@ struct ei_partial_lu_impl /** \internal performs the LU decomposition with partial pivoting in-place. */ template -void ei_partial_lu_inplace(MatrixType& lu, TranspositionType& row_transpositions, typename MatrixType::Index& nb_transpositions) +void partial_lu_inplace(MatrixType& lu, TranspositionType& row_transpositions, typename MatrixType::Index& nb_transpositions) { - ei_assert(lu.cols() == row_transpositions.size()); - ei_assert((&row_transpositions.coeffRef(1)-&row_transpositions.coeffRef(0)) == 1); + eigen_assert(lu.cols() == row_transpositions.size()); + eigen_assert((&row_transpositions.coeffRef(1)-&row_transpositions.coeffRef(0)) == 1); - ei_partial_lu_impl + partial_lu_impl ::blocked_lu(lu.rows(), lu.cols(), &lu.coeffRef(0,0), lu.outerStride(), &row_transpositions.coeffRef(0), nb_transpositions); } +} // end namespace internal + template PartialPivLU& PartialPivLU::compute(const MatrixType& matrix) { m_lu = matrix; - ei_assert(matrix.rows() == matrix.cols() && "PartialPivLU is only for square (and moreover invertible) matrices"); + eigen_assert(matrix.rows() == matrix.cols() && "PartialPivLU is only for square (and moreover invertible) matrices"); const Index size = matrix.rows(); m_rowsTranspositions.resize(size); Index nb_transpositions; - ei_partial_lu_inplace(m_lu, m_rowsTranspositions, nb_transpositions); + internal::partial_lu_inplace(m_lu, m_rowsTranspositions, nb_transpositions); m_det_p = (nb_transpositions%2) ? -1 : 1; m_p = m_rowsTranspositions; @@ -421,9 +425,9 @@ PartialPivLU& PartialPivLU::compute(const MatrixType& ma } template -typename ei_traits::Scalar PartialPivLU::determinant() const +typename internal::traits::Scalar PartialPivLU::determinant() const { - ei_assert(m_isInitialized && "PartialPivLU is not initialized."); + eigen_assert(m_isInitialized && "PartialPivLU is not initialized."); return Scalar(m_det_p) * m_lu.diagonal().prod(); } @@ -433,7 +437,7 @@ typename ei_traits::Scalar PartialPivLU::determinant() c template MatrixType PartialPivLU::reconstructedMatrix() const { - ei_assert(m_isInitialized && "LU is not initialized."); + eigen_assert(m_isInitialized && "LU is not initialized."); // LU MatrixType res = m_lu.template triangularView().toDenseMatrix() * m_lu.template triangularView(); @@ -446,9 +450,11 @@ MatrixType PartialPivLU::reconstructedMatrix() const /***** Implementation of solve() *****************************************************/ +namespace internal { + template -struct ei_solve_retval, Rhs> - : ei_solve_retval_base, Rhs> +struct solve_retval, Rhs> + : solve_retval_base, Rhs> { EIGEN_MAKE_SOLVE_HELPERS(PartialPivLU<_MatrixType>,Rhs) @@ -461,7 +467,7 @@ struct ei_solve_retval, Rhs> * Step 3: replace c by the solution x to Ux = c. */ - ei_assert(rhs().rows() == dec().matrixLU().rows()); + eigen_assert(rhs().rows() == dec().matrixLU().rows()); // Step 1 dst = dec().permutationP() * rhs(); @@ -474,6 +480,8 @@ struct ei_solve_retval, Rhs> } }; +} // end namespace internal + /******** MatrixBase methods *******/ /** \lu_module diff --git a/Eigen/src/LU/arch/Inverse_SSE.h b/Eigen/src/LU/arch/Inverse_SSE.h index 6d497d326..0fe9be388 100644 --- a/Eigen/src/LU/arch/Inverse_SSE.h +++ b/Eigen/src/LU/arch/Inverse_SSE.h @@ -42,8 +42,10 @@ #ifndef EIGEN_INVERSE_SSE_H #define EIGEN_INVERSE_SSE_H +namespace internal { + template -struct ei_compute_inverse_size4 +struct compute_inverse_size4 { enum { MatrixAlignment = bool(MatrixType::Flags&AlignedBit), @@ -171,7 +173,7 @@ struct ei_compute_inverse_size4 -struct ei_compute_inverse_size4 +struct compute_inverse_size4 { enum { MatrixAlignment = bool(MatrixType::Flags&AlignedBit), @@ -333,4 +335,6 @@ struct ei_compute_inverse_size4 class ColPivHouseholderQR typedef typename MatrixType::RealScalar RealScalar; typedef typename MatrixType::Index Index; typedef Matrix MatrixQType; - typedef typename ei_plain_diag_type::type HCoeffsType; + typedef typename internal::plain_diag_type::type HCoeffsType; typedef PermutationMatrix PermutationType; - typedef typename ei_plain_row_type::type IntRowVectorType; - typedef typename ei_plain_row_type::type RowVectorType; - typedef typename ei_plain_row_type::type RealRowVectorType; + typedef typename internal::plain_row_type::type IntRowVectorType; + typedef typename internal::plain_row_type::type RowVectorType; + typedef typename internal::plain_row_type::type RealRowVectorType; typedef typename HouseholderSequence::ConjugateReturnType HouseholderSequenceType; /** @@ -132,11 +132,11 @@ template class ColPivHouseholderQR * Output: \verbinclude ColPivHouseholderQR_solve.out */ template - inline const ei_solve_retval + inline const internal::solve_retval solve(const MatrixBase& b) const { - ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); - return ei_solve_retval(*this, b.derived()); + eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); + return internal::solve_retval(*this, b.derived()); } HouseholderSequenceType householderQ(void) const; @@ -145,7 +145,7 @@ template class ColPivHouseholderQR */ const MatrixType& matrixQR() const { - ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); return m_qr; } @@ -153,7 +153,7 @@ template class ColPivHouseholderQR const PermutationType& colsPermutation() const { - ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); return m_colsPermutation; } @@ -194,11 +194,11 @@ template class ColPivHouseholderQR */ inline Index rank() const { - ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); - RealScalar premultiplied_threshold = ei_abs(m_maxpivot) * threshold(); + eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); + RealScalar premultiplied_threshold = internal::abs(m_maxpivot) * threshold(); Index result = 0; for(Index i = 0; i < m_nonzero_pivots; ++i) - result += (ei_abs(m_qr.coeff(i,i)) > premultiplied_threshold); + result += (internal::abs(m_qr.coeff(i,i)) > premultiplied_threshold); return result; } @@ -210,7 +210,7 @@ template class ColPivHouseholderQR */ inline Index dimensionOfKernel() const { - ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); return cols() - rank(); } @@ -223,7 +223,7 @@ template class ColPivHouseholderQR */ inline bool isInjective() const { - ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); return rank() == cols(); } @@ -236,7 +236,7 @@ template class ColPivHouseholderQR */ inline bool isSurjective() const { - ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); return rank() == rows(); } @@ -248,7 +248,7 @@ template class ColPivHouseholderQR */ inline bool isInvertible() const { - ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); return isInjective() && isSurjective(); } @@ -258,11 +258,11 @@ template class ColPivHouseholderQR * Use isInvertible() to first determine whether this matrix is invertible. */ inline const - ei_solve_retval + internal::solve_retval inverse() const { - ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); - return ei_solve_retval + eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); + return internal::solve_retval (*this, MatrixType::Identity(m_qr.rows(), m_qr.cols())); } @@ -314,7 +314,7 @@ template class ColPivHouseholderQR */ RealScalar threshold() const { - ei_assert(m_isInitialized || m_usePrescribedThreshold); + eigen_assert(m_isInitialized || m_usePrescribedThreshold); return m_usePrescribedThreshold ? m_prescribedThreshold // this formula comes from experimenting (see "LU precision tuning" thread on the list) // and turns out to be identical to Higham's formula used already in LDLt. @@ -330,7 +330,7 @@ template class ColPivHouseholderQR */ inline Index nonzeroPivots() const { - ei_assert(m_isInitialized && "LU is not initialized."); + eigen_assert(m_isInitialized && "LU is not initialized."); return m_nonzero_pivots; } @@ -355,16 +355,16 @@ template class ColPivHouseholderQR template typename MatrixType::RealScalar ColPivHouseholderQR::absDeterminant() const { - ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); - ei_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); - return ei_abs(m_qr.diagonal().prod()); + eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); + eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); + return internal::abs(m_qr.diagonal().prod()); } template typename MatrixType::RealScalar ColPivHouseholderQR::logAbsDeterminant() const { - ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); - ei_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); + eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); + eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); return m_qr.diagonal().cwiseAbs().array().log().sum(); } @@ -387,7 +387,7 @@ ColPivHouseholderQR& ColPivHouseholderQR::compute(const for(Index k = 0; k < cols; ++k) m_colSqNorms.coeffRef(k) = m_qr.col(k).squaredNorm(); - RealScalar threshold_helper = m_colSqNorms.maxCoeff() * ei_abs2(NumTraits::epsilon()) / rows; + RealScalar threshold_helper = m_colSqNorms.maxCoeff() * internal::abs2(NumTraits::epsilon()) / rows; m_nonzero_pivots = size; // the generic case is that in which all pivots are nonzero (invertible case) m_maxpivot = RealScalar(0); @@ -439,7 +439,7 @@ ColPivHouseholderQR& ColPivHouseholderQR::compute(const m_qr.coeffRef(k,k) = beta; // remember the maximum absolute value of diagonal coefficients - if(ei_abs(beta) > m_maxpivot) m_maxpivot = ei_abs(beta); + if(internal::abs(beta) > m_maxpivot) m_maxpivot = internal::abs(beta); // apply the householder transformation m_qr.bottomRightCorner(rows-k, cols-k-1) @@ -459,15 +459,17 @@ ColPivHouseholderQR& ColPivHouseholderQR::compute(const return *this; } +namespace internal { + template -struct ei_solve_retval, Rhs> - : ei_solve_retval_base, Rhs> +struct solve_retval, Rhs> + : solve_retval_base, Rhs> { EIGEN_MAKE_SOLVE_HELPERS(ColPivHouseholderQR<_MatrixType>,Rhs) template void evalTo(Dest& dst) const { - ei_assert(rhs().rows() == dec().rows()); + eigen_assert(rhs().rows() == dec().rows()); const int cols = dec().cols(), nonzero_pivots = dec().nonzeroPivots(); @@ -507,12 +509,14 @@ struct ei_solve_retval, Rhs> } }; +} // end namespace internal + /** \returns the matrix Q as a sequence of householder transformations */ template typename ColPivHouseholderQR::HouseholderSequenceType ColPivHouseholderQR ::householderQ() const { - ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); return HouseholderSequenceType(m_qr, m_hCoeffs.conjugate(), false, m_nonzero_pivots, 0); } diff --git a/Eigen/src/QR/FullPivHouseholderQR.h b/Eigen/src/QR/FullPivHouseholderQR.h index e228aeb44..4dee21580 100644 --- a/Eigen/src/QR/FullPivHouseholderQR.h +++ b/Eigen/src/QR/FullPivHouseholderQR.h @@ -63,12 +63,12 @@ template class FullPivHouseholderQR typedef typename MatrixType::RealScalar RealScalar; typedef typename MatrixType::Index Index; typedef Matrix MatrixQType; - typedef typename ei_plain_diag_type::type HCoeffsType; + typedef typename internal::plain_diag_type::type HCoeffsType; typedef Matrix IntRowVectorType; typedef PermutationMatrix PermutationType; - typedef typename ei_plain_col_type::type IntColVectorType; - typedef typename ei_plain_row_type::type RowVectorType; - typedef typename ei_plain_col_type::type ColVectorType; + typedef typename internal::plain_col_type::type IntColVectorType; + typedef typename internal::plain_row_type::type RowVectorType; + typedef typename internal::plain_col_type::type ColVectorType; /** \brief Default Constructor. * @@ -129,11 +129,11 @@ template class FullPivHouseholderQR * Output: \verbinclude FullPivHouseholderQR_solve.out */ template - inline const ei_solve_retval + inline const internal::solve_retval solve(const MatrixBase& b) const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); - return ei_solve_retval(*this, b.derived()); + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + return internal::solve_retval(*this, b.derived()); } MatrixQType matrixQ(void) const; @@ -142,7 +142,7 @@ template class FullPivHouseholderQR */ const MatrixType& matrixQR() const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); return m_qr; } @@ -150,13 +150,13 @@ template class FullPivHouseholderQR const PermutationType& colsPermutation() const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); return m_cols_permutation; } const IntColVectorType& rowsTranspositions() const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); return m_rows_transpositions; } @@ -196,7 +196,7 @@ template class FullPivHouseholderQR */ inline Index rank() const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); return m_rank; } @@ -207,7 +207,7 @@ template class FullPivHouseholderQR */ inline Index dimensionOfKernel() const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); return m_qr.cols() - m_rank; } @@ -219,7 +219,7 @@ template class FullPivHouseholderQR */ inline bool isInjective() const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); return m_rank == m_qr.cols(); } @@ -231,7 +231,7 @@ template class FullPivHouseholderQR */ inline bool isSurjective() const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); return m_rank == m_qr.rows(); } @@ -242,7 +242,7 @@ template class FullPivHouseholderQR */ inline bool isInvertible() const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); return isInjective() && isSurjective(); } @@ -251,11 +251,11 @@ template class FullPivHouseholderQR * \note If this matrix is not invertible, the returned matrix has undefined coefficients. * Use isInvertible() to first determine whether this matrix is invertible. */ inline const - ei_solve_retval + internal::solve_retval inverse() const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); - return ei_solve_retval + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + return internal::solve_retval (*this, MatrixType::Identity(m_qr.rows(), m_qr.cols())); } @@ -279,16 +279,16 @@ template class FullPivHouseholderQR template typename MatrixType::RealScalar FullPivHouseholderQR::absDeterminant() const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); - ei_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); - return ei_abs(m_qr.diagonal().prod()); + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); + return internal::abs(m_qr.diagonal().prod()); } template typename MatrixType::RealScalar FullPivHouseholderQR::logAbsDeterminant() const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); - ei_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); return m_qr.diagonal().cwiseAbs().array().log().sum(); } @@ -326,7 +326,7 @@ FullPivHouseholderQR& FullPivHouseholderQR::compute(cons if(k==0) biggest = biggest_in_corner; // if the corner is negligible, then we have less than full rank, and we can finish early - if(ei_isMuchSmallerThan(biggest_in_corner, biggest, m_precision)) + if(internal::isMuchSmallerThan(biggest_in_corner, biggest, m_precision)) { m_rank = k; for(Index i = k; i < size; i++) @@ -367,16 +367,18 @@ FullPivHouseholderQR& FullPivHouseholderQR::compute(cons return *this; } +namespace internal { + template -struct ei_solve_retval, Rhs> - : ei_solve_retval_base, Rhs> +struct solve_retval, Rhs> + : solve_retval_base, Rhs> { EIGEN_MAKE_SOLVE_HELPERS(FullPivHouseholderQR<_MatrixType>,Rhs) template void evalTo(Dest& dst) const { const Index rows = dec().rows(), cols = dec().cols(); - ei_assert(rhs().rows() == rows); + eigen_assert(rhs().rows() == rows); // FIXME introduce nonzeroPivots() and use it here. and more generally, // make the same improvements in this dec as in FullPivLU. @@ -405,7 +407,7 @@ struct ei_solve_retval, Rhs> RealScalar biggest_in_lower_part_of_c = c.bottomRows(rows-dec().rank()).cwiseAbs().maxCoeff(); // FIXME brain dead const RealScalar m_precision = NumTraits::epsilon() * std::min(rows,cols); - if(!ei_isMuchSmallerThan(biggest_in_lower_part_of_c, biggest_in_upper_part_of_c, m_precision)) + if(!isMuchSmallerThan(biggest_in_lower_part_of_c, biggest_in_upper_part_of_c, m_precision)) return; } dec().matrixQR() @@ -418,11 +420,13 @@ struct ei_solve_retval, Rhs> } }; +} // end namespace internal + /** \returns the matrix Q */ template typename FullPivHouseholderQR::MatrixQType FullPivHouseholderQR::matrixQ() const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); // compute the product H'_0 H'_1 ... H'_n-1, // where H_k is the k-th Householder transformation I - h_k v_k v_k' // and v_k is the k-th Householder vector [1,m_qr(k+1,k), m_qr(k+2,k), ...] @@ -434,7 +438,7 @@ typename FullPivHouseholderQR::MatrixQType FullPivHouseholderQR= 0; k--) { res.block(k, k, rows-k, rows-k) - .applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), ei_conj(m_hCoeffs.coeff(k)), &temp.coeffRef(k)); + .applyHouseholderOnTheLeft(m_qr.col(k).tail(rows-k-1), internal::conj(m_hCoeffs.coeff(k)), &temp.coeffRef(k)); res.row(k).swap(res.row(m_rows_transpositions.coeff(k))); } return res; diff --git a/Eigen/src/QR/HouseholderQR.h b/Eigen/src/QR/HouseholderQR.h index f8d759772..0d2b74893 100644 --- a/Eigen/src/QR/HouseholderQR.h +++ b/Eigen/src/QR/HouseholderQR.h @@ -68,8 +68,8 @@ template class HouseholderQR typedef typename MatrixType::RealScalar RealScalar; typedef typename MatrixType::Index Index; typedef Matrix MatrixQType; - typedef typename ei_plain_diag_type::type HCoeffsType; - typedef typename ei_plain_row_type::type RowVectorType; + typedef typename internal::plain_diag_type::type HCoeffsType; + typedef typename internal::plain_row_type::type RowVectorType; typedef typename HouseholderSequence::ConjugateReturnType HouseholderSequenceType; /** @@ -119,16 +119,16 @@ template class HouseholderQR * Output: \verbinclude HouseholderQR_solve.out */ template - inline const ei_solve_retval + inline const internal::solve_retval solve(const MatrixBase& b) const { - ei_assert(m_isInitialized && "HouseholderQR is not initialized."); - return ei_solve_retval(*this, b.derived()); + eigen_assert(m_isInitialized && "HouseholderQR is not initialized."); + return internal::solve_retval(*this, b.derived()); } HouseholderSequenceType householderQ() const { - ei_assert(m_isInitialized && "HouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "HouseholderQR is not initialized."); return HouseholderSequenceType(m_qr, m_hCoeffs.conjugate()); } @@ -137,7 +137,7 @@ template class HouseholderQR */ const MatrixType& matrixQR() const { - ei_assert(m_isInitialized && "HouseholderQR is not initialized."); + eigen_assert(m_isInitialized && "HouseholderQR is not initialized."); return m_qr; } @@ -186,22 +186,24 @@ template class HouseholderQR template typename MatrixType::RealScalar HouseholderQR::absDeterminant() const { - ei_assert(m_isInitialized && "HouseholderQR is not initialized."); - ei_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); - return ei_abs(m_qr.diagonal().prod()); + eigen_assert(m_isInitialized && "HouseholderQR is not initialized."); + eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); + return internal::abs(m_qr.diagonal().prod()); } template typename MatrixType::RealScalar HouseholderQR::logAbsDeterminant() const { - ei_assert(m_isInitialized && "HouseholderQR is not initialized."); - ei_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); + eigen_assert(m_isInitialized && "HouseholderQR is not initialized."); + eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); return m_qr.diagonal().cwiseAbs().array().log().sum(); } +namespace internal { + /** \internal */ template -void ei_householder_qr_inplace_unblocked(MatrixQR& mat, HCoeffs& hCoeffs, typename MatrixQR::Scalar* tempData = 0) +void householder_qr_inplace_unblocked(MatrixQR& mat, HCoeffs& hCoeffs, typename MatrixQR::Scalar* tempData = 0) { typedef typename MatrixQR::Index Index; typedef typename MatrixQR::Scalar Scalar; @@ -210,7 +212,7 @@ void ei_householder_qr_inplace_unblocked(MatrixQR& mat, HCoeffs& hCoeffs, typena Index cols = mat.cols(); Index size = std::min(rows,cols); - ei_assert(hCoeffs.size() == size); + eigen_assert(hCoeffs.size() == size); typedef Matrix TempType; TempType tempVector; @@ -237,7 +239,7 @@ void ei_householder_qr_inplace_unblocked(MatrixQR& mat, HCoeffs& hCoeffs, typena /** \internal */ template -void ei_householder_qr_inplace_blocked(MatrixQR& mat, HCoeffs& hCoeffs, +void householder_qr_inplace_blocked(MatrixQR& mat, HCoeffs& hCoeffs, typename MatrixQR::Index maxBlockSize=32, typename MatrixQR::Scalar* tempData = 0) { @@ -278,37 +280,19 @@ void ei_householder_qr_inplace_blocked(MatrixQR& mat, HCoeffs& hCoeffs, BlockType A11_21 = mat.block(k,k,brows,bs); Block hCoeffsSegment = hCoeffs.segment(k,bs); - ei_householder_qr_inplace_unblocked(A11_21, hCoeffsSegment, tempData); + householder_qr_inplace_unblocked(A11_21, hCoeffsSegment, tempData); if(tcols) { BlockType A21_22 = mat.block(k,k+bs,brows,tcols); - ei_apply_block_householder_on_the_left(A21_22,A11_21,hCoeffsSegment.adjoint()); + apply_block_householder_on_the_left(A21_22,A11_21,hCoeffsSegment.adjoint()); } } } -template -HouseholderQR& HouseholderQR::compute(const MatrixType& matrix) -{ - Index rows = matrix.rows(); - Index cols = matrix.cols(); - Index size = std::min(rows,cols); - - m_qr = matrix; - m_hCoeffs.resize(size); - - m_temp.resize(cols); - - ei_householder_qr_inplace_blocked(m_qr, m_hCoeffs, 48, m_temp.data()); - - m_isInitialized = true; - return *this; -} - template -struct ei_solve_retval, Rhs> - : ei_solve_retval_base, Rhs> +struct solve_retval, Rhs> + : solve_retval_base, Rhs> { EIGEN_MAKE_SOLVE_HELPERS(HouseholderQR<_MatrixType>,Rhs) @@ -316,7 +300,7 @@ struct ei_solve_retval, Rhs> { const Index rows = dec().rows(), cols = dec().cols(); const Index rank = std::min(rows, cols); - ei_assert(rhs().rows() == rows); + eigen_assert(rhs().rows() == rows); typename Rhs::PlainObject c(rhs()); @@ -336,6 +320,26 @@ struct ei_solve_retval, Rhs> } }; +} // end namespace internal + +template +HouseholderQR& HouseholderQR::compute(const MatrixType& matrix) +{ + Index rows = matrix.rows(); + Index cols = matrix.cols(); + Index size = std::min(rows,cols); + + m_qr = matrix; + m_hCoeffs.resize(size); + + m_temp.resize(cols); + + internal::householder_qr_inplace_blocked(m_qr, m_hCoeffs, 48, m_temp.data()); + + m_isInitialized = true; + return *this; +} + /** \return the Householder QR decomposition of \c *this. * * \sa class HouseholderQR diff --git a/Eigen/src/SVD/JacobiSVD.h b/Eigen/src/SVD/JacobiSVD.h index 56ffea131..d180db7db 100644 --- a/Eigen/src/SVD/JacobiSVD.h +++ b/Eigen/src/SVD/JacobiSVD.h @@ -25,12 +25,12 @@ #ifndef EIGEN_JACOBISVD_H #define EIGEN_JACOBISVD_H +namespace internal { // forward declaration (needed by ICC) // the empty body is required by MSVC template::IsComplex> -struct ei_svd_precondition_2x2_block_to_be_real {}; - +struct svd_precondition_2x2_block_to_be_real {}; /*** QR preconditioners (R-SVD) *** @@ -42,7 +42,7 @@ struct ei_svd_precondition_2x2_block_to_be_real {}; enum { PreconditionIfMoreColsThanRows, PreconditionIfMoreRowsThanCols }; template -struct ei_qr_preconditioner_should_do_anything +struct qr_preconditioner_should_do_anything { enum { a = MatrixType::RowsAtCompileTime != Dynamic && MatrixType::ColsAtCompileTime != Dynamic && @@ -57,11 +57,11 @@ struct ei_qr_preconditioner_should_do_anything }; template::ret -> struct ei_qr_preconditioner_impl {}; + bool DoAnything = qr_preconditioner_should_do_anything::ret +> struct qr_preconditioner_impl {}; template -struct ei_qr_preconditioner_impl +struct qr_preconditioner_impl { static bool run(JacobiSVD&, const MatrixType&) { @@ -72,7 +72,7 @@ struct ei_qr_preconditioner_impl /*** preconditioner using FullPivHouseholderQR ***/ template -struct ei_qr_preconditioner_impl +struct qr_preconditioner_impl { static bool run(JacobiSVD& svd, const MatrixType& matrix) { @@ -89,7 +89,7 @@ struct ei_qr_preconditioner_impl -struct ei_qr_preconditioner_impl +struct qr_preconditioner_impl { static bool run(JacobiSVD& svd, const MatrixType& matrix) { @@ -111,7 +111,7 @@ struct ei_qr_preconditioner_impl -struct ei_qr_preconditioner_impl +struct qr_preconditioner_impl { static bool run(JacobiSVD& svd, const MatrixType& matrix) { @@ -132,7 +132,7 @@ struct ei_qr_preconditioner_impl -struct ei_qr_preconditioner_impl +struct qr_preconditioner_impl { static bool run(JacobiSVD& svd, const MatrixType& matrix) { @@ -158,7 +158,7 @@ struct ei_qr_preconditioner_impl -struct ei_qr_preconditioner_impl +struct qr_preconditioner_impl { static bool run(JacobiSVD& svd, const MatrixType& matrix) { @@ -179,7 +179,7 @@ struct ei_qr_preconditioner_impl -struct ei_qr_preconditioner_impl +struct qr_preconditioner_impl { static bool run(JacobiSVD& svd, const MatrixType& matrix) { @@ -202,7 +202,90 @@ struct ei_qr_preconditioner_impl +struct svd_precondition_2x2_block_to_be_real +{ + typedef JacobiSVD SVD; + typedef typename SVD::Index Index; + static void run(typename SVD::WorkMatrixType&, SVD&, Index, Index) {} +}; + +template +struct svd_precondition_2x2_block_to_be_real +{ + typedef JacobiSVD SVD; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef typename SVD::Index Index; + static void run(typename SVD::WorkMatrixType& work_matrix, SVD& svd, Index p, Index q) + { + Scalar z; + JacobiRotation rot; + RealScalar n = sqrt(abs2(work_matrix.coeff(p,p)) + abs2(work_matrix.coeff(q,p))); + if(n==0) + { + z = abs(work_matrix.coeff(p,q)) / work_matrix.coeff(p,q); + work_matrix.row(p) *= z; + if(svd.computeU()) svd.m_matrixU.col(p) *= conj(z); + z = abs(work_matrix.coeff(q,q)) / work_matrix.coeff(q,q); + work_matrix.row(q) *= z; + if(svd.computeU()) svd.m_matrixU.col(q) *= conj(z); + } + else + { + rot.c() = conj(work_matrix.coeff(p,p)) / n; + rot.s() = work_matrix.coeff(q,p) / n; + work_matrix.applyOnTheLeft(p,q,rot); + if(svd.computeU()) svd.m_matrixU.applyOnTheRight(p,q,rot.adjoint()); + if(work_matrix.coeff(p,q) != Scalar(0)) + { + Scalar z = abs(work_matrix.coeff(p,q)) / work_matrix.coeff(p,q); + work_matrix.col(q) *= z; + if(svd.computeV()) svd.m_matrixV.col(q) *= z; + } + if(work_matrix.coeff(q,q) != Scalar(0)) + { + z = abs(work_matrix.coeff(q,q)) / work_matrix.coeff(q,q); + work_matrix.row(q) *= z; + if(svd.computeU()) svd.m_matrixU.col(q) *= conj(z); + } + } + } +}; + +template +void real_2x2_jacobi_svd(const MatrixType& matrix, Index p, Index q, + JacobiRotation *j_left, + JacobiRotation *j_right) +{ + Matrix m; + m << real(matrix.coeff(p,p)), real(matrix.coeff(p,q)), + real(matrix.coeff(q,p)), real(matrix.coeff(q,q)); + JacobiRotation rot1; + RealScalar t = m.coeff(0,0) + m.coeff(1,1); + RealScalar d = m.coeff(1,0) - m.coeff(0,1); + if(t == RealScalar(0)) + { + rot1.c() = 0; + rot1.s() = d > 0 ? 1 : -1; + } + else + { + RealScalar u = d / t; + rot1.c() = RealScalar(1) / sqrt(1 + abs2(u)); + rot1.s() = rot1.c() * u; + } + m.applyOnTheLeft(0,1,rot1); + j_right->makeJacobi(m,0,1); + *j_left = rot1 * j_right->transpose(); +} +} // end namespace internal /** \ingroup SVD_Module * @@ -281,9 +364,9 @@ template class JacobiSVD typedef Matrix MatrixVType; - typedef typename ei_plain_diag_type::type SingularValuesType; - typedef typename ei_plain_row_type::type RowType; - typedef typename ei_plain_col_type::type ColType; + typedef typename internal::plain_diag_type::type SingularValuesType; + typedef typename internal::plain_row_type::type RowType; + typedef typename internal::plain_col_type::type ColType; typedef Matrix WorkMatrixType; @@ -345,8 +428,8 @@ template class JacobiSVD */ const MatrixUType& matrixU() const { - ei_assert(m_isInitialized && "JacobiSVD is not initialized."); - ei_assert(computeU() && "This JacobiSVD decomposition didn't compute U. Did you ask for it?"); + eigen_assert(m_isInitialized && "JacobiSVD is not initialized."); + eigen_assert(computeU() && "This JacobiSVD decomposition didn't compute U. Did you ask for it?"); return m_matrixU; } @@ -361,8 +444,8 @@ template class JacobiSVD */ const MatrixVType& matrixV() const { - ei_assert(m_isInitialized && "JacobiSVD is not initialized."); - ei_assert(computeV() && "This JacobiSVD decomposition didn't compute V. Did you ask for it?"); + eigen_assert(m_isInitialized && "JacobiSVD is not initialized."); + eigen_assert(computeV() && "This JacobiSVD decomposition didn't compute V. Did you ask for it?"); return m_matrixV; } @@ -373,7 +456,7 @@ template class JacobiSVD */ const SingularValuesType& singularValues() const { - ei_assert(m_isInitialized && "JacobiSVD is not initialized."); + eigen_assert(m_isInitialized && "JacobiSVD is not initialized."); return m_singularValues; } @@ -392,18 +475,18 @@ template class JacobiSVD * In other words, the returned solution is guaranteed to minimize the Euclidean norm \f$ \Vert A x - b \Vert \f$. */ template - inline const ei_solve_retval + inline const internal::solve_retval solve(const MatrixBase& b) const { - ei_assert(m_isInitialized && "JacobiSVD is not initialized."); - ei_assert(computeU() && computeV() && "JacobiSVD::solve() requires both unitaries U and V to be computed (thin unitaries suffice)."); - return ei_solve_retval(*this, b.derived()); + eigen_assert(m_isInitialized && "JacobiSVD is not initialized."); + eigen_assert(computeU() && computeV() && "JacobiSVD::solve() requires both unitaries U and V to be computed (thin unitaries suffice)."); + return internal::solve_retval(*this, b.derived()); } /** \returns the number of singular values that are not exactly 0 */ Index nonzeroSingularValues() const { - ei_assert(m_isInitialized && "JacobiSVD is not initialized."); + eigen_assert(m_isInitialized && "JacobiSVD is not initialized."); return m_nonzeroSingularValues; } @@ -424,9 +507,9 @@ template class JacobiSVD Index m_nonzeroSingularValues, m_rows, m_cols, m_diagSize; template - friend struct ei_svd_precondition_2x2_block_to_be_real; + friend struct internal::svd_precondition_2x2_block_to_be_real; template - friend struct ei_qr_preconditioner_impl; + friend struct internal::qr_preconditioner_impl; }; template @@ -439,13 +522,13 @@ void JacobiSVD::allocate(Index rows, Index cols, u m_computeThinU = (computationOptions & ComputeThinU) != 0; m_computeFullV = (computationOptions & ComputeFullV) != 0; m_computeThinV = (computationOptions & ComputeThinV) != 0; - ei_assert(!(m_computeFullU && m_computeThinU) && "JacobiSVD: you can't ask for both full and thin U"); - ei_assert(!(m_computeFullV && m_computeThinV) && "JacobiSVD: you can't ask for both full and thin V"); - ei_assert(EIGEN_IMPLIES(m_computeThinU || m_computeThinV, MatrixType::ColsAtCompileTime==Dynamic) && + eigen_assert(!(m_computeFullU && m_computeThinU) && "JacobiSVD: you can't ask for both full and thin U"); + eigen_assert(!(m_computeFullV && m_computeThinV) && "JacobiSVD: you can't ask for both full and thin V"); + eigen_assert(EIGEN_IMPLIES(m_computeThinU || m_computeThinV, MatrixType::ColsAtCompileTime==Dynamic) && "JacobiSVD: thin U and V are only available when your matrix has a dynamic number of columns."); if (QRPreconditioner == FullPivHouseholderQRPreconditioner) { - ei_assert(!(m_computeThinU || m_computeThinV) && + eigen_assert(!(m_computeThinU || m_computeThinV) && "JacobiSVD: can't compute thin U or thin V with the FullPivHouseholderQR preconditioner. " "Use the ColPivHouseholderQR preconditioner instead."); } @@ -460,85 +543,6 @@ void JacobiSVD::allocate(Index rows, Index cols, u m_workMatrix.resize(m_diagSize, m_diagSize); } - -template -struct ei_svd_precondition_2x2_block_to_be_real -{ - typedef JacobiSVD SVD; - typedef typename SVD::Index Index; - static void run(typename SVD::WorkMatrixType&, SVD&, Index, Index) {} -}; - -template -struct ei_svd_precondition_2x2_block_to_be_real -{ - typedef JacobiSVD SVD; - typedef typename MatrixType::Scalar Scalar; - typedef typename MatrixType::RealScalar RealScalar; - typedef typename SVD::Index Index; - static void run(typename SVD::WorkMatrixType& work_matrix, SVD& svd, Index p, Index q) - { - Scalar z; - JacobiRotation rot; - RealScalar n = ei_sqrt(ei_abs2(work_matrix.coeff(p,p)) + ei_abs2(work_matrix.coeff(q,p))); - if(n==0) - { - z = ei_abs(work_matrix.coeff(p,q)) / work_matrix.coeff(p,q); - work_matrix.row(p) *= z; - if(svd.computeU()) svd.m_matrixU.col(p) *= ei_conj(z); - z = ei_abs(work_matrix.coeff(q,q)) / work_matrix.coeff(q,q); - work_matrix.row(q) *= z; - if(svd.computeU()) svd.m_matrixU.col(q) *= ei_conj(z); - } - else - { - rot.c() = ei_conj(work_matrix.coeff(p,p)) / n; - rot.s() = work_matrix.coeff(q,p) / n; - work_matrix.applyOnTheLeft(p,q,rot); - if(svd.computeU()) svd.m_matrixU.applyOnTheRight(p,q,rot.adjoint()); - if(work_matrix.coeff(p,q) != Scalar(0)) - { - Scalar z = ei_abs(work_matrix.coeff(p,q)) / work_matrix.coeff(p,q); - work_matrix.col(q) *= z; - if(svd.computeV()) svd.m_matrixV.col(q) *= z; - } - if(work_matrix.coeff(q,q) != Scalar(0)) - { - z = ei_abs(work_matrix.coeff(q,q)) / work_matrix.coeff(q,q); - work_matrix.row(q) *= z; - if(svd.computeU()) svd.m_matrixU.col(q) *= ei_conj(z); - } - } - } -}; - -template -void ei_real_2x2_jacobi_svd(const MatrixType& matrix, Index p, Index q, - JacobiRotation *j_left, - JacobiRotation *j_right) -{ - Matrix m; - m << ei_real(matrix.coeff(p,p)), ei_real(matrix.coeff(p,q)), - ei_real(matrix.coeff(q,p)), ei_real(matrix.coeff(q,q)); - JacobiRotation rot1; - RealScalar t = m.coeff(0,0) + m.coeff(1,1); - RealScalar d = m.coeff(1,0) - m.coeff(0,1); - if(t == RealScalar(0)) - { - rot1.c() = 0; - rot1.s() = d > 0 ? 1 : -1; - } - else - { - RealScalar u = d / t; - rot1.c() = RealScalar(1) / ei_sqrt(1 + ei_abs2(u)); - rot1.s() = rot1.c() * u; - } - m.applyOnTheLeft(0,1,rot1); - j_right->makeJacobi(m,0,1); - *j_left = rot1 * j_right->transpose(); -} - template JacobiSVD& JacobiSVD::compute(const MatrixType& matrix, unsigned int computationOptions) @@ -551,8 +555,8 @@ JacobiSVD::compute(const MatrixType& matrix, unsig /*** step 1. The R-SVD step: we use a QR decomposition to reduce to the case of a square matrix */ - if(!ei_qr_preconditioner_impl::run(*this, matrix) - && !ei_qr_preconditioner_impl::run(*this, matrix)) + if(!internal::qr_preconditioner_impl::run(*this, matrix) + && !internal::qr_preconditioner_impl::run(*this, matrix)) { m_workMatrix = matrix.block(0,0,m_diagSize,m_diagSize); if(m_computeFullU) m_matrixU.setIdentity(m_rows,m_rows); @@ -577,15 +581,15 @@ JacobiSVD::compute(const MatrixType& matrix, unsig // if this 2x2 sub-matrix is not diagonal already... // notice that this comparison will evaluate to false if any NaN is involved, ensuring that NaN's don't // keep us iterating forever. - if(std::max(ei_abs(m_workMatrix.coeff(p,q)),ei_abs(m_workMatrix.coeff(q,p))) - > std::max(ei_abs(m_workMatrix.coeff(p,p)),ei_abs(m_workMatrix.coeff(q,q)))*precision) + if(std::max(internal::abs(m_workMatrix.coeff(p,q)),internal::abs(m_workMatrix.coeff(q,p))) + > std::max(internal::abs(m_workMatrix.coeff(p,p)),internal::abs(m_workMatrix.coeff(q,q)))*precision) { finished = false; // perform SVD decomposition of 2x2 sub-matrix corresponding to indices p,q to make it diagonal - ei_svd_precondition_2x2_block_to_be_real::run(m_workMatrix, *this, p, q); + internal::svd_precondition_2x2_block_to_be_real::run(m_workMatrix, *this, p, q); JacobiRotation j_left, j_right; - ei_real_2x2_jacobi_svd(m_workMatrix, p, q, &j_left, &j_right); + internal::real_2x2_jacobi_svd(m_workMatrix, p, q, &j_left, &j_right); // accumulate resulting Jacobi rotations m_workMatrix.applyOnTheLeft(p,q,j_left); @@ -602,7 +606,7 @@ JacobiSVD::compute(const MatrixType& matrix, unsig for(Index i = 0; i < m_diagSize; ++i) { - RealScalar a = ei_abs(m_workMatrix.coeff(i,i)); + RealScalar a = internal::abs(m_workMatrix.coeff(i,i)); m_singularValues.coeffRef(i) = a; if(computeU() && (a!=RealScalar(0))) m_matrixU.col(i) *= m_workMatrix.coeff(i,i)/a; } @@ -632,16 +636,17 @@ JacobiSVD::compute(const MatrixType& matrix, unsig return *this; } +namespace internal { template -struct ei_solve_retval, Rhs> - : ei_solve_retval_base, Rhs> +struct solve_retval, Rhs> + : solve_retval_base, Rhs> { typedef JacobiSVD<_MatrixType, QRPreconditioner> JacobiSVDType; EIGEN_MAKE_SOLVE_HELPERS(JacobiSVDType,Rhs) template void evalTo(Dest& dst) const { - ei_assert(rhs().rows() == dec().rows()); + eigen_assert(rhs().rows() == dec().rows()); // A = U S V^* // So A^{-1} = V S^{-1} U^* @@ -659,6 +664,7 @@ struct ei_solve_retval, Rhs> * rhs(); } }; +} // end namespace internal template JacobiSVD::PlainObject> diff --git a/Eigen/src/SVD/UpperBidiagonalization.h b/Eigen/src/SVD/UpperBidiagonalization.h index 1e1355b52..c9ba325ed 100644 --- a/Eigen/src/SVD/UpperBidiagonalization.h +++ b/Eigen/src/SVD/UpperBidiagonalization.h @@ -33,7 +33,7 @@ template class UpperBidiagonalization enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime, - ColsAtCompileTimeMinusOne = ei_decrement_size::ret + ColsAtCompileTimeMinusOne = internal::decrement_size::ret }; typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::RealScalar RealScalar; @@ -45,7 +45,7 @@ template class UpperBidiagonalization typedef Matrix SuperDiagVectorType; typedef HouseholderSequence< MatrixType, - CwiseUnaryOp, Diagonal > + CwiseUnaryOp, Diagonal > > HouseholderUSequenceType; typedef HouseholderSequence< MatrixType, @@ -76,13 +76,13 @@ template class UpperBidiagonalization HouseholderUSequenceType householderU() const { - ei_assert(m_isInitialized && "UpperBidiagonalization is not initialized."); + eigen_assert(m_isInitialized && "UpperBidiagonalization is not initialized."); return HouseholderUSequenceType(m_householder, m_householder.diagonal().conjugate()); } HouseholderVSequenceType householderV() // const here gives nasty errors and i'm lazy { - ei_assert(m_isInitialized && "UpperBidiagonalization is not initialized."); + eigen_assert(m_isInitialized && "UpperBidiagonalization is not initialized."); return HouseholderVSequenceType(m_householder, m_householder.template diagonal<1>(), false, m_householder.cols()-1, 1); } @@ -99,7 +99,7 @@ UpperBidiagonalization<_MatrixType>& UpperBidiagonalization<_MatrixType>::comput Index rows = matrix.rows(); Index cols = matrix.cols(); - ei_assert(rows >= cols && "UpperBidiagonalization is only for matrices satisfying rows>=cols."); + eigen_assert(rows >= cols && "UpperBidiagonalization is only for matrices satisfying rows>=cols."); m_householder = matrix; diff --git a/Eigen/src/Sparse/AmbiVector.h b/Eigen/src/Sparse/AmbiVector.h index f2e92f93c..01c93fbd7 100644 --- a/Eigen/src/Sparse/AmbiVector.h +++ b/Eigen/src/Sparse/AmbiVector.h @@ -183,7 +183,7 @@ void AmbiVector<_Scalar,_Index>::setZero() } else { - ei_assert(m_mode==IsSparse); + eigen_assert(m_mode==IsSparse); m_llSize = 0; m_llStart = -1; } @@ -198,7 +198,7 @@ _Scalar& AmbiVector<_Scalar,_Index>::coeffRef(_Index i) { ListEl* EIGEN_RESTRICT llElements = reinterpret_cast(m_buffer); // TODO factorize the following code to reduce code generation - ei_assert(m_mode==IsSparse); + eigen_assert(m_mode==IsSparse); if (m_llSize==0) { // this is the first element @@ -225,7 +225,7 @@ _Scalar& AmbiVector<_Scalar,_Index>::coeffRef(_Index i) else { Index nextel = llElements[m_llCurrent].next; - ei_assert(i>=llElements[m_llCurrent].index && "you must call restart() before inserting an element with lower or equal index"); + eigen_assert(i>=llElements[m_llCurrent].index && "you must call restart() before inserting an element with lower or equal index"); while (nextel >= 0 && llElements[nextel].index<=i) { m_llCurrent = nextel; @@ -244,7 +244,7 @@ _Scalar& AmbiVector<_Scalar,_Index>::coeffRef(_Index i) reallocateSparse(); llElements = reinterpret_cast(m_buffer); } - ei_internal_assert(m_llSize::coeff(_Index i) else { ListEl* EIGEN_RESTRICT llElements = reinterpret_cast(m_buffer); - ei_assert(m_mode==IsSparse); + eigen_assert(m_mode==IsSparse); if ((m_llSize==0) || (i::Iterator { ListEl* EIGEN_RESTRICT llElements = reinterpret_cast(m_vector.m_buffer); m_currentEl = m_vector.m_llStart; - while (m_currentEl>=0 && ei_abs(llElements[m_currentEl].value)=0 && internal::abs(llElements[m_currentEl].value)::Iterator { do { ++m_cachedIndex; - } while (m_cachedIndex::Iterator ListEl* EIGEN_RESTRICT llElements = reinterpret_cast(m_vector.m_buffer); do { m_currentEl = llElements[m_currentEl].next; - } while (m_currentEl>=0 && ei_abs(llElements[m_currentEl].value)=0 && internal::abs(llElements[m_currentEl].value) -struct ei_traits > +struct traits > { typedef _Scalar Scalar; typedef _Index Index; @@ -59,6 +61,7 @@ struct ei_traits > SupportedAccessPatterns = OuterRandomAccessPattern }; }; +} template class DynamicSparseMatrix @@ -158,8 +161,8 @@ class DynamicSparseMatrix /** \sa insertBack */ inline Scalar& insertBackByOuterInner(Index outer, Index inner) { - ei_assert(outer -struct ei_traits > : ei_traits > +struct traits > : traits > {}; +} template class MappedSparseMatrix @@ -101,11 +103,11 @@ class MappedSparseMatrix Index start = m_outerIndex[outer]; Index end = m_outerIndex[outer+1]; - ei_assert(end>=start && "you probably called coeffRef on a non finalized matrix"); - ei_assert(end>start && "coeffRef cannot be called on a zero coefficient"); + eigen_assert(end>=start && "you probably called coeffRef on a non finalized matrix"); + eigen_assert(end>start && "coeffRef cannot be called on a zero coefficient"); Index* r = std::lower_bound(&m_innerIndices[start],&m_innerIndices[end],inner); const Index id = r-&m_innerIndices[0]; - ei_assert((*r==inner) && (id -struct ei_traits > +struct traits > { - typedef typename ei_traits::Scalar Scalar; - typedef typename ei_traits::Index Index; - typedef typename ei_traits::StorageKind StorageKind; + typedef typename traits::Scalar Scalar; + typedef typename traits::Index Index; + typedef typename traits::StorageKind StorageKind; typedef MatrixXpr XprKind; enum { IsRowMajor = (int(MatrixType::Flags)&RowMajorBit)==RowMajorBit, @@ -42,14 +43,15 @@ struct ei_traits > CoeffReadCost = MatrixType::CoeffReadCost }; }; +} // end namespace internal template -class SparseInnerVectorSet : ei_no_assignment_operator, +class SparseInnerVectorSet : internal::no_assignment_operator, public SparseMatrixBase > { public: - enum { IsRowMajor = ei_traits::IsRowMajor }; + enum { IsRowMajor = internal::traits::IsRowMajor }; EIGEN_SPARSE_PUBLIC_INTERFACE(SparseInnerVectorSet) class InnerIterator: public MatrixType::InnerIterator @@ -67,14 +69,14 @@ class SparseInnerVectorSet : ei_no_assignment_operator, inline SparseInnerVectorSet(const MatrixType& matrix, Index outerStart, Index outerSize) : m_matrix(matrix), m_outerStart(outerStart), m_outerSize(outerSize) { - ei_assert( (outerStart>=0) && ((outerStart+outerSize)<=matrix.outerSize()) ); + eigen_assert( (outerStart>=0) && ((outerStart+outerSize)<=matrix.outerSize()) ); } inline SparseInnerVectorSet(const MatrixType& matrix, Index outer) : m_matrix(matrix), m_outerStart(outer), m_outerSize(Size) { - ei_assert(Size!=Dynamic); - ei_assert( (outer>=0) && (outer=0) && (outer @@ -96,7 +98,7 @@ class SparseInnerVectorSet : ei_no_assignment_operator, const typename MatrixType::Nested m_matrix; Index m_outerStart; - const ei_variable_if_dynamic m_outerSize; + const internal::variable_if_dynamic m_outerSize; }; /*************************************************************************** @@ -110,7 +112,7 @@ class SparseInnerVectorSet, Size> typedef DynamicSparseMatrix<_Scalar, _Options> MatrixType; public: - enum { IsRowMajor = ei_traits::IsRowMajor }; + enum { IsRowMajor = internal::traits::IsRowMajor }; EIGEN_SPARSE_PUBLIC_INTERFACE(SparseInnerVectorSet) class InnerIterator: public MatrixType::InnerIterator @@ -128,14 +130,14 @@ class SparseInnerVectorSet, Size> inline SparseInnerVectorSet(const MatrixType& matrix, Index outerStart, Index outerSize) : m_matrix(matrix), m_outerStart(outerStart), m_outerSize(outerSize) { - ei_assert( (outerStart>=0) && ((outerStart+outerSize)<=matrix.outerSize()) ); + eigen_assert( (outerStart>=0) && ((outerStart+outerSize)<=matrix.outerSize()) ); } inline SparseInnerVectorSet(const MatrixType& matrix, Index outer) : m_matrix(matrix), m_outerStart(outer), m_outerSize(Size) { - ei_assert(Size!=Dynamic); - ei_assert( (outer>=0) && (outer=0) && (outer @@ -175,7 +177,7 @@ class SparseInnerVectorSet, Size> const Scalar& lastCoeff() const { EIGEN_STATIC_ASSERT_VECTOR_ONLY(SparseInnerVectorSet); - ei_assert(m_matrix.data()[m_outerStart].size()>0); + eigen_assert(m_matrix.data()[m_outerStart].size()>0); return m_matrix.data()[m_outerStart].vale(m_matrix.data()[m_outerStart].size()-1); } @@ -192,7 +194,7 @@ class SparseInnerVectorSet, Size> const typename MatrixType::Nested m_matrix; Index m_outerStart; - const ei_variable_if_dynamic m_outerSize; + const internal::variable_if_dynamic m_outerSize; }; @@ -208,7 +210,7 @@ class SparseInnerVectorSet, Size> typedef SparseMatrix<_Scalar, _Options> MatrixType; public: - enum { IsRowMajor = ei_traits::IsRowMajor }; + enum { IsRowMajor = internal::traits::IsRowMajor }; EIGEN_SPARSE_PUBLIC_INTERFACE(SparseInnerVectorSet) class InnerIterator: public MatrixType::InnerIterator @@ -226,20 +228,20 @@ class SparseInnerVectorSet, Size> inline SparseInnerVectorSet(const MatrixType& matrix, Index outerStart, Index outerSize) : m_matrix(matrix), m_outerStart(outerStart), m_outerSize(outerSize) { - ei_assert( (outerStart>=0) && ((outerStart+outerSize)<=matrix.outerSize()) ); + eigen_assert( (outerStart>=0) && ((outerStart+outerSize)<=matrix.outerSize()) ); } inline SparseInnerVectorSet(const MatrixType& matrix, Index outer) : m_matrix(matrix), m_outerStart(outer), m_outerSize(Size) { - ei_assert(Size==1); - ei_assert( (outer>=0) && (outer=0) && (outer inline SparseInnerVectorSet& operator=(const SparseMatrixBase& other) { - typedef typename ei_cleantype::type _NestedMatrixType; + typedef typename internal::cleantype::type _NestedMatrixType; _NestedMatrixType& matrix = const_cast<_NestedMatrixType&>(m_matrix);; // This assignement is slow if this vector set not empty // and/or it is not at the end of the nonzeros of the underlying matrix. @@ -339,7 +341,7 @@ class SparseInnerVectorSet, Size> const Scalar& lastCoeff() const { EIGEN_STATIC_ASSERT_VECTOR_ONLY(SparseInnerVectorSet); - ei_assert(nonZeros()>0); + eigen_assert(nonZeros()>0); return m_matrix._valuePtr()[m_matrix._outerIndexPtr()[m_outerStart+1]-1]; } @@ -356,7 +358,7 @@ class SparseInnerVectorSet, Size> const typename MatrixType::Nested m_matrix; Index m_outerStart; - const ei_variable_if_dynamic m_outerSize; + const internal::variable_if_dynamic m_outerSize; }; diff --git a/Eigen/src/Sparse/SparseCwiseBinaryOp.h b/Eigen/src/Sparse/SparseCwiseBinaryOp.h index a4fb7ea86..cde5bbc03 100644 --- a/Eigen/src/Sparse/SparseCwiseBinaryOp.h +++ b/Eigen/src/Sparse/SparseCwiseBinaryOp.h @@ -42,12 +42,21 @@ // 4 - dense op dense product dense // generic dense -template<> struct ei_promote_storage_type +namespace internal { + +template<> struct promote_storage_type { typedef Sparse ret; }; -template<> struct ei_promote_storage_type +template<> struct promote_storage_type { typedef Sparse ret; }; +template::StorageKind, + typename _RhsStorageMode = typename traits::StorageKind> +class sparse_cwise_binary_op_inner_iterator_selector; + +} // end namespace internal + template class CwiseBinaryOpImpl : public SparseMatrixBase > @@ -58,18 +67,13 @@ class CwiseBinaryOpImpl EIGEN_SPARSE_PUBLIC_INTERFACE(Derived) }; -template::StorageKind, - typename _RhsStorageMode = typename ei_traits::StorageKind> -class ei_sparse_cwise_binary_op_inner_iterator_selector; - template class CwiseBinaryOpImpl::InnerIterator - : public ei_sparse_cwise_binary_op_inner_iterator_selector::InnerIterator> + : public internal::sparse_cwise_binary_op_inner_iterator_selector::InnerIterator> { public: typedef typename Lhs::Index Index; - typedef ei_sparse_cwise_binary_op_inner_iterator_selector< + typedef internal::sparse_cwise_binary_op_inner_iterator_selector< BinaryOp,Lhs,Rhs, InnerIterator> Base; EIGEN_STRONG_INLINE InnerIterator(const CwiseBinaryOpImpl& binOp, Index outer) @@ -81,26 +85,28 @@ class CwiseBinaryOpImpl::InnerIterator * Implementation of inner-iterators ***************************************************************************/ -// template struct ei_func_is_conjunction { enum { ret = false }; }; -// template struct ei_func_is_conjunction > { enum { ret = true }; }; +// template struct internal::func_is_conjunction { enum { ret = false }; }; +// template struct internal::func_is_conjunction > { enum { ret = true }; }; + +// TODO generalize the internal::scalar_product_op specialization to all conjunctions if any ! -// TODO generalize the ei_scalar_product_op specialization to all conjunctions if any ! +namespace internal { // sparse - sparse (generic) template -class ei_sparse_cwise_binary_op_inner_iterator_selector +class sparse_cwise_binary_op_inner_iterator_selector { typedef CwiseBinaryOp CwiseBinaryXpr; - typedef typename ei_traits::Scalar Scalar; - typedef typename ei_traits::_LhsNested _LhsNested; - typedef typename ei_traits::_RhsNested _RhsNested; + typedef typename traits::Scalar Scalar; + typedef typename traits::_LhsNested _LhsNested; + typedef typename traits::_RhsNested _RhsNested; typedef typename _LhsNested::InnerIterator LhsIterator; typedef typename _RhsNested::InnerIterator RhsIterator; typedef typename Lhs::Index Index; public: - EIGEN_STRONG_INLINE ei_sparse_cwise_binary_op_inner_iterator_selector(const CwiseBinaryXpr& xpr, Index outer) + EIGEN_STRONG_INLINE sparse_cwise_binary_op_inner_iterator_selector(const CwiseBinaryXpr& xpr, Index outer) : m_lhsIter(xpr.lhs(),outer), m_rhsIter(xpr.rhs(),outer), m_functor(xpr.functor()) { this->operator++(); @@ -153,19 +159,19 @@ class ei_sparse_cwise_binary_op_inner_iterator_selector -class ei_sparse_cwise_binary_op_inner_iterator_selector, Lhs, Rhs, Derived, Sparse, Sparse> +class sparse_cwise_binary_op_inner_iterator_selector, Lhs, Rhs, Derived, Sparse, Sparse> { - typedef ei_scalar_product_op BinaryFunc; + typedef scalar_product_op BinaryFunc; typedef CwiseBinaryOp CwiseBinaryXpr; typedef typename CwiseBinaryXpr::Scalar Scalar; - typedef typename ei_traits::_LhsNested _LhsNested; + typedef typename traits::_LhsNested _LhsNested; typedef typename _LhsNested::InnerIterator LhsIterator; - typedef typename ei_traits::_RhsNested _RhsNested; + typedef typename traits::_RhsNested _RhsNested; typedef typename _RhsNested::InnerIterator RhsIterator; typedef typename Lhs::Index Index; public: - EIGEN_STRONG_INLINE ei_sparse_cwise_binary_op_inner_iterator_selector(const CwiseBinaryXpr& xpr, Index outer) + EIGEN_STRONG_INLINE sparse_cwise_binary_op_inner_iterator_selector(const CwiseBinaryXpr& xpr, Index outer) : m_lhsIter(xpr.lhs(),outer), m_rhsIter(xpr.rhs(),outer), m_functor(xpr.functor()) { while (m_lhsIter && m_rhsIter && (m_lhsIter.index() != m_rhsIter.index())) @@ -207,19 +213,19 @@ class ei_sparse_cwise_binary_op_inner_iterator_selector, // sparse - dense (product) template -class ei_sparse_cwise_binary_op_inner_iterator_selector, Lhs, Rhs, Derived, Sparse, Dense> +class sparse_cwise_binary_op_inner_iterator_selector, Lhs, Rhs, Derived, Sparse, Dense> { - typedef ei_scalar_product_op BinaryFunc; + typedef scalar_product_op BinaryFunc; typedef CwiseBinaryOp CwiseBinaryXpr; typedef typename CwiseBinaryXpr::Scalar Scalar; - typedef typename ei_traits::_LhsNested _LhsNested; - typedef typename ei_traits::RhsNested RhsNested; + typedef typename traits::_LhsNested _LhsNested; + typedef typename traits::RhsNested RhsNested; typedef typename _LhsNested::InnerIterator LhsIterator; typedef typename Lhs::Index Index; enum { IsRowMajor = (int(Lhs::Flags)&RowMajorBit)==RowMajorBit }; public: - EIGEN_STRONG_INLINE ei_sparse_cwise_binary_op_inner_iterator_selector(const CwiseBinaryXpr& xpr, Index outer) + EIGEN_STRONG_INLINE sparse_cwise_binary_op_inner_iterator_selector(const CwiseBinaryXpr& xpr, Index outer) : m_rhs(xpr.rhs()), m_lhsIter(xpr.lhs(),outer), m_functor(xpr.functor()), m_outer(outer) {} @@ -248,19 +254,19 @@ class ei_sparse_cwise_binary_op_inner_iterator_selector, // sparse - dense (product) template -class ei_sparse_cwise_binary_op_inner_iterator_selector, Lhs, Rhs, Derived, Dense, Sparse> +class sparse_cwise_binary_op_inner_iterator_selector, Lhs, Rhs, Derived, Dense, Sparse> { - typedef ei_scalar_product_op BinaryFunc; + typedef scalar_product_op BinaryFunc; typedef CwiseBinaryOp CwiseBinaryXpr; typedef typename CwiseBinaryXpr::Scalar Scalar; - typedef typename ei_traits::_RhsNested _RhsNested; + typedef typename traits::_RhsNested _RhsNested; typedef typename _RhsNested::InnerIterator RhsIterator; typedef typename Lhs::Index Index; enum { IsRowMajor = (int(Rhs::Flags)&RowMajorBit)==RowMajorBit }; public: - EIGEN_STRONG_INLINE ei_sparse_cwise_binary_op_inner_iterator_selector(const CwiseBinaryXpr& xpr, Index outer) + EIGEN_STRONG_INLINE sparse_cwise_binary_op_inner_iterator_selector(const CwiseBinaryXpr& xpr, Index outer) : m_xpr(xpr), m_rhsIter(xpr.rhs(),outer), m_functor(xpr.functor()), m_outer(outer) {} @@ -286,6 +292,7 @@ class ei_sparse_cwise_binary_op_inner_iterator_selector, const Index m_outer; }; +} // end namespace internal /*************************************************************************** * Implementation of SparseMatrixBase and SparseCwise functions/operators @@ -293,11 +300,11 @@ class ei_sparse_cwise_binary_op_inner_iterator_selector, // template // template -// EIGEN_STRONG_INLINE const CwiseBinaryOp::Scalar>, +// EIGEN_STRONG_INLINE const CwiseBinaryOp::Scalar>, // Derived, OtherDerived> // SparseMatrixBase::operator-(const SparseMatrixBase &other) const // { -// return CwiseBinaryOp, +// return CwiseBinaryOp, // Derived, OtherDerived>(derived(), other.derived()); // } @@ -311,10 +318,10 @@ SparseMatrixBase::operator-=(const SparseMatrixBase &othe // template // template -// EIGEN_STRONG_INLINE const CwiseBinaryOp::Scalar>, Derived, OtherDerived> +// EIGEN_STRONG_INLINE const CwiseBinaryOp::Scalar>, Derived, OtherDerived> // SparseMatrixBase::operator+(const SparseMatrixBase &other) const // { -// return CwiseBinaryOp, Derived, OtherDerived>(derived(), other.derived()); +// return CwiseBinaryOp, Derived, OtherDerived>(derived(), other.derived()); // } template @@ -343,18 +350,18 @@ SparseMatrixBase::cwiseProduct(const MatrixBase &other) c // template // template -// EIGEN_STRONG_INLINE const EIGEN_SPARSE_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op) +// EIGEN_STRONG_INLINE const EIGEN_SPARSE_CWISE_BINOP_RETURN_TYPE(internal::scalar_quotient_op) // SparseCwise::operator/(const SparseMatrixBase &other) const // { -// return EIGEN_SPARSE_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op)(_expression(), other.derived()); +// return EIGEN_SPARSE_CWISE_BINOP_RETURN_TYPE(internal::scalar_quotient_op)(_expression(), other.derived()); // } // // template // template -// EIGEN_STRONG_INLINE const EIGEN_SPARSE_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op) +// EIGEN_STRONG_INLINE const EIGEN_SPARSE_CWISE_BINOP_RETURN_TYPE(internal::scalar_quotient_op) // SparseCwise::operator/(const MatrixBase &other) const // { -// return EIGEN_SPARSE_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op)(_expression(), other.derived()); +// return EIGEN_SPARSE_CWISE_BINOP_RETURN_TYPE(internal::scalar_quotient_op)(_expression(), other.derived()); // } // template diff --git a/Eigen/src/Sparse/SparseCwiseUnaryOp.h b/Eigen/src/Sparse/SparseCwiseUnaryOp.h index 514f1c00b..709661954 100644 --- a/Eigen/src/Sparse/SparseCwiseUnaryOp.h +++ b/Eigen/src/Sparse/SparseCwiseUnaryOp.h @@ -26,15 +26,15 @@ #define EIGEN_SPARSE_CWISE_UNARY_OP_H // template -// struct ei_traits > : ei_traits +// struct internal::traits > : internal::traits // { -// typedef typename ei_result_of< +// typedef typename internal::result_of< // UnaryOp(typename MatrixType::Scalar) // >::type Scalar; // typedef typename MatrixType::Nested MatrixTypeNested; -// typedef typename ei_unref::type _MatrixTypeNested; +// typedef typename internal::unref::type _MatrixTypeNested; // enum { -// CoeffReadCost = _MatrixTypeNested::CoeffReadCost + ei_functor_traits::Cost +// CoeffReadCost = _MatrixTypeNested::CoeffReadCost + internal::functor_traits::Cost // }; // }; @@ -45,7 +45,7 @@ class CwiseUnaryOpImpl public: class InnerIterator; -// typedef typename ei_unref::type _LhsNested; +// typedef typename internal::unref::type _LhsNested; typedef CwiseUnaryOp Derived; EIGEN_SPARSE_PUBLIC_INTERFACE(Derived) @@ -55,7 +55,7 @@ template class CwiseUnaryOpImpl::InnerIterator { typedef typename CwiseUnaryOpImpl::Scalar Scalar; - typedef typename ei_traits::_XprTypeNested _MatrixTypeNested; + typedef typename internal::traits::_XprTypeNested _MatrixTypeNested; typedef typename _MatrixTypeNested::InnerIterator MatrixTypeIterator; typedef typename MatrixType::Index Index; public: @@ -87,7 +87,7 @@ class CwiseUnaryViewImpl public: class InnerIterator; -// typedef typename ei_unref::type _LhsNested; +// typedef typename internal::unref::type _LhsNested; typedef CwiseUnaryView Derived; EIGEN_SPARSE_PUBLIC_INTERFACE(Derived) @@ -97,7 +97,7 @@ template class CwiseUnaryViewImpl::InnerIterator { typedef typename CwiseUnaryViewImpl::Scalar Scalar; - typedef typename ei_traits::_MatrixTypeNested _MatrixTypeNested; + typedef typename internal::traits::_MatrixTypeNested _MatrixTypeNested; typedef typename _MatrixTypeNested::InnerIterator MatrixTypeIterator; typedef typename MatrixType::Index Index; public: diff --git a/Eigen/src/Sparse/SparseDenseProduct.h b/Eigen/src/Sparse/SparseDenseProduct.h index 0489c68db..16011e58e 100644 --- a/Eigen/src/Sparse/SparseDenseProduct.h +++ b/Eigen/src/Sparse/SparseDenseProduct.h @@ -45,26 +45,28 @@ template struct DenseSparseProductReturnType Type; }; +namespace internal { + template -struct ei_traits > +struct traits > { typedef Sparse StorageKind; - typedef typename ei_scalar_product_traits::Scalar, - typename ei_traits::Scalar>::ReturnType Scalar; + typedef typename scalar_product_traits::Scalar, + typename traits::Scalar>::ReturnType Scalar; typedef typename Lhs::Index Index; typedef typename Lhs::Nested LhsNested; typedef typename Rhs::Nested RhsNested; - typedef typename ei_cleantype::type _LhsNested; - typedef typename ei_cleantype::type _RhsNested; + typedef typename cleantype::type _LhsNested; + typedef typename cleantype::type _RhsNested; enum { - LhsCoeffReadCost = ei_traits<_LhsNested>::CoeffReadCost, - RhsCoeffReadCost = ei_traits<_RhsNested>::CoeffReadCost, + LhsCoeffReadCost = traits<_LhsNested>::CoeffReadCost, + RhsCoeffReadCost = traits<_RhsNested>::CoeffReadCost, - RowsAtCompileTime = Tr ? int(ei_traits::RowsAtCompileTime) : int(ei_traits::RowsAtCompileTime), - ColsAtCompileTime = Tr ? int(ei_traits::ColsAtCompileTime) : int(ei_traits::ColsAtCompileTime), - MaxRowsAtCompileTime = Tr ? int(ei_traits::MaxRowsAtCompileTime) : int(ei_traits::MaxRowsAtCompileTime), - MaxColsAtCompileTime = Tr ? int(ei_traits::MaxColsAtCompileTime) : int(ei_traits::MaxColsAtCompileTime), + RowsAtCompileTime = Tr ? int(traits::RowsAtCompileTime) : int(traits::RowsAtCompileTime), + ColsAtCompileTime = Tr ? int(traits::ColsAtCompileTime) : int(traits::ColsAtCompileTime), + MaxRowsAtCompileTime = Tr ? int(traits::MaxRowsAtCompileTime) : int(traits::MaxRowsAtCompileTime), + MaxColsAtCompileTime = Tr ? int(traits::MaxColsAtCompileTime) : int(traits::MaxColsAtCompileTime), Flags = Tr ? RowMajorBit : 0, @@ -72,6 +74,8 @@ struct ei_traits > }; }; +} // end namespace internal + template class SparseDenseOuterProduct : public SparseMatrixBase > @@ -80,7 +84,7 @@ class SparseDenseOuterProduct typedef SparseMatrixBase Base; EIGEN_DENSE_PUBLIC_INTERFACE(SparseDenseOuterProduct) - typedef ei_traits Traits; + typedef internal::traits Traits; private: @@ -137,13 +141,15 @@ class SparseDenseOuterProduct::InnerIterator : public _LhsNes Scalar m_factor; }; +namespace internal { template -struct ei_traits > - : ei_traits, Lhs, Rhs> > +struct traits > + : traits, Lhs, Rhs> > { typedef Dense StorageKind; typedef MatrixXpr XprKind; }; +} // end namespace internal template class SparseTimeDenseProduct @@ -157,8 +163,8 @@ class SparseTimeDenseProduct template void scaleAndAddTo(Dest& dest, Scalar alpha) const { - typedef typename ei_cleantype::type _Lhs; - typedef typename ei_cleantype::type _Rhs; + typedef typename internal::cleantype::type _Lhs; + typedef typename internal::cleantype::type _Rhs; typedef typename _Lhs::InnerIterator LhsInnerIterator; enum { LhsIsRowMajor = (_Lhs::Flags&RowMajorBit)==RowMajorBit }; for(Index j=0; j -struct ei_traits > - : ei_traits, Lhs, Rhs> > +struct traits > + : traits, Lhs, Rhs> > { typedef Dense StorageKind; }; +} // end namespace internal template class DenseTimeSparseProduct @@ -199,7 +207,7 @@ class DenseTimeSparseProduct template void scaleAndAddTo(Dest& dest, Scalar alpha) const { - typedef typename ei_cleantype::type _Rhs; + typedef typename internal::cleantype::type _Rhs; typedef typename _Rhs::InnerIterator RhsInnerIterator; enum { RhsIsRowMajor = (_Rhs::Flags&RowMajorBit)==RowMajorBit }; for(Index j=0; j -struct ei_traits > +struct traits > { - typedef typename ei_cleantype::type _Lhs; - typedef typename ei_cleantype::type _Rhs; + typedef typename cleantype::type _Lhs; + typedef typename cleantype::type _Rhs; typedef typename _Lhs::Scalar Scalar; - typedef typename ei_promote_index_type::Index, - typename ei_traits::Index>::type Index; + typedef typename promote_index_type::Index, + typename traits::Index>::type Index; typedef Sparse StorageKind; typedef MatrixXpr XprKind; enum { @@ -54,7 +56,7 @@ struct ei_traits > MaxRowsAtCompileTime = _Lhs::MaxRowsAtCompileTime, MaxColsAtCompileTime = _Rhs::MaxColsAtCompileTime, - SparseFlags = ei_is_diagonal<_Lhs>::ret ? int(_Rhs::Flags) : int(_Lhs::Flags), + SparseFlags = is_diagonal<_Lhs>::ret ? int(_Rhs::Flags) : int(_Lhs::Flags), Flags = (SparseFlags&RowMajorBit), CoeffReadCost = Dynamic }; @@ -62,37 +64,39 @@ struct ei_traits > enum {SDP_IsDiagonal, SDP_IsSparseRowMajor, SDP_IsSparseColMajor}; template -class ei_sparse_diagonal_product_inner_iterator_selector; +class sparse_diagonal_product_inner_iterator_selector; + +} // end namespace internal template class SparseDiagonalProduct : public SparseMatrixBase >, - ei_no_assignment_operator + internal::no_assignment_operator { typedef typename Lhs::Nested LhsNested; typedef typename Rhs::Nested RhsNested; - typedef typename ei_cleantype::type _LhsNested; - typedef typename ei_cleantype::type _RhsNested; + typedef typename internal::cleantype::type _LhsNested; + typedef typename internal::cleantype::type _RhsNested; enum { - LhsMode = ei_is_diagonal<_LhsNested>::ret ? SDP_IsDiagonal - : (_LhsNested::Flags&RowMajorBit) ? SDP_IsSparseRowMajor : SDP_IsSparseColMajor, - RhsMode = ei_is_diagonal<_RhsNested>::ret ? SDP_IsDiagonal - : (_RhsNested::Flags&RowMajorBit) ? SDP_IsSparseRowMajor : SDP_IsSparseColMajor + LhsMode = internal::is_diagonal<_LhsNested>::ret ? internal::SDP_IsDiagonal + : (_LhsNested::Flags&RowMajorBit) ? internal::SDP_IsSparseRowMajor : internal::SDP_IsSparseColMajor, + RhsMode = internal::is_diagonal<_RhsNested>::ret ? internal::SDP_IsDiagonal + : (_RhsNested::Flags&RowMajorBit) ? internal::SDP_IsSparseRowMajor : internal::SDP_IsSparseColMajor }; public: EIGEN_SPARSE_PUBLIC_INTERFACE(SparseDiagonalProduct) - typedef ei_sparse_diagonal_product_inner_iterator_selector + typedef internal::sparse_diagonal_product_inner_iterator_selector <_LhsNested,_RhsNested,SparseDiagonalProduct,LhsMode,RhsMode> InnerIterator; EIGEN_STRONG_INLINE SparseDiagonalProduct(const Lhs& lhs, const Rhs& rhs) : m_lhs(lhs), m_rhs(rhs) { - ei_assert(lhs.cols() == rhs.rows() && "invalid sparse matrix * diagonal matrix product"); + eigen_assert(lhs.cols() == rhs.rows() && "invalid sparse matrix * diagonal matrix product"); } EIGEN_STRONG_INLINE Index rows() const { return m_lhs.rows(); } @@ -106,75 +110,78 @@ class SparseDiagonalProduct RhsNested m_rhs; }; +namespace internal { template -class ei_sparse_diagonal_product_inner_iterator_selector +class sparse_diagonal_product_inner_iterator_selector - : public CwiseUnaryOp,Rhs>::InnerIterator + : public CwiseUnaryOp,Rhs>::InnerIterator { - typedef typename CwiseUnaryOp,Rhs>::InnerIterator Base; + typedef typename CwiseUnaryOp,Rhs>::InnerIterator Base; typedef typename Lhs::Index Index; public: - inline ei_sparse_diagonal_product_inner_iterator_selector( + inline sparse_diagonal_product_inner_iterator_selector( const SparseDiagonalProductType& expr, Index outer) : Base(expr.rhs()*(expr.lhs().diagonal().coeff(outer)), outer) {} }; template -class ei_sparse_diagonal_product_inner_iterator_selector +class sparse_diagonal_product_inner_iterator_selector : public CwiseBinaryOp< - ei_scalar_product_op, + scalar_product_op, SparseInnerVectorSet, typename Lhs::DiagonalVectorType>::InnerIterator { typedef typename CwiseBinaryOp< - ei_scalar_product_op, + scalar_product_op, SparseInnerVectorSet, typename Lhs::DiagonalVectorType>::InnerIterator Base; typedef typename Lhs::Index Index; public: - inline ei_sparse_diagonal_product_inner_iterator_selector( + inline sparse_diagonal_product_inner_iterator_selector( const SparseDiagonalProductType& expr, Index outer) : Base(expr.rhs().innerVector(outer) .cwiseProduct(expr.lhs().diagonal()), 0) {} }; template -class ei_sparse_diagonal_product_inner_iterator_selector +class sparse_diagonal_product_inner_iterator_selector - : public CwiseUnaryOp,Lhs>::InnerIterator + : public CwiseUnaryOp,Lhs>::InnerIterator { - typedef typename CwiseUnaryOp,Lhs>::InnerIterator Base; + typedef typename CwiseUnaryOp,Lhs>::InnerIterator Base; typedef typename Lhs::Index Index; public: - inline ei_sparse_diagonal_product_inner_iterator_selector( + inline sparse_diagonal_product_inner_iterator_selector( const SparseDiagonalProductType& expr, Index outer) : Base(expr.lhs()*expr.rhs().diagonal().coeff(outer), outer) {} }; template -class ei_sparse_diagonal_product_inner_iterator_selector +class sparse_diagonal_product_inner_iterator_selector : public CwiseBinaryOp< - ei_scalar_product_op, + scalar_product_op, SparseInnerVectorSet, Transpose >::InnerIterator { typedef typename CwiseBinaryOp< - ei_scalar_product_op, + scalar_product_op, SparseInnerVectorSet, Transpose >::InnerIterator Base; typedef typename Lhs::Index Index; public: - inline ei_sparse_diagonal_product_inner_iterator_selector( + inline sparse_diagonal_product_inner_iterator_selector( const SparseDiagonalProductType& expr, Index outer) : Base(expr.lhs().innerVector(outer) .cwiseProduct(expr.rhs().diagonal().transpose()), 0) {} }; +} // end namespace internal + // SparseMatrixBase functions template diff --git a/Eigen/src/Sparse/SparseDot.h b/Eigen/src/Sparse/SparseDot.h index 42ad07aeb..13605ca88 100644 --- a/Eigen/src/Sparse/SparseDot.h +++ b/Eigen/src/Sparse/SparseDot.h @@ -27,23 +27,23 @@ template template -typename ei_traits::Scalar +typename internal::traits::Scalar SparseMatrixBase::dot(const MatrixBase& other) const { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived) EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived) - EIGEN_STATIC_ASSERT((ei_is_same_type::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type::ret), YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) - ei_assert(size() == other.size()); - ei_assert(other.size()>0 && "you are using a non initialized vector"); + eigen_assert(size() == other.size()); + eigen_assert(other.size()>0 && "you are using a non initialized vector"); typename Derived::InnerIterator i(derived(),0); Scalar res = 0; while (i) { - res += ei_conj(i.value()) * other.coeff(i.index()); + res += internal::conj(i.value()) * other.coeff(i.index()); ++i; } return res; @@ -51,16 +51,16 @@ SparseMatrixBase::dot(const MatrixBase& other) const template template -typename ei_traits::Scalar +typename internal::traits::Scalar SparseMatrixBase::dot(const SparseMatrixBase& other) const { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived) EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived) - EIGEN_STATIC_ASSERT((ei_is_same_type::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type::ret), YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) - ei_assert(size() == other.size()); + eigen_assert(size() == other.size()); typename Derived::InnerIterator i(derived(),0); typename OtherDerived::InnerIterator j(other.derived(),0); @@ -69,7 +69,7 @@ SparseMatrixBase::dot(const SparseMatrixBase& other) cons { if (i.index()==j.index()) { - res += ei_conj(i.value()) * j.value(); + res += internal::conj(i.value()) * j.value(); ++i; ++j; } else if (i.index()::dot(const SparseMatrixBase& other) cons } template -inline typename NumTraits::Scalar>::Real +inline typename NumTraits::Scalar>::Real SparseMatrixBase::squaredNorm() const { - return ei_real((*this).cwiseAbs2().sum()); + return internal::real((*this).cwiseAbs2().sum()); } template -inline typename NumTraits::Scalar>::Real +inline typename NumTraits::Scalar>::Real SparseMatrixBase::norm() const { - return ei_sqrt(squaredNorm()); + return internal::sqrt(squaredNorm()); } #endif // EIGEN_SPARSE_DOT_H diff --git a/Eigen/src/Sparse/SparseFuzzy.h b/Eigen/src/Sparse/SparseFuzzy.h index bf6d2e250..ddcef88ee 100644 --- a/Eigen/src/Sparse/SparseFuzzy.h +++ b/Eigen/src/Sparse/SparseFuzzy.h @@ -32,8 +32,8 @@ // typename NumTraits::Real prec // ) const // { -// const typename ei_nested::type nested(derived()); -// const typename ei_nested::type otherNested(other.derived()); +// const typename internal::nested::type nested(derived()); +// const typename internal::nested::type otherNested(other.derived()); // return (nested - otherNested).cwise().abs2().sum() // <= prec * prec * std::min(nested.cwise().abs2().sum(), otherNested.cwise().abs2().sum()); // } diff --git a/Eigen/src/Sparse/SparseMatrix.h b/Eigen/src/Sparse/SparseMatrix.h index 820cf2884..eadcee829 100644 --- a/Eigen/src/Sparse/SparseMatrix.h +++ b/Eigen/src/Sparse/SparseMatrix.h @@ -42,8 +42,10 @@ * See http://www.netlib.org/linalg/html_templates/node91.html for details on the storage scheme. * */ + +namespace internal { template -struct ei_traits > +struct traits > { typedef _Scalar Scalar; typedef _Index Index; @@ -59,6 +61,7 @@ struct ei_traits > SupportedAccessPatterns = InnerRandomAccessPattern }; }; +} // end namespace internal template class SparseMatrix @@ -120,10 +123,10 @@ class SparseMatrix Index start = m_outerIndex[outer]; Index end = m_outerIndex[outer+1]; - ei_assert(end>=start && "you probably called coeffRef on a non finalized matrix"); - ei_assert(end>start && "coeffRef cannot be called on a zero coefficient"); + eigen_assert(end>=start && "you probably called coeffRef on a non finalized matrix"); + eigen_assert(end>start && "coeffRef cannot be called on a zero coefficient"); const Index id = m_data.searchLowerIndex(start,end-1,inner); - ei_assert((id::type OtherCopy; - typedef typename ei_cleantype::type _OtherCopy; + typedef typename internal::nested::type OtherCopy; + typedef typename internal::cleantype::type _OtherCopy; OtherCopy otherCopy(other.derived()); resize(other.rows(), other.cols()); @@ -561,7 +564,7 @@ class SparseMatrix } else { - ei_assert(m_data.index(m_data.size()-1) class SparseMatrixBase : public EigenBase { public: - typedef typename ei_traits::Scalar Scalar; - typedef typename ei_packet_traits::type PacketScalar; - typedef typename ei_traits::StorageKind StorageKind; - typedef typename ei_traits::Index Index; + typedef typename internal::traits::Scalar Scalar; + typedef typename internal::packet_traits::type PacketScalar; + typedef typename internal::traits::StorageKind StorageKind; + typedef typename internal::traits::Index Index; typedef SparseMatrixBase StorageBaseType; enum { - RowsAtCompileTime = ei_traits::RowsAtCompileTime, + RowsAtCompileTime = internal::traits::RowsAtCompileTime, /**< The number of rows at compile-time. This is just a copy of the value provided * by the \a Derived type. If a value is not known at compile-time, * it is set to the \a Dynamic constant. * \sa MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */ - ColsAtCompileTime = ei_traits::ColsAtCompileTime, + ColsAtCompileTime = internal::traits::ColsAtCompileTime, /**< The number of columns at compile-time. This is just a copy of the value provided * by the \a Derived type. If a value is not known at compile-time, * it is set to the \a Dynamic constant. * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */ - SizeAtCompileTime = (ei_size_at_compile_time::RowsAtCompileTime, - ei_traits::ColsAtCompileTime>::ret), + SizeAtCompileTime = (internal::size_at_compile_time::RowsAtCompileTime, + internal::traits::ColsAtCompileTime>::ret), /**< This is equal to the number of coefficients, i.e. the number of * rows times the number of columns, or to \a Dynamic if this is not * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */ @@ -71,7 +71,7 @@ template class SparseMatrixBase : public EigenBase MaxRowsAtCompileTime = RowsAtCompileTime, MaxColsAtCompileTime = ColsAtCompileTime, - MaxSizeAtCompileTime = (ei_size_at_compile_time::ret), IsVectorAtCompileTime = RowsAtCompileTime == 1 || ColsAtCompileTime == 1, @@ -80,12 +80,12 @@ template class SparseMatrixBase : public EigenBase * we are dealing with a column-vector (if there is only one column) or with * a row-vector (if there is only one row). */ - Flags = ei_traits::Flags, + Flags = internal::traits::Flags, /**< This stores expression \ref flags flags which may or may not be inherited by new expressions * constructed from this one. See the \ref flags "list of flags". */ - CoeffReadCost = ei_traits::CoeffReadCost, + CoeffReadCost = internal::traits::CoeffReadCost, /**< This is a rough measure of how expensive it is to read one coefficient from * this expression. */ @@ -98,17 +98,17 @@ template class SparseMatrixBase : public EigenBase }; /* \internal the return type of MatrixBase::conjugate() */ -// typedef typename ei_meta_if::IsComplex, -// const SparseCwiseUnaryOp, Derived>, +// typedef typename internal::meta_if::IsComplex, +// const SparseCwiseUnaryOp, Derived>, // const Derived& // >::ret ConjugateReturnType; /* \internal the return type of MatrixBase::real() */ -// typedef SparseCwiseUnaryOp, Derived> RealReturnType; +// typedef SparseCwiseUnaryOp, Derived> RealReturnType; /* \internal the return type of MatrixBase::imag() */ -// typedef SparseCwiseUnaryOp, Derived> ImagReturnType; +// typedef SparseCwiseUnaryOp, Derived> ImagReturnType; /** \internal the return type of MatrixBase::adjoint() */ - typedef typename ei_meta_if::IsComplex, - CwiseUnaryOp, Eigen::Transpose >, + typedef typename internal::meta_if::IsComplex, + CwiseUnaryOp, Eigen::Transpose >, Transpose >::ret AdjointReturnType; @@ -132,10 +132,10 @@ template class SparseMatrixBase : public EigenBase /** \internal the return type of coeff() */ - typedef typename ei_meta_if<_HasDirectAccess, const Scalar&, Scalar>::ret CoeffReturnType; + typedef typename internal::meta_if<_HasDirectAccess, const Scalar&, Scalar>::ret CoeffReturnType; /** \internal Represents a matrix with all coefficients equal to one another*/ - typedef CwiseNullaryOp,Matrix > ConstantReturnType; + typedef CwiseNullaryOp,Matrix > ConstantReturnType; /** type of the equivalent square matrix */ typedef Matrix class SparseMatrixBase : public EigenBase { // std::cout << "Derived& operator=(const MatrixBase& other)\n"; //const bool transpose = (Flags & RowMajorBit) != (OtherDerived::Flags & RowMajorBit); - ei_assert(( ((ei_traits::SupportedAccessPatterns&OuterRandomAccessPattern)==OuterRandomAccessPattern) || + eigen_assert(( ((internal::traits::SupportedAccessPatterns&OuterRandomAccessPattern)==OuterRandomAccessPattern) || (!((Flags & RowMajorBit) != (OtherDerived::Flags & RowMajorBit)))) && "the transpose operation is supposed to be handled in SparseMatrix::operator="); enum { Flip = (Flags & RowMajorBit) != (OtherDerived::Flags & RowMajorBit) }; const Index outerSize = other.outerSize(); - //typedef typename ei_meta_if, Derived>::ret TempType; + //typedef typename internal::meta_if, Derived>::ret TempType; // thanks to shallow copies, we always eval to a tempary Derived temp(other.rows(), other.cols()); @@ -299,14 +299,14 @@ template class SparseMatrixBase : public EigenBase return s; } -// const SparseCwiseUnaryOp::Scalar>,Derived> operator-() const; +// const SparseCwiseUnaryOp::Scalar>,Derived> operator-() const; // template -// const CwiseBinaryOp::Scalar>, Derived, OtherDerived> +// const CwiseBinaryOp::Scalar>, Derived, OtherDerived> // operator+(const SparseMatrixBase &other) const; // template -// const CwiseBinaryOp::Scalar>, Derived, OtherDerived> +// const CwiseBinaryOp::Scalar>, Derived, OtherDerived> // operator-(const SparseMatrixBase &other) const; template @@ -322,10 +322,10 @@ template class SparseMatrixBase : public EigenBase #define EIGEN_SPARSE_CWISE_PRODUCT_RETURN_TYPE \ CwiseBinaryOp< \ - ei_scalar_product_op< \ - typename ei_scalar_product_traits< \ - typename ei_traits::Scalar, \ - typename ei_traits::Scalar \ + internal::scalar_product_op< \ + typename internal::scalar_product_traits< \ + typename internal::traits::Scalar, \ + typename internal::traits::Scalar \ >::ReturnType \ >, \ Derived, \ @@ -336,12 +336,12 @@ template class SparseMatrixBase : public EigenBase EIGEN_STRONG_INLINE const EIGEN_SPARSE_CWISE_PRODUCT_RETURN_TYPE cwiseProduct(const MatrixBase &other) const; -// const SparseCwiseUnaryOp::Scalar>, Derived> +// const SparseCwiseUnaryOp::Scalar>, Derived> // operator*(const Scalar& scalar) const; -// const SparseCwiseUnaryOp::Scalar>, Derived> +// const SparseCwiseUnaryOp::Scalar>, Derived> // operator/(const Scalar& scalar) const; -// inline friend const SparseCwiseUnaryOp::Scalar>, Derived> +// inline friend const SparseCwiseUnaryOp::Scalar>, Derived> // operator*(const Scalar& scalar, const SparseMatrixBase& matrix) // { return matrix*scalar; } @@ -379,7 +379,7 @@ template class SparseMatrixBase : public EigenBase #ifdef EIGEN2_SUPPORT // deprecated template - typename ei_plain_matrix_type_column_major::type + typename internal::plain_matrix_type_column_major::type solveTriangular(const MatrixBase& other) const; // deprecated @@ -545,15 +545,15 @@ template class SparseMatrixBase : public EigenBase // template -// const SparseCwiseUnaryOp::Scalar, NewType>, Derived> cast() const; +// const SparseCwiseUnaryOp::Scalar, NewType>, Derived> cast() const; /** \returns the matrix or vector obtained by evaluating this expression. * * Notice that in the case of a plain matrix or vector (not an expression) this function just returns * a const reference, in order to avoid a useless copy. */ - inline const typename ei_eval::type eval() const - { return typename ei_eval::type(derived()); } + inline const typename internal::eval::type eval() const + { return typename internal::eval::type(derived()); } // template // void swap(MatrixBase EIGEN_REF_TO_TEMPORARY other); @@ -585,14 +585,14 @@ template class SparseMatrixBase : public EigenBase Scalar sum() const; // Scalar trace() const; -// typename ei_traits::Scalar minCoeff() const; -// typename ei_traits::Scalar maxCoeff() const; +// typename internal::traits::Scalar minCoeff() const; +// typename internal::traits::Scalar maxCoeff() const; -// typename ei_traits::Scalar minCoeff(int* row, int* col = 0) const; -// typename ei_traits::Scalar maxCoeff(int* row, int* col = 0) const; +// typename internal::traits::Scalar minCoeff(int* row, int* col = 0) const; +// typename internal::traits::Scalar maxCoeff(int* row, int* col = 0) const; // template -// typename ei_result_of::Scalar)>::type +// typename internal::result_of::Scalar)>::type // redux(const BinaryOp& func) const; // template @@ -612,9 +612,9 @@ template class SparseMatrixBase : public EigenBase const VectorwiseOp rowwise() const; const VectorwiseOp colwise() const; - static const CwiseNullaryOp,Derived> Random(int rows, int cols); - static const CwiseNullaryOp,Derived> Random(int size); - static const CwiseNullaryOp,Derived> Random(); + static const CwiseNullaryOp,Derived> Random(int rows, int cols); + static const CwiseNullaryOp,Derived> Random(int size); + static const CwiseNullaryOp,Derived> Random(); template const Select @@ -638,10 +638,10 @@ template class SparseMatrixBase : public EigenBase // { // EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) // EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived) -// EIGEN_STATIC_ASSERT((ei_is_same_type::ret), +// EIGEN_STATIC_ASSERT((internal::is_same_type::ret), // YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) // -// ei_assert(derived().size() == other.size()); +// eigen_assert(derived().size() == other.size()); // // short version, but the assembly looks more complicated because // // of the CwiseBinaryOp iterator complexity // // return res = (derived().cwise() * other.derived().conjugate()).sum(); @@ -655,7 +655,7 @@ template class SparseMatrixBase : public EigenBase // if (i.index()==j.index()) // { // // std::cerr << i.value() << " * " << j.value() << "\n"; -// res += i.value() * ei_conj(j.value()); +// res += i.value() * internal::conj(j.value()); // ++i; ++j; // } // else if (i.index() struct SparseSparseProductReturnType { - typedef typename ei_traits::Scalar Scalar; + typedef typename internal::traits::Scalar Scalar; enum { - LhsRowMajor = ei_traits::Flags & RowMajorBit, - RhsRowMajor = ei_traits::Flags & RowMajorBit, + LhsRowMajor = internal::traits::Flags & RowMajorBit, + RhsRowMajor = internal::traits::Flags & RowMajorBit, TransposeRhs = (!LhsRowMajor) && RhsRowMajor, TransposeLhs = LhsRowMajor && (!RhsRowMajor) }; - typedef typename ei_meta_if, - const typename ei_nested::type>::ret LhsNested; + const typename internal::nested::type>::ret LhsNested; - typedef typename ei_meta_if, - const typename ei_nested::type>::ret RhsNested; + const typename internal::nested::type>::ret RhsNested; typedef SparseSparseProduct Type; }; +namespace internal { template -struct ei_traits > +struct traits > { typedef MatrixXpr XprKind; // clean the nested types: - typedef typename ei_cleantype::type _LhsNested; - typedef typename ei_cleantype::type _RhsNested; + typedef typename cleantype::type _LhsNested; + typedef typename cleantype::type _RhsNested; typedef typename _LhsNested::Scalar Scalar; - typedef typename ei_promote_index_type::Index, - typename ei_traits<_RhsNested>::Index>::type Index; + typedef typename promote_index_type::Index, + typename traits<_RhsNested>::Index>::type Index; enum { LhsCoeffReadCost = _LhsNested::CoeffReadCost, @@ -85,8 +86,10 @@ struct ei_traits > typedef Sparse StorageKind; }; +} // end namespace internal + template -class SparseSparseProduct : ei_no_assignment_operator, +class SparseSparseProduct : internal::no_assignment_operator, public SparseMatrixBase > { public: @@ -96,8 +99,8 @@ class SparseSparseProduct : ei_no_assignment_operator, private: - typedef typename ei_traits::_LhsNested _LhsNested; - typedef typename ei_traits::_RhsNested _RhsNested; + typedef typename internal::traits::_LhsNested _LhsNested; + typedef typename internal::traits::_RhsNested _RhsNested; public: @@ -105,7 +108,7 @@ class SparseSparseProduct : ei_no_assignment_operator, EIGEN_STRONG_INLINE SparseSparseProduct(const Lhs& lhs, const Rhs& rhs) : m_lhs(lhs), m_rhs(rhs) { - ei_assert(lhs.cols() == rhs.rows()); + eigen_assert(lhs.cols() == rhs.rows()); enum { ProductIsValid = _LhsNested::ColsAtCompileTime==Dynamic diff --git a/Eigen/src/Sparse/SparseRedux.h b/Eigen/src/Sparse/SparseRedux.h index bc10d5a4e..afc49de7a 100644 --- a/Eigen/src/Sparse/SparseRedux.h +++ b/Eigen/src/Sparse/SparseRedux.h @@ -26,10 +26,10 @@ #define EIGEN_SPARSEREDUX_H template -typename ei_traits::Scalar +typename internal::traits::Scalar SparseMatrixBase::sum() const { - ei_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix"); + eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix"); Scalar res = 0; for (Index j=0; j::sum() const } template -typename ei_traits >::Scalar +typename internal::traits >::Scalar SparseMatrix<_Scalar,_Options,_Index>::sum() const { - ei_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix"); + eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix"); return Matrix::Map(&m_data.value(0), m_data.size()).sum(); } template -typename ei_traits >::Scalar +typename internal::traits >::Scalar SparseVector<_Scalar,_Options,_Index>::sum() const { - ei_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix"); + eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix"); return Matrix::Map(&m_data.value(0), m_data.size()).sum(); } diff --git a/Eigen/src/Sparse/SparseSelfAdjointView.h b/Eigen/src/Sparse/SparseSelfAdjointView.h index dd4d925e1..51a2b0261 100644 --- a/Eigen/src/Sparse/SparseSelfAdjointView.h +++ b/Eigen/src/Sparse/SparseSelfAdjointView.h @@ -54,8 +54,8 @@ template class SparseSelfAdjointView inline SparseSelfAdjointView(const MatrixType& matrix) : m_matrix(matrix) { - ei_assert(ei_are_flags_consistent::ret); - ei_assert(rows()==cols() && "SelfAdjointView is only for squared matrices"); + eigen_assert(internal::are_flags_consistent::ret); + eigen_assert(rows()==cols() && "SelfAdjointView is only for squared matrices"); } inline Index rows() const { return m_matrix.rows(); } @@ -142,12 +142,14 @@ SparseSelfAdjointView::rankUpdate(const MatrixBase& u * Implementation of sparse self-adjoint time dense matrix ***************************************************************************/ +namespace internal { template -struct ei_traits > - : ei_traits, Lhs, Rhs> > +struct traits > + : traits, Lhs, Rhs> > { typedef Dense StorageKind; }; +} template class SparseSelfAdjointTimeDenseProduct @@ -162,9 +164,9 @@ class SparseSelfAdjointTimeDenseProduct template void scaleAndAddTo(Dest& dest, Scalar alpha) const { // TODO use alpha - ei_assert(alpha==Scalar(1) && "alpha != 1 is not implemented yet, sorry"); - typedef typename ei_cleantype::type _Lhs; - typedef typename ei_cleantype::type _Rhs; + eigen_assert(alpha==Scalar(1) && "alpha != 1 is not implemented yet, sorry"); + typedef typename internal::cleantype::type _Lhs; + typedef typename internal::cleantype::type _Rhs; typedef typename _Lhs::InnerIterator LhsInnerIterator; enum { LhsIsRowMajor = (_Lhs::Flags&RowMajorBit)==RowMajorBit, @@ -189,7 +191,7 @@ class SparseSelfAdjointTimeDenseProduct Index b = LhsIsRowMajor ? i.index() : j; typename Lhs::Scalar v = i.value(); dest.row(a) += (v) * m_rhs.row(b); - dest.row(b) += ei_conj(v) * m_rhs.row(a); + dest.row(b) += internal::conj(v) * m_rhs.row(a); } if (ProcessFirstHalf && i && (i.index()==j)) dest.row(j) += i.value() * m_rhs.row(j); @@ -200,10 +202,12 @@ class SparseSelfAdjointTimeDenseProduct SparseSelfAdjointTimeDenseProduct& operator=(const SparseSelfAdjointTimeDenseProduct&); }; +namespace internal { template -struct ei_traits > - : ei_traits, Lhs, Rhs> > +struct traits > + : traits, Lhs, Rhs> > {}; +} template class DenseTimeSparseSelfAdjointProduct diff --git a/Eigen/src/Sparse/SparseSparseProduct.h b/Eigen/src/Sparse/SparseSparseProduct.h index c8724c118..f0d774f1a 100644 --- a/Eigen/src/Sparse/SparseSparseProduct.h +++ b/Eigen/src/Sparse/SparseSparseProduct.h @@ -25,16 +25,18 @@ #ifndef EIGEN_SPARSESPARSEPRODUCT_H #define EIGEN_SPARSESPARSEPRODUCT_H +namespace internal { + template -static void ei_sparse_product_impl2(const Lhs& lhs, const Rhs& rhs, ResultType& res) +static void sparse_product_impl2(const Lhs& lhs, const Rhs& rhs, ResultType& res) { - typedef typename ei_cleantype::type::Scalar Scalar; - typedef typename ei_cleantype::type::Index Index; + typedef typename cleantype::type::Scalar Scalar; + typedef typename cleantype::type::Index Index; // make sure to call innerSize/outerSize since we fake the storage order. Index rows = lhs.innerSize(); Index cols = rhs.outerSize(); - ei_assert(lhs.outerSize() == rhs.innerSize()); + eigen_assert(lhs.outerSize() == rhs.innerSize()); std::vector mask(rows,false); Matrix values(rows); @@ -110,18 +112,18 @@ static void ei_sparse_product_impl2(const Lhs& lhs, const Rhs& rhs, ResultType& // perform a pseudo in-place sparse * sparse product assuming all matrices are col major template -static void ei_sparse_product_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res) +static void sparse_product_impl(const Lhs& lhs, const Rhs& rhs, ResultType& res) { -// return ei_sparse_product_impl2(lhs,rhs,res); +// return sparse_product_impl2(lhs,rhs,res); - typedef typename ei_cleantype::type::Scalar Scalar; - typedef typename ei_cleantype::type::Index Index; + typedef typename cleantype::type::Scalar Scalar; + typedef typename cleantype::type::Index Index; // make sure to call innerSize/outerSize since we fake the storage order. Index rows = lhs.innerSize(); Index cols = rhs.outerSize(); //int size = lhs.outerSize(); - ei_assert(lhs.outerSize() == rhs.innerSize()); + eigen_assert(lhs.outerSize() == rhs.innerSize()); // allocate a temporary buffer AmbiVector tempVector(rows); @@ -159,27 +161,27 @@ static void ei_sparse_product_impl(const Lhs& lhs, const Rhs& rhs, ResultType& r } template::Flags&RowMajorBit, - int RhsStorageOrder = ei_traits::Flags&RowMajorBit, - int ResStorageOrder = ei_traits::Flags&RowMajorBit> -struct ei_sparse_product_selector; + int LhsStorageOrder = traits::Flags&RowMajorBit, + int RhsStorageOrder = traits::Flags&RowMajorBit, + int ResStorageOrder = traits::Flags&RowMajorBit> +struct sparse_product_selector; template -struct ei_sparse_product_selector +struct sparse_product_selector { - typedef typename ei_traits::type>::Scalar Scalar; + typedef typename traits::type>::Scalar Scalar; static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { // std::cerr << __LINE__ << "\n"; - typename ei_cleantype::type _res(res.rows(), res.cols()); - ei_sparse_product_impl(lhs, rhs, _res); + typename cleantype::type _res(res.rows(), res.cols()); + sparse_product_impl(lhs, rhs, _res); res.swap(_res); } }; template -struct ei_sparse_product_selector +struct sparse_product_selector { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { @@ -187,26 +189,26 @@ struct ei_sparse_product_selector // we need a col-major matrix to hold the result typedef SparseMatrix SparseTemporaryType; SparseTemporaryType _res(res.rows(), res.cols()); - ei_sparse_product_impl(lhs, rhs, _res); + sparse_product_impl(lhs, rhs, _res); res = _res; } }; template -struct ei_sparse_product_selector +struct sparse_product_selector { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { // std::cerr << __LINE__ << "\n"; // let's transpose the product to get a column x column product - typename ei_cleantype::type _res(res.rows(), res.cols()); - ei_sparse_product_impl(rhs, lhs, _res); + typename cleantype::type _res(res.rows(), res.cols()); + sparse_product_impl(rhs, lhs, _res); res.swap(_res); } }; template -struct ei_sparse_product_selector +struct sparse_product_selector { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { @@ -215,21 +217,22 @@ struct ei_sparse_product_selector ColMajorMatrix colLhs(lhs); ColMajorMatrix colRhs(rhs); // std::cerr << "more...\n"; - ei_sparse_product_impl(colLhs, colRhs, res); + sparse_product_impl(colLhs, colRhs, res); // std::cerr << "OK.\n"; // let's transpose the product to get a column x column product // typedef SparseMatrix SparseTemporaryType; // SparseTemporaryType _res(res.cols(), res.rows()); -// ei_sparse_product_impl(rhs, lhs, _res); +// sparse_product_impl(rhs, lhs, _res); // res = _res.transpose(); } }; -// NOTE the 2 others cases (col row *) must never occurs since they are caught -// by ProductReturnType which transform it to (col col *) by evaluating rhs. +// NOTE the 2 others cases (col row *) must never occur since they are caught +// by ProductReturnType which transforms it to (col col *) by evaluating rhs. +} // end namespace internal // sparse = sparse * sparse template @@ -237,33 +240,34 @@ template inline Derived& SparseMatrixBase::operator=(const SparseSparseProduct& product) { // std::cerr << "there..." << typeid(Lhs).name() << " " << typeid(Lhs).name() << " " << (Derived::Flags&&RowMajorBit) << "\n"; - ei_sparse_product_selector< - typename ei_cleantype::type, - typename ei_cleantype::type, + internal::sparse_product_selector< + typename internal::cleantype::type, + typename internal::cleantype::type, Derived>::run(product.lhs(),product.rhs(),derived()); return derived(); } +namespace internal { template::Flags&RowMajorBit, - int RhsStorageOrder = ei_traits::Flags&RowMajorBit, - int ResStorageOrder = ei_traits::Flags&RowMajorBit> -struct ei_sparse_product_selector2; + int LhsStorageOrder = traits::Flags&RowMajorBit, + int RhsStorageOrder = traits::Flags&RowMajorBit, + int ResStorageOrder = traits::Flags&RowMajorBit> +struct sparse_product_selector2; template -struct ei_sparse_product_selector2 +struct sparse_product_selector2 { - typedef typename ei_traits::type>::Scalar Scalar; + typedef typename traits::type>::Scalar Scalar; static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { - ei_sparse_product_impl2(lhs, rhs, res); + sparse_product_impl2(lhs, rhs, res); } }; template -struct ei_sparse_product_selector2 +struct sparse_product_selector2 { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { @@ -275,79 +279,79 @@ struct ei_sparse_product_selector2 RowMajorMatrix; // RowMajorMatrix rhsRow = rhs; // RowMajorMatrix resRow(res.rows(), res.cols()); -// ei_sparse_product_impl2(rhsRow, lhs, resRow); +// sparse_product_impl2(rhsRow, lhs, resRow); // res = resRow; } }; template -struct ei_sparse_product_selector2 +struct sparse_product_selector2 { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { typedef SparseMatrix RowMajorMatrix; RowMajorMatrix lhsRow = lhs; RowMajorMatrix resRow(res.rows(), res.cols()); - ei_sparse_product_impl2(rhs, lhsRow, resRow); + sparse_product_impl2(rhs, lhsRow, resRow); res = resRow; } }; template -struct ei_sparse_product_selector2 +struct sparse_product_selector2 { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { typedef SparseMatrix RowMajorMatrix; RowMajorMatrix resRow(res.rows(), res.cols()); - ei_sparse_product_impl2(rhs, lhs, resRow); + sparse_product_impl2(rhs, lhs, resRow); res = resRow; } }; template -struct ei_sparse_product_selector2 +struct sparse_product_selector2 { - typedef typename ei_traits::type>::Scalar Scalar; + typedef typename traits::type>::Scalar Scalar; static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { typedef SparseMatrix ColMajorMatrix; ColMajorMatrix resCol(res.rows(), res.cols()); - ei_sparse_product_impl2(lhs, rhs, resCol); + sparse_product_impl2(lhs, rhs, resCol); res = resCol; } }; template -struct ei_sparse_product_selector2 +struct sparse_product_selector2 { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { typedef SparseMatrix ColMajorMatrix; ColMajorMatrix lhsCol = lhs; ColMajorMatrix resCol(res.rows(), res.cols()); - ei_sparse_product_impl2(lhsCol, rhs, resCol); + sparse_product_impl2(lhsCol, rhs, resCol); res = resCol; } }; template -struct ei_sparse_product_selector2 +struct sparse_product_selector2 { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { typedef SparseMatrix ColMajorMatrix; ColMajorMatrix rhsCol = rhs; ColMajorMatrix resCol(res.rows(), res.cols()); - ei_sparse_product_impl2(lhs, rhsCol, resCol); + sparse_product_impl2(lhs, rhsCol, resCol); res = resCol; } }; template -struct ei_sparse_product_selector2 +struct sparse_product_selector2 { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { @@ -355,26 +359,28 @@ struct ei_sparse_product_selector2(rhs, lhs, aux); +// sparse_product_impl2(rhs, lhs, aux); // // ColMajorMatrix aux2 = aux.transpose(); // res = aux; typedef SparseMatrix ColMajorMatrix; ColMajorMatrix lhsCol(lhs); ColMajorMatrix rhsCol(rhs); ColMajorMatrix resCol(res.rows(), res.cols()); - ei_sparse_product_impl2(lhsCol, rhsCol, resCol); + sparse_product_impl2(lhsCol, rhsCol, resCol); res = resCol; } }; +} // end namespace internal + template template inline void SparseMatrixBase::_experimentalNewProduct(const Lhs& lhs, const Rhs& rhs) { //derived().resize(lhs.rows(), rhs.cols()); - ei_sparse_product_selector2< - typename ei_cleantype::type, - typename ei_cleantype::type, + internal::sparse_product_selector2< + typename internal::cleantype::type, + typename internal::cleantype::type, Derived>::run(lhs,rhs,derived()); } diff --git a/Eigen/src/Sparse/SparseTranspose.h b/Eigen/src/Sparse/SparseTranspose.h index 79e0a04db..f0c471655 100644 --- a/Eigen/src/Sparse/SparseTranspose.h +++ b/Eigen/src/Sparse/SparseTranspose.h @@ -28,7 +28,7 @@ template class TransposeImpl : public SparseMatrixBase > { - typedef typename ei_cleantype::type _MatrixTypeNested; + typedef typename internal::cleantype::type _MatrixTypeNested; public: EIGEN_SPARSE_PUBLIC_INTERFACE(Transpose) diff --git a/Eigen/src/Sparse/SparseTriangularView.h b/Eigen/src/Sparse/SparseTriangularView.h index 929f58416..2d5c9cf75 100644 --- a/Eigen/src/Sparse/SparseTriangularView.h +++ b/Eigen/src/Sparse/SparseTriangularView.h @@ -25,10 +25,12 @@ #ifndef EIGEN_SPARSE_TRIANGULARVIEW_H #define EIGEN_SPARSE_TRIANGULARVIEW_H +namespace internal { template -struct ei_traits > -: public ei_traits +struct traits > +: public traits {}; +} template class SparseTriangularView : public SparseMatrixBase > @@ -44,7 +46,7 @@ template class SparseTriangularView inline Index rows() { return m_matrix.rows(); } inline Index cols() { return m_matrix.cols(); } - typedef typename ei_meta_if::ret, + typedef typename internal::meta_if::ret, MatrixType, const MatrixType&>::ret MatrixTypeNested; inline SparseTriangularView(const MatrixType& matrix) : m_matrix(matrix) {} @@ -53,7 +55,7 @@ template class SparseTriangularView inline const MatrixType& nestedExpression() const { return m_matrix; } template - typename ei_plain_matrix_type_column_major::type + typename internal::plain_matrix_type_column_major::type solve(const MatrixBase& other) const; template void solveInPlace(MatrixBase& other) const; diff --git a/Eigen/src/Sparse/SparseUtil.h b/Eigen/src/Sparse/SparseUtil.h index ddfa115dc..db9ae98e7 100644 --- a/Eigen/src/Sparse/SparseUtil.h +++ b/Eigen/src/Sparse/SparseUtil.h @@ -58,15 +58,15 @@ EIGEN_SPARSE_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, /=) #define _EIGEN_SPARSE_PUBLIC_INTERFACE(Derived, BaseClass) \ typedef BaseClass Base; \ - typedef typename Eigen::ei_traits::Scalar Scalar; \ + typedef typename Eigen::internal::traits::Scalar Scalar; \ typedef typename Eigen::NumTraits::Real RealScalar; \ - typedef typename Eigen::ei_nested::type Nested; \ - typedef typename Eigen::ei_traits::StorageKind StorageKind; \ - typedef typename Eigen::ei_traits::Index Index; \ - enum { RowsAtCompileTime = Eigen::ei_traits::RowsAtCompileTime, \ - ColsAtCompileTime = Eigen::ei_traits::ColsAtCompileTime, \ - Flags = Eigen::ei_traits::Flags, \ - CoeffReadCost = Eigen::ei_traits::CoeffReadCost, \ + typedef typename Eigen::internal::nested::type Nested; \ + typedef typename Eigen::internal::traits::StorageKind StorageKind; \ + typedef typename Eigen::internal::traits::Index Index; \ + enum { RowsAtCompileTime = Eigen::internal::traits::RowsAtCompileTime, \ + ColsAtCompileTime = Eigen::internal::traits::ColsAtCompileTime, \ + Flags = Eigen::internal::traits::Flags, \ + CoeffReadCost = Eigen::internal::traits::CoeffReadCost, \ SizeAtCompileTime = Base::SizeAtCompileTime, \ IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; \ using Base::derived; \ @@ -98,29 +98,33 @@ template class DenseTimeSparseProduct; template class SparseDenseOuterProduct; template struct SparseSparseProductReturnType; -template::ColsAtCompileTime> struct DenseSparseProductReturnType; -template::ColsAtCompileTime> struct SparseDenseProductReturnType; +template::ColsAtCompileTime> struct DenseSparseProductReturnType; +template::ColsAtCompileTime> struct SparseDenseProductReturnType; -template struct ei_eval +namespace internal { + +template struct eval { - typedef typename ei_traits::Scalar _Scalar; + typedef typename traits::Scalar _Scalar; enum { - _Flags = ei_traits::Flags + _Flags = traits::Flags }; public: typedef SparseMatrix<_Scalar, _Flags> type; }; -template struct ei_plain_matrix_type +template struct plain_matrix_type { - typedef typename ei_traits::Scalar _Scalar; + typedef typename traits::Scalar _Scalar; enum { - _Flags = ei_traits::Flags + _Flags = traits::Flags }; public: typedef SparseMatrix<_Scalar, _Flags> type; }; +} // end namespace internal + #endif // EIGEN_SPARSEUTIL_H diff --git a/Eigen/src/Sparse/SparseVector.h b/Eigen/src/Sparse/SparseVector.h index c5d0a6981..4671cf48f 100644 --- a/Eigen/src/Sparse/SparseVector.h +++ b/Eigen/src/Sparse/SparseVector.h @@ -34,8 +34,10 @@ * See http://www.netlib.org/linalg/html_templates/node91.html for details on the storage scheme. * */ + +namespace internal { template -struct ei_traits > +struct traits > { typedef _Scalar Scalar; typedef _Index Index; @@ -53,6 +55,7 @@ struct ei_traits > SupportedAccessPatterns = InnerRandomAccessPattern }; }; +} template class SparseVector @@ -68,7 +71,7 @@ class SparseVector public: typedef SparseMatrixBase SparseBase; - enum { IsColVector = ei_traits::IsColVector }; + enum { IsColVector = internal::traits::IsColVector }; CompressedStorage m_data; Index m_size; @@ -82,7 +85,7 @@ class SparseVector EIGEN_STRONG_INLINE Index cols() const { return IsColVector ? 1 : m_size; } EIGEN_STRONG_INLINE Index innerSize() const { return m_size; } EIGEN_STRONG_INLINE Index outerSize() const { return 1; } - EIGEN_STRONG_INLINE Index innerNonZeros(Index j) const { ei_assert(j==0); return m_size; } + EIGEN_STRONG_INLINE Index innerNonZeros(Index j) const { eigen_assert(j==0); return m_size; } EIGEN_STRONG_INLINE const Scalar* _valuePtr() const { return &m_data.value(0); } EIGEN_STRONG_INLINE Scalar* _valuePtr() { return &m_data.value(0); } @@ -92,14 +95,14 @@ class SparseVector inline Scalar coeff(Index row, Index col) const { - ei_assert((IsColVector ? col : row)==0); + eigen_assert((IsColVector ? col : row)==0); return coeff(IsColVector ? row : col); } inline Scalar coeff(Index i) const { return m_data.at(i); } inline Scalar& coeffRef(Index row, Index col) { - ei_assert((IsColVector ? col : row)==0); + eigen_assert((IsColVector ? col : row)==0); return coeff(IsColVector ? row : col); } @@ -125,12 +128,12 @@ class SparseVector inline void startVec(Index outer) { - ei_assert(outer==0); + eigen_assert(outer==0); } inline Scalar& insertBackByOuterInner(Index outer, Index inner) { - ei_assert(outer==0); + eigen_assert(outer==0); return insertBack(inner); } inline Scalar& insertBack(Index i) @@ -143,7 +146,7 @@ class SparseVector { Index inner = IsColVector ? row : col; Index outer = IsColVector ? col : row; - ei_assert(outer==0); + eigen_assert(outer==0); return insert(inner); } Scalar& insert(Index i) @@ -178,7 +181,7 @@ class SparseVector void resize(Index rows, Index cols) { - ei_assert(rows==1 || cols==1); + eigen_assert(rows==1 || cols==1); resize(IsColVector ? rows : cols); } @@ -260,9 +263,9 @@ class SparseVector // // 1 - compute the number of coeffs per dest inner vector // // 2 - do the actual copy/eval // // Since each coeff of the rhs has to be evaluated twice, let's evauluate it if needed -// typedef typename ei_nested::type OtherCopy; +// typedef typename internal::nested::type OtherCopy; // OtherCopy otherCopy(other.derived()); -// typedef typename ei_cleantype::type _OtherCopy; +// typedef typename internal::cleantype::type _OtherCopy; // // resize(other.rows(), other.cols()); // Eigen::Map(m_outerIndex,outerSize()).setZero(); @@ -321,7 +324,7 @@ class SparseVector // { // if (m_data.index(i)==other.m_data.index(j)) // { -// res += m_data.value(i) * ei_conj(other.m_data.value(j)); +// res += m_data.value(i) * internal::conj(other.m_data.value(j)); // ++i; ++j; // } // else if (m_data.index(i)::InnerIterator InnerIterator(const SparseVector& vec, Index outer=0) : m_data(vec.m_data), m_id(0), m_end(static_cast(m_data.size())) { - ei_assert(outer==0); + eigen_assert(outer==0); } InnerIterator(const CompressedStorage& data) diff --git a/Eigen/src/Sparse/SparseView.h b/Eigen/src/Sparse/SparseView.h index 5a152b255..091687d76 100644 --- a/Eigen/src/Sparse/SparseView.h +++ b/Eigen/src/Sparse/SparseView.h @@ -26,21 +26,25 @@ #ifndef EIGEN_SPARSEVIEW_H #define EIGEN_SPARSEVIEW_H +namespace internal { + template -struct ei_traits > : ei_traits +struct traits > : traits { typedef int Index; typedef Sparse StorageKind; enum { - Flags = int(ei_traits::Flags) & (RowMajorBit) + Flags = int(traits::Flags) & (RowMajorBit) }; }; +} // end namespace internal + template class SparseView : public SparseMatrixBase > { typedef typename MatrixType::Nested MatrixTypeNested; - typedef typename ei_cleantype::type _MatrixTypeNested; + typedef typename internal::cleantype::type _MatrixTypeNested; public: EIGEN_SPARSE_PUBLIC_INTERFACE(SparseView) @@ -88,7 +92,7 @@ protected: private: void incrementToNonZero() { - while(ei_isMuchSmallerThan(value(), m_view.m_reference, m_view.m_epsilon) && (bool(*this))) + while(internal::isMuchSmallerThan(value(), m_view.m_reference, m_view.m_epsilon) && (bool(*this))) { IterBase::operator++(); } diff --git a/Eigen/src/Sparse/TriangularSolver.h b/Eigen/src/Sparse/TriangularSolver.h index 3233ab0fd..06721ce86 100644 --- a/Eigen/src/Sparse/TriangularSolver.h +++ b/Eigen/src/Sparse/TriangularSolver.h @@ -25,18 +25,20 @@ #ifndef EIGEN_SPARSETRIANGULARSOLVER_H #define EIGEN_SPARSETRIANGULARSOLVER_H +namespace internal { + template::Flags) & RowMajorBit> -struct ei_sparse_solve_triangular_selector; + int StorageOrder = int(traits::Flags) & RowMajorBit> +struct sparse_solve_triangular_selector; // forward substitution, row-major template -struct ei_sparse_solve_triangular_selector +struct sparse_solve_triangular_selector { typedef typename Rhs::Scalar Scalar; static void run(const Lhs& lhs, Rhs& other) @@ -60,7 +62,7 @@ struct ei_sparse_solve_triangular_selector other.coeffRef(i,col) = tmp; else { - ei_assert(lastIndex==i); + eigen_assert(lastIndex==i); other.coeffRef(i,col) = tmp/lastVal; } } @@ -70,7 +72,7 @@ struct ei_sparse_solve_triangular_selector // backward substitution, row-major template -struct ei_sparse_solve_triangular_selector +struct sparse_solve_triangular_selector { typedef typename Rhs::Scalar Scalar; static void run(const Lhs& lhs, Rhs& other) @@ -93,7 +95,7 @@ struct ei_sparse_solve_triangular_selector else { typename Lhs::InnerIterator it(lhs, i); - ei_assert(it && it.index() == i); + eigen_assert(it && it.index() == i); other.coeffRef(i,col) = tmp/it.value(); } } @@ -103,7 +105,7 @@ struct ei_sparse_solve_triangular_selector // forward substitution, col-major template -struct ei_sparse_solve_triangular_selector +struct sparse_solve_triangular_selector { typedef typename Rhs::Scalar Scalar; static void run(const Lhs& lhs, Rhs& other) @@ -118,7 +120,7 @@ struct ei_sparse_solve_triangular_selector typename Lhs::InnerIterator it(lhs, i); if(!(Mode & UnitDiag)) { - ei_assert(it.index()==i); + eigen_assert(it.index()==i); tmp /= it.value(); } if (it && it.index()==i) @@ -133,7 +135,7 @@ struct ei_sparse_solve_triangular_selector // backward substitution, col-major template -struct ei_sparse_solve_triangular_selector +struct sparse_solve_triangular_selector { typedef typename Rhs::Scalar Scalar; static void run(const Lhs& lhs, Rhs& other) @@ -160,22 +162,24 @@ struct ei_sparse_solve_triangular_selector } }; +} // end namespace internal + template template void SparseTriangularView::solveInPlace(MatrixBase& other) const { - ei_assert(m_matrix.cols() == m_matrix.rows()); - ei_assert(m_matrix.cols() == other.rows()); - ei_assert(!(Mode & ZeroDiag)); - ei_assert(Mode & (Upper|Lower)); + eigen_assert(m_matrix.cols() == m_matrix.rows()); + eigen_assert(m_matrix.cols() == other.rows()); + eigen_assert(!(Mode & ZeroDiag)); + eigen_assert(Mode & (Upper|Lower)); - enum { copy = ei_traits::Flags & RowMajorBit }; + enum { copy = internal::traits::Flags & RowMajorBit }; - typedef typename ei_meta_if::type, OtherDerived&>::ret OtherCopy; + typedef typename internal::meta_if::type, OtherDerived&>::ret OtherCopy; OtherCopy otherCopy(other.derived()); - ei_sparse_solve_triangular_selector::type, Mode>::run(m_matrix, otherCopy); + internal::sparse_solve_triangular_selector::type, Mode>::run(m_matrix, otherCopy); if (copy) other = otherCopy; @@ -183,16 +187,18 @@ void SparseTriangularView::solveInPlace(MatrixBase template -typename ei_plain_matrix_type_column_major::type +typename internal::plain_matrix_type_column_major::type SparseTriangularView::solve(const MatrixBase& other) const { - typename ei_plain_matrix_type_column_major::type res(other); + typename internal::plain_matrix_type_column_major::type res(other); solveInPlace(res); return res; } // pure sparse path +namespace internal { + template -struct ei_sparse_solve_triangular_sparse_selector; +struct sparse_solve_triangular_sparse_selector; // forward substitution, col-major template -struct ei_sparse_solve_triangular_sparse_selector +struct sparse_solve_triangular_sparse_selector { typedef typename Rhs::Scalar Scalar; - typedef typename ei_promote_index_type::Index, - typename ei_traits::Index>::type Index; + typedef typename promote_index_type::Index, + typename traits::Index>::type Index; static void run(const Lhs& lhs, Rhs& other) { const bool IsLower = (UpLo==Lower); @@ -243,7 +249,7 @@ struct ei_sparse_solve_triangular_sparse_selector { if (IsLower) { - ei_assert(it.index()==i); + eigen_assert(it.index()==i); ci /= it.value(); } else @@ -283,22 +289,24 @@ struct ei_sparse_solve_triangular_sparse_selector } }; +} // end namespace internal + template template void SparseTriangularView::solveInPlace(SparseMatrixBase& other) const { - ei_assert(m_matrix.cols() == m_matrix.rows()); - ei_assert(m_matrix.cols() == other.rows()); - ei_assert(!(Mode & ZeroDiag)); - ei_assert(Mode & (Upper|Lower)); + eigen_assert(m_matrix.cols() == m_matrix.rows()); + eigen_assert(m_matrix.cols() == other.rows()); + eigen_assert(!(Mode & ZeroDiag)); + eigen_assert(Mode & (Upper|Lower)); -// enum { copy = ei_traits::Flags & RowMajorBit }; +// enum { copy = internal::traits::Flags & RowMajorBit }; -// typedef typename ei_meta_if::type, OtherDerived&>::ret OtherCopy; +// typedef typename internal::meta_if::type, OtherDerived&>::ret OtherCopy; // OtherCopy otherCopy(other.derived()); - ei_sparse_solve_triangular_sparse_selector::run(m_matrix, other.derived()); + internal::sparse_solve_triangular_sparse_selector::run(m_matrix, other.derived()); // if (copy) // other = otherCopy; @@ -319,10 +327,10 @@ void SparseMatrixBase::solveTriangularInPlace(MatrixBase& /** \deprecated */ template template -typename ei_plain_matrix_type_column_major::type +typename internal::plain_matrix_type_column_major::type SparseMatrixBase::solveTriangular(const MatrixBase& other) const { - typename ei_plain_matrix_type_column_major::type res(other); + typename internal::plain_matrix_type_column_major::type res(other); derived().solveTriangularInPlace(res); return res; } diff --git a/Eigen/src/StlSupport/details.h b/Eigen/src/StlSupport/details.h index 5ee4dba94..d3dbe0be8 100644 --- a/Eigen/src/StlSupport/details.h +++ b/Eigen/src/StlSupport/details.h @@ -27,58 +27,60 @@ #define EIGEN_STL_DETAILS_H #ifndef EIGEN_ALIGNED_ALLOCATOR - #define EIGEN_ALIGNED_ALLOCATOR Eigen::aligned_allocator + #define EIGEN_ALIGNED_ALLOCATOR Eigen::aligned_allocator #endif namespace Eigen { - // This one is needed to prevent reimplementing the whole std::vector. - template - class aligned_allocator_indirection : public EIGEN_ALIGNED_ALLOCATOR - { - public: - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef T* pointer; - typedef const T* const_pointer; - typedef T& reference; - typedef const T& const_reference; - typedef T value_type; + // This one is needed to prevent reimplementing the whole std::vector. + template + class aligned_allocator_indirection : public EIGEN_ALIGNED_ALLOCATOR + { + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef T value_type; - template - struct rebind - { - typedef aligned_allocator_indirection other; - }; + template + struct rebind + { + typedef aligned_allocator_indirection other; + }; - aligned_allocator_indirection() {} - aligned_allocator_indirection(const aligned_allocator_indirection& ) : EIGEN_ALIGNED_ALLOCATOR() {} - aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR& ) {} - template - aligned_allocator_indirection(const aligned_allocator_indirection& ) {} - template - aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR& ) {} - ~aligned_allocator_indirection() {} - }; + aligned_allocator_indirection() {} + aligned_allocator_indirection(const aligned_allocator_indirection& ) : EIGEN_ALIGNED_ALLOCATOR() {} + aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR& ) {} + template + aligned_allocator_indirection(const aligned_allocator_indirection& ) {} + template + aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR& ) {} + ~aligned_allocator_indirection() {} + }; #ifdef _MSC_VER - // sometimes, MSVC detects, at compile time, that the argument x - // in std::vector::resize(size_t s,T x) won't be aligned and generate an error - // even if this function is never called. Whence this little wrapper. -#define EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T) Eigen::ei_workaround_msvc_stl_support - template struct ei_workaround_msvc_stl_support : public T - { - inline ei_workaround_msvc_stl_support() : T() {} - inline ei_workaround_msvc_stl_support(const T& other) : T(other) {} - inline operator T& () { return *static_cast(this); } - inline operator const T& () const { return *static_cast(this); } - template - inline T& operator=(const OtherT& other) - { T::operator=(other); return *this; } - inline ei_workaround_msvc_stl_support& operator=(const ei_workaround_msvc_stl_support& other) - { T::operator=(other); return *this; } - }; + // sometimes, MSVC detects, at compile time, that the argument x + // in std::vector::resize(size_t s,T x) won't be aligned and generate an error + // even if this function is never called. Whence this little wrapper. +#define EIGEN_WORKAROUND_MSVC_STL_SUPPORT(T) Eigen::internal::workaround_msvc_stl_support + namespace internal { + template struct workaround_msvc_stl_support : public T + { + inline workaround_msvc_stl_support() : T() {} + inline workaround_msvc_stl_support(const T& other) : T(other) {} + inline operator T& () { return *static_cast(this); } + inline operator const T& () const { return *static_cast(this); } + template + inline T& operator=(const OtherT& other) + { T::operator=(other); return *this; } + inline workaround_msvc_stl_support& operator=(const workaround_msvc_stl_support& other) + { T::operator=(other); return *this; } + }; + } #else diff --git a/Eigen/src/misc/Image.h b/Eigen/src/misc/Image.h index 32392fd29..19b3e08cb 100644 --- a/Eigen/src/misc/Image.h +++ b/Eigen/src/misc/Image.h @@ -25,11 +25,13 @@ #ifndef EIGEN_MISC_IMAGE_H #define EIGEN_MISC_IMAGE_H -/** \class ei_image_retval_base +namespace internal { + +/** \class image_retval_base * */ template -struct ei_traits > +struct traits > { typedef typename DecompositionType::MatrixType MatrixType; typedef Matrix< @@ -43,15 +45,15 @@ struct ei_traits > > ReturnType; }; -template struct ei_image_retval_base - : public ReturnByValue > +template struct image_retval_base + : public ReturnByValue > { typedef _DecompositionType DecompositionType; typedef typename DecompositionType::MatrixType MatrixType; - typedef ReturnByValue Base; + typedef ReturnByValue Base; typedef typename Base::Index Index; - ei_image_retval_base(const DecompositionType& dec, const MatrixType& originalMatrix) + image_retval_base(const DecompositionType& dec, const MatrixType& originalMatrix) : m_dec(dec), m_rank(dec.rank()), m_cols(m_rank == 0 ? 1 : m_rank), m_originalMatrix(originalMatrix) @@ -65,7 +67,7 @@ template struct ei_image_retval_base template inline void evalTo(Dest& dst) const { - static_cast*>(this)->evalTo(dst); + static_cast*>(this)->evalTo(dst); } protected: @@ -74,18 +76,20 @@ template struct ei_image_retval_base const MatrixType& m_originalMatrix; }; +} // end namespace internal + #define EIGEN_MAKE_IMAGE_HELPERS(DecompositionType) \ typedef typename DecompositionType::MatrixType MatrixType; \ typedef typename MatrixType::Scalar Scalar; \ typedef typename MatrixType::RealScalar RealScalar; \ typedef typename MatrixType::Index Index; \ - typedef ei_image_retval_base Base; \ + typedef Eigen::internal::image_retval_base Base; \ using Base::dec; \ using Base::originalMatrix; \ using Base::rank; \ using Base::rows; \ using Base::cols; \ - ei_image_retval(const DecompositionType& dec, const MatrixType& originalMatrix) \ + image_retval(const DecompositionType& dec, const MatrixType& originalMatrix) \ : Base(dec, originalMatrix) {} #endif // EIGEN_MISC_IMAGE_H diff --git a/Eigen/src/misc/Kernel.h b/Eigen/src/misc/Kernel.h index 38a2d4097..0115970e8 100644 --- a/Eigen/src/misc/Kernel.h +++ b/Eigen/src/misc/Kernel.h @@ -25,11 +25,13 @@ #ifndef EIGEN_MISC_KERNEL_H #define EIGEN_MISC_KERNEL_H -/** \class ei_kernel_retval_base +namespace internal { + +/** \class kernel_retval_base * */ template -struct ei_traits > +struct traits > { typedef typename DecompositionType::MatrixType MatrixType; typedef Matrix< @@ -45,14 +47,14 @@ struct ei_traits > > ReturnType; }; -template struct ei_kernel_retval_base - : public ReturnByValue > +template struct kernel_retval_base + : public ReturnByValue > { typedef _DecompositionType DecompositionType; - typedef ReturnByValue Base; + typedef ReturnByValue Base; typedef typename Base::Index Index; - ei_kernel_retval_base(const DecompositionType& dec) + kernel_retval_base(const DecompositionType& dec) : m_dec(dec), m_rank(dec.rank()), m_cols(m_rank==dec.cols() ? 1 : dec.cols() - m_rank) @@ -65,7 +67,7 @@ template struct ei_kernel_retval_base template inline void evalTo(Dest& dst) const { - static_cast*>(this)->evalTo(dst); + static_cast*>(this)->evalTo(dst); } protected: @@ -73,16 +75,18 @@ template struct ei_kernel_retval_base Index m_rank, m_cols; }; +} // end namespace internal + #define EIGEN_MAKE_KERNEL_HELPERS(DecompositionType) \ typedef typename DecompositionType::MatrixType MatrixType; \ typedef typename MatrixType::Scalar Scalar; \ typedef typename MatrixType::RealScalar RealScalar; \ typedef typename MatrixType::Index Index; \ - typedef ei_kernel_retval_base Base; \ + typedef Eigen::internal::kernel_retval_base Base; \ using Base::dec; \ using Base::rank; \ using Base::rows; \ using Base::cols; \ - ei_kernel_retval(const DecompositionType& dec) : Base(dec) {} + kernel_retval(const DecompositionType& dec) : Base(dec) {} #endif // EIGEN_MISC_KERNEL_H diff --git a/Eigen/src/misc/Solve.h b/Eigen/src/misc/Solve.h index d6fc67406..bce2b2624 100644 --- a/Eigen/src/misc/Solve.h +++ b/Eigen/src/misc/Solve.h @@ -25,11 +25,13 @@ #ifndef EIGEN_MISC_SOLVE_H #define EIGEN_MISC_SOLVE_H -/** \class ei_solve_retval_base +namespace internal { + +/** \class solve_retval_base * */ template -struct ei_traits > +struct traits > { typedef typename DecompositionType::MatrixType MatrixType; typedef Matrix > Rhs::MaxColsAtCompileTime> ReturnType; }; -template struct ei_solve_retval_base - : public ReturnByValue > +template struct solve_retval_base + : public ReturnByValue > { - typedef typename ei_cleantype::type RhsNestedCleaned; + typedef typename cleantype::type RhsNestedCleaned; typedef _DecompositionType DecompositionType; - typedef ReturnByValue Base; + typedef ReturnByValue Base; typedef typename Base::Index Index; - ei_solve_retval_base(const DecompositionType& dec, const Rhs& rhs) + solve_retval_base(const DecompositionType& dec, const Rhs& rhs) : m_dec(dec), m_rhs(rhs) {} @@ -59,7 +61,7 @@ template struct ei_solve_retval_base template inline void evalTo(Dest& dst) const { - static_cast*>(this)->evalTo(dst); + static_cast*>(this)->evalTo(dst); } protected: @@ -67,17 +69,19 @@ template struct ei_solve_retval_base const typename Rhs::Nested m_rhs; }; +} // end namespace internal + #define EIGEN_MAKE_SOLVE_HELPERS(DecompositionType,Rhs) \ typedef typename DecompositionType::MatrixType MatrixType; \ typedef typename MatrixType::Scalar Scalar; \ typedef typename MatrixType::RealScalar RealScalar; \ typedef typename MatrixType::Index Index; \ - typedef ei_solve_retval_base Base; \ + typedef Eigen::internal::solve_retval_base Base; \ using Base::dec; \ using Base::rhs; \ using Base::rows; \ using Base::cols; \ - ei_solve_retval(const DecompositionType& dec, const Rhs& rhs) \ + solve_retval(const DecompositionType& dec, const Rhs& rhs) \ : Base(dec, rhs) {} #endif // EIGEN_MISC_SOLVE_H diff --git a/Eigen/src/plugins/ArrayCwiseBinaryOps.h b/Eigen/src/plugins/ArrayCwiseBinaryOps.h index b48a58234..d19299c35 100644 --- a/Eigen/src/plugins/ArrayCwiseBinaryOps.h +++ b/Eigen/src/plugins/ArrayCwiseBinaryOps.h @@ -14,10 +14,10 @@ operator*(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other) const * \sa MatrixBase::cwiseQuotient */ template -EIGEN_STRONG_INLINE const CwiseBinaryOp, Derived, OtherDerived> +EIGEN_STRONG_INLINE const CwiseBinaryOp, Derived, OtherDerived> operator/(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other) const { - return CwiseBinaryOp, Derived, OtherDerived>(derived(), other.derived()); + return CwiseBinaryOp, Derived, OtherDerived>(derived(), other.derived()); } /** \returns an expression of the coefficient-wise min of \c *this and \a other @@ -27,7 +27,7 @@ operator/(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other) const * * \sa max() */ -EIGEN_MAKE_CWISE_BINARY_OP(min,ei_scalar_min_op) +EIGEN_MAKE_CWISE_BINARY_OP(min,internal::scalar_min_op) /** \returns an expression of the coefficient-wise max of \c *this and \a other * @@ -36,7 +36,7 @@ EIGEN_MAKE_CWISE_BINARY_OP(min,ei_scalar_min_op) * * \sa min() */ -EIGEN_MAKE_CWISE_BINARY_OP(max,ei_scalar_max_op) +EIGEN_MAKE_CWISE_BINARY_OP(max,internal::scalar_max_op) /** \returns an expression of the coefficient-wise \< operator of *this and \a other * @@ -111,13 +111,13 @@ EIGEN_MAKE_CWISE_BINARY_OP(operator!=,std::not_equal_to) * * \sa operator+=(), operator-() */ -inline const CwiseUnaryOp, Derived> +inline const CwiseUnaryOp, Derived> operator+(const Scalar& scalar) const { - return CwiseUnaryOp, Derived>(derived(), ei_scalar_add_op(scalar)); + return CwiseUnaryOp, Derived>(derived(), internal::scalar_add_op(scalar)); } -friend inline const CwiseUnaryOp, Derived> +friend inline const CwiseUnaryOp, Derived> operator+(const Scalar& scalar,const EIGEN_CURRENT_STORAGE_BASE_CLASS& other) { return other + scalar; @@ -130,13 +130,13 @@ operator+(const Scalar& scalar,const EIGEN_CURRENT_STORAGE_BASE_CLASS& * * \sa operator+(), operator-=() */ -inline const CwiseUnaryOp, Derived> +inline const CwiseUnaryOp, Derived> operator-(const Scalar& scalar) const { return *this + (-scalar); } -friend inline const CwiseUnaryOp, CwiseUnaryOp,Derived> > +friend inline const CwiseUnaryOp, CwiseUnaryOp,Derived> > operator-(const Scalar& scalar,const EIGEN_CURRENT_STORAGE_BASE_CLASS& other) { return (-other) + scalar; diff --git a/Eigen/src/plugins/ArrayCwiseUnaryOps.h b/Eigen/src/plugins/ArrayCwiseUnaryOps.h index 9695bf921..78479b985 100644 --- a/Eigen/src/plugins/ArrayCwiseUnaryOps.h +++ b/Eigen/src/plugins/ArrayCwiseUnaryOps.h @@ -7,7 +7,7 @@ * * \sa abs2() */ -EIGEN_STRONG_INLINE const CwiseUnaryOp, Derived> +EIGEN_STRONG_INLINE const CwiseUnaryOp, Derived> abs() const { return derived(); @@ -20,7 +20,7 @@ abs() const * * \sa abs(), square() */ -EIGEN_STRONG_INLINE const CwiseUnaryOp, Derived> +EIGEN_STRONG_INLINE const CwiseUnaryOp, Derived> abs2() const { return derived(); @@ -33,7 +33,7 @@ abs2() const * * \sa pow(), log(), sin(), cos() */ -inline const CwiseUnaryOp, Derived> +inline const CwiseUnaryOp, Derived> exp() const { return derived(); @@ -46,7 +46,7 @@ exp() const * * \sa exp() */ -inline const CwiseUnaryOp, Derived> +inline const CwiseUnaryOp, Derived> log() const { return derived(); @@ -59,7 +59,7 @@ log() const * * \sa pow(), square() */ -inline const CwiseUnaryOp, Derived> +inline const CwiseUnaryOp, Derived> sqrt() const { return derived(); @@ -72,7 +72,7 @@ sqrt() const * * \sa sin(), exp() */ -inline const CwiseUnaryOp, Derived> +inline const CwiseUnaryOp, Derived> cos() const { return derived(); @@ -86,7 +86,7 @@ cos() const * * \sa cos(), exp() */ -inline const CwiseUnaryOp, Derived> +inline const CwiseUnaryOp, Derived> sin() const { return derived(); @@ -100,11 +100,11 @@ sin() const * * \sa exp(), log() */ -inline const CwiseUnaryOp, Derived> +inline const CwiseUnaryOp, Derived> pow(const Scalar& exponent) const { - return CwiseUnaryOp,Derived> - (derived(), ei_scalar_pow_op(exponent)); + return CwiseUnaryOp,Derived> + (derived(), internal::scalar_pow_op(exponent)); } @@ -115,7 +115,7 @@ pow(const Scalar& exponent) const * * \sa operator/(), operator*() */ -inline const CwiseUnaryOp, Derived> +inline const CwiseUnaryOp, Derived> inverse() const { return derived(); @@ -128,7 +128,7 @@ inverse() const * * \sa operator/(), operator*(), abs2() */ -inline const CwiseUnaryOp, Derived> +inline const CwiseUnaryOp, Derived> square() const { return derived(); @@ -141,7 +141,7 @@ square() const * * \sa square(), pow() */ -inline const CwiseUnaryOp, Derived> +inline const CwiseUnaryOp, Derived> cube() const { return derived(); diff --git a/Eigen/src/plugins/BlockMethods.h b/Eigen/src/plugins/BlockMethods.h index 3aae95a64..2a0e508e8 100644 --- a/Eigen/src/plugins/BlockMethods.h +++ b/Eigen/src/plugins/BlockMethods.h @@ -29,17 +29,17 @@ #ifndef EIGEN_PARSED_BY_DOXYGEN /** \internal expression type of a column */ -typedef Block::RowsAtCompileTime, 1, !IsRowMajor> ColXpr; +typedef Block::RowsAtCompileTime, 1, !IsRowMajor> ColXpr; /** \internal expression type of a row */ -typedef Block::ColsAtCompileTime, IsRowMajor> RowXpr; +typedef Block::ColsAtCompileTime, IsRowMajor> RowXpr; /** \internal expression type of a block of whole columns */ -typedef Block::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr; +typedef Block::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr; /** \internal expression type of a block of whole rows */ -typedef Block::ColsAtCompileTime, IsRowMajor> RowsBlockXpr; +typedef Block::ColsAtCompileTime, IsRowMajor> RowsBlockXpr; /** \internal expression type of a block of whole columns */ -template struct NColsBlockXpr { typedef Block::RowsAtCompileTime, N, !IsRowMajor> Type; }; +template struct NColsBlockXpr { typedef Block::RowsAtCompileTime, N, !IsRowMajor> Type; }; /** \internal expression type of a block of whole rows */ -template struct NRowsBlockXpr { typedef Block::ColsAtCompileTime, IsRowMajor> Type; }; +template struct NRowsBlockXpr { typedef Block::ColsAtCompileTime, IsRowMajor> Type; }; #endif // not EIGEN_PARSED_BY_DOXYGEN diff --git a/Eigen/src/plugins/CommonCwiseBinaryOps.h b/Eigen/src/plugins/CommonCwiseBinaryOps.h index bb0b17c09..944c86148 100644 --- a/Eigen/src/plugins/CommonCwiseBinaryOps.h +++ b/Eigen/src/plugins/CommonCwiseBinaryOps.h @@ -31,7 +31,7 @@ * * \sa class CwiseBinaryOp, operator-=() */ -EIGEN_MAKE_CWISE_BINARY_OP(operator-,ei_scalar_difference_op) +EIGEN_MAKE_CWISE_BINARY_OP(operator-,internal::scalar_difference_op) /** \returns an expression of the sum of \c *this and \a other * @@ -39,7 +39,7 @@ EIGEN_MAKE_CWISE_BINARY_OP(operator-,ei_scalar_difference_op) * * \sa class CwiseBinaryOp, operator+=() */ -EIGEN_MAKE_CWISE_BINARY_OP(operator+,ei_scalar_sum_op) +EIGEN_MAKE_CWISE_BINARY_OP(operator+,internal::scalar_sum_op) /** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other * diff --git a/Eigen/src/plugins/CommonCwiseUnaryOps.h b/Eigen/src/plugins/CommonCwiseUnaryOps.h index c16b177d8..775e77c81 100644 --- a/Eigen/src/plugins/CommonCwiseUnaryOps.h +++ b/Eigen/src/plugins/CommonCwiseUnaryOps.h @@ -28,34 +28,34 @@ #ifndef EIGEN_PARSED_BY_DOXYGEN /** \internal Represents a scalar multiple of an expression */ -typedef CwiseUnaryOp, Derived> ScalarMultipleReturnType; +typedef CwiseUnaryOp, Derived> ScalarMultipleReturnType; /** \internal Represents a quotient of an expression by a scalar*/ -typedef CwiseUnaryOp, Derived> ScalarQuotient1ReturnType; +typedef CwiseUnaryOp, Derived> ScalarQuotient1ReturnType; /** \internal the return type of conjugate() */ -typedef typename ei_meta_if::IsComplex, - const CwiseUnaryOp, Derived>, +typedef typename internal::meta_if::IsComplex, + const CwiseUnaryOp, Derived>, const Derived& >::ret ConjugateReturnType; /** \internal the return type of real() const */ -typedef typename ei_meta_if::IsComplex, - const CwiseUnaryOp, Derived>, +typedef typename internal::meta_if::IsComplex, + const CwiseUnaryOp, Derived>, const Derived& >::ret RealReturnType; /** \internal the return type of real() */ -typedef typename ei_meta_if::IsComplex, - CwiseUnaryView, Derived>, +typedef typename internal::meta_if::IsComplex, + CwiseUnaryView, Derived>, Derived& >::ret NonConstRealReturnType; /** \internal the return type of imag() const */ -typedef CwiseUnaryOp, Derived> ImagReturnType; +typedef CwiseUnaryOp, Derived> ImagReturnType; /** \internal the return type of imag() */ -typedef CwiseUnaryView, Derived> NonConstImagReturnType; +typedef CwiseUnaryView, Derived> NonConstImagReturnType; #endif // not EIGEN_PARSED_BY_DOXYGEN /** \returns an expression of the opposite of \c *this */ -inline const CwiseUnaryOp::Scalar>,Derived> +inline const CwiseUnaryOp::Scalar>,Derived> operator-() const { return derived(); } @@ -63,8 +63,8 @@ operator-() const { return derived(); } inline const ScalarMultipleReturnType operator*(const Scalar& scalar) const { - return CwiseUnaryOp, Derived> - (derived(), ei_scalar_multiple_op(scalar)); + return CwiseUnaryOp, Derived> + (derived(), internal::scalar_multiple_op(scalar)); } #ifdef EIGEN_PARSED_BY_DOXYGEN @@ -72,26 +72,26 @@ const ScalarMultipleReturnType operator*(const RealScalar& scalar) const; #endif /** \returns an expression of \c *this divided by the scalar value \a scalar */ -inline const CwiseUnaryOp::Scalar>, Derived> +inline const CwiseUnaryOp::Scalar>, Derived> operator/(const Scalar& scalar) const { - return CwiseUnaryOp, Derived> - (derived(), ei_scalar_quotient1_op(scalar)); + return CwiseUnaryOp, Derived> + (derived(), internal::scalar_quotient1_op(scalar)); } /** Overloaded for efficient real matrix times complex scalar value */ -inline const CwiseUnaryOp >, Derived> +inline const CwiseUnaryOp >, Derived> operator*(const std::complex& scalar) const { - return CwiseUnaryOp >, Derived> - (*static_cast(this), ei_scalar_multiple2_op >(scalar)); + return CwiseUnaryOp >, Derived> + (*static_cast(this), internal::scalar_multiple2_op >(scalar)); } inline friend const ScalarMultipleReturnType operator*(const Scalar& scalar, const StorageBaseType& matrix) { return matrix*scalar; } -inline friend const CwiseUnaryOp >, Derived> +inline friend const CwiseUnaryOp >, Derived> operator*(const std::complex& scalar, const StorageBaseType& matrix) { return matrix*scalar; } @@ -103,7 +103,7 @@ operator*(const std::complex& scalar, const StorageBaseType& matrix) * \sa class CwiseUnaryOp */ template -typename ei_cast_return_type::Scalar, NewType>, Derived> >::type +typename internal::cast_return_type::Scalar, NewType>, Derived> >::type cast() const { return derived(); diff --git a/Eigen/src/plugins/MatrixCwiseBinaryOps.h b/Eigen/src/plugins/MatrixCwiseBinaryOps.h index a1f673df5..75397c512 100644 --- a/Eigen/src/plugins/MatrixCwiseBinaryOps.h +++ b/Eigen/src/plugins/MatrixCwiseBinaryOps.h @@ -85,10 +85,10 @@ cwiseNotEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other) const * \sa class CwiseBinaryOp, max() */ template -EIGEN_STRONG_INLINE const CwiseBinaryOp, Derived, OtherDerived> +EIGEN_STRONG_INLINE const CwiseBinaryOp, Derived, OtherDerived> cwiseMin(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other) const { - return CwiseBinaryOp, Derived, OtherDerived>(derived(), other.derived()); + return CwiseBinaryOp, Derived, OtherDerived>(derived(), other.derived()); } /** \returns an expression of the coefficient-wise max of *this and \a other @@ -99,10 +99,10 @@ cwiseMin(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other) const * \sa class CwiseBinaryOp, min() */ template -EIGEN_STRONG_INLINE const CwiseBinaryOp, Derived, OtherDerived> +EIGEN_STRONG_INLINE const CwiseBinaryOp, Derived, OtherDerived> cwiseMax(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other) const { - return CwiseBinaryOp, Derived, OtherDerived>(derived(), other.derived()); + return CwiseBinaryOp, Derived, OtherDerived>(derived(), other.derived()); } /** \returns an expression of the coefficient-wise quotient of *this and \a other @@ -113,8 +113,8 @@ cwiseMax(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other) const * \sa class CwiseBinaryOp, cwiseProduct(), cwiseInverse() */ template -EIGEN_STRONG_INLINE const CwiseBinaryOp, Derived, OtherDerived> +EIGEN_STRONG_INLINE const CwiseBinaryOp, Derived, OtherDerived> cwiseQuotient(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other) const { - return CwiseBinaryOp, Derived, OtherDerived>(derived(), other.derived()); + return CwiseBinaryOp, Derived, OtherDerived>(derived(), other.derived()); } diff --git a/Eigen/src/plugins/MatrixCwiseUnaryOps.h b/Eigen/src/plugins/MatrixCwiseUnaryOps.h index a33de85a5..85df29cbe 100644 --- a/Eigen/src/plugins/MatrixCwiseUnaryOps.h +++ b/Eigen/src/plugins/MatrixCwiseUnaryOps.h @@ -32,7 +32,7 @@ * * \sa cwiseAbs2() */ -EIGEN_STRONG_INLINE const CwiseUnaryOp,Derived> +EIGEN_STRONG_INLINE const CwiseUnaryOp,Derived> cwiseAbs() const { return derived(); } /** \returns an expression of the coefficient-wise squared absolute value of \c *this @@ -42,7 +42,7 @@ cwiseAbs() const { return derived(); } * * \sa cwiseAbs() */ -EIGEN_STRONG_INLINE const CwiseUnaryOp,Derived> +EIGEN_STRONG_INLINE const CwiseUnaryOp,Derived> cwiseAbs2() const { return derived(); } /** \returns an expression of the coefficient-wise square root of *this. @@ -52,7 +52,7 @@ cwiseAbs2() const { return derived(); } * * \sa cwisePow(), cwiseSquare() */ -inline const CwiseUnaryOp,Derived> +inline const CwiseUnaryOp,Derived> cwiseSqrt() const { return derived(); } /** \returns an expression of the coefficient-wise inverse of *this. @@ -62,7 +62,7 @@ cwiseSqrt() const { return derived(); } * * \sa cwiseProduct() */ -inline const CwiseUnaryOp,Derived> +inline const CwiseUnaryOp,Derived> cwiseInverse() const { return derived(); } /** \returns an expression of the coefficient-wise == operator of \c *this and a scalar \a s diff --git a/bench/BenchSparseUtil.h b/bench/BenchSparseUtil.h index 305c70aeb..ff836bffe 100644 --- a/bench/BenchSparseUtil.h +++ b/bench/BenchSparseUtil.h @@ -31,7 +31,7 @@ void fillMatrix(float density, int rows, int cols, EigenSparseMatrix& dst) { for(int i = 0; i < rows; i++) { - Scalar v = (ei_random(0,1) < density) ? ei_random() : 0; + Scalar v = (internal::random(0,1) < density) ? internal::random() : 0; if (v!=0) dst.insert(i,j) = v; } @@ -48,12 +48,12 @@ void fillMatrix2(int nnzPerCol, int rows, int cols, EigenSparseMatrix& dst) std::set aux; for(int i = 0; i < nnzPerCol; i++) { - int k = ei_random(0,rows-1); + int k = internal::random(0,rows-1); while (aux.find(k)!=aux.end()) - k = ei_random(0,rows-1); + k = internal::random(0,rows-1); aux.insert(k); - dst.insert(k,j) = ei_random(); + dst.insert(k,j) = internal::random(); } } dst.finalize(); diff --git a/bench/benchBlasGemm.cpp b/bench/benchBlasGemm.cpp index 81ff3f724..cb086a555 100644 --- a/bench/benchBlasGemm.cpp +++ b/bench/benchBlasGemm.cpp @@ -208,9 +208,9 @@ void check_product(void) int M, N, K; for (uint i=0; i<1000; ++i) { - M = ei_random(1,64); - N = ei_random(1,768); - K = ei_random(1,768); + M = internal::random(1,64); + N = internal::random(1,768); + K = internal::random(1,768); M = (0 + M) * 1; std::cout << M << " x " << N << " x " << K << "\n"; check_product(M, N, K); diff --git a/bench/benchCholesky.cpp b/bench/benchCholesky.cpp index ca9bb20bc..42b3e1285 100644 --- a/bench/benchCholesky.cpp +++ b/bench/benchCholesky.cpp @@ -49,8 +49,8 @@ __attribute__ ((noinline)) void benchLLT(const MatrixType& m) BenchTimer timerNoSqrt, timerSqrt; Scalar acc = 0; - int r = ei_random(0,covMat.rows()-1); - int c = ei_random(0,covMat.cols()-1); + int r = internal::random(0,covMat.rows()-1); + int c = internal::random(0,covMat.cols()-1); for (int t=0; t(0,covMat.rows()-1); - int c = ei_random(0,covMat.cols()-1); + int r = internal::random(0,covMat.rows()-1); + int c = internal::random(0,covMat.cols()-1); { SelfAdjointEigenSolver ei(covMat); for (int t=0; t(size2); - Scalar* b = ei_aligned_new(size2+4)+1; - Scalar* c = ei_aligned_new(size2); + Scalar* a = internal::aligned_new(size2); + Scalar* b = internal::aligned_new(size2+4)+1; + Scalar* c = internal::aligned_new(size2); for (int i=0; i::type PacketScalar; - const int PacketSize = ei_packet_traits::size; + typedef internal::packet_traits::type PacketScalar; + const int PacketSize = internal::packet_traits::size; PacketScalar a0, a1, a2, a3, b0, b1, b2, b3; for (int k=0; k Traits; + typedef internal::gebp_traits Traits; std::cout << "Register blocking = " << Traits::mr << " x " << Traits::nr << "\n"; int rep = 1; // number of repetitions per try diff --git a/bench/bench_norm.cpp b/bench/bench_norm.cpp index 1436ddbf5..806db292c 100644 --- a/bench/bench_norm.cpp +++ b/bench/bench_norm.cpp @@ -32,18 +32,18 @@ EIGEN_DONT_INLINE typename T::Scalar lapackNorm(T& v) Scalar ssq = 1; for (int i=0;i= ax) { - ssq += ei_abs2(ax/scale); + ssq += internal::abs2(ax/scale); } else { - ssq = Scalar(1) + ssq * ei_abs2(scale/ax); + ssq = Scalar(1) + ssq * internal::abs2(scale/ax); scale = ax; } } - return scale * ei_sqrt(ssq); + return scale * internal::sqrt(ssq); } template @@ -73,15 +73,15 @@ EIGEN_DONT_INLINE typename T::Scalar divacNorm(T& v) v(i) = v(2*i) + v(2*i+1); n = n/2; } - return ei_sqrt(v(0)); + return internal::sqrt(v(0)); } #ifdef EIGEN_VECTORIZE -Packet4f ei_plt(const Packet4f& a, Packet4f& b) { return _mm_cmplt_ps(a,b); } -Packet2d ei_plt(const Packet2d& a, Packet2d& b) { return _mm_cmplt_pd(a,b); } +Packet4f internal::plt(const Packet4f& a, Packet4f& b) { return _mm_cmplt_ps(a,b); } +Packet2d internal::plt(const Packet2d& a, Packet2d& b) { return _mm_cmplt_pd(a,b); } -Packet4f ei_pandnot(const Packet4f& a, Packet4f& b) { return _mm_andnot_ps(a,b); } -Packet2d ei_pandnot(const Packet2d& a, Packet2d& b) { return _mm_andnot_pd(a,b); } +Packet4f internal::pandnot(const Packet4f& a, Packet4f& b) { return _mm_andnot_ps(a,b); } +Packet2d internal::pandnot(const Packet2d& a, Packet2d& b) { return _mm_andnot_pd(a,b); } #endif template @@ -112,7 +112,7 @@ EIGEN_DONT_INLINE typename T::Scalar pblueNorm(const T& v) if(iemin > 1 - 2*it || 1+it>iemax || (it==2 && ibeta<5) || (it<=4 && ibeta <= 3 ) || it<2) { - ei_assert(false && "the algorithm cannot be guaranteed on this computer"); + eigen_assert(false && "the algorithm cannot be guaranteed on this computer"); } iexp = -((1-iemin)/2); b1 = std::pow(ibeta, iexp); // lower boundary of midrange @@ -126,60 +126,60 @@ EIGEN_DONT_INLINE typename T::Scalar pblueNorm(const T& v) overfl = rbig*s2m; // overfow boundary for abig eps = std::pow(ibeta, 1-it); - relerr = ei_sqrt(eps); // tolerance for neglecting asml + relerr = internal::sqrt(eps); // tolerance for neglecting asml abig = 1.0/eps - 1.0; if (Scalar(nbig)>abig) nmax = abig; // largest safe n else nmax = nbig; } - typedef typename ei_packet_traits::type Packet; - const int ps = ei_packet_traits::size; - Packet pasml = ei_pset1(Scalar(0)); - Packet pamed = ei_pset1(Scalar(0)); - Packet pabig = ei_pset1(Scalar(0)); - Packet ps2m = ei_pset1(s2m); - Packet ps1m = ei_pset1(s1m); - Packet pb2 = ei_pset1(b2); - Packet pb1 = ei_pset1(b1); + typedef typename internal::packet_traits::type Packet; + const int ps = internal::packet_traits::size; + Packet pasml = internal::pset1(Scalar(0)); + Packet pamed = internal::pset1(Scalar(0)); + Packet pabig = internal::pset1(Scalar(0)); + Packet ps2m = internal::pset1(s2m); + Packet ps1m = internal::pset1(s1m); + Packet pb2 = internal::pset1(b2); + Packet pb1 = internal::pset1(b1); for(int j=0; j(j)); - Packet ax_s2m = ei_pmul(ax,ps2m); - Packet ax_s1m = ei_pmul(ax,ps1m); - Packet maskBig = ei_plt(pb2,ax); - Packet maskSml = ei_plt(ax,pb1); - -// Packet maskMed = ei_pand(maskSml,maskBig); -// Packet scale = ei_pset1(Scalar(0)); -// scale = ei_por(scale, ei_pand(maskBig,ps2m)); -// scale = ei_por(scale, ei_pand(maskSml,ps1m)); -// scale = ei_por(scale, ei_pandnot(ei_pset1(Scalar(1)),maskMed)); -// ax = ei_pmul(ax,scale); -// ax = ei_pmul(ax,ax); -// pabig = ei_padd(pabig, ei_pand(maskBig, ax)); -// pasml = ei_padd(pasml, ei_pand(maskSml, ax)); -// pamed = ei_padd(pamed, ei_pandnot(ax,maskMed)); - - - pabig = ei_padd(pabig, ei_pand(maskBig, ei_pmul(ax_s2m,ax_s2m))); - pasml = ei_padd(pasml, ei_pand(maskSml, ei_pmul(ax_s1m,ax_s1m))); - pamed = ei_padd(pamed, ei_pandnot(ei_pmul(ax,ax),ei_pand(maskSml,maskBig))); + Packet ax = internal::pabs(v.template packet(j)); + Packet ax_s2m = internal::pmul(ax,ps2m); + Packet ax_s1m = internal::pmul(ax,ps1m); + Packet maskBig = internal::plt(pb2,ax); + Packet maskSml = internal::plt(ax,pb1); + +// Packet maskMed = internal::pand(maskSml,maskBig); +// Packet scale = internal::pset1(Scalar(0)); +// scale = internal::por(scale, internal::pand(maskBig,ps2m)); +// scale = internal::por(scale, internal::pand(maskSml,ps1m)); +// scale = internal::por(scale, internal::pandnot(internal::pset1(Scalar(1)),maskMed)); +// ax = internal::pmul(ax,scale); +// ax = internal::pmul(ax,ax); +// pabig = internal::padd(pabig, internal::pand(maskBig, ax)); +// pasml = internal::padd(pasml, internal::pand(maskSml, ax)); +// pamed = internal::padd(pamed, internal::pandnot(ax,maskMed)); + + + pabig = internal::padd(pabig, internal::pand(maskBig, internal::pmul(ax_s2m,ax_s2m))); + pasml = internal::padd(pasml, internal::pand(maskSml, internal::pmul(ax_s1m,ax_s1m))); + pamed = internal::padd(pamed, internal::pandnot(internal::pmul(ax,ax),internal::pand(maskSml,maskBig))); } - Scalar abig = ei_predux(pabig); - Scalar asml = ei_predux(pasml); - Scalar amed = ei_predux(pamed); + Scalar abig = internal::predux(pabig); + Scalar asml = internal::predux(pasml); + Scalar amed = internal::predux(pamed); if(abig > Scalar(0)) { - abig = ei_sqrt(abig); + abig = internal::sqrt(abig); if(abig > overfl) { - ei_assert(false && "overflow"); + eigen_assert(false && "overflow"); return rbig; } if(amed > Scalar(0)) { abig = abig/s2m; - amed = ei_sqrt(amed); + amed = internal::sqrt(amed); } else { @@ -191,24 +191,24 @@ EIGEN_DONT_INLINE typename T::Scalar pblueNorm(const T& v) { if (amed > Scalar(0)) { - abig = ei_sqrt(amed); - amed = ei_sqrt(asml) / s1m; + abig = internal::sqrt(amed); + amed = internal::sqrt(asml) / s1m; } else { - return ei_sqrt(asml)/s1m; + return internal::sqrt(asml)/s1m; } } else { - return ei_sqrt(amed); + return internal::sqrt(amed); } asml = std::min(abig, amed); abig = std::max(abig, amed); if(asml <= abig*relerr) return abig; else - return abig * ei_sqrt(Scalar(1) + ei_abs2(asml/abig)); + return abig * internal::sqrt(Scalar(1) + internal::abs2(asml/abig)); #endif } @@ -234,12 +234,12 @@ EIGEN_DONT_INLINE typename T::Scalar pblueNorm(const T& v) void check_accuracy(double basef, double based, int s) { - double yf = basef * ei_abs(ei_random()); - double yd = based * ei_abs(ei_random()); + double yf = basef * internal::abs(internal::random()); + double yd = based * internal::abs(internal::random()); VectorXf vf = VectorXf::Ones(s) * yf; VectorXd vd = VectorXd::Ones(s) * yd; - std::cout << "reference\t" << ei_sqrt(double(s))*yf << "\t" << ei_sqrt(double(s))*yd << "\n"; + std::cout << "reference\t" << internal::sqrt(double(s))*yf << "\t" << internal::sqrt(double(s))*yd << "\n"; std::cout << "sqsumNorm\t" << sqsumNorm(vf) << "\t" << sqsumNorm(vd) << "\n"; std::cout << "hypotNorm\t" << hypotNorm(vf) << "\t" << hypotNorm(vd) << "\n"; std::cout << "blueNorm\t" << blueNorm(vf) << "\t" << blueNorm(vd) << "\n"; @@ -255,11 +255,11 @@ void check_accuracy_var(int ef0, int ef1, int ed0, int ed1, int s) VectorXd vd(s); for (int i=0; i()) * std::pow(double(10), ei_random(ef0,ef1)); - vd[i] = ei_abs(ei_random()) * std::pow(double(10), ei_random(ed0,ed1)); + vf[i] = internal::abs(internal::random()) * std::pow(double(10), internal::random(ef0,ef1)); + vd[i] = internal::abs(internal::random()) * std::pow(double(10), internal::random(ed0,ed1)); } - //std::cout << "reference\t" << ei_sqrt(double(s))*yf << "\t" << ei_sqrt(double(s))*yd << "\n"; + //std::cout << "reference\t" << internal::sqrt(double(s))*yf << "\t" << internal::sqrt(double(s))*yd << "\n"; std::cout << "sqsumNorm\t" << sqsumNorm(vf) << "\t" << sqsumNorm(vd) << "\t" << sqsumNorm(vf.cast()) << "\t" << sqsumNorm(vd.cast()) << "\n"; std::cout << "hypotNorm\t" << hypotNorm(vf) << "\t" << hypotNorm(vd) << "\t" << hypotNorm(vf.cast()) << "\t" << hypotNorm(vd.cast()) << "\n"; std::cout << "blueNorm\t" << blueNorm(vf) << "\t" << blueNorm(vd) << "\t" << blueNorm(vf.cast()) << "\t" << blueNorm(vd.cast()) << "\n"; @@ -273,7 +273,7 @@ int main(int argc, char** argv) { int tries = 10; int iters = 100000; - double y = 1.1345743233455785456788e12 * ei_random(); + double y = 1.1345743233455785456788e12 * internal::random(); VectorXf v = VectorXf::Ones(1024) * y; // return 0; diff --git a/bench/bench_reverse.cpp b/bench/bench_reverse.cpp index 0e695b2f2..1e69ca1b2 100644 --- a/bench/bench_reverse.cpp +++ b/bench/bench_reverse.cpp @@ -28,8 +28,8 @@ __attribute__ ((noinline)) void bench_reverse(const MatrixType& m) BenchTimer timerB, timerH, timerV; Scalar acc = 0; - int r = ei_random(0,rows-1); - int c = ei_random(0,cols-1); + int r = internal::random(0,rows-1); + int c = internal::random(0,cols-1); for (int t=0; t(0,10); - c = Eigen::ei_random(0,10); - nr = Eigen::ei_random(50,80); - nc = Eigen::ei_random(50,80); + r = Eigen::internal::random(0,10); + c = Eigen::internal::random(0,10); + nr = Eigen::internal::random(50,80); + nc = Eigen::internal::random(50,80); m.block(r,c,nr,nc) += Mat::Ones(nr,nc); m.block(r,c,nr,nc) *= SCALAR(10); m.block(r,c,nr,nc) -= Mat::constant(nr,nc,10); diff --git a/bench/btl/libs/eigen2/eigen2_interface.hh b/bench/btl/libs/eigen2/eigen2_interface.hh index 428ddc547..ae280008b 100644 --- a/bench/btl/libs/eigen2/eigen2_interface.hh +++ b/bench/btl/libs/eigen2/eigen2_interface.hh @@ -106,13 +106,13 @@ public : static inline void symv(const gene_matrix & A, const gene_vector & B, gene_vector & X, int N){ X.noalias() = (A.template selfadjointView() * B); -// ei_product_selfadjoint_vector(N,A.data(),N, B.data(), 1, X.data(), 1); +// internal::product_selfadjoint_vector(N,A.data(),N, B.data(), 1, X.data(), 1); } template static void triassign(Dest& dst, const Src& src) { typedef typename Dest::Scalar Scalar; - typedef typename ei_packet_traits::type Packet; + typedef typename internal::packet_traits::type Packet; const int PacketSize = sizeof(Packet)/sizeof(Scalar); int size = dst.cols(); for(int j=0; j(N,A.data(),N, X.data(), 1, Y.data(), 1, -1); + // internal::product_selfadjoint_rank2_update(N,A.data(),N, X.data(), 1, Y.data(), 1, -1); for(int j=0; j(c,s)); + internal::apply_rotation_in_the_plane(A, B, JacobiRotation(c,s)); } static inline void atv_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ @@ -203,7 +203,7 @@ public : static inline void cholesky(const gene_matrix & X, gene_matrix & C, int N){ C = X; - ei_llt_inplace::blocked(C); + internal::llt_inplace::blocked(C); //C = X.llt().matrixL(); // C = X; // Cholesky::computeInPlace(C); @@ -218,14 +218,14 @@ public : Matrix piv(N); DenseIndex nb; C = X; - ei_partial_lu_inplace(C,piv,nb); + internal::partial_lu_inplace(C,piv,nb); // C = X.partialPivLu().matrixLU(); } static inline void tridiagonalization(const gene_matrix & X, gene_matrix & C, int N){ typename Tridiagonalization::CoeffVectorType aux(N-1); C = X; - ei_tridiagonalization_inplace(C, aux); + internal::tridiagonalization_inplace(C, aux); } static inline void hessenberg(const gene_matrix & X, gene_matrix & C, int N){ diff --git a/bench/btl/libs/hand_vec/hand_vec_interface.hh b/bench/btl/libs/hand_vec/hand_vec_interface.hh index be5d5e6b6..0bb4b64ca 100755 --- a/bench/btl/libs/hand_vec/hand_vec_interface.hh +++ b/bench/btl/libs/hand_vec/hand_vec_interface.hh @@ -29,8 +29,8 @@ class hand_vec_interface : public f77_interface_base { public : - typedef typename ei_packet_traits::type Packet; - static const int PacketSize = ei_packet_traits::size; + typedef typename internal::packet_traits::type Packet; + static const int PacketSize = internal::packet_traits::size; typedef typename f77_interface_base::stl_matrix stl_matrix; typedef typename f77_interface_base::stl_vector stl_vector; @@ -38,16 +38,16 @@ public : typedef typename f77_interface_base::gene_vector gene_vector; static void free_matrix(gene_matrix & A, int N){ - ei_aligned_free(A); + internal::aligned_free(A); } static void free_vector(gene_vector & B){ - ei_aligned_free(B); + internal::aligned_free(B); } static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){ int N = A_stl.size(); - A = (real*)ei_aligned_malloc(N*N*sizeof(real)); + A = (real*)internal::aligned_malloc(N*N*sizeof(real)); for (int j=0;j0) { bool aligned0 = (iN0 % PacketSize) == 0; if (aligned0) for (int j = 0;j0) // { // bool aligned0 = (iN0 % PacketSize) == 0; // if (aligned0) // for (int j = 0;j0) @@ -497,27 +497,27 @@ public : // { // for (int j = 0;j0) // { // bool aligned0 = (iN0 % PacketSize) == 0; // if (aligned0) // for (int j = 0;j0) // { @@ -595,45 +595,45 @@ public : // int ANP = (AN/(8*PacketSize))*8*PacketSize; // for (int j = 0;j0) { if (iN0 % PacketSize==0) for (int j = 0;j0) // { @@ -781,21 +781,21 @@ public : // for (int j = 0;j0) { - Packet pcoef = ei_pset1(coef); + Packet pcoef = internal::pset1(coef); #ifdef PEELING const int peelSize = 3; int ANP = (AN/(peelSize*PacketSize))*peelSize*PacketSize; @@ -846,33 +846,33 @@ public : Packet x0,x1,x2,y0,y1,y2; for (int j = 0;j=4) { - ei_queryCacheSizes_intel_direct(l1, l2, l3); + internal::queryCacheSizes_intel_direct(l1, l2, l3); cout << "Eigen's intel direct L1, L2, L3 = " << l1 << " " << l2 << " " << l3 << endl; } - ei_queryCacheSizes_amd(l1, l2, l3); + internal::queryCacheSizes_amd(l1, l2, l3); cout << "Eigen's amd L1, L2, L3 = " << l1 << " " << l2 << " " << l3 << endl; cout << endl; diff --git a/bench/eig33.cpp b/bench/eig33.cpp index df07ad79d..da8518012 100644 --- a/bench/eig33.cpp +++ b/bench/eig33.cpp @@ -65,7 +65,7 @@ inline void computeRoots(const Matrix& m, Roots& roots) { typedef typename Matrix::Scalar Scalar; const Scalar s_inv3 = 1.0/3.0; - const Scalar s_sqrt3 = ei_sqrt(Scalar(3.0)); + const Scalar s_sqrt3 = internal::sqrt(Scalar(3.0)); // The characteristic equation is x^3 - c2*x^2 + c1*x - c0 = 0. The // eigenvalues are the roots to this equation, all guaranteed to be @@ -88,10 +88,10 @@ inline void computeRoots(const Matrix& m, Roots& roots) q = Scalar(0); // Compute the eigenvalues by solving for the roots of the polynomial. - Scalar rho = ei_sqrt(-a_over_3); - Scalar theta = std::atan2(ei_sqrt(-q),half_b)*s_inv3; - Scalar cos_theta = ei_cos(theta); - Scalar sin_theta = ei_sin(theta); + Scalar rho = internal::sqrt(-a_over_3); + Scalar theta = std::atan2(internal::sqrt(-q),half_b)*s_inv3; + Scalar cos_theta = internal::cos(theta); + Scalar sin_theta = internal::sin(theta); roots(0) = c2_over_3 + Scalar(2)*rho*cos_theta; roots(1) = c2_over_3 - rho*(cos_theta + s_sqrt3*sin_theta); roots(2) = c2_over_3 - rho*(cos_theta - s_sqrt3*sin_theta); diff --git a/bench/quat_slerp.cpp b/bench/quat_slerp.cpp index 27a2067ab..bffb3bf11 100644 --- a/bench/quat_slerp.cpp +++ b/bench/quat_slerp.cpp @@ -25,16 +25,16 @@ EIGEN_DONT_INLINE Q slerp_legacy(const Q& a, const Q& b, typename Q::Scalar t) typedef typename Q::Scalar Scalar; static const Scalar one = Scalar(1) - dummy_precision(); Scalar d = a.dot(b); - Scalar absD = ei_abs(d); + Scalar absD = internal::abs(d); if (absD>=one) return a; // theta is the angle between the 2 quaternions Scalar theta = std::acos(absD); - Scalar sinTheta = ei_sin(theta); + Scalar sinTheta = internal::sin(theta); - Scalar scale0 = ei_sin( ( Scalar(1) - t ) * theta) / sinTheta; - Scalar scale1 = ei_sin( ( t * theta) ) / sinTheta; + Scalar scale0 = internal::sin( ( Scalar(1) - t ) * theta) / sinTheta; + Scalar scale1 = internal::sin( ( t * theta) ) / sinTheta; if (d<0) scale1 = -scale1; @@ -47,7 +47,7 @@ EIGEN_DONT_INLINE Q slerp_legacy_nlerp(const Q& a, const Q& b, typename Q::Scala typedef typename Q::Scalar Scalar; static const Scalar one = Scalar(1) - epsilon(); Scalar d = a.dot(b); - Scalar absD = ei_abs(d); + Scalar absD = internal::abs(d); Scalar scale0; Scalar scale1; @@ -61,10 +61,10 @@ EIGEN_DONT_INLINE Q slerp_legacy_nlerp(const Q& a, const Q& b, typename Q::Scala { // theta is the angle between the 2 quaternions Scalar theta = std::acos(absD); - Scalar sinTheta = ei_sin(theta); + Scalar sinTheta = internal::sin(theta); - scale0 = ei_sin( ( Scalar(1) - t ) * theta) / sinTheta; - scale1 = ei_sin( ( t * theta) ) / sinTheta; + scale0 = internal::sin( ( Scalar(1) - t ) * theta) / sinTheta; + scale1 = internal::sin( ( t * theta) ) / sinTheta; if (d<0) scale1 = -scale1; } @@ -132,8 +132,8 @@ EIGEN_DONT_INLINE Q slerp_gael(const Q& a, const Q& b, typename Q::Scalar t) else { Scalar sinTheta = std::sin(theta); - scale0 = ei_sin( ( Scalar(1) - t ) * theta) / sinTheta; - scale1 = ei_sin( ( t * theta) ) / sinTheta; + scale0 = internal::sin( ( Scalar(1) - t ) * theta) / sinTheta; + scale1 = internal::sin( ( t * theta) ) / sinTheta; if (d<0) scale1 = -scale1; } diff --git a/bench/quatmul.cpp b/bench/quatmul.cpp index d91a4b01b..8d9d7922c 100644 --- a/bench/quatmul.cpp +++ b/bench/quatmul.cpp @@ -14,7 +14,7 @@ EIGEN_DONT_INLINE void quatmul_default(const Quat& a, const Quat& b, Quat& c) template EIGEN_DONT_INLINE void quatmul_novec(const Quat& a, const Quat& b, Quat& c) { - c = ei_quat_product<0, Quat, Quat, typename Quat::Scalar, Aligned>::run(a,b); + c = internal::quat_product<0, Quat, Quat, typename Quat::Scalar, Aligned>::run(a,b); } template void bench(const std::string& label) diff --git a/bench/sparse_cholesky.cpp b/bench/sparse_cholesky.cpp index 4b8ff34f8..ecb226786 100644 --- a/bench/sparse_cholesky.cpp +++ b/bench/sparse_cholesky.cpp @@ -46,10 +46,10 @@ void fillSpdMatrix(float density, int rows, int cols, EigenSparseSelfAdjointMat dst.startFill(rows*cols*density); for(int j = 0; j < cols; j++) { - dst.fill(j,j) = ei_random(10,20); + dst.fill(j,j) = internal::random(10,20); for(int i = j+1; i < rows; i++) { - Scalar v = (ei_random(0,1) < density) ? ei_random() : 0; + Scalar v = (internal::random(0,1) < density) ? internal::random() : 0; if (v!=0) dst.fill(i,j) = v; } @@ -116,7 +116,7 @@ int main(int argc, char *argv[]) int count = 0; for (int j=0; j(0,rows-1),ei_random(0,cols-1)) += 1; + (*set1)(internal::random(0,rows-1),internal::random(0,cols-1)) += 1; t.stop(); std::cout << "std::map => \t" << t.value()-rtime << " nnz=" << set1->nonZeros() << std::flush; @@ -78,7 +78,7 @@ int main(int argc, char *argv[]) t.reset(); t.start(); for (int k=0; k(0,rows-1) + ei_random(0,cols-1); + dummy = internal::random(0,rows-1) + internal::random(0,cols-1); t.stop(); rtime = t.value(); std::cout << "rtime = " << rtime << " (" << dummy << ")\n\n"; @@ -94,7 +94,7 @@ int main(int argc, char *argv[]) // RandomSetter set1(sm1); // t.reset(); t.start(); // for (int k=0; k(0,rows-1),ei_random(0,cols-1)) += 1; +// set1(internal::random(0,rows-1),internal::random(0,cols-1)) += 1; // t.stop(); // std::cout << "gnu::hash_map => \t" << t.value()-rtime // << " nnz=" << set1.nonZeros() << "\n";getchar(); @@ -103,7 +103,7 @@ int main(int argc, char *argv[]) // RandomSetter set1(sm1); // t.reset(); t.start(); // for (int k=0; k(0,rows-1),ei_random(0,cols-1)) += 1; +// set1(internal::random(0,rows-1),internal::random(0,cols-1)) += 1; // t.stop(); // std::cout << "google::dense => \t" << t.value()-rtime // << " nnz=" << set1.nonZeros() << "\n";getchar(); @@ -112,7 +112,7 @@ int main(int argc, char *argv[]) // RandomSetter set1(sm1); // t.reset(); t.start(); // for (int k=0; k(0,rows-1),ei_random(0,cols-1)) += 1; +// set1(internal::random(0,rows-1),internal::random(0,cols-1)) += 1; // t.stop(); // std::cout << "google::sparse => \t" << t.value()-rtime // << " nnz=" << set1.nonZeros() << "\n";getchar(); diff --git a/bench/sparse_setter.cpp b/bench/sparse_setter.cpp index 9c22636d7..a9f0b11cc 100644 --- a/bench/sparse_setter.cpp +++ b/bench/sparse_setter.cpp @@ -75,7 +75,7 @@ int main(int argc, char *argv[]) for (int i=0; i stencil(SIZE,SIZE); - Vector2i ij(ei_random(0,rows-1),ei_random(0,cols-1)); + Vector2i ij(internal::random(0,rows-1),internal::random(0,cols-1)); // if(stencil.coeffRef(ij.x(), ij.y())==0) { // stencil.coeffRef(ij.x(), ij.y()) = 1; @@ -90,9 +90,9 @@ int main(int argc, char *argv[]) values.reserve(n); for (int i=0; i(0,pool.size()); + int i = internal::random(0,pool.size()); coords.push_back(pool[i]); - values.push_back(ei_random()); + values.push_back(internal::random()); } } else @@ -100,8 +100,8 @@ int main(int argc, char *argv[]) for (int j=0; j(0,rows-1),j)); - values.push_back(ei_random()); + coords.push_back(Vector2i(internal::random(0,rows-1),j)); + values.push_back(internal::random()); } } std::cout << "nnz = " << coords.size() << "\n"; diff --git a/bench/sparse_trisolver.cpp b/bench/sparse_trisolver.cpp index 6d433ad9e..13f4f0a24 100644 --- a/bench/sparse_trisolver.cpp +++ b/bench/sparse_trisolver.cpp @@ -44,11 +44,11 @@ void fillMatrix(float density, int rows, int cols, EigenSparseTriMatrix& dst) { for(int i = 0; i < j; i++) { - Scalar v = (ei_random(0,1) < density) ? ei_random() : 0; + Scalar v = (internal::random(0,1) < density) ? internal::random() : 0; if (v!=0) dst.fill(i,j) = v; } - dst.fill(j,j) = ei_random(); + dst.fill(j,j) = internal::random(); } dst.endFill(); } diff --git a/blas/level1_impl.h b/blas/level1_impl.h index 174ede3ce..64a30f523 100644 --- a/blas/level1_impl.h +++ b/blas/level1_impl.h @@ -55,13 +55,13 @@ RealScalar EIGEN_BLAS_FUNC(asum)(int *n, RealScalar *px, int *incx) } #else -struct ei_scalar_norm1_op { +struct internal::scalar_norm1_op { typedef RealScalar result_type; - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_norm1_op) - inline RealScalar operator() (const Scalar& a) const { return ei_norm1(a); } + EIGEN_EMPTY_STRUCT_CTOR(internal::scalar_norm1_op) + inline RealScalar operator() (const Scalar& a) const { return internal::norm1(a); } }; namespace Eigen { -template<> struct ei_functor_traits +template<> struct internal::functor_traits { enum { Cost = 3 * NumTraits::AddCost, PacketAccess = 0 }; }; @@ -75,8 +75,8 @@ RealScalar EIGEN_CAT(EIGEN_CAT(REAL_SCALAR_SUFFIX,SCALAR_SUFFIX),asum_)(int *n, if(*n<=0) return 0; - if(*incx==1) return vector(x,*n).unaryExpr().sum(); - else return vector(x,*n,std::abs(*incx)).unaryExpr().sum(); + if(*incx==1) return vector(x,*n).unaryExpr().sum(); + else return vector(x,*n,std::abs(*incx)).unaryExpr().sum(); } #endif @@ -233,9 +233,9 @@ int EIGEN_BLAS_FUNC(rot)(int *n, RealScalar *px, int *incx, RealScalar *py, int Reverse rvx(vx); Reverse rvy(vy); - if(*incx<0 && *incy>0) ei_apply_rotation_in_the_plane(rvx, vy, JacobiRotation(c,s)); - else if(*incx>0 && *incy<0) ei_apply_rotation_in_the_plane(vx, rvy, JacobiRotation(c,s)); - else ei_apply_rotation_in_the_plane(vx, vy, JacobiRotation(c,s)); + if(*incx<0 && *incy>0) internal::apply_rotation_in_the_plane(rvx, vy, JacobiRotation(c,s)); + else if(*incx>0 && *incy<0) internal::apply_rotation_in_the_plane(vx, rvy, JacobiRotation(c,s)); + else internal::apply_rotation_in_the_plane(vx, vy, JacobiRotation(c,s)); return 0; @@ -250,8 +250,8 @@ int EIGEN_BLAS_FUNC(rotg)(RealScalar *pa, RealScalar *pb, RealScalar *pc, RealSc #if !ISCOMPLEX Scalar r,z; - Scalar aa = ei_abs(a); - Scalar ab = ei_abs(b); + Scalar aa = internal::abs(a); + Scalar ab = internal::abs(b); if((aa+ab)==Scalar(0)) { *c = 1; @@ -261,7 +261,7 @@ int EIGEN_BLAS_FUNC(rotg)(RealScalar *pa, RealScalar *pb, RealScalar *pc, RealSc } else { - r = ei_sqrt(a*a + b*b); + r = internal::sqrt(a*a + b*b); Scalar amax = aa>ab ? a : b; r = amax>0 ? r : -r; *c = a/r; @@ -276,7 +276,7 @@ int EIGEN_BLAS_FUNC(rotg)(RealScalar *pa, RealScalar *pb, RealScalar *pc, RealSc #else Scalar alpha; RealScalar norm,scale; - if(ei_abs(a)==RealScalar(0)) + if(internal::abs(a)==RealScalar(0)) { *c = RealScalar(0); *s = Scalar(1); @@ -284,11 +284,11 @@ int EIGEN_BLAS_FUNC(rotg)(RealScalar *pa, RealScalar *pb, RealScalar *pc, RealSc } else { - scale = ei_abs(a) + ei_abs(b); - norm = scale*ei_sqrt((ei_abs2(a/scale))+ (ei_abs2(b/scale))); - alpha = a/ei_abs(a); - *c = ei_abs(a)/norm; - *s = alpha*ei_conj(b)/norm; + scale = internal::abs(a) + internal::abs(b); + norm = scale*internal::sqrt((internal::abs2(a/scale))+ (internal::abs2(b/scale))); + alpha = a/internal::abs(a); + *c = internal::abs(a)/norm; + *s = alpha*internal::conj(b)/norm; a = alpha*norm; } #endif diff --git a/blas/level2_impl.h b/blas/level2_impl.h index 329d3d333..c3f8405b3 100644 --- a/blas/level2_impl.h +++ b/blas/level2_impl.h @@ -70,21 +70,21 @@ int EIGEN_BLAS_FUNC(trsv)(char *uplo, char *opa, char *diag, int *n, RealScalar for(int k=0; k<16; ++k) func[k] = 0; -// func[NOTR | (UP << 2) | (NUNIT << 3)] = (ei_triangular_solve_vector::run); -// func[TR | (UP << 2) | (NUNIT << 3)] = (ei_triangular_solve_vector::run); -// func[ADJ | (UP << 2) | (NUNIT << 3)] = (ei_triangular_solve_vector::run); +// func[NOTR | (UP << 2) | (NUNIT << 3)] = (internal::triangular_solve_vector::run); +// func[TR | (UP << 2) | (NUNIT << 3)] = (internal::triangular_solve_vector::run); +// func[ADJ | (UP << 2) | (NUNIT << 3)] = (internal::triangular_solve_vector::run); // -// func[NOTR | (LO << 2) | (NUNIT << 3)] = (ei_triangular_solve_vector::run); -// func[TR | (LO << 2) | (NUNIT << 3)] = (ei_triangular_solve_vector::run); -// func[ADJ | (LO << 2) | (NUNIT << 3)] = (ei_triangular_solve_vector::run); +// func[NOTR | (LO << 2) | (NUNIT << 3)] = (internal::triangular_solve_vector::run); +// func[TR | (LO << 2) | (NUNIT << 3)] = (internal::triangular_solve_vector::run); +// func[ADJ | (LO << 2) | (NUNIT << 3)] = (internal::triangular_solve_vector::run); // -// func[NOTR | (UP << 3) | (UNIT << 3)] = (ei_triangular_solve_vector::run); -// func[TR | (UP << 2) | (UNIT << 3)] = (ei_triangular_solve_vector::run); -// func[ADJ | (UP << 2) | (UNIT << 3)] = (ei_triangular_solve_vector::run); +// func[NOTR | (UP << 3) | (UNIT << 3)] = (internal::triangular_solve_vector::run); +// func[TR | (UP << 2) | (UNIT << 3)] = (internal::triangular_solve_vector::run); +// func[ADJ | (UP << 2) | (UNIT << 3)] = (internal::triangular_solve_vector::run); // -// func[NOTR | (LO << 2) | (UNIT << 3)] = (ei_triangular_solve_vector::run); -// func[TR | (LO << 2) | (UNIT << 3)] = (ei_triangular_solve_vector::run); -// func[ADJ | (LO << 2) | (UNIT << 3)] = (ei_triangular_solve_vector::run); +// func[NOTR | (LO << 2) | (UNIT << 3)] = (internal::triangular_solve_vector::run); +// func[TR | (LO << 2) | (UNIT << 3)] = (internal::triangular_solve_vector::run); +// func[ADJ | (LO << 2) | (UNIT << 3)] = (internal::triangular_solve_vector::run); init = true; } @@ -116,21 +116,21 @@ int EIGEN_BLAS_FUNC(trmv)(char *uplo, char *opa, char *diag, int *n, RealScalar for(int k=0; k<16; ++k) func[k] = 0; -// func[NOTR | (UP << 2) | (NUNIT << 3)] = (ei_product_triangular_matrix_vector::run); -// func[TR | (UP << 2) | (NUNIT << 3)] = (ei_product_triangular_matrix_vector::run); -// func[ADJ | (UP << 2) | (NUNIT << 3)] = (ei_product_triangular_matrix_vector::run); +// func[NOTR | (UP << 2) | (NUNIT << 3)] = (internal::product_triangular_matrix_vector::run); +// func[TR | (UP << 2) | (NUNIT << 3)] = (internal::product_triangular_matrix_vector::run); +// func[ADJ | (UP << 2) | (NUNIT << 3)] = (internal::product_triangular_matrix_vector::run); // -// func[NOTR | (LO << 2) | (NUNIT << 3)] = (ei_product_triangular_matrix_vector::run); -// func[TR | (LO << 2) | (NUNIT << 3)] = (ei_product_triangular_matrix_vector::run); -// func[ADJ | (LO << 2) | (NUNIT << 3)] = (ei_product_triangular_matrix_vector::run); +// func[NOTR | (LO << 2) | (NUNIT << 3)] = (internal::product_triangular_matrix_vector::run); +// func[TR | (LO << 2) | (NUNIT << 3)] = (internal::product_triangular_matrix_vector::run); +// func[ADJ | (LO << 2) | (NUNIT << 3)] = (internal::product_triangular_matrix_vector::run); // -// func[NOTR | (UP << 2) | (UNIT << 3)] = (ei_product_triangular_matrix_vector::run); -// func[TR | (UP << 2) | (UNIT << 3)] = (ei_product_triangular_matrix_vector::run); -// func[ADJ | (UP << 2) | (UNIT << 3)] = (ei_product_triangular_matrix_vector::run); +// func[NOTR | (UP << 2) | (UNIT << 3)] = (internal::product_triangular_matrix_vector::run); +// func[TR | (UP << 2) | (UNIT << 3)] = (internal::product_triangular_matrix_vector::run); +// func[ADJ | (UP << 2) | (UNIT << 3)] = (internal::product_triangular_matrix_vector::run); // -// func[NOTR | (LO << 2) | (UNIT << 3)] = (ei_product_triangular_matrix_vector::run); -// func[TR | (LO << 2) | (UNIT << 3)] = (ei_product_triangular_matrix_vector::run); -// func[ADJ | (LO << 2) | (UNIT << 3)] = (ei_product_triangular_matrix_vector::run); +// func[NOTR | (LO << 2) | (UNIT << 3)] = (internal::product_triangular_matrix_vector::run); +// func[TR | (LO << 2) | (UNIT << 3)] = (internal::product_triangular_matrix_vector::run); +// func[ADJ | (LO << 2) | (UNIT << 3)] = (internal::product_triangular_matrix_vector::run); init = true; } @@ -168,8 +168,8 @@ int EIGEN_BLAS_FUNC(syr)(char *uplo, int *n, RealScalar *palpha, RealScalar *pa, for(int k=0; k<2; ++k) func[k] = 0; -// func[UP] = (ei_selfadjoint_product::run); -// func[LO] = (ei_selfadjoint_product::run); +// func[UP] = (internal::selfadjoint_product::run); +// func[LO] = (internal::selfadjoint_product::run); init = true; } @@ -202,8 +202,8 @@ int EIGEN_BLAS_FUNC(syr2)(char *uplo, int *n, RealScalar *palpha, RealScalar *pa for(int k=0; k<2; ++k) func[k] = 0; -// func[UP] = (ei_selfadjoint_product::run); -// func[LO] = (ei_selfadjoint_product::run); +// func[UP] = (internal::selfadjoint_product::run); +// func[LO] = (internal::selfadjoint_product::run); init = true; } diff --git a/blas/level3_impl.h b/blas/level3_impl.h index e5b781cd6..49731f8bc 100644 --- a/blas/level3_impl.h +++ b/blas/level3_impl.h @@ -27,7 +27,7 @@ int EIGEN_BLAS_FUNC(gemm)(char *opa, char *opb, int *m, int *n, int *k, RealScalar *palpha, RealScalar *pa, int *lda, RealScalar *pb, int *ldb, RealScalar *pbeta, RealScalar *pc, int *ldc) { // std::cerr << "in gemm " << *opa << " " << *opb << " " << *m << " " << *n << " " << *k << " " << *lda << " " << *ldb << " " << *ldc << " " << *palpha << " " << *pbeta << "\n"; - typedef void (*functype)(DenseIndex, DenseIndex, DenseIndex, const Scalar *, DenseIndex, const Scalar *, DenseIndex, Scalar *, DenseIndex, Scalar, ei_level3_blocking&, Eigen::GemmParallelInfo*); + typedef void (*functype)(DenseIndex, DenseIndex, DenseIndex, const Scalar *, DenseIndex, const Scalar *, DenseIndex, Scalar *, DenseIndex, Scalar, internal::level3_blocking&, Eigen::GemmParallelInfo*); static functype func[12]; static bool init = false; @@ -35,15 +35,15 @@ int EIGEN_BLAS_FUNC(gemm)(char *opa, char *opb, int *m, int *n, int *k, RealScal { for(int k=0; k<12; ++k) func[k] = 0; - func[NOTR | (NOTR << 2)] = (ei_general_matrix_matrix_product::run); - func[TR | (NOTR << 2)] = (ei_general_matrix_matrix_product::run); - func[ADJ | (NOTR << 2)] = (ei_general_matrix_matrix_product::run); - func[NOTR | (TR << 2)] = (ei_general_matrix_matrix_product::run); - func[TR | (TR << 2)] = (ei_general_matrix_matrix_product::run); - func[ADJ | (TR << 2)] = (ei_general_matrix_matrix_product::run); - func[NOTR | (ADJ << 2)] = (ei_general_matrix_matrix_product::run); - func[TR | (ADJ << 2)] = (ei_general_matrix_matrix_product::run); - func[ADJ | (ADJ << 2)] = (ei_general_matrix_matrix_product::run); + func[NOTR | (NOTR << 2)] = (internal::general_matrix_matrix_product::run); + func[TR | (NOTR << 2)] = (internal::general_matrix_matrix_product::run); + func[ADJ | (NOTR << 2)] = (internal::general_matrix_matrix_product::run); + func[NOTR | (TR << 2)] = (internal::general_matrix_matrix_product::run); + func[TR | (TR << 2)] = (internal::general_matrix_matrix_product::run); + func[ADJ | (TR << 2)] = (internal::general_matrix_matrix_product::run); + func[NOTR | (ADJ << 2)] = (internal::general_matrix_matrix_product::run); + func[TR | (ADJ << 2)] = (internal::general_matrix_matrix_product::run); + func[ADJ | (ADJ << 2)] = (internal::general_matrix_matrix_product::run); init = true; } @@ -67,7 +67,7 @@ int EIGEN_BLAS_FUNC(gemm)(char *opa, char *opb, int *m, int *n, int *k, RealScal else matrix(c, *m, *n, *ldc) *= beta; } - ei_gemm_blocking_space blocking(*m,*n,*k); + internal::gemm_blocking_space blocking(*m,*n,*k); func[code](*m, *n, *k, a, *lda, b, *ldb, c, *ldc, alpha, blocking, 0); return 0; @@ -85,38 +85,38 @@ int EIGEN_BLAS_FUNC(trsm)(char *side, char *uplo, char *opa, char *diag, int *m, for(int k=0; k<32; ++k) func[k] = 0; - func[NOTR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix::run); - func[TR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix::run); - func[ADJ | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix::run); + func[NOTR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix::run); + func[TR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix::run); + func[ADJ | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix::run); - func[NOTR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix::run); - func[TR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix::run); - func[ADJ | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix::run); + func[NOTR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix::run); + func[TR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix::run); + func[ADJ | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix::run); - func[NOTR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix::run); - func[TR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix::run); - func[ADJ | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix::run); + func[NOTR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix::run); + func[TR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix::run); + func[ADJ | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix::run); - func[NOTR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix::run); - func[TR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix::run); - func[ADJ | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix::run); + func[NOTR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix::run); + func[TR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix::run); + func[ADJ | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix::run); - func[NOTR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix::run); - func[TR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix::run); - func[ADJ | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix::run); + func[NOTR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix::run); + func[TR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix::run); + func[ADJ | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix::run); - func[NOTR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix::run); - func[TR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix::run); - func[ADJ | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix::run); + func[NOTR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix::run); + func[TR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix::run); + func[ADJ | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix::run); - func[NOTR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix::run); - func[TR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix::run); - func[ADJ | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix::run); + func[NOTR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix::run); + func[TR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix::run); + func[ADJ | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix::run); - func[NOTR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix::run); - func[TR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix::run); - func[ADJ | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix::run); + func[NOTR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix::run); + func[TR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix::run); + func[ADJ | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix::run); init = true; } @@ -158,37 +158,37 @@ int EIGEN_BLAS_FUNC(trmm)(char *side, char *uplo, char *opa, char *diag, int *m, for(int k=0; k<32; ++k) func[k] = 0; - func[NOTR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[TR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[ADJ | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix::run); + func[NOTR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[TR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[ADJ | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix::run); - func[NOTR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[TR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[ADJ | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix::run); + func[NOTR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[TR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[ADJ | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix::run); - func[NOTR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[TR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[ADJ | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix::run); + func[NOTR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[TR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[ADJ | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix::run); - func[NOTR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[TR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[ADJ | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix::run); + func[NOTR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[TR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[ADJ | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix::run); - func[NOTR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[TR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[ADJ | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix::run); + func[NOTR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[TR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[ADJ | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix::run); - func[NOTR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[TR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[ADJ | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix::run); + func[NOTR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[TR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[ADJ | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix::run); - func[NOTR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[TR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[ADJ | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix::run); + func[NOTR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[TR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[ADJ | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix::run); - func[NOTR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[TR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix::run); - func[ADJ | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix::run); + func[NOTR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[TR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix::run); + func[ADJ | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix::run); init = true; } @@ -268,12 +268,12 @@ int EIGEN_BLAS_FUNC(symm)(char *side, char *uplo, int *m, int *n, RealScalar *pa matrix(c, *m, *n, *ldc) += alpha * matrix(b, *m, *n, *ldb) * matA; #else if(SIDE(*side)==LEFT) - if(UPLO(*uplo)==UP) ei_product_selfadjoint_matrix::run(*m, *n, a, *lda, b, *ldb, c, *ldc, alpha); - else if(UPLO(*uplo)==LO) ei_product_selfadjoint_matrix::run(*m, *n, a, *lda, b, *ldb, c, *ldc, alpha); + if(UPLO(*uplo)==UP) internal::product_selfadjoint_matrix::run(*m, *n, a, *lda, b, *ldb, c, *ldc, alpha); + else if(UPLO(*uplo)==LO) internal::product_selfadjoint_matrix::run(*m, *n, a, *lda, b, *ldb, c, *ldc, alpha); else return 0; else if(SIDE(*side)==RIGHT) - if(UPLO(*uplo)==UP) ei_product_selfadjoint_matrix::run(*m, *n, b, *ldb, a, *lda, c, *ldc, alpha); - else if(UPLO(*uplo)==LO) ei_product_selfadjoint_matrix::run(*m, *n, b, *ldb, a, *lda, c, *ldc, alpha); + if(UPLO(*uplo)==UP) internal::product_selfadjoint_matrix::run(*m, *n, b, *ldb, a, *lda, c, *ldc, alpha); + else if(UPLO(*uplo)==LO) internal::product_selfadjoint_matrix::run(*m, *n, b, *ldb, a, *lda, c, *ldc, alpha); else return 0; else return 0; @@ -296,13 +296,13 @@ int EIGEN_BLAS_FUNC(syrk)(char *uplo, char *op, int *n, int *k, RealScalar *palp for(int k=0; k<8; ++k) func[k] = 0; - func[NOTR | (UP << 2)] = (ei_selfadjoint_product::run); - func[TR | (UP << 2)] = (ei_selfadjoint_product::run); - func[ADJ | (UP << 2)] = (ei_selfadjoint_product::run); + func[NOTR | (UP << 2)] = (internal::selfadjoint_product::run); + func[TR | (UP << 2)] = (internal::selfadjoint_product::run); + func[ADJ | (UP << 2)] = (internal::selfadjoint_product::run); - func[NOTR | (LO << 2)] = (ei_selfadjoint_product::run); - func[TR | (LO << 2)] = (ei_selfadjoint_product::run); - func[ADJ | (LO << 2)] = (ei_selfadjoint_product::run); + func[NOTR | (LO << 2)] = (internal::selfadjoint_product::run); + func[TR | (LO << 2)] = (internal::selfadjoint_product::run); + func[ADJ | (LO << 2)] = (internal::selfadjoint_product::run); init = true; } @@ -433,17 +433,17 @@ int EIGEN_BLAS_FUNC(hemm)(char *side, char *uplo, int *m, int *n, RealScalar *pa if(SIDE(*side)==LEFT) { - if(UPLO(*uplo)==UP) ei_product_selfadjoint_matrix + if(UPLO(*uplo)==UP) internal::product_selfadjoint_matrix ::run(*m, *n, a, *lda, b, *ldb, c, *ldc, alpha); - else if(UPLO(*uplo)==LO) ei_product_selfadjoint_matrix + else if(UPLO(*uplo)==LO) internal::product_selfadjoint_matrix ::run(*m, *n, a, *lda, b, *ldb, c, *ldc, alpha); else return 0; } else if(SIDE(*side)==RIGHT) { - if(UPLO(*uplo)==UP) matrix(c,*m,*n,*ldc) += alpha * matrix(b,*m,*n,*ldb) * matrix(a,*n,*n,*lda).selfadjointView();/*ei_product_selfadjoint_matrix + if(UPLO(*uplo)==UP) matrix(c,*m,*n,*ldc) += alpha * matrix(b,*m,*n,*ldb) * matrix(a,*n,*n,*lda).selfadjointView();/*internal::product_selfadjoint_matrix ::run(*m, *n, b, *ldb, a, *lda, c, *ldc, alpha);*/ - else if(UPLO(*uplo)==LO) ei_product_selfadjoint_matrix + else if(UPLO(*uplo)==LO) internal::product_selfadjoint_matrix ::run(*m, *n, b, *ldb, a, *lda, c, *ldc, alpha); else return 0; } @@ -468,11 +468,11 @@ int EIGEN_BLAS_FUNC(herk)(char *uplo, char *op, int *n, int *k, RealScalar *palp for(int k=0; k<8; ++k) func[k] = 0; - func[NOTR | (UP << 2)] = (ei_selfadjoint_product::run); - func[ADJ | (UP << 2)] = (ei_selfadjoint_product::run); + func[NOTR | (UP << 2)] = (internal::selfadjoint_product::run); + func[ADJ | (UP << 2)] = (internal::selfadjoint_product::run); - func[NOTR | (LO << 2)] = (ei_selfadjoint_product::run); - func[ADJ | (LO << 2)] = (ei_selfadjoint_product::run); + func[NOTR | (LO << 2)] = (internal::selfadjoint_product::run); + func[ADJ | (LO << 2)] = (internal::selfadjoint_product::run); init = true; } @@ -545,23 +545,23 @@ int EIGEN_BLAS_FUNC(her2k)(char *uplo, char *op, int *n, int *k, RealScalar *pal { matrix(c, *n, *n, *ldc).triangularView() += alpha *matrix(a, *n, *k, *lda)*matrix(b, *n, *k, *ldb).adjoint() - + ei_conj(alpha)*matrix(b, *n, *k, *ldb)*matrix(a, *n, *k, *lda).adjoint(); + + internal::conj(alpha)*matrix(b, *n, *k, *ldb)*matrix(a, *n, *k, *lda).adjoint(); } else if(UPLO(*uplo)==LO) matrix(c, *n, *n, *ldc).triangularView() += alpha*matrix(a, *n, *k, *lda)*matrix(b, *n, *k, *ldb).adjoint() - + ei_conj(alpha)*matrix(b, *n, *k, *ldb)*matrix(a, *n, *k, *lda).adjoint(); + + internal::conj(alpha)*matrix(b, *n, *k, *ldb)*matrix(a, *n, *k, *lda).adjoint(); } else if(OP(*op)==ADJ) { if(UPLO(*uplo)==UP) matrix(c, *n, *n, *ldc).triangularView() += alpha*matrix(a, *k, *n, *lda).adjoint()*matrix(b, *k, *n, *ldb) - + ei_conj(alpha)*matrix(b, *k, *n, *ldb).adjoint()*matrix(a, *k, *n, *lda); + + internal::conj(alpha)*matrix(b, *k, *n, *ldb).adjoint()*matrix(a, *k, *n, *lda); else if(UPLO(*uplo)==LO) matrix(c, *n, *n, *ldc).triangularView() += alpha*matrix(a, *k, *n, *lda).adjoint()*matrix(b, *k, *n, *ldb) - + ei_conj(alpha)*matrix(b, *k, *n, *ldb).adjoint()*matrix(a, *k, *n, *lda); + + internal::conj(alpha)*matrix(b, *k, *n, *ldb).adjoint()*matrix(a, *k, *n, *lda); } return 1; diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp index f89526cf6..91c0b404f 100644 --- a/demos/mandelbrot/mandelbrot.cpp +++ b/demos/mandelbrot/mandelbrot.cpp @@ -45,7 +45,7 @@ template<> struct iters_before_test { enum { ret = 16 }; }; template void MandelbrotThread::render(int img_width, int img_height) { - enum { packetSize = Eigen::ei_packet_traits::size }; // number of reals in a Packet + enum { packetSize = Eigen::internal::packet_traits::size }; // number of reals in a Packet typedef Eigen::Array Packet; // wrap a Packet as a vector enum { iters_before_test = iters_before_test::ret }; @@ -163,8 +163,8 @@ void MandelbrotWidget::paintEvent(QPaintEvent *) << elapsed << " ms, " << speed << " iters/s (max " << max_speed << ")" << std::endl; int packetSize = threads[0]->single_precision - ? int(Eigen::ei_packet_traits::size) - : int(Eigen::ei_packet_traits::size); + ? int(Eigen::internal::packet_traits::size) + : int(Eigen::internal::packet_traits::size); setWindowTitle(QString("resolution ")+QString::number(xradius*2/width(), 'e', 2) +QString(", %1 iterations per pixel, ").arg(threads[0]->max_iter) +(threads[0]->single_precision ? QString("single ") : QString("double ")) diff --git a/demos/opengl/gpuhelper.h b/demos/opengl/gpuhelper.h index c7b924b0e..d0fe71bc7 100644 --- a/demos/opengl/gpuhelper.h +++ b/demos/opengl/gpuhelper.h @@ -67,7 +67,7 @@ class GpuHelper template void loadMatrix( - const Eigen::CwiseNullaryOp,Derived>&, + const Eigen::CwiseNullaryOp,Derived>&, GLenum matrixTarget); /** Make the matrix \a matrixTarget the current OpenGL matrix target. @@ -86,7 +86,7 @@ class GpuHelper template void pushMatrix( - const Eigen::CwiseNullaryOp,Derived>&, + const Eigen::CwiseNullaryOp,Derived>&, GLenum matrixTarget); /** Push and clone the OpenGL matrix \a matrixTarget @@ -161,7 +161,7 @@ void GpuHelper::multMatrix(const Matrix& mat, GLenum ma template void GpuHelper::loadMatrix( - const Eigen::CwiseNullaryOp,Derived>&, + const Eigen::CwiseNullaryOp,Derived>&, GLenum matrixTarget) { setMatrixTarget(matrixTarget); @@ -190,7 +190,7 @@ inline void GpuHelper::pushMatrix(const Matrix& mat, GL template void GpuHelper::pushMatrix( - const Eigen::CwiseNullaryOp,Derived>&, + const Eigen::CwiseNullaryOp,Derived>&, GLenum matrixTarget) { pushMatrix(matrixTarget); diff --git a/demos/opengl/quaternion_demo.cpp b/demos/opengl/quaternion_demo.cpp index 9d496f922..899075669 100644 --- a/demos/opengl/quaternion_demo.cpp +++ b/demos/opengl/quaternion_demo.cpp @@ -249,7 +249,7 @@ void RenderingWidget::drawScene() gpu.drawVector(Vector3f::Zero(), length*Vector3f::UnitZ(), Color(0,0,1,1)); // draw the fractal object - float sqrt3 = ei_sqrt(3.); + float sqrt3 = internal::sqrt(3.); glLightfv(GL_LIGHT0, GL_AMBIENT, Vector4f(0.5,0.5,0.5,1).data()); glLightfv(GL_LIGHT0, GL_DIFFUSE, Vector4f(0.5,1,0.5,1).data()); glLightfv(GL_LIGHT0, GL_SPECULAR, Vector4f(1,1,1,1).data()); diff --git a/demos/opengl/trackball.cpp b/demos/opengl/trackball.cpp index 05e45c1d0..f8da7779a 100644 --- a/demos/opengl/trackball.cpp +++ b/demos/opengl/trackball.cpp @@ -38,7 +38,7 @@ void Trackball::track(const Vector2i& point2D) { Vector3f axis = mLastPoint3D.cross(newPoint3D).normalized(); float cos_angle = mLastPoint3D.dot(newPoint3D); - if ( ei_abs(cos_angle) < 1.0 ) + if ( internal::abs(cos_angle) < 1.0 ) { float angle = 2. * acos(cos_angle); if (mMode==Around) diff --git a/doc/D11_UnalignedArrayAssert.dox b/doc/D11_UnalignedArrayAssert.dox index 5b9ac5a2a..d173ee5f4 100644 --- a/doc/D11_UnalignedArrayAssert.dox +++ b/doc/D11_UnalignedArrayAssert.dox @@ -5,7 +5,7 @@ namespace Eigen { Hello! You are seeing this webpage because your program terminated on an assertion failure like this one: 
 my_program: path/to/eigen/Eigen/src/Core/DenseStorage.h:44:
-Eigen::ei_matrix_array::ei_matrix_array()
+Eigen::internal::matrix_array::internal::matrix_array()
 [with T = double, int Size = 2, int MatrixOptions = 2, bool Align = true]:
 Assertion `(reinterpret_cast(array) & 0xf) == 0 && "this assertion
 is explained here: http://eigen.tuxfamily.org/dox/UnalignedArrayAssert.html
diff --git a/doc/I00_CustomizingEigen.dox b/doc/I00_CustomizingEigen.dox
index d87fb8d6a..1c7a45355 100644
--- a/doc/I00_CustomizingEigen.dox
+++ b/doc/I00_CustomizingEigen.dox
@@ -43,7 +43,7 @@ inline Scalar squaredDistanceTo(const MatrixBase& other) const
 
 template
 inline RealScalar distanceTo(const MatrixBase& other) const
-{ return ei_sqrt(derived().squaredDistanceTo(other)); }
+{ return internal::sqrt(derived().squaredDistanceTo(other)); }
 
 inline void scaleTo(RealScalar l) { RealScalar vl = norm(); if (vl>1e-9) derived() *= (l/vl); }
 
@@ -58,13 +58,13 @@ void makeFloor(const MatrixBase& other) { derived() = derived().cw
 template
 void makeCeil(const MatrixBase& other) { derived() = derived().cwiseMax(other.derived()); }
 
-const CwiseUnaryOp, Derived>
+const CwiseUnaryOp, Derived>
 operator+(const Scalar& scalar) const
-{ return CwiseUnaryOp, Derived>(derived(), ei_scalar_add_op(scalar)); }
+{ return CwiseUnaryOp, Derived>(derived(), internal::scalar_add_op(scalar)); }
 
-friend const CwiseUnaryOp, Derived>
+friend const CwiseUnaryOp, Derived>
 operator+(const Scalar& scalar, const MatrixBase& mat)
-{ return CwiseUnaryOp, Derived>(mat.derived(), ei_scalar_add_op(scalar)); }
+{ return CwiseUnaryOp, Derived>(mat.derived(), internal::scalar_add_op(scalar)); }
 \endcode
 
 Then one can the following declaration in the config.h or whatever prerequisites header file of his project:
@@ -124,7 +124,7 @@ By default, Eigen currently supports the following scalar types: \c int, \c floa
 In order to add support for a custom type \c T you need:
  1 - make sure the common operator (+,-,*,/,etc.) are supported by the type \c T
  2 - add a specialization of struct Eigen::NumTraits (see \ref NumTraits)
- 3 - define a couple of math functions for your type such as: ei_sqrt, ei_abs, etc...
+ 3 - define a couple of math functions for your type such as: internal::sqrt, internal::abs, etc...
      (see the file Eigen/src/Core/MathFunctions.h)
 
 Here is a concrete example adding support for the Adolc's \c adouble type. Adolc is an automatic differentiation library. The type \c adouble is basically a real value tracking the values of any number of partial derivatives.
@@ -158,21 +158,21 @@ template<> struct NumTraits
 }
 
 // the Adolc's type adouble is defined in the adtl namespace
-// therefore, the following ei_* functions *must* be defined
+// therefore, the following internal::* functions *must* be defined
 // in the same namespace
 namespace adtl {
 
-  inline const adouble& ei_conj(const adouble& x)  { return x; }
-  inline const adouble& ei_real(const adouble& x)  { return x; }
-  inline adouble ei_imag(const adouble&)    { return 0.; }
-  inline adouble ei_abs(const adouble&  x)  { return fabs(x); }
-  inline adouble ei_abs2(const adouble& x)  { return x*x; }
-  inline adouble ei_sqrt(const adouble& x)  { return sqrt(x); }
-  inline adouble ei_exp(const adouble&  x)  { return exp(x); }
-  inline adouble ei_log(const adouble&  x)  { return log(x); }
-  inline adouble ei_sin(const adouble&  x)  { return sin(x); }
-  inline adouble ei_cos(const adouble&  x)  { return cos(x); }
-  inline adouble ei_pow(const adouble& x, adouble y)  { return pow(x, y); }
+  inline const adouble& internal::conj(const adouble& x)  { return x; }
+  inline const adouble& internal::real(const adouble& x)  { return x; }
+  inline adouble internal::imag(const adouble&)    { return 0.; }
+  inline adouble internal::abs(const adouble&  x)  { return fabs(x); }
+  inline adouble internal::abs2(const adouble& x)  { return x*x; }
+  inline adouble internal::sqrt(const adouble& x)  { return sqrt(x); }
+  inline adouble internal::exp(const adouble&  x)  { return exp(x); }
+  inline adouble internal::log(const adouble&  x)  { return log(x); }
+  inline adouble internal::sin(const adouble&  x)  { return sin(x); }
+  inline adouble internal::cos(const adouble&  x)  { return cos(x); }
+  inline adouble internal::pow(const adouble& x, adouble y)  { return pow(x, y); }
 
 }
 
diff --git a/doc/I03_InsideEigenExample.dox b/doc/I03_InsideEigenExample.dox
index 9ee253133..0c60984a2 100644
--- a/doc/I03_InsideEigenExample.dox
+++ b/doc/I03_InsideEigenExample.dox
@@ -101,10 +101,10 @@ with size=50, rows=50, columns=1.
 
 Here is this constructor:
 \code
-inline DenseStorage(int size, int rows, int) : m_data(ei_aligned_new(size)), m_rows(rows) {}
+inline DenseStorage(int size, int rows, int) : m_data(internal::aligned_new(size)), m_rows(rows) {}
 \endcode
 
-Here, the \a m_data member is the actual array of coefficients of the matrix. As you see, it is dynamically allocated. Rather than calling new[] or malloc(), as you can see, we have our own ei_aligned_new defined in src/Core/util/Memory.h. What it does is that if vectorization is enabled, then it uses a platform-specific call to allocate a 128-bit-aligned array, as that is very useful for vectorization with both SSE2 and AltiVec. If vectorization is disabled, it amounts to the standard new[].
+Here, the \a m_data member is the actual array of coefficients of the matrix. As you see, it is dynamically allocated. Rather than calling new[] or malloc(), as you can see, we have our own internal::aligned_new defined in src/Core/util/Memory.h. What it does is that if vectorization is enabled, then it uses a platform-specific call to allocate a 128-bit-aligned array, as that is very useful for vectorization with both SSE2 and AltiVec. If vectorization is disabled, it amounts to the standard new[].
 
 As you can see, the constructor also sets the \a m_rows member to \a size. Notice that there is no \a m_columns member: indeed, in this partial specialization of DenseStorage, we know the number of columns at compile-time, since the _Cols template parameter is different from Dynamic. Namely, in our case, _Cols is 1, which is to say that our vector is just a matrix with 1 column. Hence, there is no need to store the number of columns as a runtime variable.
 
@@ -136,7 +136,7 @@ MatrixBase::operator+(const MatrixBase&)
 
 The return type of this operator is
 \code
-CwiseBinaryOp, VectorXf, VectorXf>
+CwiseBinaryOp, VectorXf, VectorXf>
 \endcode
 The CwiseBinaryOp class is our first encounter with an expression template. As we said, the operator+ doesn't by itself perform any computation, it just returns an abstract "sum of vectors" expression. Since there are also "difference of vectors" and "coefficient-wise product of vectors" expressions, we unify them all as "coefficient-wise binary operations", which we abbreviate as "CwiseBinaryOp". "Coefficient-wise" means that the operations is performed coefficient by coefficient. "binary" means that there are two operands -- we are adding two vectors with one another.
 
@@ -177,7 +177,7 @@ class MatrixBase
   // ...
 
   template
-  const CwiseBinaryOp::Scalar>, Derived, OtherDerived>
+  const CwiseBinaryOp::Scalar>, Derived, OtherDerived>
   operator+(const MatrixBase &other) const;
 
   // ...
@@ -186,17 +186,17 @@ class MatrixBase
 
 Here of course, \a Derived and \a OtherDerived are VectorXf.
 
-As we said, CwiseBinaryOp is also used for other operations such as substration, so it takes another template parameter determining the operation that will be applied to coefficients. This template parameter is a functor, that is, a class in which we have an operator() so it behaves like a function. Here, the functor used is ei_scalar_sum_op. It is defined in src/Core/Functors.h.
+As we said, CwiseBinaryOp is also used for other operations such as substration, so it takes another template parameter determining the operation that will be applied to coefficients. This template parameter is a functor, that is, a class in which we have an operator() so it behaves like a function. Here, the functor used is internal::scalar_sum_op. It is defined in src/Core/Functors.h.
 
-Let us now explain the ei_traits here. The ei_scalar_sum_op class takes one template parameter: the type of the numbers to handle. Here of course we want to pass the scalar type (a.k.a. numeric type) of VectorXf, which is \c float. How do we determine which is the scalar type of \a Derived ? Throughout Eigen, all matrix and expression types define a typedef \a Scalar which gives its scalar type. For example, VectorXf::Scalar is a typedef for \c float. So here, if life was easy, we could find the numeric type of \a Derived as just
+Let us now explain the internal::traits here. The internal::scalar_sum_op class takes one template parameter: the type of the numbers to handle. Here of course we want to pass the scalar type (a.k.a. numeric type) of VectorXf, which is \c float. How do we determine which is the scalar type of \a Derived ? Throughout Eigen, all matrix and expression types define a typedef \a Scalar which gives its scalar type. For example, VectorXf::Scalar is a typedef for \c float. So here, if life was easy, we could find the numeric type of \a Derived as just
 \code
 typename Derived::Scalar
 \endcode
 Unfortunately, we can't do that here, as the compiler would complain that the type Derived hasn't yet been defined. So we use a workaround: in src/Core/util/ForwardDeclarations.h, we declared (not defined!) all our subclasses, like Matrix, and we also declared the following class template:
 \code
-template struct ei_traits;
+template struct internal::traits;
 \endcode
-In src/Core/Matrix.h, right \em before the definition of class Matrix, we define a partial specialization of ei_traits for T=Matrix\. In this specialization of ei_traits, we define the Scalar typedef. So when we actually define Matrix, it is legal to refer to "typename ei_traits\::Scalar".
+In src/Core/Matrix.h, right \em before the definition of class Matrix, we define a partial specialization of internal::traits for T=Matrix\. In this specialization of internal::traits, we define the Scalar typedef. So when we actually define Matrix, it is legal to refer to "typename internal::traits\::Scalar".
 
 Anyway, we have declared our operator+. In our case, where \a Derived and \a OtherDerived are VectorXf, the above declaration amounts to:
 \code
@@ -204,7 +204,7 @@ class MatrixBase
 {
   // ...
 
-  const CwiseBinaryOp, VectorXf, VectorXf>
+  const CwiseBinaryOp, VectorXf, VectorXf>
   operator+(const MatrixBase &other) const;
 
   // ...
@@ -228,7 +228,7 @@ What operator= is being called here? The vector u is an object of class VectorXf
     template
     inline Matrix& operator=(const MatrixBase& other)
     {
-      ei_assert(m_storage.data()!=0 && "you cannot use operator= with a non initialized matrix (instead use set()");
+      eigen_assert(m_storage.data()!=0 && "you cannot use operator= with a non initialized matrix (instead use set()");
       return Base::operator=(other.derived());
     }
 \endcode
@@ -239,11 +239,11 @@ Here, Base is a typedef for MatrixBase\. So, what is being called is th
 \endcode
 Here, \a Derived is VectorXf (since u is a VectorXf) and \a OtherDerived is CwiseBinaryOp. More specifically, as explained in the previous section, \a OtherDerived is:
 \code
-CwiseBinaryOp, VectorXf, VectorXf>
+CwiseBinaryOp, VectorXf, VectorXf>
 \endcode
 So the full prototype of the operator= being called is:
 \code
-VectorXf& MatrixBase::operator=(const MatrixBase, VectorXf, VectorXf> > & other);
+VectorXf& MatrixBase::operator=(const MatrixBase, VectorXf, VectorXf> > & other);
 \endcode
 This operator= literally reads "copying a sum of two VectorXf's into another VectorXf".
 
@@ -256,11 +256,11 @@ template
 inline Derived& MatrixBase
   ::operator=(const MatrixBase& other)
 {
-  return ei_assign_selector::run(derived(), other.derived());
+  return internal::assign_selector::run(derived(), other.derived());
 }
 \endcode
 
-OK so our next task is to understand ei_assign_selector :)
+OK so our next task is to understand internal::assign_selector :)
 
 Here is its declaration (all that is still in the same file src/Core/Assign.h)
 \code
@@ -271,24 +271,24 @@ template
-struct ei_assign_selector;
+struct internal::assign_selector;
 \endcode
 
-So ei_assign_selector takes 4 template parameters, but the 2 last ones are automatically determined by the 2 first ones.
+So internal::assign_selector takes 4 template parameters, but the 2 last ones are automatically determined by the 2 first ones.
 
-EvalBeforeAssigning is here to enforce the EvalBeforeAssigningBit. As explained here, certain expressions have this flag which makes them automatically evaluate into temporaries before assigning them to another expression. This is the case of the Product expression, in order to avoid strange aliasing effects when doing "m = m * m;" However, of course here our CwiseBinaryOp expression doesn't have the EvalBeforeAssigningBit: we said since the beginning that we didn't want a temporary to be introduced here. So if you go to src/Core/CwiseBinaryOp.h, you'll see that the Flags in ei_traits\ don't include the EvalBeforeAssigningBit. The Flags member of CwiseBinaryOp is then imported from the ei_traits by the EIGEN_GENERIC_PUBLIC_INTERFACE macro. Anyway, here the template parameter EvalBeforeAssigning has the value \c false.
+EvalBeforeAssigning is here to enforce the EvalBeforeAssigningBit. As explained here, certain expressions have this flag which makes them automatically evaluate into temporaries before assigning them to another expression. This is the case of the Product expression, in order to avoid strange aliasing effects when doing "m = m * m;" However, of course here our CwiseBinaryOp expression doesn't have the EvalBeforeAssigningBit: we said since the beginning that we didn't want a temporary to be introduced here. So if you go to src/Core/CwiseBinaryOp.h, you'll see that the Flags in internal::traits\ don't include the EvalBeforeAssigningBit. The Flags member of CwiseBinaryOp is then imported from the internal::traits by the EIGEN_GENERIC_PUBLIC_INTERFACE macro. Anyway, here the template parameter EvalBeforeAssigning has the value \c false.
 
 NeedToTranspose is here for the case where the user wants to copy a row-vector into a column-vector. We allow this as a special exception to the general rule that in assignments we require the dimesions to match. Anyway, here both the left-hand and right-hand sides are column vectors, in the sense that ColsAtCompileTime is equal to 1. So NeedToTranspose is \c false too.
 
 So, here we are in the partial specialization:
 \code
-ei_assign_selector
+internal::assign_selector
 \endcode
 
 Here's how it is defined:
 \code
 template
-struct ei_assign_selector {
+struct internal::assign_selector {
   static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.derived()); }
 };
 \endcode
@@ -302,48 +302,48 @@ inline Derived& MatrixBase
   ::lazyAssign(const MatrixBase& other)
 {
   EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived)
-  ei_assert(rows() == other.rows() && cols() == other.cols());
-  ei_assign_impl::run(derived(),other.derived());
+  eigen_assert(rows() == other.rows() && cols() == other.cols());
+  internal::assign_impl::run(derived(),other.derived());
   return derived();
 }
 \endcode
 
 What do we see here? Some assertions, and then the only interesting line is:
 \code
-  ei_assign_impl::run(derived(),other.derived());
+  internal::assign_impl::run(derived(),other.derived());
 \endcode
 
-OK so now we want to know what is inside ei_assign_impl.
+OK so now we want to know what is inside internal::assign_impl.
 
 Here is its declaration:
 \code
 template::Vectorization,
-         int Unrolling = ei_assign_traits::Unrolling>
-struct ei_assign_impl;
+         int Vectorization = internal::assign_traits::Vectorization,
+         int Unrolling = internal::assign_traits::Unrolling>
+struct internal::assign_impl;
 \endcode
-Again, ei_assign_selector takes 4 template parameters, but the 2 last ones are automatically determined by the 2 first ones.
+Again, internal::assign_selector takes 4 template parameters, but the 2 last ones are automatically determined by the 2 first ones.
 
-These two parameters \a Vectorization and \a Unrolling are determined by a helper class ei_assign_traits. Its job is to determine which vectorization strategy to use (that is \a Vectorization) and which unrolling strategy to use (that is \a Unrolling).
+These two parameters \a Vectorization and \a Unrolling are determined by a helper class internal::assign_traits. Its job is to determine which vectorization strategy to use (that is \a Vectorization) and which unrolling strategy to use (that is \a Unrolling).
 
-We'll not enter into the details of how these strategies are chosen (this is in the implementation of ei_assign_traits at the top of the same file). Let's just say that here \a Vectorization has the value \a LinearVectorization, and \a Unrolling has the value \a NoUnrolling (the latter is obvious since our vectors have dynamic size so there's no way to unroll the loop at compile-time).
+We'll not enter into the details of how these strategies are chosen (this is in the implementation of internal::assign_traits at the top of the same file). Let's just say that here \a Vectorization has the value \a LinearVectorization, and \a Unrolling has the value \a NoUnrolling (the latter is obvious since our vectors have dynamic size so there's no way to unroll the loop at compile-time).
 
-So the partial specialization of ei_assign_impl that we're looking at is:
+So the partial specialization of internal::assign_impl that we're looking at is:
 \code
-ei_assign_impl
+internal::assign_impl
 \endcode
 
 Here is how it's defined:
 \code
 template
-struct ei_assign_impl
+struct internal::assign_impl
 {
   static void run(Derived1 &dst, const Derived2 &src)
   {
     const int size = dst.size();
-    const int packetSize = ei_packet_traits::size;
-    const int alignedStart = ei_assign_traits::DstIsAligned ? 0
-                           : ei_first_aligned(&dst.coeffRef(0), size);
+    const int packetSize = internal::packet_traits::size;
+    const int alignedStart = internal::assign_traits::DstIsAligned ? 0
+                           : internal::first_aligned(&dst.coeffRef(0), size);
     const int alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;
 
     for(int index = 0; index < alignedStart; index++)
@@ -351,7 +351,7 @@ struct ei_assign_impl
 
     for(int index = alignedStart; index < alignedEnd; index += packetSize)
     {
-      dst.template copyPacket::SrcAlignment>(index, src);
+      dst.template copyPacket::SrcAlignment>(index, src);
     }
 
     for(int index = alignedEnd; index < size; index++)
@@ -374,7 +374,7 @@ First, the vectorized part: the 48 first coefficients out of 50 will be copied b
 \code
   for(int index = alignedStart; index < alignedEnd; index += packetSize)
   {
-    dst.template copyPacket::SrcAlignment>(index, src);
+    dst.template copyPacket::SrcAlignment>(index, src);
   }
 \endcode
 
@@ -384,7 +384,7 @@ template
 template
 inline void MatrixBase::copyPacket(int index, const MatrixBase& other)
 {
-  ei_internal_assert(index >= 0 && index < size());
+  eigen_internal_assert(index >= 0 && index < size());
   derived().template writePacket(index,
     other.derived().template packet(index));
 }
@@ -397,30 +397,30 @@ First, writePacket() here is a method on the left-hand side VectorXf. So we go t
 template
 inline void writePacket(int index, const PacketScalar& x)
 {
-  ei_pstoret(m_storage.data() + index, x);
+  internal::pstoret(m_storage.data() + index, x);
 }
 \endcode
-Here, \a StoreMode is \a Aligned, indicating that we are doing a 128-bit-aligned write access, \a PacketScalar is a type representing a "SSE packet of 4 floats" and ei_pstoret is a function writing such a packet in memory. Their definitions are architecture-specific, we find them in src/Core/arch/SSE/PacketMath.h:
+Here, \a StoreMode is \a Aligned, indicating that we are doing a 128-bit-aligned write access, \a PacketScalar is a type representing a "SSE packet of 4 floats" and internal::pstoret is a function writing such a packet in memory. Their definitions are architecture-specific, we find them in src/Core/arch/SSE/PacketMath.h:
 
 The line in src/Core/arch/SSE/PacketMath.h that determines the PacketScalar type (via a typedef in Matrix.h) is:
 \code
-template<> struct ei_packet_traits  { typedef __m128  type; enum {size=4}; };
+template<> struct internal::packet_traits  { typedef __m128  type; enum {size=4}; };
 \endcode
 Here, __m128 is a SSE-specific type. Notice that the enum \a size here is what was used to define \a packetSize above.
 
-And here is the implementation of ei_pstoret:
+And here is the implementation of internal::pstoret:
 \code
-template<> inline void ei_pstore(float*  to, const __m128&  from) { _mm_store_ps(to, from); }
+template<> inline void internal::pstore(float*  to, const __m128&  from) { _mm_store_ps(to, from); }
 \endcode
-Here, __mm_store_ps is a SSE-specific intrinsic function, representing a single SSE instruction. The difference between ei_pstore and ei_pstoret is that ei_pstoret is a dispatcher handling both the aligned and unaligned cases, you find its definition in src/Core/GenericPacketMath.h:
+Here, __mm_store_ps is a SSE-specific intrinsic function, representing a single SSE instruction. The difference between internal::pstore and internal::pstoret is that internal::pstoret is a dispatcher handling both the aligned and unaligned cases, you find its definition in src/Core/GenericPacketMath.h:
 \code
 template
-inline void ei_pstoret(Scalar* to, const Packet& from)
+inline void internal::pstoret(Scalar* to, const Packet& from)
 {
   if(LoadMode == Aligned)
-    ei_pstore(to, from);
+    internal::pstore(to, from);
   else
-    ei_pstoreu(to, from);
+    internal::pstoreu(to, from);
 }
 \endcode
 
@@ -450,30 +450,30 @@ class Matrix
     template
     inline PacketScalar packet(int index) const
     {
-      return ei_ploadt(m_storage.data() + index);
+      return internal::ploadt(m_storage.data() + index);
     }
 };
 \endcode
-We let you look up the definition of ei_ploadt in GenericPacketMath.h and the ei_pload in src/Core/arch/SSE/PacketMath.h. It is very similar to the above for ei_pstore.
+We let you look up the definition of internal::ploadt in GenericPacketMath.h and the internal::pload in src/Core/arch/SSE/PacketMath.h. It is very similar to the above for internal::pstore.
 
 Let's go back to CwiseBinaryOp::packet(). Once the packets from the vectors \a v and \a w have been returned, what does this function do? It calls m_functor.packetOp() on them. What is m_functor? Here we must remember what particular template specialization of CwiseBinaryOp we're dealing with:
 \code
-CwiseBinaryOp, VectorXf, VectorXf>
+CwiseBinaryOp, VectorXf, VectorXf>
 \endcode
-So m_functor is an object of the empty class ei_scalar_sum_op. As we mentioned above, don't worry about why we constructed an object of this empty class at all -- it's an implementation detail, the point is that some other functors need to store member data.
+So m_functor is an object of the empty class internal::scalar_sum_op. As we mentioned above, don't worry about why we constructed an object of this empty class at all -- it's an implementation detail, the point is that some other functors need to store member data.
 
-Anyway, ei_scalar_sum_op is defined in src/Core/Functors.h:
+Anyway, internal::scalar_sum_op is defined in src/Core/Functors.h:
 \code
-template struct ei_scalar_sum_op EIGEN_EMPTY_STRUCT {
+template struct internal::scalar_sum_op EIGEN_EMPTY_STRUCT {
   inline const Scalar operator() (const Scalar& a, const Scalar& b) const { return a + b; }
   template
   inline const PacketScalar packetOp(const PacketScalar& a, const PacketScalar& b) const
-  { return ei_padd(a,b); }
+  { return internal::padd(a,b); }
 };
 \endcode
-As you can see, all what packetOp() does is to call ei_padd on the two packets. Here is the definition of ei_padd from src/Core/arch/SSE/PacketMath.h:
+As you can see, all what packetOp() does is to call internal::padd on the two packets. Here is the definition of internal::padd from src/Core/arch/SSE/PacketMath.h:
 \code
-template<> inline __m128  ei_padd(const __m128&  a, const __m128&  b) { return _mm_add_ps(a,b); }
+template<> inline __m128  internal::padd(const __m128&  a, const __m128&  b) { return _mm_add_ps(a,b); }
 \endcode
 Here, _mm_add_ps is a SSE-specific intrinsic function, representing a single SSE instruction.
 
@@ -481,7 +481,7 @@ To summarize, the loop
 \code
   for(int index = alignedStart; index < alignedEnd; index += packetSize)
   {
-    dst.template copyPacket::SrcAlignment>(index, src);
+    dst.template copyPacket::SrcAlignment>(index, src);
   }
 \endcode
 has been compiled to the following code: for \a index going from 0 to the 11 ( = 48/4 - 1), read the i-th packet (of 4 floats) from the vector v and the i-th packet from the vector w using two __mm_load_ps SSE instructions, then add them together using a __mm_add_ps instruction, then store the result using a __mm_store_ps instruction.
diff --git a/doc/I11_Aliasing.dox b/doc/I11_Aliasing.dox
index 302575368..04a24bded 100644
--- a/doc/I11_Aliasing.dox
+++ b/doc/I11_Aliasing.dox
@@ -68,7 +68,7 @@ and exits with a message like
 \verbatim
 void Eigen::DenseBase::checkTransposeAliasing(const OtherDerived&) const 
 [with OtherDerived = Eigen::Transpose >, Derived = Eigen::Matrix]: 
-Assertion `(!ei_check_transpose_aliasing_selector::IsTransposed,OtherDerived>::run(ei_extract_data(derived()), other)) 
+Assertion `(!internal::check_transpose_aliasing_selector::IsTransposed,OtherDerived>::run(internal::extract_data(derived()), other)) 
 && "aliasing detected during tranposition, use transposeInPlace() or evaluate the rhs into a temporary using .eval()"' failed.
 \endverbatim
 
diff --git a/doc/I13_FunctionsTakingEigenTypes.dox b/doc/I13_FunctionsTakingEigenTypes.dox
index fea6b940f..8f2542632 100644
--- a/doc/I13_FunctionsTakingEigenTypes.dox
+++ b/doc/I13_FunctionsTakingEigenTypes.dox
@@ -111,8 +111,8 @@ The solution which is preferred at the moment is based on a little \em hack. One
 template 
 void cov(const MatrixBase& x, const MatrixBase& y, MatrixBase EIGEN_REF_TO_TEMPORARY C)
 {
-  typedef typename ei_traits::Scalar Scalar;
-  typedef typename ei_plain_row_type::type RowVectorType;
+  typedef typename internal::traits::Scalar Scalar;
+  typedef typename internal::plain_row_type::type RowVectorType;
 
   const Scalar num_observations = static_cast(x.rows());
 
@@ -141,8 +141,8 @@ This is not the case anymore, when we are using an implementation taking MatrixB
 template 
 void cov(const MatrixBase& x, const MatrixBase& y, MatrixBase EIGEN_REF_TO_TEMPORARY C_)
 {
-  typedef typename ei_traits::Scalar Scalar;
-  typedef typename ei_plain_row_type::type RowVectorType;
+  typedef typename internal::traits::Scalar Scalar;
+  typedef typename internal::plain_row_type::type RowVectorType;
 
   const Scalar num_observations = static_cast(x.rows());
 
diff --git a/doc/snippets/Tridiagonalization_decomposeInPlace.cpp b/doc/snippets/Tridiagonalization_decomposeInPlace.cpp
index 1d0961aee..93dcfca1d 100644
--- a/doc/snippets/Tridiagonalization_decomposeInPlace.cpp
+++ b/doc/snippets/Tridiagonalization_decomposeInPlace.cpp
@@ -4,7 +4,7 @@ cout << "Here is a random symmetric 5x5 matrix:" << endl << A << endl << endl;
 
 VectorXd diag(5);
 VectorXd subdiag(4);
-ei_tridiagonalization_inplace(A, diag, subdiag, true);
+internal::tridiagonalization_inplace(A, diag, subdiag, true);
 cout << "The orthogonal matrix Q is:" << endl << A << endl;
 cout << "The diagonal of the tridiagonal matrix T is:" << endl << diag << endl;
 cout << "The subdiagonal of the tridiagonal matrix T is:" << endl << subdiag << endl;
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 void adjoint(const MatrixType& m)
   Index cols = m.cols();
 
   RealScalar largerEps = test_precision();
-  if (ei_is_same_type::ret)
+  if (internal::is_same_type::ret)
     largerEps = RealScalar(1e-3f);
 
   MatrixType m1 = MatrixType::Random(rows, cols),
@@ -55,8 +55,8 @@ template void adjoint(const MatrixType& m)
              v3 = VectorType::Random(rows),
              vzero = VectorType::Zero(rows);
 
-  Scalar s1 = ei_random(),
-         s2 = ei_random();
+  Scalar s1 = internal::random(),
+         s2 = internal::random();
 
   // check basic compatibility of adjoint, transpose, conjugate
   VERIFY_IS_APPROX(m1.transpose().conjugate().adjoint(),    m1);
@@ -64,26 +64,26 @@ template 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::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::IsInteger)
     VERIFY_IS_APPROX(v1.squaredNorm(),                v1.norm() * v1.norm());
-  VERIFY_IS_MUCH_SMALLER_THAN(ei_abs(vzero.dot(v1)),  static_cast(1));
+  VERIFY_IS_MUCH_SMALLER_THAN(internal::abs(vzero.dot(v1)),  static_cast(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(0, rows-1),
-      c = ei_random(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(0, rows-1),
+      c = internal::random(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::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 void array(const ArrayType& m)
   ColVectorType cv1 = ColVectorType::Random(rows);
   RowVectorType rv1 = RowVectorType::Random(cols);
 
-  Scalar  s1 = ei_random(),
-          s2 = ei_random();
+  Scalar  s1 = internal::random(),
+          s2 = internal::random();
 
   // scalar addition
   VERIFY_IS_APPROX(m1 + s1, s1 + m1);
@@ -62,9 +62,9 @@ template 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()));
+  VERIFY_IS_APPROX(m1.colwise().sum(), m1.colwise().redux(internal::scalar_sum_op()));
 
   // vector-wise ops
   m3 = m1;
@@ -87,8 +87,8 @@ template void comparisons(const ArrayType& m)
   Index rows = m.rows();
   Index cols = m.cols();
 
-  Index r = ei_random(0, rows-1),
-        c = ei_random(0, cols-1);
+  Index r = internal::random(0, rows-1),
+        c = internal::random(0, cols-1);
 
   ArrayType m1 = ArrayType::Random(rows, cols),
              m2 = ArrayType::Random(rows, cols),
@@ -116,7 +116,7 @@ template void comparisons(const ArrayType& m)
   Scalar mid = (m1.cwiseAbs().minCoeff() + m1.cwiseAbs().maxCoeff())/Scalar(2);
   for (int j=0; j 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::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::type, int >::ret));
-  VERIFY((ei_is_same_type< ei_global_math_functions_filtering_base::type, float >::ret));
-  VERIFY((ei_is_same_type< ei_global_math_functions_filtering_base::type, ArrayBase >::ret));
-  typedef CwiseUnaryOp, ArrayXd > Xpr;
-  VERIFY((ei_is_same_type< ei_global_math_functions_filtering_base::type,
+  VERIFY((internal::is_same_type< internal::global_math_functions_filtering_base::type, int >::ret));
+  VERIFY((internal::is_same_type< internal::global_math_functions_filtering_base::type, float >::ret));
+  VERIFY((internal::is_same_type< internal::global_math_functions_filtering_base::type, ArrayBase >::ret));
+  typedef CwiseUnaryOp, ArrayXd > Xpr;
+  VERIFY((internal::is_same_type< internal::global_math_functions_filtering_base::type,
                            ArrayBase
                          >::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 void array_for_matrix(const MatrixType& m)
   ColVectorType cv1 = ColVectorType::Random(rows);
   RowVectorType rv1 = RowVectorType::Random(cols);
 
-  Scalar  s1 = ei_random(),
-          s2 = ei_random();
+  Scalar  s1 = internal::random(),
+          s2 = internal::random();
 
   // scalar addition
   VERIFY_IS_APPROX(m1.array() + s1, s1 + m1.array());
@@ -59,9 +59,9 @@ template 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()));
+  VERIFY_IS_APPROX(m1.colwise().sum(), m1.colwise().redux(internal::scalar_sum_op()));
 
   // vector-wise ops
   m3 = m1;
@@ -88,8 +88,8 @@ template void comparisons(const MatrixType& m)
   Index rows = m.rows();
   Index cols = m.cols();
 
-  Index r = ei_random(0, rows-1),
-        c = ei_random(0, cols-1);
+  Index r = internal::random(0, rows-1),
+        c = internal::random(0, cols-1);
 
   MatrixType m1 = MatrixType::Random(rows, cols),
              m2 = MatrixType::Random(rows, cols),
@@ -117,7 +117,7 @@ template void comparisons(const MatrixType& m)
   Scalar mid = (m1.cwiseAbs().minCoeff() + m1.cwiseAbs().maxCoeff())/Scalar(2);
   for (int j=0; j void lpNorm(const VectorType& v)
 
   VERIFY_IS_APPROX(u.template lpNorm(), 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 void replicate(const MatrixType& m)
   MatrixX x1, x2;
   VectorX vx1;
 
-  int  f1 = ei_random(1,10),
-       f2 = ei_random(1,10);
+  int  f1 = internal::random(1,10),
+       f2 = internal::random(1,10);
 
   x1.resize(rows*f1,cols*f2);
   for(int j=0; j void reverse(const MatrixType& m)
     }
   }
 
-  Scalar x = ei_random();
+  Scalar x = internal::random();
 
-  Index r = ei_random(0, rows-1),
-        c = ei_random(0, cols-1);
+  Index r = internal::random(0, rows-1),
+        c = internal::random(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::Index Index;
 
   for(int i = 0; i < 10*g_repeat ; i++) {
-    Index rows = ei_random(1,10);
-    Index cols = ei_random(1,10);
-    Index sups = ei_random(0,cols-1);
-    Index subs = ei_random(0,rows-1);
+    Index rows = internal::random(1,10);
+    Index cols = internal::random(1,10);
+    Index sups = internal::random(0,cols-1);
+    Index subs = internal::random(0,rows-1);
     CALL_SUBTEST(bandmatrix(BandMatrix(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 void basicStuff(const MatrixType& m)
              vzero = VectorType::Zero(rows);
   SquareMatrixType sm1 = SquareMatrixType::Random(rows,rows), sm2(rows,rows);
 
-  Scalar x = ei_random();
+  Scalar x = internal::random();
 
-  Index r = ei_random(0, rows-1),
-        c = ei_random(0, cols-1);
+  Index r = internal::random(0, rows-1),
+        c = internal::random(0, cols-1);
 
   m1.coeffRef(r,c) = x;
   VERIFY_IS_APPROX(x, m1.coeff(r,c));
@@ -156,14 +156,14 @@ template void basicStuffComplex(const MatrixType& m)
   Index rows = m.rows();
   Index cols = m.cols();
 
-  Scalar s1 = ei_random(),
-         s2 = ei_random();
+  Scalar s1 = internal::random(),
+         s2 = internal::random();
 
-  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::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::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()) );
     CALL_SUBTEST_2( basicStuff(Matrix4d()) );
-    CALL_SUBTEST_3( basicStuff(MatrixXcf(ei_random(1,100), ei_random(1,100))) );
-    CALL_SUBTEST_4( basicStuff(MatrixXi(ei_random(1,100), ei_random(1,100))) );
-    CALL_SUBTEST_5( basicStuff(MatrixXcd(ei_random(1,100), ei_random(1,100))) );
+    CALL_SUBTEST_3( basicStuff(MatrixXcf(internal::random(1,100), internal::random(1,100))) );
+    CALL_SUBTEST_4( basicStuff(MatrixXi(internal::random(1,100), internal::random(1,100))) );
+    CALL_SUBTEST_5( basicStuff(MatrixXcd(internal::random(1,100), internal::random(1,100))) );
     CALL_SUBTEST_6( basicStuff(Matrix()) );
-    CALL_SUBTEST_7( basicStuff(Matrix(ei_random(1,100),ei_random(1,100))) );
+    CALL_SUBTEST_7( basicStuff(Matrix(internal::random(1,100),internal::random(1,100))) );
 
-    CALL_SUBTEST_3( basicStuffComplex(MatrixXcf(ei_random(1,100), ei_random(1,100))) );
-    CALL_SUBTEST_5( basicStuffComplex(MatrixXcd(ei_random(1,100), ei_random(1,100))) );
+    CALL_SUBTEST_3( basicStuffComplex(MatrixXcf(internal::random(1,100), internal::random(1,100))) );
+    CALL_SUBTEST_5( basicStuffComplex(MatrixXcd(internal::random(1,100), internal::random(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 void block(const MatrixType& m)
              v3 = VectorType::Random(rows),
              vzero = VectorType::Zero(rows);
 
-  Scalar s1 = ei_random();
+  Scalar s1 = internal::random();
 
-  Index r1 = ei_random(0,rows-1);
-  Index r2 = ei_random(r1,rows-1);
-  Index c1 = ei_random(0,cols-1);
-  Index c2 = ei_random(c1,cols-1);
+  Index r1 = internal::random(0,rows-1);
+  Index r2 = internal::random(r1,rows-1);
+  Index c1 = internal::random(0,cols-1);
+  Index c2 = internal::random(c1,cols-1);
 
   //check row() and col()
   VERIFY_IS_EQUAL(m1.col(c1).transpose(), m1.transpose().row(c1));
@@ -100,16 +100,16 @@ template 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(0,rows-2);
+    i = internal::random(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(0,rows-1);
-  Index r2 = ei_random(r1,rows-1);
-  Index c1 = ei_random(0,cols-1);
-  Index c2 = ei_random(c1,cols-1);
+  Index r1 = internal::random(0,rows-1);
+  Index r2 = internal::random(r1,rows-1);
+  Index c1 = internal::random(0,cols-1);
+  Index c2 = internal::random(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(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(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(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 void cholesky(const MatrixType& m)
   //symm.template part().setZero();
 
   #ifdef HAS_GSL
-//   if (ei_is_same_type::ret)
+//   if (internal::is_same_type::ret)
 //   {
 //     typedef GslTraits Gsl;
 //     typename Gsl::Matrix gMatA=0, gSymm=0;
@@ -128,7 +128,7 @@ template void cholesky(const MatrixType& m)
 
   // LDLT
   {
-    int sign = ei_random()%2 ? 1 : -1;
+    int sign = internal::random()%2 ? 1 : -1;
 
     if(sign == -1)
     {
@@ -226,7 +226,7 @@ template void cholesky_cplx(const MatrixType& m)
 
   // LDLT
   {
-    int sign = ei_random()%2 ? 1 : -1;
+    int sign = internal::random()%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(1,200);
+    s = internal::random(1,200);
     CALL_SUBTEST_2( cholesky(MatrixXd(s,s)) );
-    s = ei_random(1,100);
+    s = internal::random(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(1,50);
-    const Index cols = ei_random(1,50);
+    const Index rows = internal::random(1,50);
+    const Index cols = internal::random(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(50,75);
-    const Index cols = ei_random(50,75);
+    const Index rows = internal::random(50,75);
+    const Index cols = internal::random(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(1,50);
+    const int size = internal::random(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(50,100);
+    const int size = internal::random(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 void corners(const MatrixType& m)
   Index rows = m.rows();
   Index cols = m.cols();
 
-  Index r = ei_random(1,rows);
-  Index c = ei_random(1,cols);
+  Index r = internal::random(1,rows);
+  Index c = internal::random(1,cols);
 
   MatrixType matrix = MatrixType::Random(rows,cols);
   const MatrixType const_matrix = MatrixType::Random(rows,cols);
@@ -45,10 +45,10 @@ template 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(1,rows) - 1;
-  Index nr = ei_random(1,rows-sr);
-  Index sc = ei_random(1,cols) - 1;
-  Index nc = ei_random(1,cols-sc);
+  Index sr = internal::random(1,rows) - 1;
+  Index nr = internal::random(1,rows-sr);
+  Index sc = internal::random(1,cols) - 1;
+  Index nc = internal::random(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 void cwiseops(const MatrixType& m)
              vones = VectorType::Ones(rows),
              v3(rows);
 
-  Index r = ei_random(0, rows-1),
-        c = ei_random(0, cols-1);
+  Index r = internal::random(0, rows-1),
+        c = internal::random(0, cols-1);
 
-  Scalar s1 = ei_random();
+  Scalar s1 = internal::random();
 
   // 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 void determinant(const MatrixType& m)
   m1.setRandom();
   m2.setRandom();
   typedef typename MatrixType::Scalar Scalar;
-  Scalar x = ei_random();
+  Scalar x = internal::random();
   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(0, size-1);
+  Index i = internal::random(0, size-1);
   Index j;
   do {
-    j = ei_random(0, size-1);
+    j = internal::random(0, size-1);
   } while(j==i);
   m2 = m1;
   m2.row(i).swap(m2.row(j));
@@ -54,7 +54,7 @@ template 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 void diagonalmatrices(const MatrixType& m)
   sq_m1.transpose() = ldm1;
   VERIFY_IS_APPROX(sq_m1, ldm1.toDenseMatrix());
   
-  Index i = ei_random(0, rows-1);
-  Index j = ei_random(0, cols-1);
+  Index i = internal::random(0, rows-1);
+  Index j = internal::random(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(i);
+    float *p = internal::aligned_new(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 void eigen2support(const MatrixType& m)
              m2 = MatrixType::Random(rows, cols),
              m3(rows, cols);
 
-  Scalar  s1 = ei_random(),
-          s2 = ei_random();
+  Scalar  s1 = internal::random(),
+          s2 = internal::random();
 
   // 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 void selfadjointeigensolver(const MatrixType& m)
   GeneralizedSelfAdjointEigenSolver eiSymmGen(symmA, symmB);
 
   #ifdef HAS_GSL
-  if (ei_is_same_type::ret)
+  if (internal::is_same_type::ret)
   {
     // restore symmA and symmB.
     symmA = MatrixType(symmA.template selfadjointView());
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
 void test_first_aligned_helper(Scalar *array, int size)
 {
-  const int packet_size = sizeof(Scalar) * ei_packet_traits::size;
-  VERIFY(((size_t(array) + sizeof(Scalar) * ei_first_aligned(array, size)) % packet_size) == 0);
+  const int packet_size = sizeof(Scalar) * internal::packet_traits::size;
+  VERIFY(((size_t(array) + sizeof(Scalar) * internal::first_aligned(array, size)) % packet_size) == 0);
 }
 
 template
@@ -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::size == 1 || ei_first_aligned(array, size) == size);
+  VERIFY(internal::packet_traits::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 void alignedbox(const BoxType& _box)
   VectorType p1 = VectorType::Random(dim);
   while( p1 == p0 ){
       p1 =  VectorType::Random(dim); }
-  RealScalar s1 = ei_random(0,1);
+  RealScalar s1 = internal::random(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 void eulerangles(void)
   typedef Quaternion Quaternionx;
   typedef AngleAxis AngleAxisx;
 
-  Scalar a = ei_random(-Scalar(M_PI), Scalar(M_PI));
+  Scalar a = internal::random(-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 void homogeneous(void)
   typedef Matrix T3MatrixType;
 
   Scalar largeEps = test_precision();
-  if (ei_is_same_type::ret)
+  if (internal::is_same_type::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 void hyperplane(const HyperplaneType& _plane)
   HyperplaneType pl1(n1, p1);
   HyperplaneType pl2 = pl1;
 
-  Scalar s0 = ei_random();
-  Scalar s1 = ei_random();
+  Scalar s0 = internal::random();
+  Scalar s1 = internal::random();
 
   VERIFY_IS_APPROX( n1.dot(n1), Scalar(1) );
 
@@ -103,8 +103,8 @@ template void lines()
     Vector center = Vector::Random();
     Vector u = Vector::Random();
     Vector v = Vector::Random();
-    Scalar a = ei_random();
-    while (ei_abs(a-1) < 1e-4) a = ei_random();
+    Scalar a = internal::random();
+    while (internal::abs(a-1) < 1e-4) a = internal::random();
     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 void orthomethods_3()
   mat3.setRandom();
   Vector3 vec3 = Vector3::Random();
   Matrix3 mcross;
-  int i = ei_random(0,2);
+  int i = internal::random(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 void orthomethods(int size=Size)
 
   // colwise/rowwise cross product
   Vector3 vec3 = Vector3::Random();
-  int i = ei_random(0,size-1);
+  int i = internal::random(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 void parametrizedline(const LineType& _line)
 
   LineType l0(p0, d0);
 
-  Scalar s0 = ei_random();
-  Scalar s1 = ei_abs(ei_random());
+  Scalar s0 = internal::random();
+  Scalar s1 = internal::abs(internal::random());
 
   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 void quaternion(void)
   typedef AngleAxis AngleAxisx;
 
   Scalar largeEps = test_precision();
-  if (ei_is_same_type::ret)
+  if (internal::is_same_type::ret)
     largeEps = 1e-3f;
 
-  Scalar eps = ei_random() * Scalar(1e-2);
+  Scalar eps = internal::random() * Scalar(1e-2);
 
   Vector3 v0 = Vector3::Random(),
           v1 = Vector3::Random(),
           v2 = Vector3::Random(),
           v3 = Vector3::Random();
 
-  Scalar a = ei_random(-Scalar(M_PI), Scalar(M_PI));
+  Scalar a = internal::random(-Scalar(M_PI), Scalar(M_PI));
 
   // Quaternion: Identity(), setIdentity();
   Quaternionx q1, q2;
@@ -66,13 +66,13 @@ template 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 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::ret)
+  if (internal::is_same_type::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 void non_projective_only(void)
   typedef Translation Translation3;
 
   Scalar largeEps = test_precision();
-  if (ei_is_same_type::ret)
+  if (internal::is_same_type::ret)
     largeEps = 1e-2f;
 
   Vector3 v0 = Vector3::Random(),
@@ -59,7 +59,7 @@ template void non_projective_only(void)
 
   Transform3 t0, t1, t2;
 
-  Scalar a = ei_random(-Scalar(M_PI), Scalar(M_PI));
+  Scalar a = internal::random(-Scalar(M_PI), Scalar(M_PI));
 
   Quaternionx q1, q2;
 
@@ -126,7 +126,7 @@ template void transformations(void)
   typedef Translation Translation3;
 
   Scalar largeEps = test_precision();
-  if (ei_is_same_type::ret)
+  if (internal::is_same_type::ret)
     largeEps = 1e-2f;
 
   Vector3 v0 = Vector3::Random(),
@@ -135,12 +135,12 @@ template void transformations(void)
   Vector2 u0 = Vector2::Random();
   Matrix3 matrot1, m;
 
-  Scalar a = ei_random(-Scalar(M_PI), Scalar(M_PI));
-  Scalar s0 = ei_random();
+  Scalar a = internal::random(-Scalar(M_PI), Scalar(M_PI));
+  Scalar s0 = internal::random();
 
   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 void transformations(void)
   // Transform
   // TODO complete the tests !
   a = 0;
-  while (ei_abs(a)(-Scalar(0.4)*Scalar(M_PI), Scalar(0.4)*Scalar(M_PI));
+  while (internal::abs(a)(-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 void transformations(void)
     tmat4.matrix()(3,3) = Scalar(1);
   VERIFY_IS_APPROX(tmat3.matrix(), tmat4.matrix());
 
-  Scalar a3 = ei_random(-Scalar(M_PI), Scalar(M_PI));
+  Scalar a3 = internal::random(-Scalar(M_PI), Scalar(M_PI));
   Vector3 v3 = Vector3::Random().normalized();
   AngleAxisx aa3(a3, v3);
   Transform3 t3(aa3);
@@ -274,7 +274,7 @@ template void transformations(void)
   Vector2 v20 = Vector2::Random();
   Vector2 v21 = Vector2::Random();
   for (int k=0; k<2; ++k)
-    if (ei_abs(v21[k])(a).toRotationMatrix();
   VERIFY_IS_APPROX(t20.fromPositionOrientationScale(v20,a,v21).matrix(),
@@ -411,7 +411,7 @@ template void transformations(void)
   AngleAxis aa1d = aa1.template cast();
   VERIFY_IS_APPROX(aa1d.template cast(),aa1);
 
-  Rotation2D r2d1(ei_random());
+  Rotation2D r2d1(internal::random());
   Rotation2D r2d1f = r2d1.template cast();
   VERIFY_IS_APPROX(r2d1f.template cast(),r2d1);
   Rotation2D r2d1d = r2d1.template cast();
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,1>() ));
   CALL_SUBTEST_2(( hessenberg,2>() ));
   CALL_SUBTEST_3(( hessenberg,4>() ));
-  CALL_SUBTEST_4(( hessenberg(ei_random(1,320)) ));
-  CALL_SUBTEST_5(( hessenberg,Dynamic>(ei_random(1,320)) ));
+  CALL_SUBTEST_4(( hessenberg(internal::random(1,320)) ));
+  CALL_SUBTEST_5(( hessenberg,Dynamic>(internal::random(1,320)) ));
 
   // Test problem size constructors
   CALL_SUBTEST_6(HessenbergDecomposition(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 void householder(const MatrixType& m)
   typedef typename MatrixType::Scalar Scalar;
   typedef typename NumTraits::Real RealScalar;
   typedef Matrix VectorType;
-  typedef Matrix::ret, 1> EssentialVectorType;
+  typedef Matrix::ret, 1> EssentialVectorType;
   typedef Matrix SquareMatrixType;
   typedef Matrix HBlockMatrixType;
   typedef Matrix HCoeffsVectorType;
@@ -77,8 +77,8 @@ template 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 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(0, std::max(rows-2,0));
+  Index shift = internal::random(0, std::max(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 void signed_integer_type_tests(const MatrixType& m
 
   Scalar s1;
   do {
-    s1 = ei_random();
+    s1 = internal::random();
   } while(s1 == 0);
 
   VERIFY_IS_EQUAL(-(-m1),                  m1);
@@ -126,7 +126,7 @@ template void integer_type_tests(const MatrixType& m)
 
   Scalar s1;
   do {
-    s1 = ei_random();
+    s1 = internal::random();
   } 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 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()) );
-    s = ei_random(50,320);
+    s = internal::random(50,320);
     CALL_SUBTEST_5( inverse(MatrixXf(s,s)) );
-    s = ei_random(25,100);
+    s = internal::random(25,100);
     CALL_SUBTEST_6( inverse(MatrixXcd(s,s)) );
     CALL_SUBTEST_7( inverse(Matrix4d()) );
     CALL_SUBTEST_7( inverse(Matrix()) );
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 rot(c, s);
 
   {
-    Index p = ei_random(0, rows-1);
+    Index p = internal::random(0, rows-1);
     Index q;
     do {
-      q = ei_random(0, rows-1);
+      q = internal::random(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(0, cols-1);
+    Index p = internal::random(0, cols-1);
     Index q;
     do {
-      q = ei_random(0, cols-1);
+      q = internal::random(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() ));
     CALL_SUBTEST_3(( jacobi >() ));
 
-    int r = ei_random(2, 20),
-        c = ei_random(2, 20);
+    int r = internal::random(2, 20),
+        c = internal::random(2, 20);
     CALL_SUBTEST_4(( jacobi(MatrixXf(r,c)) ));
     CALL_SUBTEST_5(( jacobi(MatrixXcd(r,c)) ));
     CALL_SUBTEST_5(( jacobi >(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 RhsType;
   typedef Matrix SolutionType;
 
-  RhsType rhs = RhsType::Random(rows, ei_random(1, cols));
+  RhsType rhs = RhsType::Random(rows, internal::random(1, cols));
   JacobiSVD 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(0,9), ei_random(0,9)) = some_inf;
+  m(internal::random(0,9), internal::random(0,9)) = some_inf;
   svd.compute(m, ComputeFullU | ComputeFullV);
 
   m = MatrixType::Zero(10,10);
-  m(ei_random(0,9), ei_random(0,9)) = some_nan;
+  m(internal::random(0,9), internal::random(0,9)) = some_nan;
   svd.compute(m, ComputeFullU | ComputeFullV);
 }
 
@@ -267,8 +267,8 @@ void test_jacobisvd()
     CALL_SUBTEST_5(( jacobisvd >() ));
     CALL_SUBTEST_6(( jacobisvd >(Matrix(10,2)) ));
 
-    int r = ei_random(1, 30),
-        c = ei_random(1, 30);
+    int r = internal::random(1, 30),
+        c = internal::random(1, 30);
     CALL_SUBTEST_7(( jacobisvd(MatrixXf(r,c)) ));
     CALL_SUBTEST_8(( jacobisvd(MatrixXcd(r,c)) ));
     (void) r;
@@ -278,8 +278,8 @@ void test_jacobisvd()
     CALL_SUBTEST_7( jacobisvd_inf_nan() );
   }
 
-  CALL_SUBTEST_7(( jacobisvd(MatrixXf(ei_random(100, 150), ei_random(100, 150))) ));
-  CALL_SUBTEST_8(( jacobisvd(MatrixXcd(ei_random(80, 100), ei_random(80, 100))) ));
+  CALL_SUBTEST_7(( jacobisvd(MatrixXf(internal::random(100, 150), internal::random(100, 150))) ));
+  CALL_SUBTEST_8(( jacobisvd(MatrixXcd(internal::random(80, 100), internal::random(80, 100))) ));
 
   // test matrixbase method
   CALL_SUBTEST_1(( jacobisvd_method() ));
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 void linearStructure(const MatrixType& m)
              m3(rows, cols),
              mzero = MatrixType::Zero(rows, cols);
 
-  Scalar s1 = ei_random();
-  while (ei_abs(s1)<1e-3) s1 = ei_random();
+  Scalar s1 = internal::random();
+  while (internal::abs(s1)<1e-3) s1 = internal::random();
 
-  Index r = ei_random(0, rows-1),
-        c = ei_random(0, cols-1);
+  Index r = internal::random(0, rows-1),
+        c = internal::random(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 void lu_non_invertible()
   Index rows, cols, cols2;
   if(MatrixType::RowsAtCompileTime==Dynamic)
   {
-    rows = ei_random(2,200);
+    rows = internal::random(2,200);
   }
   else
   {
@@ -45,8 +45,8 @@ template void lu_non_invertible()
   }
   if(MatrixType::ColsAtCompileTime==Dynamic)
   {
-    cols = ei_random(2,200);
-    cols2 = ei_random(2,200);
+    cols = internal::random(2,200);
+    cols2 = internal::random(2,200);
   }
   else
   {
@@ -57,14 +57,14 @@ template void lu_non_invertible()
     RowsAtCompileTime = MatrixType::RowsAtCompileTime,
     ColsAtCompileTime = MatrixType::ColsAtCompileTime
   };
-  typedef typename ei_kernel_retval_base >::ReturnType KernelMatrixType;
-  typedef typename ei_image_retval_base >::ReturnType ImageMatrixType;
+  typedef typename internal::kernel_retval_base >::ReturnType KernelMatrixType;
+  typedef typename internal::image_retval_base >::ReturnType ImageMatrixType;
   typedef Matrix
           CMatrixType;
   typedef Matrix
           RMatrixType;
 
-  Index rank = ei_random(1, std::min(rows, cols)-1);
+  Index rank = internal::random(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 void lu_invertible()
   */
   typedef typename MatrixType::Scalar Scalar;
   typedef typename NumTraits::Real RealScalar;
-  int size = ei_random(1,200);
+  int size = internal::random(1,200);
 
   MatrixType m1(size, size), m2(size, size), m3(size, size);
   FullPivLU lu;
@@ -149,7 +149,7 @@ template void lu_partial_piv()
   typedef typename MatrixType::Index Index;
   typedef typename MatrixType::Scalar Scalar;
   typedef typename NumTraits::Real RealScalar;
-  Index rows = ei_random(1,4);
+  Index rows = internal::random(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 ei_assert_list;
+      static bool internal::push_assert = false;
+      static std::vector 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 inline float test_precision >() { return test_pre
 template<> inline double test_precision >() { return test_precision(); }
 template<> inline long double test_precision() { return 1e-6; }
 
-inline bool test_ei_isApprox(const int& a, const int& b)
-{ return ei_isApprox(a, b, test_precision()); }
-inline bool test_ei_isMuchSmallerThan(const int& a, const int& b)
-{ return ei_isMuchSmallerThan(a, b, test_precision()); }
-inline bool test_ei_isApproxOrLessThan(const int& a, const int& b)
-{ return ei_isApproxOrLessThan(a, b, test_precision()); }
-
-inline bool test_ei_isApprox(const float& a, const float& b)
-{ return ei_isApprox(a, b, test_precision()); }
-inline bool test_ei_isMuchSmallerThan(const float& a, const float& b)
-{ return ei_isMuchSmallerThan(a, b, test_precision()); }
-inline bool test_ei_isApproxOrLessThan(const float& a, const float& b)
-{ return ei_isApproxOrLessThan(a, b, test_precision()); }
-
-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()); }
+inline bool test_isMuchSmallerThan(const int& a, const int& b)
+{ return internal::isMuchSmallerThan(a, b, test_precision()); }
+inline bool test_isApproxOrLessThan(const int& a, const int& b)
+{ return internal::isApproxOrLessThan(a, b, test_precision()); }
+
+inline bool test_isApprox(const float& a, const float& b)
+{ return internal::isApprox(a, b, test_precision()); }
+inline bool test_isMuchSmallerThan(const float& a, const float& b)
+{ return internal::isMuchSmallerThan(a, b, test_precision()); }
+inline bool test_isApproxOrLessThan(const float& a, const float& b)
+{ return internal::isApproxOrLessThan(a, b, test_precision()); }
+
+inline bool test_isApprox(const double& a, const double& b)
 {
-    bool ret = ei_isApprox(a, b, test_precision());
+    bool ret = internal::isApprox(a, b, test_precision());
     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()); }
-inline bool test_ei_isApproxOrLessThan(const double& a, const double& b)
-{ return ei_isApproxOrLessThan(a, b, test_precision()); }
+inline bool test_isMuchSmallerThan(const double& a, const double& b)
+{ return internal::isMuchSmallerThan(a, b, test_precision()); }
+inline bool test_isApproxOrLessThan(const double& a, const double& b)
+{ return internal::isApproxOrLessThan(a, b, test_precision()); }
 
-inline bool test_ei_isApprox(const std::complex& a, const std::complex& b)
-{ return ei_isApprox(a, b, test_precision >()); }
-inline bool test_ei_isMuchSmallerThan(const std::complex& a, const std::complex& b)
-{ return ei_isMuchSmallerThan(a, b, test_precision >()); }
+inline bool test_isApprox(const std::complex& a, const std::complex& b)
+{ return internal::isApprox(a, b, test_precision >()); }
+inline bool test_isMuchSmallerThan(const std::complex& a, const std::complex& b)
+{ return internal::isMuchSmallerThan(a, b, test_precision >()); }
 
-inline bool test_ei_isApprox(const std::complex& a, const std::complex& b)
-{ return ei_isApprox(a, b, test_precision >()); }
-inline bool test_ei_isMuchSmallerThan(const std::complex& a, const std::complex& b)
-{ return ei_isMuchSmallerThan(a, b, test_precision >()); }
+inline bool test_isApprox(const std::complex& a, const std::complex& b)
+{ return internal::isApprox(a, b, test_precision >()); }
+inline bool test_isMuchSmallerThan(const std::complex& a, const std::complex& b)
+{ return internal::isMuchSmallerThan(a, b, test_precision >()); }
 
-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());
+    bool ret = internal::isApprox(a, b, test_precision());
     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()); }
-inline bool test_ei_isApproxOrLessThan(const long double& a, const long double& b)
-{ return ei_isApproxOrLessThan(a, b, test_precision()); }
+inline bool test_isMuchSmallerThan(const long double& a, const long double& b)
+{ return internal::isMuchSmallerThan(a, b, test_precision()); }
+inline bool test_isApproxOrLessThan(const long double& a, const long double& b)
+{ return internal::isApproxOrLessThan(a, b, test_precision()); }
 
 template
-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());
 }
 
 template
-inline bool test_ei_isMuchSmallerThan(const MatrixBase& m1,
+inline bool test_isMuchSmallerThan(const MatrixBase& m1,
                                    const MatrixBase& m2)
 {
-  return m1.isMuchSmallerThan(m2, test_precision::Scalar>());
+  return m1.isMuchSmallerThan(m2, test_precision::Scalar>());
 }
 
 template
-inline bool test_ei_isMuchSmallerThan(const MatrixBase& m,
-                                   const typename NumTraits::Scalar>::Real& s)
+inline bool test_isMuchSmallerThan(const MatrixBase& m,
+                                   const typename NumTraits::Scalar>::Real& s)
 {
-  return m.isMuchSmallerThan(s, test_precision::Scalar>());
+  return m.isMuchSmallerThan(s, test_precision::Scalar>());
 }
 
 template
 inline bool test_isUnitary(const MatrixBase& m)
 {
-  return m.isUnitary(test_precision::Scalar>());
+  return m.isUnitary(test_precision::Scalar>());
 }
 
 template
@@ -388,8 +388,8 @@ bool test_is_equal(const T& actual, const U& expected)
 template
 void createRandomPIMatrixOfRank(typename MatrixType::Index desired_rank, typename MatrixType::Index rows, typename MatrixType::Index cols, MatrixType& m)
 {
-  typedef typename ei_traits::Index Index;
-  typedef typename ei_traits::Scalar Scalar;
+  typedef typename internal::traits::Index Index;
+  typedef typename internal::traits::Scalar Scalar;
   enum { Rows = MatrixType::RowsAtCompileTime, Cols = MatrixType::ColsAtCompileTime };
 
   typedef Matrix 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 void map_class_vector(const VectorType& m)
   Index size = m.size();
 
   // test Map.h
-  Scalar* array1 = ei_aligned_new(size);
-  Scalar* array2 = ei_aligned_new(size);
+  Scalar* array1 = internal::aligned_new(size);
+  Scalar* array2 = internal::aligned_new(size);
   Scalar* array3 = new Scalar[size+1];
   Scalar* array3unaligned = size_t(array3)%16 == 0 ? array3+1 : array3;
 
@@ -49,8 +49,8 @@ template void map_class_vector(const VectorType& m)
   VERIFY_RAISES_ASSERT((Map(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 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(size);
+  Scalar* array1 = internal::aligned_new(size);
   for(int i = 0; i < size; i++) array1[i] = Scalar(1);
-  Scalar* array2 = ei_aligned_new(size);
+  Scalar* array2 = internal::aligned_new(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 void map_class_matrix(const MatrixType& m)
   MatrixType ma3 = Map(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 void map_static_methods(const VectorType& m)
   Index size = m.size();
 
   // test Map.h
-  Scalar* array1 = ei_aligned_new(size);
-  Scalar* array2 = ei_aligned_new(size);
+  Scalar* array1 = internal::aligned_new(size);
+  Scalar* array2 = internal::aligned_new(size);
   Scalar* array3 = new Scalar[size+1];
   Scalar* array3unaligned = size_t(array3)%16 == 0 ? array3+1 : array3;
 
@@ -105,8 +105,8 @@ template 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()) );
     CALL_SUBTEST_2( map_class_matrix(Matrix4d()) );
     CALL_SUBTEST_11( map_class_matrix(Matrix()) );
-    CALL_SUBTEST_4( map_class_matrix(MatrixXcf(ei_random(1,10),ei_random(1,10))) );
-    CALL_SUBTEST_5( map_class_matrix(MatrixXi(ei_random(1,10),ei_random(1,10))) );
+    CALL_SUBTEST_4( map_class_matrix(MatrixXcf(internal::random(1,10),internal::random(1,10))) );
+    CALL_SUBTEST_5( map_class_matrix(MatrixXi(internal::random(1,10),internal::random(1,10))) );
 
     CALL_SUBTEST_6( map_static_methods(Matrix()) );
     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 void map_class_vector(const VectorType& m)
 
   Index arraysize = 3*size;
   
-  Scalar* array = ei_aligned_new(arraysize);
+  Scalar* array = internal::aligned_new(arraysize);
 
   {
     Map > map(array, size);
@@ -57,7 +57,7 @@ template void map_class_vector(const VectorType& m)
     }
   }
 
-  ei_aligned_delete(array, arraysize);
+  internal::aligned_delete(array, arraysize);
 }
 
 template void map_class_matrix(const MatrixType& _m)
@@ -71,7 +71,7 @@ template void map_class_matrix(const MatrixType& _m)
 
   Index arraysize = 2*(rows+4)*(cols+4);
 
-  Scalar* array = ei_aligned_new(arraysize);
+  Scalar* array = internal::aligned_new(arraysize);
 
   // test no inner stride and some dynamic outer stride
   {
@@ -119,7 +119,7 @@ template 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()) );
     CALL_SUBTEST_3( map_class_matrix(Matrix()) );
-    CALL_SUBTEST_4( map_class_matrix(MatrixXcf(ei_random(1,10),ei_random(1,10))) );
-    CALL_SUBTEST_5( map_class_matrix(MatrixXi(5,5)));//ei_random(1,10),ei_random(1,10))) );
+    CALL_SUBTEST_4( map_class_matrix(MatrixXcf(internal::random(1,10),internal::random(1,10))) );
+    CALL_SUBTEST_5( map_class_matrix(MatrixXi(5,5)));//internal::random(1,10),internal::random(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::ret));
-  VERIFY((!ei_is_same_type::ret));
-  VERIFY((!ei_is_same_type::ret));
-  VERIFY((!ei_is_same_type::ret));
+  VERIFY((internal::meta_if<(3<4),internal::meta_true, internal::meta_false>::ret::ret));
+  VERIFY(( internal::is_same_type::ret));
+  VERIFY((!internal::is_same_type::ret));
+  VERIFY((!internal::is_same_type::ret));
+  VERIFY((!internal::is_same_type::ret));
   
-  VERIFY(( ei_is_same_type::type >::ret));
-  VERIFY(( ei_is_same_type::type >::ret));
-  VERIFY(( ei_is_same_type::type >::ret));
-  VERIFY(( ei_is_same_type::type >::ret));
-  VERIFY(( ei_is_same_type::type >::ret));
-  VERIFY(( ei_is_same_type::type >::ret));
-  VERIFY(( ei_is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
 
-  VERIFY(( ei_is_same_type::type >::ret));
-  VERIFY(( ei_is_same_type::type >::ret));
-  VERIFY(( ei_is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
   
-  VERIFY(( ei_is_same_type::type >::ret));
-  VERIFY(( ei_is_same_type::type >::ret));
-  VERIFY(( ei_is_same_type::type >::ret));
-  VERIFY(( ei_is_same_type::type >::ret));
-  VERIFY(( ei_is_same_type::type >::ret));
-  VERIFY(( ei_is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
+  VERIFY(( internal::is_same_type::type >::ret));
   
-  VERIFY(ei_meta_sqrt<1>::ret == 1);
-  #define VERIFY_META_SQRT(X) VERIFY(ei_meta_sqrt::ret == int(ei_sqrt(double(X))))
+  VERIFY(internal::meta_sqrt<1>::ret == 1);
+  #define VERIFY_META_SQRT(X) VERIFY(internal::meta_sqrt::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 void miscMatrices(const MatrixType& m)
   Index rows = m.rows();
   Index cols = m.cols();
 
-  Index r = ei_random(0, rows-1), r2 = ei_random(0, rows-1), c = ei_random(0, cols-1);
+  Index r = internal::random(0, rows-1), r2 = internal::random(0, rows-1), c = internal::random(0, cols-1);
   VERIFY_IS_APPROX(MatrixType::Ones(rows,cols)(r,c), static_cast(1));
   MatrixType m1 = MatrixType::Ones(rows,cols);
   VERIFY_IS_APPROX(m1(r,c), static_cast(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 void mixingtypes(int size = SizeAtCompileType)
   Vec_d vd    = vf.template cast();
   Vec_cf vcf  = Vec_cf::Random(size,1);
   Vec_cd vcd  = vcf.template cast >();
-  float           sf  = ei_random();
-  double          sd  = ei_random();
-  complex  scf = ei_random >();
-  complex scd = ei_random >();
+  float           sf  = internal::random();
+  double          sd  = internal::random();
+  complex  scf = internal::random >();
+  complex scd = internal::random >();
 
 
   mf+mf;
@@ -144,5 +144,5 @@ void test_mixingtypes()
 {
   CALL_SUBTEST_1(mixingtypes<3>());
   CALL_SUBTEST_2(mixingtypes<4>());
-  CALL_SUBTEST_3(mixingtypes(ei_random(1,310)));
+  CALL_SUBTEST_3(mixingtypes(internal::random(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 void nomalloc(const MatrixType& m)
              v2 = VectorType::Random(rows),
              vzero = VectorType::Zero(rows);
 
-  Scalar s1 = ei_random();
+  Scalar s1 = internal::random();
 
-  Index r = ei_random(0, rows-1),
-        c = ei_random(0, cols-1);
+  Index r = internal::random(0, rows-1),
+        c = internal::random(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
 void testVectorType(const VectorType& base)
 {
-  typedef typename ei_traits::Index Index;
-  typedef typename ei_traits::Scalar Scalar;
-  Scalar low = ei_random(-500,500);
-  Scalar high = ei_random(-500,500);
+  typedef typename internal::traits::Index Index;
+  typedef typename internal::traits::Scalar Scalar;
+  Scalar low = internal::random(-500,500);
+  Scalar high = internal::random(-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 T ei_negate(const T& x) { return -x; }
+namespace Eigen {
+namespace internal {
+template T negate(const T& x) { return -x; }
+}
+}
 
 template bool isApproxAbs(const Scalar& a, const Scalar& b, const typename NumTraits::Real& refvalue)
 {
-  return ei_isMuchSmallerThan(a-b, refvalue);
+  return internal::isMuchSmallerThan(a-b, refvalue);
 }
 
 template bool areApproxAbs(const Scalar* a, const Scalar* b, int size, const typename NumTraits::Real& refvalue)
@@ -51,7 +55,7 @@ template bool areApprox(const Scalar* a, const Scalar* b, int s
 {
   for (int i=0; i bool areApprox(const Scalar* a, const Scalar* b, int s
 #define CHECK_CWISE2(REFOP, POP) { \
   for (int i=0; i(data1), ei_pload(data1+PacketSize))); \
+  internal::pstore(data2, POP(internal::pload(data1), internal::pload(data1+PacketSize))); \
   VERIFY(areApprox(ref, data2, PacketSize) && #POP); \
 }
 
 #define CHECK_CWISE1(REFOP, POP) { \
   for (int i=0; i(data1))); \
+  internal::pstore(data2, POP(internal::pload(data1))); \
   VERIFY(areApprox(ref, data2, PacketSize) && #POP); \
 }
 
@@ -79,10 +83,10 @@ template
 struct packet_helper
 {
   template
-  inline Packet load(const T* from) const { return ei_pload(from); }
+  inline Packet load(const T* from) const { return internal::pload(from); }
 
   template
-  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
@@ -110,150 +114,150 @@ struct packet_helper
 
 template void packetmath()
 {
-  typedef typename ei_packet_traits::type Packet;
-  const int PacketSize = ei_packet_traits::size;
+  typedef typename internal::packet_traits::type Packet;
+  const int PacketSize = internal::packet_traits::size;
   typedef typename NumTraits::Real RealScalar;
 
   const int size = PacketSize*4;
-  EIGEN_ALIGN16 Scalar data1[ei_packet_traits::size*4];
-  EIGEN_ALIGN16 Scalar data2[ei_packet_traits::size*4];
+  EIGEN_ALIGN16 Scalar data1[internal::packet_traits::size*4];
+  EIGEN_ALIGN16 Scalar data2[internal::packet_traits::size*4];
   EIGEN_ALIGN16 Packet packets[PacketSize*2];
-  EIGEN_ALIGN16 Scalar ref[ei_packet_traits::size*4];
+  EIGEN_ALIGN16 Scalar ref[internal::packet_traits::size*4];
   RealScalar refvalue = 0;
   for (int i=0; i();
-    data2[i] = ei_random();
-    refvalue = std::max(refvalue,ei_abs(data1[i]));
+    data1[i] = internal::random();
+    data2[i] = internal::random();
+    refvalue = std::max(refvalue,internal::abs(data1[i]));
   }
 
-  ei_pstore(data2, ei_pload(data1));
+  internal::pstore(data2, internal::pload(data1));
   VERIFY(areApprox(data1, data2, PacketSize) && "aligned load/store");
 
   for (int offset=0; offset(data1+offset));
-    VERIFY(areApprox(data1+offset, data2, PacketSize) && "ei_ploadu");
+    internal::pstore(data2, internal::ploadu(data1+offset));
+    VERIFY(areApprox(data1+offset, data2, PacketSize) && "internal::ploadu");
   }
 
   for (int offset=0; offset(data1));
-    VERIFY(areApprox(data1, data2+offset, PacketSize) && "ei_pstoreu");
+    internal::pstoreu(data2+offset, internal::pload(data1));
+    VERIFY(areApprox(data1, data2+offset, PacketSize) && "internal::pstoreu");
   }
 
   for (int offset=0; offset(data1);
-    packets[1] = ei_pload(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(data1);
+    packets[1] = internal::pload(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 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::ret)
-    CHECK_CWISE2(REF_DIV,  ei_pdiv);
+  if (!internal::is_same_type::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(data1[0]));
-  VERIFY(areApprox(ref, data2, PacketSize) && "ei_pset1");
+  internal::pstore(data2, internal::pset1(data1[0]));
+  VERIFY(areApprox(ref, data2, PacketSize) && "internal::pset1");
 
-  VERIFY(ei_isApprox(data1[0], ei_pfirst(ei_pload(data1))) && "ei_pfirst");
+  VERIFY(internal::isApprox(data1[0], internal::pfirst(internal::pload(data1))) && "internal::pfirst");
 
   ref[0] = 0;
   for (int i=0; i(data1)), refvalue) && "ei_predux");
+  VERIFY(isApproxAbs(ref[0], internal::predux(internal::pload(data1)), refvalue) && "internal::predux");
 
   ref[0] = 1;
   for (int i=0; i(data1))) && "ei_predux_mul");
+  VERIFY(internal::isApprox(ref[0], internal::predux_mul(internal::pload(data1))) && "internal::predux_mul");
 
   for (int j=0; j(data1+j*PacketSize);
+    packets[j] = internal::pload(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(data1)));
-  VERIFY(areApprox(ref, data2, PacketSize) && "ei_preverse");
+  internal::pstore(data2, internal::preverse(internal::pload(data1)));
+  VERIFY(areApprox(ref, data2, PacketSize) && "internal::preverse");
 }
 
 template void packetmath_real()
 {
-  typedef typename ei_packet_traits::type Packet;
-  const int PacketSize = ei_packet_traits::size;
+  typedef typename internal::packet_traits::type Packet;
+  const int PacketSize = internal::packet_traits::size;
 
   const int size = PacketSize*4;
-  EIGEN_ALIGN16 Scalar data1[ei_packet_traits::size*4];
-  EIGEN_ALIGN16 Scalar data2[ei_packet_traits::size*4];
-  EIGEN_ALIGN16 Scalar ref[ei_packet_traits::size*4];
+  EIGEN_ALIGN16 Scalar data1[internal::packet_traits::size*4];
+  EIGEN_ALIGN16 Scalar data2[internal::packet_traits::size*4];
+  EIGEN_ALIGN16 Scalar ref[internal::packet_traits::size*4];
 
   for (int i=0; i(-1e3,1e3);
-    data2[i] = ei_random(-1e3,1e3);
+    data1[i] = internal::random(-1e3,1e3);
+    data2[i] = internal::random(-1e3,1e3);
   }
-  CHECK_CWISE1_IF(ei_packet_traits::HasSin, ei_sin, ei_psin);
-  CHECK_CWISE1_IF(ei_packet_traits::HasCos, ei_cos, ei_pcos);
+  CHECK_CWISE1_IF(internal::packet_traits::HasSin, internal::sin, internal::psin);
+  CHECK_CWISE1_IF(internal::packet_traits::HasCos, internal::cos, internal::pcos);
 
   for (int i=0; i(-87,88);
-    data2[i] = ei_random(-87,88);
+    data1[i] = internal::random(-87,88);
+    data2[i] = internal::random(-87,88);
   }
-  CHECK_CWISE1_IF(ei_packet_traits::HasExp, ei_exp, ei_pexp);
+  CHECK_CWISE1_IF(internal::packet_traits::HasExp, internal::exp, internal::pexp);
 
   for (int i=0; i(0,1e6);
-    data2[i] = ei_random(0,1e6);
+    data1[i] = internal::random(0,1e6);
+    data2[i] = internal::random(0,1e6);
   }
-  CHECK_CWISE1_IF(ei_packet_traits::HasLog, ei_log, ei_plog);
-  CHECK_CWISE1_IF(ei_packet_traits::HasSqrt, ei_sqrt, ei_psqrt);
+  CHECK_CWISE1_IF(internal::packet_traits::HasLog, internal::log, internal::plog);
+  CHECK_CWISE1_IF(internal::packet_traits::HasSqrt, internal::sqrt, internal::psqrt);
 
   ref[0] = data1[0];
   for (int i=0; i(data1))) && "ei_predux_min");
+  VERIFY(internal::isApprox(ref[0], internal::predux_min(internal::pload(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(data1))) && "ei_predux_max");
+  VERIFY(internal::isApprox(ref[0], internal::predux_max(internal::pload(data1))) && "internal::predux_max");
 }
 
 template void packetmath_complex()
 {
-  typedef typename ei_packet_traits::type Packet;
-  const int PacketSize = ei_packet_traits::size;
+  typedef typename internal::packet_traits::type Packet;
+  const int PacketSize = internal::packet_traits::size;
 
   const int size = PacketSize*4;
   EIGEN_ALIGN16 Scalar data1[PacketSize*4];
@@ -263,52 +267,52 @@ template void packetmath_complex()
 
   for (int i=0; i() * Scalar(1e2);
-    data2[i] = ei_random() * Scalar(1e2);
+    data1[i] = internal::random() * Scalar(1e2);
+    data2[i] = internal::random() * Scalar(1e2);
   }
 
   {
-    ei_conj_helper cj;
-    ei_conj_helper pcj;
+    internal::conj_helper cj;
+    internal::conj_helper pcj;
     for(int i=0;i(data1),ei_pload(data2)));
+    internal::pstore(pval,pcj.pmul(internal::pload(data1),internal::pload(data2)));
     VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper");
   }
   {
-    ei_conj_helper cj;
-    ei_conj_helper pcj;
+    internal::conj_helper cj;
+    internal::conj_helper pcj;
     for(int i=0;i(data1),ei_pload(data2)));
+    internal::pstore(pval,pcj.pmul(internal::pload(data1),internal::pload(data2)));
     VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper");
   }
   {
-    ei_conj_helper cj;
-    ei_conj_helper pcj;
+    internal::conj_helper cj;
+    internal::conj_helper pcj;
     for(int i=0;i(data1),ei_pload(data2)));
+    internal::pstore(pval,pcj.pmul(internal::pload(data1),internal::pload(data2)));
     VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper");
   }
   {
-    ei_conj_helper cj;
-    ei_conj_helper pcj;
+    internal::conj_helper cj;
+    internal::conj_helper pcj;
     for(int i=0;i(data1),ei_pload(data2)));
+    internal::pstore(pval,pcj.pmul(internal::pload(data1),internal::pload(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(0, size-1);
+    Index i = internal::random(0, size-1);
     Index j;
-    do j = ei_random(0, size-1); while(j==i);
+    do j = internal::random(0, size-1); while(j==i);
     std::swap(v(i), v(j));
   }
 }
@@ -108,17 +108,17 @@ template void permutationmatrices(const MatrixType& m)
   if(rows>1 && cols>1)
   {
     lp2 = lp;
-    Index i = ei_random(0, rows-1);
+    Index i = internal::random(0, rows-1);
     Index j;
-    do j = ei_random(0, rows-1); while(j==i);
+    do j = internal::random(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());
 
     RightPermutationType rp2 = rp;
-    i = ei_random(0, cols-1);
-    do j = ei_random(0, cols-1); while(j==i);
+    i = internal::random(0, cols-1);
+    do j = internal::random(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 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::epsilon());
     MatrixType inv = m.inverse();
     double error = double( (m*inv-MatrixType::Identity()).norm() * absdet / NumTraits::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 void product(const MatrixType& m)
   ColVectorType vc2 = ColVectorType::Random(cols), vcres(cols);
   OtherMajorMatrixType tm1 = m1;
 
-  Scalar s1 = ei_random();
+  Scalar s1 = internal::random();
 
-  Index r  = ei_random(0, rows-1),
-        c  = ei_random(0, cols-1),
-        c2 = ei_random(0, cols-1);
+  Index r  = internal::random(0, rows-1),
+        c  = internal::random(0, cols-1),
+        c2 = internal::random(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 void product_extra(const MatrixType& m)
   ColVectorType vc2 = ColVectorType::Random(cols), vcres(cols);
   OtherMajorMatrixType tm1 = m1;
 
-  Scalar s1 = ei_random(),
-         s2 = ei_random(),
-         s3 = ei_random();
+  Scalar s1 = internal::random(),
+         s2 = internal::random(),
+         s3 = internal::random();
 
   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 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(0,m1.rows()-2);
-  Index j = ei_random(0,m1.cols()-2);
-  Index r = ei_random(1,m1.rows()-i);
-  Index c = ei_random(1,m1.cols()-j);
-  Index i2 = ei_random(0,m1.rows()-1);
-  Index j2 = ei_random(0,m1.cols()-1);
+  Index i = internal::random(0,m1.rows()-2);
+  Index j = internal::random(0,m1.cols()-2);
+  Index r = internal::random(1,m1.rows()-i);
+  Index c = internal::random(1,m1.cols()-j);
+  Index i2 = internal::random(0,m1.rows()-1);
+  Index j2 = internal::random(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 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(1,320), ei_random(1,320))) );
-    CALL_SUBTEST_2( product_extra(MatrixXd(ei_random(1,320), ei_random(1,320))) );
-    CALL_SUBTEST_3( product_extra(MatrixXcf(ei_random(1,150), ei_random(1,150))) );
-    CALL_SUBTEST_4( product_extra(MatrixXcd(ei_random(1,150), ei_random(1,150))) );
+    CALL_SUBTEST_1( product_extra(MatrixXf(internal::random(1,320), internal::random(1,320))) );
+    CALL_SUBTEST_2( product_extra(MatrixXd(internal::random(1,320), internal::random(1,320))) );
+    CALL_SUBTEST_3( product_extra(MatrixXcf(internal::random(1,150), internal::random(1,150))) );
+    CALL_SUBTEST_4( product_extra(MatrixXcd(internal::random(1,150), internal::random(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(1,320), ei_random(1,320))) );
-    CALL_SUBTEST_2( product(MatrixXd(ei_random(1,320), ei_random(1,320))) );
-    CALL_SUBTEST_3( product(MatrixXi(ei_random(1,320), ei_random(1,320))) );
-    CALL_SUBTEST_4( product(MatrixXcf(ei_random(1,150), ei_random(1,150))) );
-    CALL_SUBTEST_5( product(Matrix(ei_random(1,320), ei_random(1,320))) );
+    CALL_SUBTEST_1( product(MatrixXf(internal::random(1,320), internal::random(1,320))) );
+    CALL_SUBTEST_2( product(MatrixXd(internal::random(1,320), internal::random(1,320))) );
+    CALL_SUBTEST_3( product(MatrixXi(internal::random(1,320), internal::random(1,320))) );
+    CALL_SUBTEST_4( product(MatrixXcf(internal::random(1,150), internal::random(1,150))) );
+    CALL_SUBTEST_5( product(Matrix(internal::random(1,320), internal::random(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(10000,20000);
-    std::ptrdiff_t l2 = ei_random(1000000,2000000);
+    std::ptrdiff_t l1 = internal::random(10000,20000);
+    std::ptrdiff_t l2 = internal::random(1000000,2000000);
     setCpuCacheSizes(l1,l2);
     VERIFY(l1==l1CacheSize());
     VERIFY(l2==l2CacheSize());
-    std::ptrdiff_t k1 = ei_random(10,100)*16;
-    std::ptrdiff_t m1 = ei_random(10,100)*16;
-    std::ptrdiff_t n1 = ei_random(10,100)*16;
+    std::ptrdiff_t k1 = internal::random(10,100)*16;
+    std::ptrdiff_t m1 = internal::random(10,100)*16;
+    std::ptrdiff_t n1 = internal::random(10,100)*16;
     // only makes sure it compiles fine
-    computeProductBlockingSizes(k1,m1,n1);
+    internal::computeProductBlockingSizes(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 void product_notemporary(const MatrixType& m)
   ColVectorType vc2 = ColVectorType::Random(cols), cvres(cols);
   RowMajorMatrixType rm3(rows, cols);
 
-  Scalar s1 = ei_random(),
-         s2 = ei_random(),
-         s3 = ei_random();
+  Scalar s1 = internal::random(),
+         s2 = internal::random(),
+         s3 = internal::random();
 
-  Index c0 = ei_random(4,cols-8),
-        c1 = ei_random(8,cols-c0),
-        r0 = ei_random(4,cols-8),
-        r1 = ei_random(8,rows-r0);
+  Index c0 = internal::random(4,cols-8),
+        c1 = internal::random(8,cols-c0),
+        r0 = internal::random(4,cols-8),
+        r1 = internal::random(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(16,320);
+    s = internal::random(16,320);
     CALL_SUBTEST_1( product_notemporary(MatrixXf(s, s)) );
-    s = ei_random(16,320);
+    s = internal::random(16,320);
     CALL_SUBTEST_2( product_notemporary(MatrixXd(s, s)) );
-    s = ei_random(16,120);
+    s = internal::random(16,120);
     CALL_SUBTEST_3( product_notemporary(MatrixXcf(s,s)) );
-    s = ei_random(16,120);
+    s = internal::random(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 void product_selfadjoint(const MatrixType& m)
                 r2 = RowVectorType::Random(rows);
   RhsMatrixType m4 = RhsMatrixType::Random(rows,10);
 
-  Scalar s1 = ei_random(),
-         s2 = ei_random(),
-         s3 = ei_random();
+  Scalar s1 = internal::random(),
+         s2 = internal::random(),
+         s3 = internal::random();
 
   m1 = (m1.adjoint() + m1).eval();
 
@@ -83,13 +83,13 @@ void test_product_selfadjoint()
     CALL_SUBTEST_1( product_selfadjoint(Matrix()) );
     CALL_SUBTEST_2( product_selfadjoint(Matrix()) );
     CALL_SUBTEST_3( product_selfadjoint(Matrix3d()) );
-    s = ei_random(1,150);
+    s = internal::random(1,150);
     CALL_SUBTEST_4( product_selfadjoint(MatrixXcf(s, s)) );
-    s = ei_random(1,150);
+    s = internal::random(1,150);
     CALL_SUBTEST_5( product_selfadjoint(MatrixXcd(s,s)) );
-    s = ei_random(1,320);
+    s = internal::random(1,320);
     CALL_SUBTEST_6( product_selfadjoint(MatrixXd(s,s)) );
-    s = ei_random(1,320);
+    s = internal::random(1,320);
     CALL_SUBTEST_7( product_selfadjoint(Matrix(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 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(),
-         s2 = ei_random();
+  Scalar s1 = internal::random(),
+         s2 = internal::random();
 
   m2 = m1.template triangularView();
   m3 = m2.template selfadjointView();
@@ -98,14 +98,14 @@ void test_product_symm()
 {
   for(int i = 0; i < g_repeat ; i++)
   {
-    CALL_SUBTEST_1(( symm(ei_random(1,320),ei_random(1,320)) ));
-    CALL_SUBTEST_2(( symm(ei_random(1,320),ei_random(1,320)) ));
-    CALL_SUBTEST_3(( symm,Dynamic,Dynamic>(ei_random(1,200),ei_random(1,200)) ));
-    CALL_SUBTEST_4(( symm,Dynamic,Dynamic>(ei_random(1,200),ei_random(1,200)) ));
-
-    CALL_SUBTEST_5(( symm(ei_random(1,320)) ));
-    CALL_SUBTEST_6(( symm(ei_random(1,320)) ));
-    CALL_SUBTEST_7(( symm,Dynamic,1>(ei_random(1,320)) ));
-    CALL_SUBTEST_8(( symm,Dynamic,1>(ei_random(1,320)) ));
+    CALL_SUBTEST_1(( symm(internal::random(1,320),internal::random(1,320)) ));
+    CALL_SUBTEST_2(( symm(internal::random(1,320),internal::random(1,320)) ));
+    CALL_SUBTEST_3(( symm,Dynamic,Dynamic>(internal::random(1,200),internal::random(1,200)) ));
+    CALL_SUBTEST_4(( symm,Dynamic,Dynamic>(internal::random(1,200),internal::random(1,200)) ));
+
+    CALL_SUBTEST_5(( symm(internal::random(1,320)) ));
+    CALL_SUBTEST_6(( symm(internal::random(1,320)) ));
+    CALL_SUBTEST_7(( symm,Dynamic,1>(internal::random(1,320)) ));
+    CALL_SUBTEST_8(( symm,Dynamic,1>(internal::random(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 void syrk(const MatrixType& m)
   MatrixType m1 = MatrixType::Random(rows, cols),
              m2 = MatrixType::Random(rows, cols);
 
-  Rhs1 rhs1 = Rhs1::Random(ei_random(1,320), cols);
-  Rhs2 rhs2 = Rhs2::Random(rows, ei_random(1,320));
-  Rhs3 rhs3 = Rhs3::Random(ei_random(1,320), rows);
+  Rhs1 rhs1 = Rhs1::Random(internal::random(1,320), cols);
+  Rhs2 rhs2 = Rhs2::Random(rows, internal::random(1,320));
+  Rhs3 rhs3 = Rhs3::Random(internal::random(1,320), rows);
 
-  Scalar s1 = ei_random();
+  Scalar s1 = internal::random();
 
   m2.setZero();
   VERIFY_IS_APPROX((m2.template selfadjointView().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(1,320);
+    s = internal::random(1,320);
     CALL_SUBTEST_1( syrk(MatrixXf(s, s)) );
-    s = ei_random(1,320);
+    s = internal::random(1,320);
     CALL_SUBTEST_2( syrk(MatrixXd(s, s)) );
-    s = ei_random(1,200);
+    s = internal::random(1,200);
     CALL_SUBTEST_3( syrk(MatrixXcf(s, s)) );
-    s = ei_random(1,200);
+    s = internal::random(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 void trmm(int size,int /*othersize*/)
   typedef Matrix MatrixRowMaj;
 
   DenseIndex rows = size;
-  DenseIndex cols = ei_random(1,size);
+  DenseIndex cols = internal::random(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(),
-         s2 = ei_random();
+  Scalar s1 = internal::random(),
+         s2 = internal::random();
 
   triV.setRandom();
   triH.setRandom();
@@ -65,7 +65,7 @@ template void trmm(int size,int /*othersize*/)
   VERIFY_IS_APPROX( ge3 = ge1.adjoint() * triV.template triangularView(), ge1.adjoint() * loTri);
   VERIFY_IS_APPROX( ge3 = triH.template triangularView() * ge2.adjoint(), upTri * ge2.adjoint());
   VERIFY_IS_APPROX(rge3.noalias() = triH.template triangularView() * ge2.adjoint(), upTri * ge2.adjoint());
-  VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView() * ge2.adjoint(), ei_conj(s1) * loTri.adjoint() * ge2.adjoint());
+  VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView() * ge2.adjoint(), internal::conj(s1) * loTri.adjoint() * ge2.adjoint());
   VERIFY_IS_APPROX(rge3.noalias() = triV.adjoint().template triangularView() * ge2.adjoint(), loTri.adjoint() * ge2.adjoint());
   VERIFY_IS_APPROX( ge3 = triH.adjoint().template triangularView() * ge1.adjoint(), upTri.adjoint() * ge1.adjoint());
   VERIFY_IS_APPROX(rge3.noalias() = triH.adjoint().template triangularView() * ge1.adjoint(), upTri.adjoint() * ge1.adjoint());
@@ -73,21 +73,21 @@ template void trmm(int size,int /*othersize*/)
   VERIFY_IS_APPROX( ge3 = triV.template triangularView() * ge2, unitLoTri * ge2);
   VERIFY_IS_APPROX( rge3.noalias() = ge2 * triV.template triangularView(), ge2 * unitLoTri);
   VERIFY_IS_APPROX( ge3 = ge2 * triV.template triangularView(), ge2 * unitLoTri);
-  VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView() * ge2.adjoint(), ei_conj(s1) * unitLoTri.adjoint() * ge2.adjoint());
+  VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView() * ge2.adjoint(), internal::conj(s1) * unitLoTri.adjoint() * ge2.adjoint());
 
   VERIFY_IS_APPROX( ge3 = triV.template triangularView() * ge2, strictlyLoTri * ge2);
   VERIFY_IS_APPROX( rge3.noalias() = ge2 * triV.template triangularView(), ge2 * strictlyLoTri);
   VERIFY_IS_APPROX( ge3 = ge2 * triV.template triangularView(), ge2 * strictlyLoTri);
-  VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView() * ge2.adjoint(), ei_conj(s1) * strictlyLoTri.adjoint() * ge2.adjoint());
+  VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView() * 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(ei_random(1,320),ei_random(1,320))));
-    CALL_SUBTEST_2((trmm(ei_random(1,320),ei_random(1,320))));
-    CALL_SUBTEST_3((trmm >(ei_random(1,200),ei_random(1,200))));
-    CALL_SUBTEST_4((trmm >(ei_random(1,200),ei_random(1,200))));
+    CALL_SUBTEST_1((trmm(internal::random(1,320),internal::random(1,320))));
+    CALL_SUBTEST_2((trmm(internal::random(1,320),internal::random(1,320))));
+    CALL_SUBTEST_3((trmm >(internal::random(1,200),internal::random(1,200))));
+    CALL_SUBTEST_4((trmm >(internal::random(1,200),internal::random(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 void trmv(const MatrixType& m)
              m3(rows, cols);
   VectorType v1 = VectorType::Random(rows);
 
-  Scalar s1 = ei_random();
+  Scalar s1 = internal::random();
 
   m1 = MatrixType::Random(rows, cols);
 
@@ -93,11 +93,11 @@ void test_product_trmv()
     CALL_SUBTEST_1( trmv(Matrix()) );
     CALL_SUBTEST_2( trmv(Matrix()) );
     CALL_SUBTEST_3( trmv(Matrix3d()) );
-    s = ei_random(1,200);
+    s = internal::random(1,200);
     CALL_SUBTEST_4( trmv(MatrixXcf(s,s)) );
-    s = ei_random(1,200);
+    s = internal::random(1,200);
     CALL_SUBTEST_5( trmv(MatrixXcd(s,s)) );
-    s = ei_random(1,320);
+    s = internal::random(1,320);
     CALL_SUBTEST_6( trmv(Matrix(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(ei_random(1,320),ei_random(1,320))));
-    CALL_SUBTEST_2((trsolve(ei_random(1,320),ei_random(1,320))));
-    CALL_SUBTEST_3((trsolve,Dynamic,Dynamic>(ei_random(1,200),ei_random(1,200))));
-    CALL_SUBTEST_4((trsolve,Dynamic,Dynamic>(ei_random(1,200),ei_random(1,200))));
+    CALL_SUBTEST_1((trsolve(internal::random(1,320),internal::random(1,320))));
+    CALL_SUBTEST_2((trsolve(internal::random(1,320),internal::random(1,320))));
+    CALL_SUBTEST_3((trsolve,Dynamic,Dynamic>(internal::random(1,200),internal::random(1,200))));
+    CALL_SUBTEST_4((trsolve,Dynamic,Dynamic>(internal::random(1,200),internal::random(1,200))));
 
     // vectors
-    CALL_SUBTEST_5((trsolve,Dynamic,1>(ei_random(1,320))));
+    CALL_SUBTEST_5((trsolve,Dynamic,1>(internal::random(1,320))));
     CALL_SUBTEST_6((trsolve()));
     CALL_SUBTEST_7((trsolve()));
     CALL_SUBTEST_8((trsolve,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 void qr_invertible()
   typedef typename NumTraits::Real RealScalar;
   typedef typename MatrixType::Scalar Scalar;
 
-  int size = ei_random(10,50);
+  int size = internal::random(10,50);
 
   MatrixType m1(size, size), m2(size, size), m3(size, size);
   m1 = MatrixType::Random(size,size);
 
-  if (ei_is_same_type::ret)
+  if (internal::is_same_type::ret)
   {
     // let's build a matrix more stable to inverse
     MatrixType a = MatrixType::Random(size,size*2);
@@ -90,13 +90,13 @@ template void qr_invertible()
 
   // now construct a matrix with prescribed determinant
   m1.setZero();
-  for(int i = 0; i < size; i++) m1(i,i) = ei_random();
-  RealScalar absdet = ei_abs(m1.diagonal().prod());
+  for(int i = 0; i < size; i++) m1(i,i) = internal::random();
+  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 void qr_verify_assert()
@@ -114,8 +114,8 @@ template void qr_verify_assert()
 void test_qr()
 {
   for(int i = 0; i < g_repeat; i++) {
-   CALL_SUBTEST_1( qr(MatrixXf(ei_random(1,200),ei_random(1,200))) );
-   CALL_SUBTEST_2( qr(MatrixXcd(ei_random(1,200),ei_random(1,200))) );
+   CALL_SUBTEST_1( qr(MatrixXf(internal::random(1,200),internal::random(1,200))) );
+   CALL_SUBTEST_2( qr(MatrixXcd(internal::random(1,200),internal::random(1,200))) );
    CALL_SUBTEST_3(( qr_fixedsize, 2 >() ));
    CALL_SUBTEST_4(( qr_fixedsize, 4 >() ));
    CALL_SUBTEST_5(( qr_fixedsize, 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 void qr()
 {
   typedef typename MatrixType::Index Index;
 
-  Index rows = ei_random(2,200), cols = ei_random(2,200), cols2 = ei_random(2,200);
-  Index rank = ei_random(1, std::min(rows, cols)-1);
+  Index rows = internal::random(2,200), cols = internal::random(2,200), cols2 = internal::random(2,200);
+  Index rank = internal::random(1, std::min(rows, cols)-1);
 
   typedef typename MatrixType::Scalar Scalar;
   typedef typename MatrixType::RealScalar RealScalar;
@@ -64,7 +64,7 @@ template void qr_fixedsize()
 {
   enum { Rows = MatrixType::RowsAtCompileTime, Cols = MatrixType::ColsAtCompileTime };
   typedef typename MatrixType::Scalar Scalar;
-  int rank = ei_random(1, std::min(int(Rows), int(Cols))-1);
+  int rank = internal::random(1, std::min(int(Rows), int(Cols))-1);
   Matrix m1;
   createRandomPIMatrixOfRank(rank,Rows,Cols,m1);
   ColPivHouseholderQR > qr(m1);
@@ -90,12 +90,12 @@ template void qr_invertible()
   typedef typename NumTraits::Real RealScalar;
   typedef typename MatrixType::Scalar Scalar;
 
-  int size = ei_random(10,50);
+  int size = internal::random(10,50);
 
   MatrixType m1(size, size), m2(size, size), m3(size, size);
   m1 = MatrixType::Random(size,size);
 
-  if (ei_is_same_type::ret)
+  if (internal::is_same_type::ret)
   {
     // let's build a matrix more stable to inverse
     MatrixType a = MatrixType::Random(size,size*2);
@@ -109,13 +109,13 @@ template void qr_invertible()
 
   // now construct a matrix with prescribed determinant
   m1.setZero();
-  for(int i = 0; i < size; i++) m1(i,i) = ei_random();
-  RealScalar absdet = ei_abs(m1.diagonal().prod());
+  for(int i = 0; i < size; i++) m1(i,i) = internal::random();
+  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 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 void qr()
 {
   typedef typename MatrixType::Index Index;
 
-  Index rows = ei_random(20,200), cols = ei_random(20,200), cols2 = ei_random(20,200);
-  Index rank = ei_random(1, std::min(rows, cols)-1);
+  Index rows = internal::random(20,200), cols = internal::random(20,200), cols2 = internal::random(20,200);
+  Index rank = internal::random(1, std::min(rows, cols)-1);
 
   typedef typename MatrixType::Scalar Scalar;
   typedef Matrix MatrixQType;
@@ -69,12 +69,12 @@ template void qr_invertible()
   typedef typename NumTraits::Real RealScalar;
   typedef typename MatrixType::Scalar Scalar;
 
-  int size = ei_random(10,50);
+  int size = internal::random(10,50);
 
   MatrixType m1(size, size), m2(size, size), m3(size, size);
   m1 = MatrixType::Random(size,size);
 
-  if (ei_is_same_type::ret)
+  if (internal::is_same_type::ret)
   {
     // let's build a matrix more stable to inverse
     MatrixType a = MatrixType::Random(size,size*2);
@@ -92,13 +92,13 @@ template void qr_invertible()
 
   // now construct a matrix with prescribed determinant
   m1.setZero();
-  for(int i = 0; i < size; i++) m1(i,i) = ei_random();
-  RealScalar absdet = ei_abs(m1.diagonal().prod());
+  for(int i = 0; i < size; i++) m1(i,i) = internal::random();
+  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 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 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(0,rows-1);
-  Index c0 = ei_random(0,cols-1);
-  Index r1 = ei_random(r0+1,rows)-r0;
-  Index c1 = ei_random(c0+1,cols)-c0;
+  Index r0 = internal::random(0,rows-1);
+  Index c0 = internal::random(0,cols-1);
+  Index r1 = internal::random(r0+1,rows)-r0;
+  Index c1 = internal::random(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 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 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 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 void schur(int size = MatrixType::ColsAtCompileTim
 void test_schur_complex()
 {
   CALL_SUBTEST_1(( schur() ));
-  CALL_SUBTEST_2(( schur(ei_random(1,50)) ));
+  CALL_SUBTEST_2(( schur(internal::random(1,50)) ));
   CALL_SUBTEST_3(( schur, 1, 1> >() ));
   CALL_SUBTEST_4(( schur >() ));
 
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 void schur(int size = MatrixType::ColsAtCompileTim
 void test_schur_real()
 {
   CALL_SUBTEST_1(( schur() ));
-  CALL_SUBTEST_2(( schur(ei_random(1,50)) ));
+  CALL_SUBTEST_2(( schur(internal::random(1,50)) ));
   CALL_SUBTEST_3(( schur >() ));
   CALL_SUBTEST_4(( schur >() ));
 
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(1,20); EIGEN_UNUSED_VARIABLE(s);
+    int s = internal::random(1,20); EIGEN_UNUSED_VARIABLE(s);
 
     CALL_SUBTEST_1( selfadjoint(Matrix()) );
     CALL_SUBTEST_2( selfadjoint(Matrix()) );
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 void smallVectors()
   typedef Matrix V2;
   typedef Matrix V3;
   typedef Matrix V4;
-  Scalar x1 = ei_random(),
-         x2 = ei_random(),
-         x3 = ei_random(),
-         x4 = ei_random();
+  Scalar x1 = internal::random(),
+         x2 = internal::random(),
+         x3 = internal::random(),
+         x4 = internal::random();
   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(0,1) < density) ? ei_random() : Scalar(0);
+      Scalar v = (internal::random(0,1) < density) ? internal::random() : Scalar(0);
       if ((flags&ForceNonZeroDiag) && (i==j))
       {
-        v = ei_random()*Scalar(3.);
+        v = internal::random()*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(0,1) < density) ? ei_random() : Scalar(0);
+      Scalar v = (internal::random(0,1) < density) ? internal::random() : Scalar(0);
       if ((flags&ForceNonZeroDiag) && (i==j))
       {
-        v = ei_random()*Scalar(3.);
+        v = internal::random()*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(0,1) < density) ? ei_random() : Scalar(0);
+    Scalar v = (internal::random(0,1) < density) ? internal::random() : 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 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 s1 = internal::random();
 
   std::vector zeroCoords;
   std::vector nonzeroCoords;
@@ -54,7 +54,7 @@ template 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 >::ret)
+    if(internal::is_same_type >::ret)
       VERIFY_RAISES_ASSERT( m.coeffRef(zeroCoords[0].x(),zeroCoords[0].y()) = 5 );
   }
   VERIFY_IS_APPROX(m, refMat);
@@ -67,10 +67,10 @@ template void sparse_basic(const SparseMatrixType& re
   // test InnerIterators and Block expressions
   for (int t=0; t<10; ++t)
   {
-    int j = ei_random(0,cols-1);
-    int i = ei_random(0,rows-1);
-    int w = ei_random(1,cols-j-1);
-    int h = ei_random(1,rows-i-1);
+    int j = internal::random(0,cols-1);
+    int i = internal::random(0,rows-1);
+    int w = internal::random(1,cols-j-1);
+    int h = internal::random(1,rows-i-1);
 
 //     VERIFY_IS_APPROX(m.block(i,j,h,w), refMat.block(i,j,h,w));
     for(int c=0; c void sparse_basic(const SparseMatrixType& re
       {
         for (int k=0; k(0,rows-1);
+          int i = internal::random(0,rows-1);
           if (m1.coeff(i,j)==Scalar(0))
-            m2.insert(i,j) = m1(i,j) = ei_random();
+            m2.insert(i,j) = m1(i,j) = internal::random();
         }
       }
       m2.finalize();
@@ -131,10 +131,10 @@ template void sparse_basic(const SparseMatrixType& re
       m2.reserve(10);
       for (int k=0; k(0,rows-1);
-        int j = ei_random(0,cols-1);
+        int i = internal::random(0,rows-1);
+        int j = internal::random(0,cols-1);
         if (m1.coeff(i,j)==Scalar(0))
-          m2.insert(i,j) = m1(i,j) = ei_random();
+          m2.insert(i,j) = m1(i,j) = internal::random();
       }
       m2.finalize();
       VERIFY_IS_APPROX(m2,m1);
@@ -190,8 +190,8 @@ template void sparse_basic(const SparseMatrixType& re
     DenseMatrix refMat2 = DenseMatrix::Zero(rows, rows);
     SparseMatrixType m2(rows, rows);
     initSparse(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 void sparse_basic(const SparseMatrixType& re
     DenseMatrix refMat2 = DenseMatrix::Zero(rows, rows);
     SparseMatrixType m2(rows, rows);
     initSparse(density, refMat2, m2);
-    int j0 = ei_random(0,rows-2);
-    int j1 = ei_random(0,rows-2);
-    int n0 = ei_random(1,rows-std::max(j0,j1));
+    int j0 = internal::random(0,rows-2);
+    int j1 = internal::random(0,rows-2);
+    int n0 = internal::random(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 void sparse_basic(const SparseMatrixType& re
       m2.startVec(j);
       for (int i=0; i(0,1);
+        float x = internal::random(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 void sparse_product(const SparseMatrixType&
   typedef Matrix DenseMatrix;
   typedef Matrix DenseVector;
 
-  Scalar s1 = ei_random();
-  Scalar s2 = ei_random();
+  Scalar s1 = internal::random();
+  Scalar s2 = internal::random();
 
   // test matrix-matrix product
   {
@@ -54,7 +54,7 @@ template void sparse_product(const SparseMatrixType&
     initSparse(density, refMat3, m3);
     initSparse(density, refMat4, m4);
 
-    int c = ei_random(0,rows-1);
+    int c = internal::random(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(8, 8) );
-    int s = ei_random(1,300);
+    int s = internal::random(1,300);
     CALL_SUBTEST_2(sparse_solvers >(s,s) );
     CALL_SUBTEST_1(sparse_solvers(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 void sparse_vector(int rows, int cols)
   initSparse(densityVec, refV2, v2);
   initSparse(densityVec, refV3, v3);
 
-  Scalar s1 = ei_random();
+  Scalar s1 = internal::random();
 
   // test coeff and coeffRef
   for (unsigned int i=0; i void stable_norm(const MatrixType& m)
   Index rows = m.rows();
   Index cols = m.cols();
 
-  Scalar big = ei_random() * (std::numeric_limits::max() * RealScalar(1e-4));
+  Scalar big = internal::random() * (std::numeric_limits::max() * RealScalar(1e-4));
   Scalar small = static_cast(1)/big;
 
   MatrixType  vzero = MatrixType::Zero(rows, cols),
@@ -75,33 +75,33 @@ template void stable_norm(const MatrixType& m)
 
   // test isFinite
   VERIFY(!isFinite( std::numeric_limits::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::size>1)
+  if(internal::packet_traits::size>1)
   {
-    VERIFY_IS_NOT_APPROX(static_cast(vbig.norm()),   ei_sqrt(size)*big); // here the default norm must fail
+    VERIFY_IS_NOT_APPROX(static_cast(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::size>1)
+  if(internal::packet_traits::size>1)
   {
-    VERIFY_IS_NOT_APPROX(static_cast(vsmall.norm()),   ei_sqrt(size)*small); // here the default norm must fail
+    VERIFY_IS_NOT_APPROX(static_cast(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()) );
     CALL_SUBTEST_2( stable_norm(Vector4d()) );
-    CALL_SUBTEST_3( stable_norm(VectorXd(ei_random(10,2000))) );
-    CALL_SUBTEST_4( stable_norm(VectorXf(ei_random(10,2000))) );
-    CALL_SUBTEST_5( stable_norm(VectorXcd(ei_random(10,2000))) );
+    CALL_SUBTEST_3( stable_norm(VectorXd(internal::random(10,2000))) );
+    CALL_SUBTEST_4( stable_norm(VectorXf(internal::random(10,2000))) );
+    CALL_SUBTEST_5( stable_norm(VectorXcd(internal::random(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 void swap(const MatrixType& m)
   typedef typename other_matrix_type::type OtherMatrixType;
   typedef typename MatrixType::Scalar Scalar;
 
-  ei_assert((!ei_is_same_type::ret));
+  eigen_assert((!internal::is_same_type::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 void triangular_square(const MatrixType& m)
 
   m1 = MatrixType::Random(rows, cols);
   for (int i=0; i();
+    while (internal::abs2(m1(i,i))<1e-1) m1(i,i) = internal::random();
 
   Transpose 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(2,20); EIGEN_UNUSED_VARIABLE(r);
-    int c = ei_random(2,20); EIGEN_UNUSED_VARIABLE(c);
+    int r = internal::random(2,20); EIGEN_UNUSED_VARIABLE(r);
+    int c = internal::random(2,20); EIGEN_UNUSED_VARIABLE(c);
 
     CALL_SUBTEST_1( triangular_square(Matrix()) );
     CALL_SUBTEST_2( triangular_square(Matrix()) );
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 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 randMatrixSpecialUnitary(int si
   MatrixType Q = randMatrixUnitary(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 randMatrixSpecialUnitary(int si
 template 
 void run_test(int dim, int num_elements)
 {
-  typedef typename ei_traits::Scalar Scalar;
+  typedef typename internal::traits::Scalar Scalar;
   typedef Matrix MatrixX;
   typedef Matrix 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());
+  const Scalar c = internal::abs(internal::random());
 
   MatrixX R = randMatrixSpecialUnitary(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());
+  const Scalar c = internal::abs(internal::random());
 
   FixedMatrix R = randMatrixSpecialUnitary(dim);
   FixedVector t = Scalar(50)*FixedVector::Random(dim,1);
@@ -175,7 +175,7 @@ void test_umeyama()
 {
   for (int i=0; i(40,500);
+    const int num_elements = internal::random(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
 bool test_assign(const Dst&, const Src&, int traversal, int unrolling)
 {
-  ei_assign_traits::debug();
-  bool res = ei_assign_traits::Traversal==traversal
-          && ei_assign_traits::Unrolling==unrolling;
+  internal::assign_traits::debug();
+  bool res = internal::assign_traits::Traversal==traversal
+          && internal::assign_traits::Unrolling==unrolling;
   if(!res)
   {
     std::cerr << " Expected Traversal == " << demangle_traversal(traversal)
-              << " got " << demangle_traversal(ei_assign_traits::Traversal) << "\n";
+              << " got " << demangle_traversal(internal::assign_traits::Traversal) << "\n";
     std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling)
-              << " got " << demangle_unrolling(ei_assign_traits::Unrolling) << "\n";
+              << " got " << demangle_unrolling(internal::assign_traits::Unrolling) << "\n";
   }
   return res;
 }
@@ -62,15 +62,15 @@ bool test_assign(const Dst&, const Src&, int traversal, int unrolling)
 template
 bool test_assign(int traversal, int unrolling)
 {
-  ei_assign_traits::debug();
-  bool res = ei_assign_traits::Traversal==traversal
-          && ei_assign_traits::Unrolling==unrolling;
+  internal::assign_traits::debug();
+  bool res = internal::assign_traits::Traversal==traversal
+          && internal::assign_traits::Unrolling==unrolling;
   if(!res)
   {
     std::cerr << " Expected Traversal == " << demangle_traversal(traversal)
-              << " got " << demangle_traversal(ei_assign_traits::Traversal) << "\n";
+              << " got " << demangle_traversal(internal::assign_traits::Traversal) << "\n";
     std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling)
-              << " got " << demangle_unrolling(ei_assign_traits::Unrolling) << "\n";
+              << " got " << demangle_unrolling(internal::assign_traits::Unrolling) << "\n";
   }
   return res;
 }
@@ -78,7 +78,7 @@ bool test_assign(int traversal, int unrolling)
 template
 bool test_redux(const Xpr&, int traversal, int unrolling)
 {
-  typedef ei_redux_traits,Xpr> traits;
+  typedef internal::redux_traits,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::Vectorizable> struct vectorization_logic
+template::Vectorizable> struct vectorization_logic
 {
   enum {
-    PacketSize = ei_packet_traits::size
+    PacketSize = internal::packet_traits::size
   };
   static void run()
   {
@@ -221,7 +221,7 @@ void test_vectorization_logic()
   vectorization_logic >::run();
   vectorization_logic >::run();
   
-  if(ei_packet_traits::Vectorizable)
+  if(internal::packet_traits::Vectorizable)
   {
     VERIFY(test_assign(Matrix(),Matrix()+Matrix(),
       LinearTraversal,CompleteUnrolling));
@@ -230,7 +230,7 @@ void test_vectorization_logic()
       DefaultTraversal,CompleteUnrolling));
   }
   
-  if(ei_packet_traits::Vectorizable)
+  if(internal::packet_traits::Vectorizable)
   {
     VERIFY(test_assign(Matrix(),Matrix()+Matrix(),
       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 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();
+        m(i) = internal::random();
   
   Scalar minc = Scalar(1000), maxc = Scalar(-1000);
   Index minrow=0,mincol=0,maxrow=0,maxcol=0;
@@ -85,7 +85,7 @@ template 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();
+        v(i) = internal::random();
   
   Scalar minc = Scalar(1000), maxc = Scalar(-1000);
   Index minidx=0,maxidx=0;
diff --git a/unsupported/Eigen/AdolcForward b/unsupported/Eigen/AdolcForward
index 8f1a00d20..1ecf98794 100644
--- a/unsupported/Eigen/AdolcForward
+++ b/unsupported/Eigen/AdolcForward
@@ -66,7 +66,7 @@ namespace Eigen {
   * see https://projects.coin-or.org/ADOL-C for more information.
   * It mainly consists in:
   *  - a struct Eigen::NumTraits specialization
-  *  - overloads of ei_* math function for adtl::adouble type.
+  *  - overloads of internal::* math function for adtl::adouble type.
   *
   * Note that the maximal number of directions is controlled by
   * the preprocessor token NUMBER_DIRECTIONS. The default is 2.
@@ -80,21 +80,25 @@ namespace Eigen {
 } // namespace Eigen
 
 // the Adolc's type adouble is defined in the adtl namespace
-// therefore, the following ei_* functions *must* be defined
+// therefore, the following internal::* functions *must* be defined
 // in the same namespace
 namespace adtl {
 
-  inline const adouble& ei_conj(const adouble& x)  { return x; }
-  inline const adouble& ei_real(const adouble& x)  { return x; }
-  inline adouble ei_imag(const adouble&)    { return 0.; }
-  inline adouble ei_abs(const adouble&  x)  { return fabs(x); }
-  inline adouble ei_abs2(const adouble& x)  { return x*x; }
-  inline adouble ei_sqrt(const adouble& x)  { return sqrt(x); }
-  inline adouble ei_exp(const adouble&  x)  { return exp(x); }
-  inline adouble ei_log(const adouble&  x)  { return log(x); }
-  inline adouble ei_sin(const adouble&  x)  { return sin(x); }
-  inline adouble ei_cos(const adouble&  x)  { return cos(x); }
-  inline adouble ei_pow(const adouble& x, adouble y)  { return pow(x, y); }
+  namespace internal {
+
+  inline const adouble& internal::conj(const adouble& x)  { return x; }
+  inline const adouble& internal::real(const adouble& x)  { return x; }
+  inline adouble internal::imag(const adouble&)    { return 0.; }
+  inline adouble internal::abs(const adouble&  x)  { return fabs(x); }
+  inline adouble internal::abs2(const adouble& x)  { return x*x; }
+  inline adouble internal::sqrt(const adouble& x)  { return sqrt(x); }
+  inline adouble internal::exp(const adouble&  x)  { return exp(x); }
+  inline adouble internal::log(const adouble&  x)  { return log(x); }
+  inline adouble internal::sin(const adouble&  x)  { return sin(x); }
+  inline adouble internal::cos(const adouble&  x)  { return cos(x); }
+  inline adouble internal::pow(const adouble& x, adouble y)  { return pow(x, y); }
+
+  }
 
 }
 
@@ -140,7 +144,7 @@ public:
 
   void operator() (const InputType& x, ValueType* v, JacobianType* _jac) const
   {
-    ei_assert(v!=0);
+    eigen_assert(v!=0);
     if (!_jac)
     {
       Functor::operator()(x, v);
diff --git a/unsupported/Eigen/AlignedVector3 b/unsupported/Eigen/AlignedVector3
index 7efe4ac21..804142a00 100644
--- a/unsupported/Eigen/AlignedVector3
+++ b/unsupported/Eigen/AlignedVector3
@@ -52,10 +52,12 @@ namespace Eigen {
 // TODO specialize Cwise
 template class AlignedVector3;
 
-template struct ei_traits >
-  : ei_traits >
+namespace internal {
+template struct traits >
+  : traits >
 {
 };
+}
 
 template class AlignedVector3
   : public MatrixBase >
@@ -151,8 +153,8 @@ template class AlignedVector3
 
     inline Scalar dot(const AlignedVector3& other) const
     {
-      ei_assert(m_coeffs.w()==Scalar(0));
-      ei_assert(other.m_coeffs.w()==Scalar(0));
+      eigen_assert(m_coeffs.w()==Scalar(0));
+      eigen_assert(other.m_coeffs.w()==Scalar(0));
       return m_coeffs.dot(other.m_coeffs);
     }
 
@@ -168,19 +170,19 @@ template class AlignedVector3
 
     inline Scalar sum() const
     {
-      ei_assert(m_coeffs.w()==Scalar(0));
+      eigen_assert(m_coeffs.w()==Scalar(0));
       return m_coeffs.sum();
     }
 
     inline Scalar squaredNorm() const
     {
-      ei_assert(m_coeffs.w()==Scalar(0));
+      eigen_assert(m_coeffs.w()==Scalar(0));
       return m_coeffs.squaredNorm();
     }
 
     inline Scalar norm() const
     {
-      return ei_sqrt(squaredNorm());
+      return internal::sqrt(squaredNorm());
     }
 
     inline AlignedVector3 cross(const AlignedVector3& other) const
diff --git a/unsupported/Eigen/FFT b/unsupported/Eigen/FFT
index a72198ccf..592898078 100644
--- a/unsupported/Eigen/FFT
+++ b/unsupported/Eigen/FFT
@@ -88,23 +88,23 @@
 #  include 
    namespace Eigen {
 #    include "src/FFT/ei_fftw_impl.h"
-     //template  typedef struct ei_fftw_impl  default_fft_impl; this does not work
-     template  struct default_fft_impl : public ei_fftw_impl {};
+     //template  typedef struct internal::fftw_impl  default_fft_impl; this does not work
+     template  struct default_fft_impl : public internal::fftw_impl {};
    }
 #elif defined EIGEN_MKL_DEFAULT
 // TODO 
 // intel Math Kernel Library: fastest, commercial -- may be incompatible with Eigen in GPL form
    namespace Eigen {
 #    include "src/FFT/ei_imklfft_impl.h"
-     template  struct default_fft_impl : public ei_imklfft_impl {};
+     template  struct default_fft_impl : public internal::imklfft_impl {};
    }
 #else
-// ei_kissfft_impl:  small, free, reasonably efficient default, derived from kissfft
+// internal::kissfft_impl:  small, free, reasonably efficient default, derived from kissfft
 //
   namespace Eigen {
 #   include "src/FFT/ei_kissfft_impl.h"
      template  
-       struct default_fft_impl : public ei_kissfft_impl {};
+       struct default_fft_impl : public internal::kissfft_impl {};
   }
 #endif
 
@@ -115,16 +115,18 @@ namespace Eigen {
 template struct fft_fwd_proxy;
 template struct fft_inv_proxy;
 
+namespace internal {
 template
-struct ei_traits< fft_fwd_proxy >
+struct traits< fft_fwd_proxy >
 {
   typedef typename T_SrcMat::PlainObject ReturnType;
 };
 template
-struct ei_traits< fft_inv_proxy >
+struct traits< fft_inv_proxy >
 {
   typedef typename T_SrcMat::PlainObject ReturnType;
 };
+}
 
 template 
 struct fft_fwd_proxy
@@ -238,7 +240,7 @@ class FFT
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(InputDerived)
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(ComplexDerived)
       EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(ComplexDerived,InputDerived) // size at compile-time
-      EIGEN_STATIC_ASSERT((ei_is_same_type::ret),
+      EIGEN_STATIC_ASSERT((internal::is_same_type::ret),
             YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
       EIGEN_STATIC_ASSERT(int(InputDerived::Flags)&int(ComplexDerived::Flags)&DirectAccessBit,
             THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_WITH_DIRECT_MEMORY_ACCESS_SUCH_AS_MAP_OR_PLAIN_MATRICES)
@@ -307,7 +309,7 @@ class FFT
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(OutputDerived)
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(ComplexDerived)
       EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(ComplexDerived,OutputDerived) // size at compile-time
-      EIGEN_STATIC_ASSERT((ei_is_same_type::ret),
+      EIGEN_STATIC_ASSERT((internal::is_same_type::ret),
             YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
       EIGEN_STATIC_ASSERT(int(OutputDerived::Flags)&int(ComplexDerived::Flags)&DirectAccessBit,
             THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_WITH_DIRECT_MEMORY_ACCESS_SUCH_AS_MAP_OR_PLAIN_MATRICES)
diff --git a/unsupported/Eigen/MPRealSupport b/unsupported/Eigen/MPRealSupport
index abc719ba7..0d60cd99a 100644
--- a/unsupported/Eigen/MPRealSupport
+++ b/unsupported/Eigen/MPRealSupport
@@ -102,7 +102,9 @@ int main()
     }
   };
 
-  template<> mpfr::mpreal ei_random()
+  namespace internal {
+
+  template<> mpfr::mpreal random()
   {
 #if (MPFR_VERSION >= MPFR_VERSION_NUM(3,0,0))
     static gmp_randstate_t state;
@@ -117,44 +119,50 @@ int main()
 
     return mpfr::urandom(state)*2-1;
 #else
-    return mpfr::mpreal(ei_random());
+    return mpfr::mpreal(random());
 #endif
   }
 
-  template<> mpfr::mpreal ei_random(const mpfr::mpreal& a, const mpfr::mpreal& b)
+  template<> mpfr::mpreal random(const mpfr::mpreal& a, const mpfr::mpreal& b)
   {
-    return a + (b-a) * ei_random();
+    return a + (b-a) * random();
   }
+
+  } // end namespace internal
 }
 
 namespace mpfr {
 
-  inline const mpreal& ei_conj(const mpreal& x)  { return x; }
-  inline const mpreal& ei_real(const mpreal& x)  { return x; }
-  inline mpreal ei_imag(const mpreal&)    { return 0.0; }
-  inline mpreal ei_abs(const mpreal&  x)  { return fabs(x); }
-  inline mpreal ei_abs2(const mpreal& x)  { return x*x; }
-  inline mpreal ei_sqrt(const mpreal& x)  { return sqrt(x); }
-  inline mpreal ei_exp(const mpreal&  x)  { return exp(x); }
-  inline mpreal ei_log(const mpreal&  x)  { return log(x); }
-  inline mpreal ei_sin(const mpreal&  x)  { return sin(x); }
-  inline mpreal ei_cos(const mpreal&  x)  { return cos(x); }
-  inline mpreal ei_pow(const mpreal& x, mpreal& y)  { return pow(x, y); }
-
-  bool ei_isMuchSmallerThan(const mpreal& a, const mpreal& b, const mpreal& prec)
+  namespace internal {
+
+  inline const mpreal& conj(const mpreal& x)  { return x; }
+  inline const mpreal& real(const mpreal& x)  { return x; }
+  inline mpreal imag(const mpreal&)    { return 0.0; }
+  inline mpreal abs(const mpreal&  x)  { return mpfr::fabs(x); }
+  inline mpreal abs2(const mpreal& x)  { return x*x; }
+  inline mpreal sqrt(const mpreal& x)  { return mpfr::sqrt(x); }
+  inline mpreal exp(const mpreal&  x)  { return mpfr::exp(x); }
+  inline mpreal log(const mpreal&  x)  { return mpfr::log(x); }
+  inline mpreal sin(const mpreal&  x)  { return mpfr::sin(x); }
+  inline mpreal cos(const mpreal&  x)  { return mpfr::cos(x); }
+  inline mpreal pow(const mpreal& x, mpreal& y)  { return mpfr::pow(x, y); }
+
+  bool isMuchSmallerThan(const mpreal& a, const mpreal& b, const mpreal& prec)
   {
-    return ei_abs(a) <= abs(b) * prec;
+    return mpfr::abs(a) <= mpfr::abs(b) * prec;
   }
 
-  inline bool ei_isApprox(const mpreal& a, const mpreal& b, const mpreal& prec)
+  inline bool isApprox(const mpreal& a, const mpreal& b, const mpreal& prec)
   {
-  return ei_abs(a - b) <= min(abs(a), abs(b)) * prec;
+  return mpfr::abs(a - b) <= mpfr::min(mpfr::abs(a), mpfr::abs(b)) * prec;
   }
 
-  inline bool ei_isApproxOrLessThan(const mpreal& a, const mpreal& b, const mpreal& prec)
+  inline bool isApproxOrLessThan(const mpreal& a, const mpreal& b, const mpreal& prec)
   {
-    return a <= b || ei_isApprox(a, b, prec);
+    return a <= b || isApprox(a, b, prec);
   }
+
+  } // end namespace internal
 }
 
 #endif // EIGEN_MPREALSUPPORT_MODULE_H
diff --git a/unsupported/Eigen/MatrixFunctions b/unsupported/Eigen/MatrixFunctions
index e0bc4732c..d39c49e53 100644
--- a/unsupported/Eigen/MatrixFunctions
+++ b/unsupported/Eigen/MatrixFunctions
@@ -176,7 +176,7 @@ Output: \verbinclude MatrixExponential.out
 Compute a matrix function.
 
 \code
-const MatrixFunctionReturnValue MatrixBase::matrixFunction(typename ei_stem_function::Scalar>::type f) const
+const MatrixFunctionReturnValue MatrixBase::matrixFunction(typename internal::stem_function::Scalar>::type f) const
 \endcode
 
 \param[in]  M  argument of matrix function, should be a square matrix.
diff --git a/unsupported/Eigen/OpenGLSupport b/unsupported/Eigen/OpenGLSupport
index 51d890a19..b967f0d7a 100644
--- a/unsupported/Eigen/OpenGLSupport
+++ b/unsupported/Eigen/OpenGLSupport
@@ -63,30 +63,30 @@ template< typename XprType,
           bool IsGLCompatible = bool(XprType::Flags&LinearAccessBit)                                                \
                              && bool(XprType::Flags&DirectAccessBit)                                                \
                              && (XprType::IsVectorAtCompileTime || (XprType::Flags&RowMajorBit)==0)>                \
-struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl);                                                                     \
+struct EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl);                                                                     \
                                                                                                                     \
 template                                                     \
-struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl) {                                    \
+struct EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl) {                                    \
   inline static void run(const XprType& p) {                                                                        \
-    EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)::type>::run(p); }   \
+    EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)::type>::run(p); }   \
 };                                                                                                                  \
                                                                                                                     \
 template inline void FUNC(const Eigen::DenseBase& p) {                                   \
-  EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)::run(p.derived());                                               \
+  EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)::run(p.derived());                                               \
 }
 
 
 #define EIGEN_GL_FUNC_SPECIALIZATION_MAT(FUNC,SCALAR,ROWS,COLS,SUFFIX)                                              \
-  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl) {   \
+  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl) {   \
     inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }                                            \
   };
 
   
 #define EIGEN_GL_FUNC_SPECIALIZATION_VEC(FUNC,SCALAR,SIZE,SUFFIX)                                                   \
-  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl) {      \
+  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl) {      \
     inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }                                            \
   };                                                                                                                \
-  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl) {      \
+  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl) {      \
     inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }                                            \
   };
 
@@ -202,6 +202,9 @@ template void glRotate(const RotationBase& rot)
 #define EIGEN_GL_EVAL(X) X
 
 #define EIGEN_GL_FUNC1_DECLARATION(FUNC,ARG1,CONST)                                                                             \
+                                                                                                                                \
+namespace internal {                                                                                                                  \
+                                                                                                                                \
 template< typename XprType,                                                                                                     \
           typename Scalar = typename XprType::Scalar,                                                                           \
           int Rows = XprType::RowsAtCompileTime,                                                                                \
@@ -209,32 +212,38 @@ template< typename XprType,
           bool IsGLCompatible = bool(XprType::Flags&LinearAccessBit)                                                            \
                              && bool(XprType::Flags&DirectAccessBit)                                                            \
                              && (XprType::IsVectorAtCompileTime || (XprType::Flags&RowMajorBit)==0)>                            \
-struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl);                                                                                 \
+struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl);                                                                                 \
                                                                                                                                 \
 template                                                                 \
-struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl) {                                                \
+struct EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl) {                                                \
   inline static void run(ARG1 a,EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) {                                        \
-    EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)::type>::run(a,p); }             \
+    EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)::type>::run(a,p); }             \
 };                                                                                                                              \
                                                                                                                                 \
+} // end namespace internal                                                                                                           \
+                                                                                                                                \
 template inline void FUNC(ARG1 a,EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) Eigen::DenseBase& p) {   \
-  EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)::run(a,p.derived());                                                         \
+  EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)::run(a,p.derived());                                                         \
 }
 
 
 #define EIGEN_GL_FUNC1_SPECIALIZATION_MAT(FUNC,ARG1,CONST,SCALAR,ROWS,COLS,SUFFIX)                                              \
-  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl) {               \
+namespace internal {                                                                                                                  \
+  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl) {               \
     inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); }         \
-  };
+  }; \
+}
 
   
 #define EIGEN_GL_FUNC1_SPECIALIZATION_VEC(FUNC,ARG1,CONST,SCALAR,SIZE,SUFFIX)                                                   \
-  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl) {                  \
+namespace internal {                                                                                                                  \
+  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl) {                  \
     inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); }         \
   };                                                                                                                            \
-  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl) {                  \
+  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl) {                  \
     inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); }         \
-  };
+  }; \
+}
 
 EIGEN_GL_FUNC1_DECLARATION       (glGet,GLenum,_)
 EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glGet,GLenum,_,float,  4,4,Floatv)
diff --git a/unsupported/Eigen/src/AutoDiff/AutoDiffJacobian.h b/unsupported/Eigen/src/AutoDiff/AutoDiffJacobian.h
index 0c79214bd..4fe168a88 100644
--- a/unsupported/Eigen/src/AutoDiff/AutoDiffJacobian.h
+++ b/unsupported/Eigen/src/AutoDiff/AutoDiffJacobian.h
@@ -62,7 +62,7 @@ public:
 
   void operator() (const InputType& x, ValueType* v, JacobianType* _jac=0) const
   {
-    ei_assert(v!=0);
+    eigen_assert(v!=0);
     if (!_jac)
     {
       Functor::operator()(x, v);
diff --git a/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h b/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h
index 9169c0b16..1809d4e93 100644
--- a/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h
+++ b/unsupported/Eigen/src/AutoDiff/AutoDiffScalar.h
@@ -27,18 +27,24 @@
 
 namespace Eigen {
 
+namespace internal {
+
 template
-struct ei_make_coherent_impl {
+struct make_coherent_impl {
   static void run(A&, B&) {}
 };
 
 // resize a to match b is a.size()==0, and conversely.
 template
-void ei_make_coherent(const A& a, const B&b)
+void make_coherent(const A& a, const B&b)
 {
-  ei_make_coherent_impl::run(a.const_cast_derived(), b.const_cast_derived());
+  make_coherent_impl::run(a.const_cast_derived(), b.const_cast_derived());
 }
 
+template struct auto_diff_special_op;
+
+} // end namespace internal
+
 /** \class AutoDiffScalar
   * \brief A scalar type replacement with automatic differentation capability
   *
@@ -56,8 +62,8 @@ void ei_make_coherent(const A& a, const B&b)
   *
   * It supports the following list of global math function:
   *  - std::abs, std::sqrt, std::pow, std::exp, std::log, std::sin, std::cos,
-  *  - ei_abs, ei_sqrt, ei_pow, ei_exp, ei_log, ei_sin, ei_cos,
-  *  - ei_conj, ei_real, ei_imag, ei_abs2.
+  *  - internal::abs, internal::sqrt, internal::pow, internal::exp, internal::log, internal::sin, internal::cos,
+  *  - internal::conj, internal::real, internal::imag, internal::abs2.
   *
   * AutoDiffScalar can be used as the scalar type of an Eigen::Matrix object. However,
   * in that case, the expression template mechanism only occurs at the top Matrix level,
@@ -65,21 +71,18 @@ void ei_make_coherent(const A& a, const B&b)
   *
   */
 
-template struct ei_auto_diff_special_op;
-
-
 template
 class AutoDiffScalar
-  : public ei_auto_diff_special_op
-            <_DerType, !ei_is_same_type::type>::Scalar,
-                                        typename NumTraits::type>::Scalar>::Real>::ret>
+  : public internal::auto_diff_special_op
+            <_DerType, !internal::is_same_type::type>::Scalar,
+                                        typename NumTraits::type>::Scalar>::Real>::ret>
 {
   public:
-    typedef ei_auto_diff_special_op
-            <_DerType, !ei_is_same_type::type>::Scalar,
-                       typename NumTraits::type>::Scalar>::Real>::ret> Base;
-    typedef typename ei_cleantype<_DerType>::type DerType;
-    typedef typename ei_traits::Scalar Scalar;
+    typedef internal::auto_diff_special_op
+            <_DerType, !internal::is_same_type::type>::Scalar,
+                       typename NumTraits::type>::Scalar>::Real>::ret> Base;
+    typedef typename internal::cleantype<_DerType>::type DerType;
+    typedef typename internal::traits::Scalar Scalar;
     typedef typename NumTraits::Real Real;
 
     using Base::operator+;
@@ -175,11 +178,11 @@ class AutoDiffScalar
     }
 
     template
-    inline const AutoDiffScalar,DerType,typename ei_cleantype::type> >
+    inline const AutoDiffScalar,DerType,typename internal::cleantype::type> >
     operator+(const AutoDiffScalar& other) const
     {
-      ei_make_coherent(m_derivatives, other.derivatives());
-      return AutoDiffScalar,DerType,typename ei_cleantype::type> >(
+      internal::make_coherent(m_derivatives, other.derivatives());
+      return AutoDiffScalar,DerType,typename internal::cleantype::type> >(
         m_value + other.value(),
         m_derivatives + other.derivatives());
     }
@@ -193,11 +196,11 @@ class AutoDiffScalar
     }
 
     template
-    inline const AutoDiffScalar, DerType,typename ei_cleantype::type> >
+    inline const AutoDiffScalar, DerType,typename internal::cleantype::type> >
     operator-(const AutoDiffScalar& other) const
     {
-      ei_make_coherent(m_derivatives, other.derivatives());
-      return AutoDiffScalar, DerType,typename ei_cleantype::type> >(
+      internal::make_coherent(m_derivatives, other.derivatives());
+      return AutoDiffScalar, DerType,typename internal::cleantype::type> >(
         m_value - other.value(),
         m_derivatives - other.derivatives());
     }
@@ -211,105 +214,105 @@ class AutoDiffScalar
     }
 
     template
-    inline const AutoDiffScalar, DerType> >
+    inline const AutoDiffScalar, DerType> >
     operator-() const
     {
-      return AutoDiffScalar, DerType> >(
+      return AutoDiffScalar, DerType> >(
         -m_value,
         -m_derivatives);
     }
 
-    inline const AutoDiffScalar, DerType> >
+    inline const AutoDiffScalar, DerType> >
     operator*(const Scalar& other) const
     {
-      return AutoDiffScalar, DerType> >(
+      return AutoDiffScalar, DerType> >(
         m_value * other,
         (m_derivatives * other));
     }
 
-    friend inline const AutoDiffScalar, DerType> >
+    friend inline const AutoDiffScalar, DerType> >
     operator*(const Scalar& other, const AutoDiffScalar& a)
     {
-      return AutoDiffScalar, DerType> >(
+      return AutoDiffScalar, DerType> >(
         a.value() * other,
         a.derivatives() * other);
     }
 
-//     inline const AutoDiffScalar, DerType>::Type >
+//     inline const AutoDiffScalar, DerType>::Type >
 //     operator*(const Real& other) const
 //     {
-//       return AutoDiffScalar, DerType>::Type >(
+//       return AutoDiffScalar, DerType>::Type >(
 //         m_value * other,
 //         (m_derivatives * other));
 //     }
 //
-//     friend inline const AutoDiffScalar, DerType>::Type >
+//     friend inline const AutoDiffScalar, DerType>::Type >
 //     operator*(const Real& other, const AutoDiffScalar& a)
 //     {
-//       return AutoDiffScalar, DerType>::Type >(
+//       return AutoDiffScalar, DerType>::Type >(
 //         a.value() * other,
 //         a.derivatives() * other);
 //     }
 
-    inline const AutoDiffScalar, DerType> >
+    inline const AutoDiffScalar, DerType> >
     operator/(const Scalar& other) const
     {
-      return AutoDiffScalar, DerType> >(
+      return AutoDiffScalar, DerType> >(
         m_value / other,
         (m_derivatives * (Scalar(1)/other)));
     }
 
-    friend inline const AutoDiffScalar, DerType> >
+    friend inline const AutoDiffScalar, DerType> >
     operator/(const Scalar& other, const AutoDiffScalar& a)
     {
-      return AutoDiffScalar, DerType> >(
+      return AutoDiffScalar, DerType> >(
         other / a.value(),
         a.derivatives() * (-Scalar(1)/other));
     }
 
-//     inline const AutoDiffScalar, DerType>::Type >
+//     inline const AutoDiffScalar, DerType>::Type >
 //     operator/(const Real& other) const
 //     {
-//       return AutoDiffScalar, DerType>::Type >(
+//       return AutoDiffScalar, DerType>::Type >(
 //         m_value / other,
 //         (m_derivatives * (Real(1)/other)));
 //     }
 //
-//     friend inline const AutoDiffScalar, DerType>::Type >
+//     friend inline const AutoDiffScalar, DerType>::Type >
 //     operator/(const Real& other, const AutoDiffScalar& a)
 //     {
-//       return AutoDiffScalar, DerType>::Type >(
+//       return AutoDiffScalar, DerType>::Type >(
 //         other / a.value(),
 //         a.derivatives() * (-Real(1)/other));
 //     }
 
     template
-    inline const AutoDiffScalar,
-        CwiseBinaryOp,
-          CwiseUnaryOp, DerType>,
-          CwiseUnaryOp, typename ei_cleantype::type > > > >
+    inline const AutoDiffScalar,
+        CwiseBinaryOp,
+          CwiseUnaryOp, DerType>,
+          CwiseUnaryOp, typename internal::cleantype::type > > > >
     operator/(const AutoDiffScalar& other) const
     {
-      ei_make_coherent(m_derivatives, other.derivatives());
-      return AutoDiffScalar,
-        CwiseBinaryOp,
-          CwiseUnaryOp, DerType>,
-          CwiseUnaryOp, typename ei_cleantype::type > > > >(
+      internal::make_coherent(m_derivatives, other.derivatives());
+      return AutoDiffScalar,
+        CwiseBinaryOp,
+          CwiseUnaryOp, DerType>,
+          CwiseUnaryOp, typename internal::cleantype::type > > > >(
         m_value / other.value(),
           ((m_derivatives * other.value()) - (m_value * other.derivatives()))
         * (Scalar(1)/(other.value()*other.value())));
     }
 
     template
-    inline const AutoDiffScalar,
-        CwiseUnaryOp, DerType>,
-        CwiseUnaryOp, typename ei_cleantype::type> > >
+    inline const AutoDiffScalar,
+        CwiseUnaryOp, DerType>,
+        CwiseUnaryOp, typename internal::cleantype::type> > >
     operator*(const AutoDiffScalar& other) const
     {
-      ei_make_coherent(m_derivatives, other.derivatives());
-      return AutoDiffScalar,
-        CwiseUnaryOp, DerType>,
-        CwiseUnaryOp, typename ei_cleantype::type > > >(
+      internal::make_coherent(m_derivatives, other.derivatives());
+      return AutoDiffScalar,
+        CwiseUnaryOp, DerType>,
+        CwiseUnaryOp, typename internal::cleantype::type > > >(
         m_value * other.value(),
         (m_derivatives * other.value()) + (m_value * other.derivatives()));
     }
@@ -333,18 +336,19 @@ class AutoDiffScalar
 
 };
 
+namespace internal {
 
 template
-struct ei_auto_diff_special_op<_DerType, true>
-//   : ei_auto_diff_scalar_op<_DerType, typename NumTraits::Real,
-//                            ei_is_same_type::Real>::ret>
+struct auto_diff_special_op<_DerType, true>
+//   : auto_diff_scalar_op<_DerType, typename NumTraits::Real,
+//                            is_same_type::Real>::ret>
 {
-  typedef typename ei_cleantype<_DerType>::type DerType;
-  typedef typename ei_traits::Scalar Scalar;
+  typedef typename cleantype<_DerType>::type DerType;
+  typedef typename traits::Scalar Scalar;
   typedef typename NumTraits::Real Real;
 
-//   typedef ei_auto_diff_scalar_op<_DerType, typename NumTraits::Real,
-//                            ei_is_same_type::Real>::ret> Base;
+//   typedef auto_diff_scalar_op<_DerType, typename NumTraits::Real,
+//                            is_same_type::Real>::ret> Base;
 
 //   using Base::operator+;
 //   using Base::operator+=;
@@ -374,18 +378,18 @@ struct ei_auto_diff_special_op<_DerType, true>
   }
 
 
-  inline const AutoDiffScalar, DerType>::Type >
+  inline const AutoDiffScalar, DerType>::Type >
   operator*(const Real& other) const
   {
-    return AutoDiffScalar, DerType>::Type >(
+    return AutoDiffScalar, DerType>::Type >(
       derived().value() * other,
       derived().derivatives() * other);
   }
 
-  friend inline const AutoDiffScalar, DerType>::Type >
+  friend inline const AutoDiffScalar, DerType>::Type >
   operator*(const Real& other, const AutoDiffScalar<_DerType>& a)
   {
-    return AutoDiffScalar, DerType>::Type >(
+    return AutoDiffScalar, DerType>::Type >(
       a.value() * other,
       a.derivatives() * other);
   }
@@ -398,7 +402,7 @@ struct ei_auto_diff_special_op<_DerType, true>
 };
 
 template
-struct ei_auto_diff_special_op<_DerType, false>
+struct auto_diff_special_op<_DerType, false>
 {
   void operator*() const;
   void operator-() const;
@@ -406,7 +410,7 @@ struct ei_auto_diff_special_op<_DerType, false>
 };
 
 template
-struct ei_make_coherent_impl, B> {
+struct make_coherent_impl, B> {
   typedef Matrix A;
   static void run(A& a, B& b) {
     if((A_Rows==Dynamic || A_Cols==Dynamic) && (a.size()==0))
@@ -418,7 +422,7 @@ struct ei_make_coherent_impl
-struct ei_make_coherent_impl > {
+struct make_coherent_impl > {
   typedef Matrix B;
   static void run(A& a, B& b) {
     if((B_Rows==Dynamic || B_Cols==Dynamic) && (b.size()==0))
@@ -431,7 +435,7 @@ struct ei_make_coherent_impl
-struct ei_make_coherent_impl,
+struct make_coherent_impl,
                              Matrix > {
   typedef Matrix A;
   typedef Matrix B;
@@ -449,31 +453,33 @@ struct ei_make_coherent_impl struct ei_scalar_product_traits,A_Scalar>
+template struct scalar_product_traits,A_Scalar>
 {
    typedef Matrix ReturnType;
 };
 
-template struct ei_scalar_product_traits >
+template struct scalar_product_traits >
 {
    typedef Matrix ReturnType;
 };
 
 template
-struct ei_scalar_product_traits,T>
+struct scalar_product_traits,T>
 {
  typedef AutoDiffScalar ReturnType;
 };
 
-}
+} // end namespace internal
+
+} // end namespace Eigen
 
 #define EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(FUNC,CODE) \
   template \
-  inline const Eigen::AutoDiffScalar::type>::Scalar>, typename Eigen::ei_cleantype::type> > \
+  inline const Eigen::AutoDiffScalar::type>::Scalar>, typename Eigen::internal::cleantype::type> > \
   FUNC(const Eigen::AutoDiffScalar& x) { \
     using namespace Eigen; \
-    typedef typename ei_traits::type>::Scalar Scalar; \
-    typedef AutoDiffScalar, typename ei_cleantype::type> > ReturnType; \
+    typedef typename internal::traits::type>::Scalar Scalar; \
+    typedef AutoDiffScalar, typename internal::cleantype::type> > ReturnType; \
     CODE; \
   }
 
@@ -500,12 +506,12 @@ namespace std
     return ReturnType(std::log(x.value()),x.derivatives() * (Scalar(1)/x.value()));)
 
   template
-  inline const Eigen::AutoDiffScalar::Scalar>, DerType> >
-  pow(const Eigen::AutoDiffScalar& x, typename Eigen::ei_traits::Scalar y)
+  inline const Eigen::AutoDiffScalar::Scalar>, DerType> >
+  pow(const Eigen::AutoDiffScalar& x, typename Eigen::internal::traits::Scalar y)
   {
     using namespace Eigen;
-    typedef typename ei_traits::Scalar Scalar;
-    return AutoDiffScalar, DerType> >(
+    typedef typename internal::traits::Scalar Scalar;
+    return AutoDiffScalar, DerType> >(
       std::pow(x.value(),y),
       x.derivatives() * (y * std::pow(x.value(),y-1)));
   }
@@ -514,41 +520,45 @@ namespace std
 
 namespace Eigen {
 
+namespace internal {
+
 template
-inline const AutoDiffScalar& ei_conj(const AutoDiffScalar& x)  { return x; }
+inline const AutoDiffScalar& conj(const AutoDiffScalar& x)  { return x; }
 template
-inline const AutoDiffScalar& ei_real(const AutoDiffScalar& x)  { return x; }
+inline const AutoDiffScalar& real(const AutoDiffScalar& x)  { return x; }
 template
-inline typename DerType::Scalar ei_imag(const AutoDiffScalar&)    { return 0.; }
+inline typename DerType::Scalar imag(const AutoDiffScalar&)    { return 0.; }
 
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(ei_abs,
-  return ReturnType(ei_abs(x.value()), x.derivatives() * (sign(x.value())));)
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs,
+  return ReturnType(abs(x.value()), x.derivatives() * (sign(x.value())));)
 
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(ei_abs2,
-  return ReturnType(ei_abs2(x.value()), x.derivatives() * (Scalar(2)*x.value()));)
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(abs2,
+  return ReturnType(abs2(x.value()), x.derivatives() * (Scalar(2)*x.value()));)
 
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(ei_sqrt,
-  Scalar sqrtx = ei_sqrt(x.value());
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(sqrt,
+  Scalar sqrtx = sqrt(x.value());
   return ReturnType(sqrtx,x.derivatives() * (Scalar(0.5) / sqrtx));)
 
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(ei_cos,
-  return ReturnType(ei_cos(x.value()), x.derivatives() * (-ei_sin(x.value())));)
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(cos,
+  return ReturnType(cos(x.value()), x.derivatives() * (-sin(x.value())));)
 
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(ei_sin,
-  return ReturnType(ei_sin(x.value()),x.derivatives() * ei_cos(x.value()));)
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(sin,
+  return ReturnType(sin(x.value()),x.derivatives() * cos(x.value()));)
 
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(ei_exp,
-  Scalar expx = ei_exp(x.value());
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(exp,
+  Scalar expx = exp(x.value());
   return ReturnType(expx,x.derivatives() * expx);)
 
-EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(ei_log,
-  return ReturnType(ei_log(x.value()),x.derivatives() * (Scalar(1)/x.value()));)
+EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(log,
+  return ReturnType(log(x.value()),x.derivatives() * (Scalar(1)/x.value()));)
 
 template
-inline const AutoDiffScalar::Scalar>, DerType> >
-ei_pow(const AutoDiffScalar& x, typename ei_traits::Scalar y)
+inline const AutoDiffScalar::Scalar>, DerType> >
+pow(const AutoDiffScalar& x, typename traits::Scalar y)
 { return std::pow(x,y);}
 
+} // end namespace internal
+
 #undef EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY
 
 template struct NumTraits >
diff --git a/unsupported/Eigen/src/AutoDiff/AutoDiffVector.h b/unsupported/Eigen/src/AutoDiff/AutoDiffVector.h
index a160a216e..a8f041f6f 100644
--- a/unsupported/Eigen/src/AutoDiff/AutoDiffVector.h
+++ b/unsupported/Eigen/src/AutoDiff/AutoDiffVector.h
@@ -36,8 +36,8 @@ namespace Eigen {
   *
   * It supports the following list of global math function:
   *  - std::abs, std::sqrt, std::pow, std::exp, std::log, std::sin, std::cos,
-  *  - ei_abs, ei_sqrt, ei_pow, ei_exp, ei_log, ei_sin, ei_cos,
-  *  - ei_conj, ei_real, ei_imag, ei_abs2.
+  *  - internal::abs, internal::sqrt, internal::pow, internal::exp, internal::log, internal::sin, internal::cos,
+  *  - internal::conj, internal::real, internal::imag, internal::abs2.
   *
   * AutoDiffScalar can be used as the scalar type of an Eigen::Matrix object. However,
   * in that case, the expression template mechanism only occurs at the top Matrix level,
@@ -48,8 +48,8 @@ template
 class AutoDiffVector
 {
   public:
-    //typedef typename ei_traits::Scalar Scalar;
-    typedef typename ei_traits::Scalar BaseScalar;
+    //typedef typename internal::traits::Scalar Scalar;
+    typedef typename internal::traits::Scalar BaseScalar;
     typedef AutoDiffScalar > ActiveScalar;
     typedef ActiveScalar Scalar;
     typedef AutoDiffScalar CoeffType;
@@ -115,13 +115,13 @@ class AutoDiffVector
 
     template
     inline const AutoDiffVector<
-      typename MakeCwiseBinaryOp,ValueType,OtherValueType>::Type,
-      typename MakeCwiseBinaryOp,JacobianType,OtherJacobianType>::Type >
+      typename MakeCwiseBinaryOp,ValueType,OtherValueType>::Type,
+      typename MakeCwiseBinaryOp,JacobianType,OtherJacobianType>::Type >
     operator+(const AutoDiffVector& other) const
     {
       return AutoDiffVector<
-      typename MakeCwiseBinaryOp,ValueType,OtherValueType>::Type,
-      typename MakeCwiseBinaryOp,JacobianType,OtherJacobianType>::Type >(
+      typename MakeCwiseBinaryOp,ValueType,OtherValueType>::Type,
+      typename MakeCwiseBinaryOp,JacobianType,OtherJacobianType>::Type >(
         m_values + other.values(),
         m_jacobian + other.jacobian());
     }
@@ -137,13 +137,13 @@ class AutoDiffVector
 
     template
     inline const AutoDiffVector<
-      typename MakeCwiseBinaryOp,ValueType,OtherValueType>::Type,
-      typename MakeCwiseBinaryOp,JacobianType,OtherJacobianType>::Type >
+      typename MakeCwiseBinaryOp,ValueType,OtherValueType>::Type,
+      typename MakeCwiseBinaryOp,JacobianType,OtherJacobianType>::Type >
     operator-(const AutoDiffVector& other) const
     {
       return AutoDiffVector<
-        typename MakeCwiseBinaryOp,ValueType,OtherValueType>::Type,
-        typename MakeCwiseBinaryOp,JacobianType,OtherJacobianType>::Type >(
+        typename MakeCwiseBinaryOp,ValueType,OtherValueType>::Type,
+        typename MakeCwiseBinaryOp,JacobianType,OtherJacobianType>::Type >(
           m_values - other.values(),
           m_jacobian - other.jacobian());
     }
@@ -158,54 +158,54 @@ class AutoDiffVector
     }
 
     inline const AutoDiffVector<
-      typename MakeCwiseUnaryOp, ValueType>::Type,
-      typename MakeCwiseUnaryOp, JacobianType>::Type >
+      typename MakeCwiseUnaryOp, ValueType>::Type,
+      typename MakeCwiseUnaryOp, JacobianType>::Type >
     operator-() const
     {
       return AutoDiffVector<
-        typename MakeCwiseUnaryOp, ValueType>::Type,
-        typename MakeCwiseUnaryOp, JacobianType>::Type >(
+        typename MakeCwiseUnaryOp, ValueType>::Type,
+        typename MakeCwiseUnaryOp, JacobianType>::Type >(
           -m_values,
           -m_jacobian);
     }
 
     inline const AutoDiffVector<
-      typename MakeCwiseUnaryOp, ValueType>::Type,
-      typename MakeCwiseUnaryOp, JacobianType>::Type>
+      typename MakeCwiseUnaryOp, ValueType>::Type,
+      typename MakeCwiseUnaryOp, JacobianType>::Type>
     operator*(const BaseScalar& other) const
     {
       return AutoDiffVector<
-        typename MakeCwiseUnaryOp, ValueType>::Type,
-        typename MakeCwiseUnaryOp, JacobianType>::Type >(
+        typename MakeCwiseUnaryOp, ValueType>::Type,
+        typename MakeCwiseUnaryOp, JacobianType>::Type >(
           m_values * other,
           m_jacobian * other);
     }
 
     friend inline const AutoDiffVector<
-      typename MakeCwiseUnaryOp, ValueType>::Type,
-      typename MakeCwiseUnaryOp, JacobianType>::Type >
+      typename MakeCwiseUnaryOp, ValueType>::Type,
+      typename MakeCwiseUnaryOp, JacobianType>::Type >
     operator*(const Scalar& other, const AutoDiffVector& v)
     {
       return AutoDiffVector<
-        typename MakeCwiseUnaryOp, ValueType>::Type,
-        typename MakeCwiseUnaryOp, JacobianType>::Type >(
+        typename MakeCwiseUnaryOp, ValueType>::Type,
+        typename MakeCwiseUnaryOp, JacobianType>::Type >(
           v.values() * other,
           v.jacobian() * other);
     }
 
 //     template
 //     inline const AutoDiffVector<
-//       CwiseBinaryOp, ValueType, OtherValueType>
-//       CwiseBinaryOp,
-//         CwiseUnaryOp, JacobianType>,
-//         CwiseUnaryOp, OtherJacobianType> > >
+//       CwiseBinaryOp, ValueType, OtherValueType>
+//       CwiseBinaryOp,
+//         CwiseUnaryOp, JacobianType>,
+//         CwiseUnaryOp, OtherJacobianType> > >
 //     operator*(const AutoDiffVector& other) const
 //     {
 //       return AutoDiffVector<
-//         CwiseBinaryOp, ValueType, OtherValueType>
-//         CwiseBinaryOp,
-//           CwiseUnaryOp, JacobianType>,
-//           CwiseUnaryOp, OtherJacobianType> > >(
+//         CwiseBinaryOp, ValueType, OtherValueType>
+//         CwiseBinaryOp,
+//           CwiseUnaryOp, JacobianType>,
+//           CwiseUnaryOp, OtherJacobianType> > >(
 //             m_values.cwise() * other.values(),
 //             (m_jacobian * other.values()) + (m_values * other.jacobian()));
 //     }
diff --git a/unsupported/Eigen/src/BVH/BVAlgorithms.h b/unsupported/Eigen/src/BVH/BVAlgorithms.h
index 40320291d..2412680e7 100644
--- a/unsupported/Eigen/src/BVH/BVAlgorithms.h
+++ b/unsupported/Eigen/src/BVH/BVAlgorithms.h
@@ -25,21 +25,11 @@
 #ifndef EIGEN_BVALGORITHMS_H
 #define EIGEN_BVALGORITHMS_H
 
-/**  Given a BVH, runs the query encapsulated by \a intersector.
-  *  The Intersector type must provide the following members: \code
-     bool intersectVolume(const BVH::Volume &volume) //returns true if volume intersects the query
-     bool intersectObject(const BVH::Object &object) //returns true if the search should terminate immediately
-  \endcode
-  */
-template
-void BVIntersect(const BVH &tree, Intersector &intersector)
-{
-  ei_intersect_helper(tree, intersector, tree.getRootIndex());
-}
+namespace internal {
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
 template
-bool ei_intersect_helper(const BVH &tree, Intersector &intersector, typename BVH::Index root)
+bool intersect_helper(const BVH &tree, Intersector &intersector, typename BVH::Index root)
 {
   typedef typename BVH::Index Index;
   typedef typename BVH::VolumeIterator VolIter;
@@ -67,29 +57,43 @@ bool ei_intersect_helper(const BVH &tree, Intersector &intersector, typename BVH
 #endif //not EIGEN_PARSED_BY_DOXYGEN
 
 template
-struct ei_intersector_helper1
+struct intersector_helper1
 {
-  ei_intersector_helper1(const Object2 &inStored, Intersector &in) : stored(inStored), intersector(in) {}
+  intersector_helper1(const Object2 &inStored, Intersector &in) : stored(inStored), intersector(in) {}
   bool intersectVolume(const Volume1 &vol) { return intersector.intersectVolumeObject(vol, stored); }
   bool intersectObject(const Object1 &obj) { return intersector.intersectObjectObject(obj, stored); }
   Object2 stored;
   Intersector &intersector;
 private:
-  ei_intersector_helper1& operator=(const ei_intersector_helper1&);
+  intersector_helper1& operator=(const intersector_helper1&);
 };
 
 template
-struct ei_intersector_helper2
+struct intersector_helper2
 {
-  ei_intersector_helper2(const Object1 &inStored, Intersector &in) : stored(inStored), intersector(in) {}
+  intersector_helper2(const Object1 &inStored, Intersector &in) : stored(inStored), intersector(in) {}
   bool intersectVolume(const Volume2 &vol) { return intersector.intersectObjectVolume(stored, vol); }
   bool intersectObject(const Object2 &obj) { return intersector.intersectObjectObject(stored, obj); }
   Object1 stored;
   Intersector &intersector;
 private:
-  ei_intersector_helper2& operator=(const ei_intersector_helper2&);
+  intersector_helper2& operator=(const intersector_helper2&);
 };
 
+} // end namespace internal
+
+/**  Given a BVH, runs the query encapsulated by \a intersector.
+  *  The Intersector type must provide the following members: \code
+     bool intersectVolume(const BVH::Volume &volume) //returns true if volume intersects the query
+     bool intersectObject(const BVH::Object &object) //returns true if the search should terminate immediately
+  \endcode
+  */
+template
+void BVIntersect(const BVH &tree, Intersector &intersector)
+{
+  internal::intersect_helper(tree, intersector, tree.getRootIndex());
+}
+
 /**  Given two BVH's, runs the query on their Cartesian product encapsulated by \a intersector.
   *  The Intersector type must provide the following members: \code
      bool intersectVolumeVolume(const BVH1::Volume &v1, const BVH2::Volume &v2) //returns true if product of volumes intersects the query
@@ -103,8 +107,8 @@ void BVIntersect(const BVH1 &tree1, const BVH2 &tree2, Intersector &intersector)
 {
   typedef typename BVH1::Index Index1;
   typedef typename BVH2::Index Index2;
-  typedef ei_intersector_helper1 Helper1;
-  typedef ei_intersector_helper2 Helper2;
+  typedef internal::intersector_helper1 Helper1;
+  typedef internal::intersector_helper2 Helper2;
   typedef typename BVH1::VolumeIterator VolIter1;
   typedef typename BVH1::ObjectIterator ObjIter1;
   typedef typename BVH2::VolumeIterator VolIter2;
@@ -131,7 +135,7 @@ void BVIntersect(const BVH1 &tree1, const BVH2 &tree2, Intersector &intersector)
 
       for(oCur2 = oBegin2; oCur2 != oEnd2; ++oCur2) {//go through child objects of second tree
         Helper1 helper(*oCur2, intersector);
-        if(ei_intersect_helper(tree1, helper, *vBegin1))
+        if(internal::intersect_helper(tree1, helper, *vBegin1))
           return; //intersector said to stop query
       }
     }
@@ -139,7 +143,7 @@ void BVIntersect(const BVH1 &tree1, const BVH2 &tree2, Intersector &intersector)
     for(; oBegin1 != oEnd1; ++oBegin1) { //go through child objects of first tree
       for(vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) { //go through child volumes of second tree
         Helper2 helper(*oBegin1, intersector);
-        if(ei_intersect_helper(tree2, helper, *vCur2))
+        if(internal::intersect_helper(tree2, helper, *vCur2))
           return; //intersector said to stop query
       }
 
@@ -151,23 +155,11 @@ void BVIntersect(const BVH1 &tree1, const BVH2 &tree2, Intersector &intersector)
   }
 }
 
-/**  Given a BVH, runs the query encapsulated by \a minimizer.
-  *  \returns the minimum value.
-  *  The Minimizer type must provide the following members: \code
-     typedef Scalar //the numeric type of what is being minimized--not necessarily the Scalar type of the BVH (if it has one)
-     Scalar minimumOnVolume(const BVH::Volume &volume)
-     Scalar minimumOnObject(const BVH::Object &object)
-  \endcode
-  */
-template
-typename Minimizer::Scalar BVMinimize(const BVH &tree, Minimizer &minimizer)
-{
-  return ei_minimize_helper(tree, minimizer, tree.getRootIndex(), std::numeric_limits::max());
-}
+namespace internal {
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
 template
-typename Minimizer::Scalar ei_minimize_helper(const BVH &tree, Minimizer &minimizer, typename BVH::Index root, typename Minimizer::Scalar minimum)
+typename Minimizer::Scalar minimize_helper(const BVH &tree, Minimizer &minimizer, typename BVH::Index root, typename Minimizer::Scalar minimum)
 {
   typedef typename Minimizer::Scalar Scalar;
   typedef typename BVH::Index Index;
@@ -201,31 +193,47 @@ typename Minimizer::Scalar ei_minimize_helper(const BVH &tree, Minimizer &minimi
 
 
 template
-struct ei_minimizer_helper1
+struct minimizer_helper1
 {
   typedef typename Minimizer::Scalar Scalar;
-  ei_minimizer_helper1(const Object2 &inStored, Minimizer &m) : stored(inStored), minimizer(m) {}
+  minimizer_helper1(const Object2 &inStored, Minimizer &m) : stored(inStored), minimizer(m) {}
   Scalar minimumOnVolume(const Volume1 &vol) { return minimizer.minimumOnVolumeObject(vol, stored); }
   Scalar minimumOnObject(const Object1 &obj) { return minimizer.minimumOnObjectObject(obj, stored); }
   Object2 stored;
   Minimizer &minimizer;
 private:
-  ei_minimizer_helper1& operator=(const ei_minimizer_helper1&) {}
+  minimizer_helper1& operator=(const minimizer_helper1&) {}
 };
 
 template
-struct ei_minimizer_helper2
+struct minimizer_helper2
 {
   typedef typename Minimizer::Scalar Scalar;
-  ei_minimizer_helper2(const Object1 &inStored, Minimizer &m) : stored(inStored), minimizer(m) {}
+  minimizer_helper2(const Object1 &inStored, Minimizer &m) : stored(inStored), minimizer(m) {}
   Scalar minimumOnVolume(const Volume2 &vol) { return minimizer.minimumOnObjectVolume(stored, vol); }
   Scalar minimumOnObject(const Object2 &obj) { return minimizer.minimumOnObjectObject(stored, obj); }
   Object1 stored;
   Minimizer &minimizer;
 private:
-  ei_minimizer_helper2& operator=(const ei_minimizer_helper2&);
+  minimizer_helper2& operator=(const minimizer_helper2&);
 };
 
+} // end namespace internal
+
+/**  Given a BVH, runs the query encapsulated by \a minimizer.
+  *  \returns the minimum value.
+  *  The Minimizer type must provide the following members: \code
+     typedef Scalar //the numeric type of what is being minimized--not necessarily the Scalar type of the BVH (if it has one)
+     Scalar minimumOnVolume(const BVH::Volume &volume)
+     Scalar minimumOnObject(const BVH::Object &object)
+  \endcode
+  */
+template
+typename Minimizer::Scalar BVMinimize(const BVH &tree, Minimizer &minimizer)
+{
+  return internal::minimize_helper(tree, minimizer, tree.getRootIndex(), std::numeric_limits::max());
+}
+
 /**  Given two BVH's, runs the query on their cartesian product encapsulated by \a minimizer.
   *  \returns the minimum value.
   *  The Minimizer type must provide the following members: \code
@@ -242,8 +250,8 @@ typename Minimizer::Scalar BVMinimize(const BVH1 &tree1, const BVH2 &tree2, Mini
   typedef typename Minimizer::Scalar Scalar;
   typedef typename BVH1::Index Index1;
   typedef typename BVH2::Index Index2;
-  typedef ei_minimizer_helper1 Helper1;
-  typedef ei_minimizer_helper2 Helper2;
+  typedef internal::minimizer_helper1 Helper1;
+  typedef internal::minimizer_helper2 Helper2;
   typedef std::pair > QueueElement; //first element is priority
   typedef typename BVH1::VolumeIterator VolIter1;
   typedef typename BVH1::ObjectIterator ObjIter1;
@@ -271,7 +279,7 @@ typename Minimizer::Scalar BVMinimize(const BVH1 &tree1, const BVH2 &tree2, Mini
 
       for(vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) { //go through child volumes of second tree
         Helper2 helper(*oBegin1, minimizer);
-        minimum = std::min(minimum, ei_minimize_helper(tree2, helper, *vCur2, minimum));
+        minimum = std::min(minimum, internal::minimize_helper(tree2, helper, *vCur2, minimum));
       }
     }
 
@@ -280,7 +288,7 @@ typename Minimizer::Scalar BVMinimize(const BVH1 &tree1, const BVH2 &tree2, Mini
 
       for(oCur2 = oBegin2; oCur2 != oEnd2; ++oCur2) {//go through child objects of second tree
         Helper1 helper(*oCur2, minimizer);
-        minimum = std::min(minimum, ei_minimize_helper(tree1, helper, *vBegin1, minimum));
+        minimum = std::min(minimum, internal::minimize_helper(tree1, helper, *vBegin1, minimum));
       }
 
       for(vCur2 = vBegin2; vCur2 != vEnd2; ++vCur2) { //go through child volumes of second tree
diff --git a/unsupported/Eigen/src/BVH/KdBVH.h b/unsupported/Eigen/src/BVH/KdBVH.h
index c4719607f..028b4811e 100644
--- a/unsupported/Eigen/src/BVH/KdBVH.h
+++ b/unsupported/Eigen/src/BVH/KdBVH.h
@@ -25,47 +25,51 @@
 #ifndef KDBVH_H_INCLUDED
 #define KDBVH_H_INCLUDED
 
+namespace internal {
+
 //internal pair class for the BVH--used instead of std::pair because of alignment
 template
-struct ei_vector_int_pair
+struct vector_int_pair
 {
 EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar, Dim)
   typedef Matrix VectorType;
 
-  ei_vector_int_pair(const VectorType &v, int i) : first(v), second(i) {}
+  vector_int_pair(const VectorType &v, int i) : first(v), second(i) {}
 
   VectorType first;
   int second;
 };
 
 //these templates help the tree initializer get the bounding boxes either from a provided
-//iterator range or using ei_bounding_box in a unified way
+//iterator range or using bounding_box in a unified way
 template
-struct ei_get_boxes_helper {
+struct get_boxes_helper {
   void operator()(const ObjectList &objects, BoxIter boxBegin, BoxIter boxEnd, VolumeList &outBoxes)
   {
     outBoxes.insert(outBoxes.end(), boxBegin, boxEnd);
-    ei_assert(outBoxes.size() == objects.size());
+    eigen_assert(outBoxes.size() == objects.size());
   }
 };
 
 template
-struct ei_get_boxes_helper {
+struct get_boxes_helper {
   void operator()(const ObjectList &objects, int, int, VolumeList &outBoxes)
   {
     outBoxes.reserve(objects.size());
     for(int i = 0; i < (int)objects.size(); ++i)
-      outBoxes.push_back(ei_bounding_box(objects[i]));
+      outBoxes.push_back(bounding_box(objects[i]));
   }
 };
 
+} // end namespace internal
+
 
 /** \class KdBVH
  *  \brief A simple bounding volume hierarchy based on AlignedBox
  *
  *  \param _Scalar The underlying scalar type of the bounding boxes
  *  \param _Dim The dimension of the space in which the hierarchy lives
- *  \param _Object The object type that lives in the hierarchy.  It must have value semantics.  Either ei_bounding_box(_Object) must
+ *  \param _Object The object type that lives in the hierarchy.  It must have value semantics.  Either internal::bounding_box(_Object) must
  *                 be defined and return an AlignedBox<_Scalar, _Dim> or bounding boxes must be provided to the tree initializer.
  *
  *  This class provides a simple (as opposed to optimized) implementation of a bounding volume hierarchy analogous to a Kd-tree.
@@ -88,14 +92,14 @@ public:
 
   KdBVH() {}
 
-  /** Given an iterator range over \a Object references, constructs the BVH.  Requires that ei_bounding_box(Object) return a Volume. */
+  /** Given an iterator range over \a Object references, constructs the BVH.  Requires that internal::bounding_box(Object) return a Volume. */
   template KdBVH(Iter begin, Iter end) { init(begin, end, 0, 0); } //int is recognized by init as not being an iterator type
 
   /** Given an iterator range over \a Object references and an iterator range over their bounding boxes, constructs the BVH */
   template KdBVH(OIter begin, OIter end, BIter boxBegin, BIter boxEnd) { init(begin, end, boxBegin, boxEnd); }
 
   /** Given an iterator range over \a Object references, constructs the BVH, overwriting whatever is in there currently.
-    * Requires that ei_bounding_box(Object) return a Volume. */
+    * Requires that internal::bounding_box(Object) return a Volume. */
   template void init(Iter begin, Iter end) { init(begin, end, 0, 0); }
 
   /** Given an iterator range over \a Object references and an iterator range over their bounding boxes,
@@ -116,7 +120,7 @@ public:
     VIPairList objCenters;
 
     //compute the bounding boxes depending on BIter type
-    ei_get_boxes_helper()(objects, boxBegin, boxEnd, objBoxes);
+    internal::get_boxes_helper()(objects, boxBegin, boxEnd, objBoxes);
 
     objCenters.reserve(n);
     boxes.reserve(n - 1);
@@ -176,7 +180,7 @@ public:
   }
 
 private:
-  typedef ei_vector_int_pair VIPair;
+  typedef internal::vector_int_pair VIPair;
   typedef std::vector > VIPairList;
   typedef Matrix VectorType;
   struct VectorComparator //compares vectors, or, more specificall, VIPairs along a particular dimension
@@ -191,7 +195,7 @@ private:
   //the two halves, and adds their parent node.  TODO: a cache-friendlier layout
   void build(VIPairList &objCenters, int from, int to, const VolumeList &objBoxes, int dim)
   {
-    ei_assert(to - from > 1);
+    eigen_assert(to - from > 1);
     if(to - from == 2) {
       boxes.push_back(objBoxes[objCenters[from].second].merged(objBoxes[objCenters[from + 1].second]));
       children.push_back(from + (int)objects.size() - 1); //there are objects.size() - 1 tree nodes
diff --git a/unsupported/Eigen/src/FFT/ei_fftw_impl.h b/unsupported/Eigen/src/FFT/ei_fftw_impl.h
index c1f777e6d..84e4fcda5 100644
--- a/unsupported/Eigen/src/FFT/ei_fftw_impl.h
+++ b/unsupported/Eigen/src/FFT/ei_fftw_impl.h
@@ -22,7 +22,7 @@
 // License and a copy of the GNU General Public License along with
 // Eigen. If not, see .
 
-
+namespace internal {
 
   // FFTW uses non-const arguments
   // so we must use ugly const_cast calls for all the args it uses
@@ -34,40 +34,40 @@
   //    This assumes std::complex layout is array of size 2 with real,imag
   template  
   inline 
-  T * ei_fftw_cast(const T* p) 
+  T * fftw_cast(const T* p)
   { 
       return const_cast( p); 
   }
 
   inline 
-  fftw_complex * ei_fftw_cast( const std::complex * p) 
+  fftw_complex * fftw_cast( const std::complex * p)
   {
       return const_cast( reinterpret_cast(p) ); 
   }
 
   inline 
-  fftwf_complex * ei_fftw_cast( const std::complex * p) 
+  fftwf_complex * fftw_cast( const std::complex * p)
   { 
       return const_cast( reinterpret_cast(p) ); 
   }
 
   inline 
-  fftwl_complex * ei_fftw_cast( const std::complex * p) 
+  fftwl_complex * fftw_cast( const std::complex * p)
   { 
       return const_cast( reinterpret_cast(p) ); 
   }
 
   template  
-  struct ei_fftw_plan {};
+  struct fftw_plan {};
 
   template <> 
-  struct ei_fftw_plan
+  struct fftw_plan
   {
       typedef float scalar_type;
       typedef fftwf_complex complex_type;
       fftwf_plan m_plan;
-      ei_fftw_plan() :m_plan(NULL) {}
-      ~ei_fftw_plan() {if (m_plan) fftwf_destroy_plan(m_plan);}
+      fftw_plan() :m_plan(NULL) {}
+      ~fftw_plan() {if (m_plan) fftwf_destroy_plan(m_plan);}
 
       inline
       void fwd(complex_type * dst,complex_type * src,int nfft) {
@@ -104,13 +104,13 @@
 
   };
   template <> 
-  struct ei_fftw_plan
+  struct fftw_plan
   {
       typedef double scalar_type;
       typedef fftw_complex complex_type;
       fftw_plan m_plan;
-      ei_fftw_plan() :m_plan(NULL) {}
-      ~ei_fftw_plan() {if (m_plan) fftw_destroy_plan(m_plan);}
+      fftw_plan() :m_plan(NULL) {}
+      ~fftw_plan() {if (m_plan) fftw_destroy_plan(m_plan);}
 
       inline
       void fwd(complex_type * dst,complex_type * src,int nfft) {
@@ -145,13 +145,13 @@
       }
   };
   template <> 
-  struct ei_fftw_plan
+  struct fftw_plan
   {
       typedef long double scalar_type;
       typedef fftwl_complex complex_type;
       fftwl_plan m_plan;
-      ei_fftw_plan() :m_plan(NULL) {}
-      ~ei_fftw_plan() {if (m_plan) fftwl_destroy_plan(m_plan);}
+      fftw_plan() :m_plan(NULL) {}
+      ~fftw_plan() {if (m_plan) fftwl_destroy_plan(m_plan);}
 
       inline
       void fwd(complex_type * dst,complex_type * src,int nfft) {
@@ -187,7 +187,7 @@
   };
 
   template 
-  struct ei_fftw_impl
+  struct fftw_impl
   {
       typedef _Scalar Scalar;
       typedef std::complex Complex;
@@ -202,47 +202,47 @@
       inline
       void fwd( Complex * dst,const Complex *src,int nfft)
       {
-        get_plan(nfft,false,dst,src).fwd(ei_fftw_cast(dst), ei_fftw_cast(src),nfft );
+        get_plan(nfft,false,dst,src).fwd(fftw_cast(dst), fftw_cast(src),nfft );
       }
 
       // real-to-complex forward FFT
       inline
       void fwd( Complex * dst,const Scalar * src,int nfft) 
       {
-          get_plan(nfft,false,dst,src).fwd(ei_fftw_cast(dst), ei_fftw_cast(src) ,nfft);
+          get_plan(nfft,false,dst,src).fwd(fftw_cast(dst), fftw_cast(src) ,nfft);
       }
 
       // 2-d complex-to-complex
       inline
       void fwd2(Complex * dst, const Complex * src, int n0,int n1)
       {
-          get_plan(n0,n1,false,dst,src).fwd2(ei_fftw_cast(dst), ei_fftw_cast(src) ,n0,n1);
+          get_plan(n0,n1,false,dst,src).fwd2(fftw_cast(dst), fftw_cast(src) ,n0,n1);
       }
 
       // inverse complex-to-complex
       inline
       void inv(Complex * dst,const Complex  *src,int nfft)
       {
-        get_plan(nfft,true,dst,src).inv(ei_fftw_cast(dst), ei_fftw_cast(src),nfft );
+        get_plan(nfft,true,dst,src).inv(fftw_cast(dst), fftw_cast(src),nfft );
       }
 
       // half-complex to scalar
       inline
       void inv( Scalar * dst,const Complex * src,int nfft) 
       {
-        get_plan(nfft,true,dst,src).inv(ei_fftw_cast(dst), ei_fftw_cast(src),nfft );
+        get_plan(nfft,true,dst,src).inv(fftw_cast(dst), fftw_cast(src),nfft );
       }
 
       // 2-d complex-to-complex
       inline
       void inv2(Complex * dst, const Complex * src, int n0,int n1)
       {
-        get_plan(n0,n1,true,dst,src).inv2(ei_fftw_cast(dst), ei_fftw_cast(src) ,n0,n1);
+        get_plan(n0,n1,true,dst,src).inv2(fftw_cast(dst), fftw_cast(src) ,n0,n1);
       }
 
 
   protected:
-      typedef ei_fftw_plan PlanData;
+      typedef fftw_plan PlanData;
 
       typedef std::map PlanMap;
 
@@ -266,5 +266,7 @@
           return m_plans[key];
       }
   };
-/* vim: set filetype=cpp et sw=2 ts=2 ai: */
 
+} // end namespace internal
+
+/* vim: set filetype=cpp et sw=2 ts=2 ai: */
diff --git a/unsupported/Eigen/src/FFT/ei_kissfft_impl.h b/unsupported/Eigen/src/FFT/ei_kissfft_impl.h
index 5db1bf37d..667638f40 100644
--- a/unsupported/Eigen/src/FFT/ei_kissfft_impl.h
+++ b/unsupported/Eigen/src/FFT/ei_kissfft_impl.h
@@ -22,13 +22,13 @@
 // License and a copy of the GNU General Public License along with
 // Eigen. If not, see .
 
-
+namespace internal {
 
   // This FFT implementation was derived from kissfft http:sourceforge.net/projects/kissfft
   // Copyright 2003-2009 Mark Borgerding
 
 template 
-struct ei_kiss_cpx_fft
+struct kiss_cpx_fft
 {
   typedef _Scalar Scalar;
   typedef std::complex Complex;
@@ -274,7 +274,7 @@ struct ei_kiss_cpx_fft
 };
 
 template 
-struct ei_kissfft_impl
+struct kissfft_impl
 {
   typedef _Scalar Scalar;
   typedef std::complex Complex;
@@ -378,7 +378,7 @@ struct ei_kissfft_impl
     }
 
   protected:
-  typedef ei_kiss_cpx_fft PlanData;
+  typedef kiss_cpx_fft PlanData;
   typedef std::map PlanMap;
 
   PlanMap m_plans;
@@ -416,5 +416,7 @@ struct ei_kissfft_impl
     }
 };
 
+} // end namespace internal
+
 /* vim: set filetype=cpp et sw=2 ts=2 ai: */
 
diff --git a/unsupported/Eigen/src/IterativeSolvers/ConstrainedConjGrad.h b/unsupported/Eigen/src/IterativeSolvers/ConstrainedConjGrad.h
index 88339b354..f4851d316 100644
--- a/unsupported/Eigen/src/IterativeSolvers/ConstrainedConjGrad.h
+++ b/unsupported/Eigen/src/IterativeSolvers/ConstrainedConjGrad.h
@@ -50,14 +50,16 @@
 
 #include 
 
+namespace internal {
+
 /** \ingroup IterativeSolvers_Module
   * Compute the pseudo inverse of the non-square matrix C such that
   * \f$ CINV = (C * C^T)^{-1} * C \f$ based on a conjugate gradient method.
   *
-  * This function is internally used by ei_constrained_cg.
+  * This function is internally used by constrained_cg.
   */
 template 
-void ei_pseudo_inverse(const CMatrix &C, CINVMatrix &CINV)
+void pseudo_inverse(const CMatrix &C, CINVMatrix &CINV)
 {
   // optimisable : copie de la ligne, precalcul de C * trans(C).
   typedef typename CMatrix::Scalar Scalar;
@@ -113,7 +115,7 @@ void ei_pseudo_inverse(const CMatrix &C, CINVMatrix &CINV)
   */
 template
-void ei_constrained_cg(const TMatrix& A, const CMatrix& C, VectorX& x,
+void constrained_cg(const TMatrix& A, const CMatrix& C, VectorX& x,
                        const VectorB& b, const VectorF& f, IterationController &iter)
 {
   typedef typename TMatrix::Scalar Scalar;
@@ -127,11 +129,11 @@ void ei_constrained_cg(const TMatrix& A, const CMatrix& C, VectorX& x,
           memox(xSize);
   std::vector satured(C.rows());
   p.setZero();
-  iter.setRhsNorm(ei_sqrt(b.dot(b))); // gael vect_sp(PS, b, b)
+  iter.setRhsNorm(sqrt(b.dot(b))); // gael vect_sp(PS, b, b)
   if (iter.rhsNorm() == 0.0) iter.setRhsNorm(1.0);
 
   SparseMatrix CINV(C.rows(), C.cols());
-  ei_pseudo_inverse(C, CINV);
+  pseudo_inverse(C, CINV);
 
   while(true)
   {
@@ -191,4 +193,6 @@ void ei_constrained_cg(const TMatrix& A, const CMatrix& C, VectorX& x,
   }
 }
 
+} // end namespace internal
+
 #endif // EIGEN_CONSTRAINEDCG_H
diff --git a/unsupported/Eigen/src/IterativeSolvers/IterationController.h b/unsupported/Eigen/src/IterativeSolvers/IterationController.h
index 7d579a6fd..385d8c546 100644
--- a/unsupported/Eigen/src/IterativeSolvers/IterationController.h
+++ b/unsupported/Eigen/src/IterativeSolvers/IterationController.h
@@ -140,7 +140,7 @@ class IterationController
     bool converged() const { return m_res <= m_rhsn * m_resmax; }
     bool converged(double nr)
     {
-      m_res = ei_abs(nr); 
+      m_res = internal::abs(nr); 
       m_resminreach = std::min(m_resminreach, m_res);
       return converged();
     }
diff --git a/unsupported/Eigen/src/MatrixFunctions/MatrixExponential.h b/unsupported/Eigen/src/MatrixFunctions/MatrixExponential.h
index 006371474..ae937acda 100644
--- a/unsupported/Eigen/src/MatrixFunctions/MatrixExponential.h
+++ b/unsupported/Eigen/src/MatrixFunctions/MatrixExponential.h
@@ -128,11 +128,11 @@ class MatrixExponential {
      */
     void computeUV(float);
 
-    typedef typename ei_traits::Scalar Scalar;
+    typedef typename internal::traits::Scalar Scalar;
     typedef typename NumTraits::Real RealScalar;
 
     /** \brief Reference to matrix whose exponential is to be computed. */
-    typename ei_nested::type m_M;
+    typename internal::nested::type m_M;
 
     /** \brief Even-degree terms in numerator of Padé approximant. */
     MatrixType m_U;
@@ -327,16 +327,18 @@ template struct MatrixExponentialReturnValue
     MatrixExponentialReturnValue& operator=(const MatrixExponentialReturnValue&);
 };
 
+namespace internal {
 template
-struct ei_traits >
+struct traits >
 {
   typedef typename Derived::PlainObject ReturnType;
 };
+}
 
 template 
 const MatrixExponentialReturnValue MatrixBase::exp() const
 {
-  ei_assert(rows() == cols());
+  eigen_assert(rows() == cols());
   return MatrixExponentialReturnValue(derived());
 }
 
diff --git a/unsupported/Eigen/src/MatrixFunctions/MatrixFunction.h b/unsupported/Eigen/src/MatrixFunctions/MatrixFunction.h
index e83e055e9..a4aa9baa7 100644
--- a/unsupported/Eigen/src/MatrixFunctions/MatrixFunction.h
+++ b/unsupported/Eigen/src/MatrixFunctions/MatrixFunction.h
@@ -34,14 +34,14 @@
   * \tparam MatrixType type of the argument of the matrix function,
   * expected to be an instantiation of the Matrix class template.
   */
-template ::Scalar>::IsComplex>
+template ::Scalar>::IsComplex>
 class MatrixFunction
 {  
   private:
 
-    typedef typename ei_traits::Index Index;
-    typedef typename ei_traits::Scalar Scalar;    
-    typedef typename ei_stem_function::type StemFunction;
+    typedef typename internal::traits::Index Index;
+    typedef typename internal::traits::Scalar Scalar;    
+    typedef typename internal::stem_function::type StemFunction;
 
   public:
 
@@ -76,7 +76,7 @@ class MatrixFunction
 {  
   private:
 
-    typedef ei_traits Traits;
+    typedef internal::traits Traits;
     typedef typename Traits::Scalar Scalar;
     static const int Rows = Traits::RowsAtCompileTime;
     static const int Cols = Traits::ColsAtCompileTime;
@@ -86,7 +86,7 @@ class MatrixFunction
 
     typedef std::complex ComplexScalar;
     typedef Matrix ComplexMatrix;
-    typedef typename ei_stem_function::type StemFunction;
+    typedef typename internal::stem_function::type StemFunction;
 
   public:
 
@@ -117,7 +117,7 @@ class MatrixFunction
     }
 
   private:
-    typename ei_nested::type m_A; /**< \brief Reference to argument of matrix function. */
+    typename internal::nested::type m_A; /**< \brief Reference to argument of matrix function. */
     StemFunction *m_f; /**< \brief Stem function for matrix function under consideration */    
 
     MatrixFunction& operator=(const MatrixFunction&);
@@ -132,14 +132,14 @@ class MatrixFunction
 {
   private:
 
-    typedef ei_traits Traits;
+    typedef internal::traits Traits;
     typedef typename MatrixType::Scalar Scalar;
     typedef typename MatrixType::Index Index;
     static const int RowsAtCompileTime = Traits::RowsAtCompileTime;
     static const int ColsAtCompileTime = Traits::ColsAtCompileTime;
     static const int Options = MatrixType::Options;
     typedef typename NumTraits::Real RealScalar;
-    typedef typename ei_stem_function::type StemFunction;
+    typedef typename internal::stem_function::type StemFunction;
     typedef Matrix VectorType;
     typedef Matrix IntVectorType;
     typedef Matrix DynamicIntVectorType;
@@ -167,7 +167,7 @@ class MatrixFunction
     void computeOffDiagonal();
     DynMatrixType solveTriangularSylvester(const DynMatrixType& A, const DynMatrixType& B, const DynMatrixType& C);
 
-    typename ei_nested::type m_A; /**< \brief Reference to argument of matrix function. */
+    typename internal::nested::type m_A; /**< \brief Reference to argument of matrix function. */
     StemFunction *m_f; /**< \brief Stem function for matrix function under consideration */
     MatrixType m_T; /**< \brief Triangular part of Schur decomposition */
     MatrixType m_U; /**< \brief Unitary part of Schur decomposition */
@@ -260,7 +260,7 @@ void MatrixFunction::partitionEigenvalues()
 
     // Look for other element to add to the set
     for (Index j=i+1; jbegin(), qi->end(), diag(j)) == qi->end()) {
+      if (internal::abs(diag(j) - diag(i)) <= separation() && std::find(qi->begin(), qi->end(), diag(j)) == qi->end()) {
 	typename ListOfClusters::iterator qj = findCluster(diag(j));
 	if (qj == m_clusters.end()) {
 	  qi->push_back(diag(j));
@@ -346,7 +346,7 @@ void MatrixFunction::permuteSchur()
     for (j = i; j < p.rows(); j++) {
       if (p(j) == i) break;
     }
-    ei_assert(p(j) == i);
+    eigen_assert(p(j) == i);
     for (Index k = j-1; k >= i; k--) {
       swapEntriesInSchur(k);
       std::swap(p.coeffRef(k), p.coeffRef(k+1));
@@ -445,12 +445,12 @@ typename MatrixFunction::DynMatrixType MatrixFunction class MatrixFunctionReturnValue
 
     typedef typename Derived::Scalar Scalar;
     typedef typename Derived::Index Index;
-    typedef typename ei_stem_function::type StemFunction;
+    typedef typename internal::stem_function::type StemFunction;
 
    /** \brief Constructor.
       *
@@ -529,58 +529,60 @@ template class MatrixFunctionReturnValue
     Index cols() const { return m_A.cols(); }
 
   private:
-    typename ei_nested::type m_A;
+    typename internal::nested::type m_A;
     StemFunction *m_f;
 
     MatrixFunctionReturnValue& operator=(const MatrixFunctionReturnValue&);
 };
 
+namespace internal {
 template
-struct ei_traits >
+struct traits >
 {
   typedef typename Derived::PlainObject ReturnType;
 };
+}
 
 
 /********** MatrixBase methods **********/
 
 
 template 
-const MatrixFunctionReturnValue MatrixBase::matrixFunction(typename ei_stem_function::Scalar>::type f) const
+const MatrixFunctionReturnValue MatrixBase::matrixFunction(typename internal::stem_function::Scalar>::type f) const
 {
-  ei_assert(rows() == cols());
+  eigen_assert(rows() == cols());
   return MatrixFunctionReturnValue(derived(), f);
 }
 
 template 
 const MatrixFunctionReturnValue MatrixBase::sin() const
 {
-  ei_assert(rows() == cols());
-  typedef typename ei_stem_function::ComplexScalar ComplexScalar;
+  eigen_assert(rows() == cols());
+  typedef typename internal::stem_function::ComplexScalar ComplexScalar;
   return MatrixFunctionReturnValue(derived(), StdStemFunctions::sin);
 }
 
 template 
 const MatrixFunctionReturnValue MatrixBase::cos() const
 {
-  ei_assert(rows() == cols());
-  typedef typename ei_stem_function::ComplexScalar ComplexScalar;
+  eigen_assert(rows() == cols());
+  typedef typename internal::stem_function::ComplexScalar ComplexScalar;
   return MatrixFunctionReturnValue(derived(), StdStemFunctions::cos);
 }
 
 template 
 const MatrixFunctionReturnValue MatrixBase::sinh() const
 {
-  ei_assert(rows() == cols());
-  typedef typename ei_stem_function::ComplexScalar ComplexScalar;
+  eigen_assert(rows() == cols());
+  typedef typename internal::stem_function::ComplexScalar ComplexScalar;
   return MatrixFunctionReturnValue(derived(), StdStemFunctions::sinh);
 }
 
 template 
 const MatrixFunctionReturnValue MatrixBase::cosh() const
 {
-  ei_assert(rows() == cols());
-  typedef typename ei_stem_function::ComplexScalar ComplexScalar;
+  eigen_assert(rows() == cols());
+  typedef typename internal::stem_function::ComplexScalar ComplexScalar;
   return MatrixFunctionReturnValue(derived(), StdStemFunctions::cosh);
 }
 
diff --git a/unsupported/Eigen/src/MatrixFunctions/MatrixFunctionAtomic.h b/unsupported/Eigen/src/MatrixFunctions/MatrixFunctionAtomic.h
index ceb0a84f1..87dc64ce1 100644
--- a/unsupported/Eigen/src/MatrixFunctions/MatrixFunctionAtomic.h
+++ b/unsupported/Eigen/src/MatrixFunctions/MatrixFunctionAtomic.h
@@ -41,7 +41,7 @@ class MatrixFunctionAtomic
     typedef typename MatrixType::Scalar Scalar;
     typedef typename MatrixType::Index Index;
     typedef typename NumTraits::Real RealScalar;
-    typedef typename ei_stem_function::type StemFunction;
+    typedef typename internal::stem_function::type StemFunction;
     typedef Matrix VectorType;
 
     /** \brief Constructor
@@ -99,7 +99,7 @@ MatrixType MatrixFunctionAtomic::compute(const MatrixType& A)
       return F;
     }
   }
-  ei_assert("Taylor series does not converge" && 0);
+  eigen_assert("Taylor series does not converge" && 0);
   return F;
 }
 
diff --git a/unsupported/Eigen/src/MoreVectorization/MathFunctions.h b/unsupported/Eigen/src/MoreVectorization/MathFunctions.h
index a998a0615..bc948d0bd 100644
--- a/unsupported/Eigen/src/MoreVectorization/MathFunctions.h
+++ b/unsupported/Eigen/src/MoreVectorization/MathFunctions.h
@@ -26,12 +26,14 @@
 #ifndef EIGEN_MOREVECTORIZATION_MATHFUNCTIONS_H
 #define EIGEN_MOREVECTORIZATION_MATHFUNCTIONS_H
 
+namespace internal {
+
 /** \internal \returns the arcsin of \a a (coeff-wise) */
-template inline static Packet ei_pasin(Packet a) { return std::asin(a); }
+template inline static Packet pasin(Packet a) { return std::asin(a); }
 
 #ifdef EIGEN_VECTORIZE_SSE
 
-template<> EIGEN_DONT_INLINE Packet4f ei_pasin(Packet4f x)
+template<> EIGEN_DONT_INLINE Packet4f pasin(Packet4f x)
 {
   _EIGEN_DECLARE_CONST_Packet4f(half, 0.5);
   _EIGEN_DECLARE_CONST_Packet4f(minus_half, -0.5);
@@ -48,9 +50,9 @@ template<> EIGEN_DONT_INLINE Packet4f ei_pasin(Packet4f x)
   _EIGEN_DECLARE_CONST_Packet4f(asin4, 7.4953002686E-2);
   _EIGEN_DECLARE_CONST_Packet4f(asin5, 1.6666752422E-1);
 
-  Packet4f a = ei_pabs(x);//got the absolute value
+  Packet4f a = pabs(x);//got the absolute value
 
-  Packet4f sign_bit= _mm_and_ps(x, ei_p4f_sign_mask);//extracted the sign bit
+  Packet4f sign_bit= _mm_and_ps(x, p4f_sign_mask);//extracted the sign bit
 
   Packet4f z1,z2;//will need them during computation    
 
@@ -58,34 +60,34 @@ template<> EIGEN_DONT_INLINE Packet4f ei_pasin(Packet4f x)
 //will compute the two branches for asin
 //so first compare with half
 
-  Packet4f branch_mask= _mm_cmpgt_ps(a, ei_p4f_half);//this is to select which branch to take
+  Packet4f branch_mask= _mm_cmpgt_ps(a, p4f_half);//this is to select which branch to take
 //both will be taken, and finally results will be merged
 //the branch for values >0.5
 
     {
 //the core series expansion 
-    z1=ei_pmadd(ei_p4f_minus_half,a,ei_p4f_half);
-    Packet4f x1=ei_psqrt(z1);
-    Packet4f s1=ei_pmadd(ei_p4f_asin1, z1, ei_p4f_asin2);
-    Packet4f s2=ei_pmadd(s1, z1, ei_p4f_asin3);
-    Packet4f s3=ei_pmadd(s2,z1, ei_p4f_asin4);
-    Packet4f s4=ei_pmadd(s3,z1, ei_p4f_asin5);
-    Packet4f temp=ei_pmul(s4,z1);//not really a madd but a mul by z so that the next term can be a madd
-    z1=ei_pmadd(temp,x1,x1);
-    z1=ei_padd(z1,z1);
-    z1=ei_psub(ei_p4f_pi_over_2,z1);
+    z1=pmadd(p4f_minus_half,a,p4f_half);
+    Packet4f x1=psqrt(z1);
+    Packet4f s1=pmadd(p4f_asin1, z1, p4f_asin2);
+    Packet4f s2=pmadd(s1, z1, p4f_asin3);
+    Packet4f s3=pmadd(s2,z1, p4f_asin4);
+    Packet4f s4=pmadd(s3,z1, p4f_asin5);
+    Packet4f temp=pmul(s4,z1);//not really a madd but a mul by z so that the next term can be a madd
+    z1=pmadd(temp,x1,x1);
+    z1=padd(z1,z1);
+    z1=psub(p4f_pi_over_2,z1);
     }
 
     {
 //the core series expansion 
     Packet4f x2=a;
-    z2=ei_pmul(x2,x2);
-    Packet4f s1=ei_pmadd(ei_p4f_asin1, z2, ei_p4f_asin2);
-    Packet4f s2=ei_pmadd(s1, z2, ei_p4f_asin3);
-    Packet4f s3=ei_pmadd(s2,z2, ei_p4f_asin4);
-    Packet4f s4=ei_pmadd(s3,z2, ei_p4f_asin5);
-    Packet4f temp=ei_pmul(s4,z2);//not really a madd but a mul by z so that the next term can be a madd
-    z2=ei_pmadd(temp,x2,x2);
+    z2=pmul(x2,x2);
+    Packet4f s1=pmadd(p4f_asin1, z2, p4f_asin2);
+    Packet4f s2=pmadd(s1, z2, p4f_asin3);
+    Packet4f s3=pmadd(s2,z2, p4f_asin4);
+    Packet4f s4=pmadd(s3,z2, p4f_asin5);
+    Packet4f temp=pmul(s4,z2);//not really a madd but a mul by z so that the next term can be a madd
+    z2=pmadd(temp,x2,x2);
     }
 
 /* select the correct result from the two branch evaluations */
@@ -97,6 +99,7 @@ template<> EIGEN_DONT_INLINE Packet4f ei_pasin(Packet4f x)
   return _mm_xor_ps(z, sign_bit);
 }
 
+} // end namespace internal
 
 #endif
 
diff --git a/unsupported/Eigen/src/NonLinearOptimization/HybridNonLinearSolver.h b/unsupported/Eigen/src/NonLinearOptimization/HybridNonLinearSolver.h
index 3308a4a34..a4863700e 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/HybridNonLinearSolver.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/HybridNonLinearSolver.h
@@ -65,7 +65,7 @@ public:
         Parameters()
             : factor(Scalar(100.))
             , maxfev(1000)
-            , xtol(ei_sqrt(NumTraits::epsilon()))
+            , xtol(internal::sqrt(NumTraits::epsilon()))
             , nb_of_subdiagonals(-1)
             , nb_of_superdiagonals(-1)
             , epsfcn(Scalar(0.)) {}
@@ -83,7 +83,7 @@ public:
 
     HybridNonLinearSolverSpace::Status hybrj1(
             FVectorType  &x,
-            const Scalar tol = ei_sqrt(NumTraits::epsilon())
+            const Scalar tol = internal::sqrt(NumTraits::epsilon())
             );
 
     HybridNonLinearSolverSpace::Status solveInit(FVectorType  &x);
@@ -92,7 +92,7 @@ public:
 
     HybridNonLinearSolverSpace::Status hybrd1(
             FVectorType  &x,
-            const Scalar tol = ei_sqrt(NumTraits::epsilon())
+            const Scalar tol = internal::sqrt(NumTraits::epsilon())
             );
 
     HybridNonLinearSolverSpace::Status solveNumericalDiffInit(FVectorType  &x);
@@ -246,7 +246,7 @@ HybridNonLinearSolver::solveOneStep(FVectorType  &x)
 
     while (true) {
         /* determine the direction p. */
-        ei_dogleg(R, diag, qtf, delta, wa1);
+        internal::dogleg(R, diag, qtf, delta, wa1);
 
         /* store the direction p and x + p. calculate the norm of p. */
         wa1 = -wa1;
@@ -266,14 +266,14 @@ HybridNonLinearSolver::solveOneStep(FVectorType  &x)
         /* compute the scaled actual reduction. */
         actred = -1.;
         if (fnorm1 < fnorm) /* Computing 2nd power */
-            actred = 1. - ei_abs2(fnorm1 / fnorm);
+            actred = 1. - internal::abs2(fnorm1 / fnorm);
 
         /* compute the scaled predicted reduction. */
         wa3 = R.template triangularView()*wa1 + qtf;
         temp = wa3.stableNorm();
         prered = 0.;
         if (temp < fnorm) /* Computing 2nd power */
-            prered = 1. - ei_abs2(temp / fnorm);
+            prered = 1. - internal::abs2(temp / fnorm);
 
         /* compute the ratio of the actual to the predicted reduction. */
         ratio = 0.;
@@ -290,7 +290,7 @@ HybridNonLinearSolver::solveOneStep(FVectorType  &x)
             ++ncsuc;
             if (ratio >= Scalar(.5) || ncsuc > 1)
                 delta = std::max(delta, pnorm / Scalar(.5));
-            if (ei_abs(ratio - 1.) <= Scalar(.1)) {
+            if (internal::abs(ratio - 1.) <= Scalar(.1)) {
                 delta = pnorm / Scalar(.5);
             }
         }
@@ -342,9 +342,9 @@ HybridNonLinearSolver::solveOneStep(FVectorType  &x)
         wa2 = (wa2-wa3)/pnorm;
 
         /* compute the qr factorization of the updated jacobian. */
-        ei_r1updt(R, wa1, v_givens, w_givens, wa2, wa3, &sing);
-        ei_r1mpyq(n, n, fjac.data(), v_givens, w_givens);
-        ei_r1mpyq(1, n, qtf.data(), v_givens, w_givens);
+        internal::r1updt(R, wa1, v_givens, w_givens, wa2, wa3, &sing);
+        internal::r1mpyq(n, n, fjac.data(), v_givens, w_givens);
+        internal::r1mpyq(1, n, qtf.data(), v_givens, w_givens);
 
         jeval = false;
     }
@@ -447,7 +447,7 @@ HybridNonLinearSolver::solveNumericalDiffOneStep(FVectorType
     if (parameters.nb_of_superdiagonals<0) parameters.nb_of_superdiagonals= n-1;
 
     /* calculate the jacobian matrix. */
-    if (ei_fdjac1(functor, x, fvec, fjac, parameters.nb_of_subdiagonals, parameters.nb_of_superdiagonals, parameters.epsfcn) <0)
+    if (internal::fdjac1(functor, x, fvec, fjac, parameters.nb_of_subdiagonals, parameters.nb_of_superdiagonals, parameters.epsfcn) <0)
         return HybridNonLinearSolverSpace::UserAksed;
     nfev += std::min(parameters.nb_of_subdiagonals+parameters.nb_of_superdiagonals+ 1, n);
 
@@ -487,7 +487,7 @@ HybridNonLinearSolver::solveNumericalDiffOneStep(FVectorType
 
     while (true) {
         /* determine the direction p. */
-        ei_dogleg(R, diag, qtf, delta, wa1);
+        internal::dogleg(R, diag, qtf, delta, wa1);
 
         /* store the direction p and x + p. calculate the norm of p. */
         wa1 = -wa1;
@@ -507,14 +507,14 @@ HybridNonLinearSolver::solveNumericalDiffOneStep(FVectorType
         /* compute the scaled actual reduction. */
         actred = -1.;
         if (fnorm1 < fnorm) /* Computing 2nd power */
-            actred = 1. - ei_abs2(fnorm1 / fnorm);
+            actred = 1. - internal::abs2(fnorm1 / fnorm);
 
         /* compute the scaled predicted reduction. */
         wa3 = R.template triangularView()*wa1 + qtf;
         temp = wa3.stableNorm();
         prered = 0.;
         if (temp < fnorm) /* Computing 2nd power */
-            prered = 1. - ei_abs2(temp / fnorm);
+            prered = 1. - internal::abs2(temp / fnorm);
 
         /* compute the ratio of the actual to the predicted reduction. */
         ratio = 0.;
@@ -531,7 +531,7 @@ HybridNonLinearSolver::solveNumericalDiffOneStep(FVectorType
             ++ncsuc;
             if (ratio >= Scalar(.5) || ncsuc > 1)
                 delta = std::max(delta, pnorm / Scalar(.5));
-            if (ei_abs(ratio - 1.) <= Scalar(.1)) {
+            if (internal::abs(ratio - 1.) <= Scalar(.1)) {
                 delta = pnorm / Scalar(.5);
             }
         }
@@ -583,9 +583,9 @@ HybridNonLinearSolver::solveNumericalDiffOneStep(FVectorType
         wa2 = (wa2-wa3)/pnorm;
 
         /* compute the qr factorization of the updated jacobian. */
-        ei_r1updt(R, wa1, v_givens, w_givens, wa2, wa3, &sing);
-        ei_r1mpyq(n, n, fjac.data(), v_givens, w_givens);
-        ei_r1mpyq(1, n, qtf.data(), v_givens, w_givens);
+        internal::r1updt(R, wa1, v_givens, w_givens, wa2, wa3, &sing);
+        internal::r1mpyq(n, n, fjac.data(), v_givens, w_givens);
+        internal::r1mpyq(1, n, qtf.data(), v_givens, w_givens);
 
         jeval = false;
     }
diff --git a/unsupported/Eigen/src/NonLinearOptimization/LevenbergMarquardt.h b/unsupported/Eigen/src/NonLinearOptimization/LevenbergMarquardt.h
index a8f3f3e64..c43df3f7a 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/LevenbergMarquardt.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/LevenbergMarquardt.h
@@ -69,8 +69,8 @@ public:
         Parameters()
             : factor(Scalar(100.))
             , maxfev(400)
-            , ftol(ei_sqrt(NumTraits::epsilon()))
-            , xtol(ei_sqrt(NumTraits::epsilon()))
+            , ftol(internal::sqrt(NumTraits::epsilon()))
+            , xtol(internal::sqrt(NumTraits::epsilon()))
             , gtol(Scalar(0.))
             , epsfcn(Scalar(0.)) {}
         Scalar factor;
@@ -86,7 +86,7 @@ public:
 
     LevenbergMarquardtSpace::Status lmder1(
             FVectorType &x,
-            const Scalar tol = ei_sqrt(NumTraits::epsilon())
+            const Scalar tol = internal::sqrt(NumTraits::epsilon())
             );
 
     LevenbergMarquardtSpace::Status minimize(FVectorType &x);
@@ -97,12 +97,12 @@ public:
             FunctorType &functor,
             FVectorType &x,
             Index *nfev,
-            const Scalar tol = ei_sqrt(NumTraits::epsilon())
+            const Scalar tol = internal::sqrt(NumTraits::epsilon())
             );
 
     LevenbergMarquardtSpace::Status lmstr1(
             FVectorType  &x,
-            const Scalar tol = ei_sqrt(NumTraits::epsilon())
+            const Scalar tol = internal::sqrt(NumTraits::epsilon())
             );
 
     LevenbergMarquardtSpace::Status minimizeOptimumStorage(FVectorType  &x);
@@ -263,7 +263,7 @@ LevenbergMarquardt::minimizeOneStep(FVectorType  &x)
     if (fnorm != 0.)
         for (Index j = 0; j < n; ++j)
             if (wa2[permutation.indices()[j]] != 0.)
-                gnorm = std::max(gnorm, ei_abs( fjac.col(j).head(j+1).dot(qtf.head(j+1)/fnorm) / wa2[permutation.indices()[j]]));
+                gnorm = std::max(gnorm, internal::abs( fjac.col(j).head(j+1).dot(qtf.head(j+1)/fnorm) / wa2[permutation.indices()[j]]));
 
     /* test for convergence of the gradient norm. */
     if (gnorm <= parameters.gtol)
@@ -276,7 +276,7 @@ LevenbergMarquardt::minimizeOneStep(FVectorType  &x)
     do {
 
         /* determine the levenberg-marquardt parameter. */
-        ei_lmpar2(qrfac, diag, qtf, delta, par, wa1);
+        internal::lmpar2(qrfac, diag, qtf, delta, par, wa1);
 
         /* store the direction p and x + p. calculate the norm of p. */
         wa1 = -wa1;
@@ -296,13 +296,13 @@ LevenbergMarquardt::minimizeOneStep(FVectorType  &x)
         /* compute the scaled actual reduction. */
         actred = -1.;
         if (Scalar(.1) * fnorm1 < fnorm)
-            actred = 1. - ei_abs2(fnorm1 / fnorm);
+            actred = 1. - internal::abs2(fnorm1 / fnorm);
 
         /* compute the scaled predicted reduction and */
         /* the scaled directional derivative. */
         wa3 = fjac.template triangularView() * (qrfac.colsPermutation().inverse() *wa1);
-        temp1 = ei_abs2(wa3.stableNorm() / fnorm);
-        temp2 = ei_abs2(ei_sqrt(par) * pnorm / fnorm);
+        temp1 = internal::abs2(wa3.stableNorm() / fnorm);
+        temp2 = internal::abs2(internal::sqrt(par) * pnorm / fnorm);
         prered = temp1 + temp2 / Scalar(.5);
         dirder = -(temp1 + temp2);
 
@@ -340,9 +340,9 @@ LevenbergMarquardt::minimizeOneStep(FVectorType  &x)
         }
 
         /* tests for convergence. */
-        if (ei_abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1. && delta <= parameters.xtol * xnorm)
+        if (internal::abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1. && delta <= parameters.xtol * xnorm)
             return LevenbergMarquardtSpace::RelativeErrorAndReductionTooSmall;
-        if (ei_abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1.)
+        if (internal::abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1.)
             return LevenbergMarquardtSpace::RelativeReductionTooSmall;
         if (delta <= parameters.xtol * xnorm)
             return LevenbergMarquardtSpace::RelativeErrorTooSmall;
@@ -350,7 +350,7 @@ LevenbergMarquardt::minimizeOneStep(FVectorType  &x)
         /* tests for termination and stringent tolerances. */
         if (nfev >= parameters.maxfev)
             return LevenbergMarquardtSpace::TooManyFunctionEvaluation;
-        if (ei_abs(actred) <= NumTraits::epsilon() && prered <= NumTraits::epsilon() && Scalar(.5) * ratio <= 1.)
+        if (internal::abs(actred) <= NumTraits::epsilon() && prered <= NumTraits::epsilon() && Scalar(.5) * ratio <= 1.)
             return LevenbergMarquardtSpace::FtolTooSmall;
         if (delta <= NumTraits::epsilon() * xnorm)
             return LevenbergMarquardtSpace::XtolTooSmall;
@@ -451,7 +451,7 @@ LevenbergMarquardt::minimizeOptimumStorageOneStep(FVectorTyp
     Index rownb = 2;
     for (i = 0; i < m; ++i) {
         if (functor.df(x, wa3, rownb) < 0) return LevenbergMarquardtSpace::UserAsked;
-        ei_rwupdt(fjac, wa3, qtf, fvec[i]);
+        internal::rwupdt(fjac, wa3, qtf, fvec[i]);
         ++rownb;
     }
     ++njev;
@@ -510,7 +510,7 @@ LevenbergMarquardt::minimizeOptimumStorageOneStep(FVectorTyp
     if (fnorm != 0.)
         for (j = 0; j < n; ++j)
             if (wa2[permutation.indices()[j]] != 0.)
-                gnorm = std::max(gnorm, ei_abs( fjac.col(j).head(j+1).dot(qtf.head(j+1)/fnorm) / wa2[permutation.indices()[j]]));
+                gnorm = std::max(gnorm, internal::abs( fjac.col(j).head(j+1).dot(qtf.head(j+1)/fnorm) / wa2[permutation.indices()[j]]));
 
     /* test for convergence of the gradient norm. */
     if (gnorm <= parameters.gtol)
@@ -523,7 +523,7 @@ LevenbergMarquardt::minimizeOptimumStorageOneStep(FVectorTyp
     do {
 
         /* determine the levenberg-marquardt parameter. */
-        ei_lmpar(fjac, permutation.indices(), diag, qtf, delta, par, wa1);
+        internal::lmpar(fjac, permutation.indices(), diag, qtf, delta, par, wa1);
 
         /* store the direction p and x + p. calculate the norm of p. */
         wa1 = -wa1;
@@ -543,13 +543,13 @@ LevenbergMarquardt::minimizeOptimumStorageOneStep(FVectorTyp
         /* compute the scaled actual reduction. */
         actred = -1.;
         if (Scalar(.1) * fnorm1 < fnorm)
-            actred = 1. - ei_abs2(fnorm1 / fnorm);
+            actred = 1. - internal::abs2(fnorm1 / fnorm);
 
         /* compute the scaled predicted reduction and */
         /* the scaled directional derivative. */
         wa3 = fjac.topLeftCorner(n,n).template triangularView() * (permutation.inverse() * wa1);
-        temp1 = ei_abs2(wa3.stableNorm() / fnorm);
-        temp2 = ei_abs2(ei_sqrt(par) * pnorm / fnorm);
+        temp1 = internal::abs2(wa3.stableNorm() / fnorm);
+        temp2 = internal::abs2(internal::sqrt(par) * pnorm / fnorm);
         prered = temp1 + temp2 / Scalar(.5);
         dirder = -(temp1 + temp2);
 
@@ -587,9 +587,9 @@ LevenbergMarquardt::minimizeOptimumStorageOneStep(FVectorTyp
         }
 
         /* tests for convergence. */
-        if (ei_abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1. && delta <= parameters.xtol * xnorm)
+        if (internal::abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1. && delta <= parameters.xtol * xnorm)
             return LevenbergMarquardtSpace::RelativeErrorAndReductionTooSmall;
-        if (ei_abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1.)
+        if (internal::abs(actred) <= parameters.ftol && prered <= parameters.ftol && Scalar(.5) * ratio <= 1.)
             return LevenbergMarquardtSpace::RelativeReductionTooSmall;
         if (delta <= parameters.xtol * xnorm)
             return LevenbergMarquardtSpace::RelativeErrorTooSmall;
@@ -597,7 +597,7 @@ LevenbergMarquardt::minimizeOptimumStorageOneStep(FVectorTyp
         /* tests for termination and stringent tolerances. */
         if (nfev >= parameters.maxfev)
             return LevenbergMarquardtSpace::TooManyFunctionEvaluation;
-        if (ei_abs(actred) <= NumTraits::epsilon() && prered <= NumTraits::epsilon() && Scalar(.5) * ratio <= 1.)
+        if (internal::abs(actred) <= NumTraits::epsilon() && prered <= NumTraits::epsilon() && Scalar(.5) * ratio <= 1.)
             return LevenbergMarquardtSpace::FtolTooSmall;
         if (delta <= NumTraits::epsilon() * xnorm)
             return LevenbergMarquardtSpace::XtolTooSmall;
diff --git a/unsupported/Eigen/src/NonLinearOptimization/chkder.h b/unsupported/Eigen/src/NonLinearOptimization/chkder.h
index 4cb4fbdef..e2bdf923c 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/chkder.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/chkder.h
@@ -2,8 +2,10 @@
 #define chkder_log10e 0.43429448190325182765
 #define chkder_factor 100.
 
+namespace internal {
+
 template
-void ei_chkder(
+void chkder(
         const Matrix< Scalar, Dynamic, 1 >  &x,
         const Matrix< Scalar, Dynamic, 1 >  &fvec,
         const Matrix< Scalar, Dynamic, Dynamic > &fjac,
@@ -15,9 +17,9 @@ void ei_chkder(
 {
     typedef DenseIndex Index;
 
-    const Scalar eps = ei_sqrt(NumTraits::epsilon());
+    const Scalar eps = sqrt(NumTraits::epsilon());
     const Scalar epsf = chkder_factor * NumTraits::epsilon();
-    const Scalar epslog = chkder_log10e * ei_log(eps);
+    const Scalar epslog = chkder_log10e * log(eps);
     Scalar temp;
 
     const Index m = fvec.size(), n = x.size();
@@ -26,7 +28,7 @@ void ei_chkder(
         /* mode = 1. */
         xp.resize(n);
         for (Index j = 0; j < n; ++j) {
-            temp = eps * ei_abs(x[j]);
+            temp = eps * abs(x[j]);
             if (temp == 0.)
                 temp = eps;
             xp[j] = x[j] + temp;
@@ -36,21 +38,22 @@ void ei_chkder(
         /* mode = 2. */
         err.setZero(m); 
         for (Index j = 0; j < n; ++j) {
-            temp = ei_abs(x[j]);
+            temp = abs(x[j]);
             if (temp == 0.)
                 temp = 1.;
             err += temp * fjac.col(j);
         }
         for (Index i = 0; i < m; ++i) {
             temp = 1.;
-            if (fvec[i] != 0. && fvecp[i] != 0. && ei_abs(fvecp[i] - fvec[i]) >= epsf * ei_abs(fvec[i]))
-                temp = eps * ei_abs((fvecp[i] - fvec[i]) / eps - err[i]) / (ei_abs(fvec[i]) + ei_abs(fvecp[i]));
+            if (fvec[i] != 0. && fvecp[i] != 0. && abs(fvecp[i] - fvec[i]) >= epsf * abs(fvec[i]))
+                temp = eps * abs((fvecp[i] - fvec[i]) / eps - err[i]) / (abs(fvec[i]) + abs(fvecp[i]));
             err[i] = 1.;
             if (temp > NumTraits::epsilon() && temp < eps)
-                err[i] = (chkder_log10e * ei_log(temp) - epslog) / epslog;
+                err[i] = (chkder_log10e * log(temp) - epslog) / epslog;
             if (temp >= eps)
                 err[i] = 0.;
         }
     }
 }
 
+} // end namespace internal
\ No newline at end of file
diff --git a/unsupported/Eigen/src/NonLinearOptimization/covar.h b/unsupported/Eigen/src/NonLinearOptimization/covar.h
index 104898a30..6c77916f5 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/covar.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/covar.h
@@ -1,9 +1,10 @@
+namespace internal {
 
 template 
-void ei_covar(
+void covar(
         Matrix< Scalar, Dynamic, Dynamic > &r,
         const VectorXi &ipvt,
-        Scalar tol = ei_sqrt(NumTraits::epsilon()) )
+        Scalar tol = sqrt(NumTraits::epsilon()) )
 {
     typedef DenseIndex Index;
 
@@ -14,14 +15,14 @@ void ei_covar(
 
     /* Function Body */
     const Index n = r.cols();
-    const Scalar tolr = tol * ei_abs(r(0,0));
+    const Scalar tolr = tol * abs(r(0,0));
     Matrix< Scalar, Dynamic, 1 > wa(n);
     assert(ipvt.size()==n);
 
     /* form the inverse of r in the full upper triangle of r. */
     l = -1;
     for (k = 0; k < n; ++k)
-        if (ei_abs(r(k,k)) > tolr) {
+        if (abs(r(k,k)) > tolr) {
             r(k,k) = 1. / r(k,k);
             for (j = 0; j <= k-1; ++j) {
                 temp = r(k,k) * r(j,k);
@@ -61,3 +62,4 @@ void ei_covar(
     r.diagonal() = wa;
 }
 
+} // end namespace internal
diff --git a/unsupported/Eigen/src/NonLinearOptimization/dogleg.h b/unsupported/Eigen/src/NonLinearOptimization/dogleg.h
index ab01d5c47..fffd9e0be 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/dogleg.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/dogleg.h
@@ -1,6 +1,7 @@
+namespace internal {
 
 template 
-void ei_dogleg(
+void dogleg(
         const Matrix< Scalar, Dynamic, Dynamic >  &qrfac,
         const Matrix< Scalar, Dynamic, 1 >  &diag,
         const Matrix< Scalar, Dynamic, 1 >  &qtb,
@@ -86,8 +87,8 @@ void ei_dogleg(
     /* at which the quadratic is minimized. */
     bnorm = qtb.stableNorm();
     temp = bnorm / gnorm * (bnorm / qnorm) * (sgnorm / delta);
-    temp = temp - delta / qnorm * ei_abs2(sgnorm / delta) + ei_sqrt(ei_abs2(temp - delta / qnorm) + (1.-ei_abs2(delta / qnorm)) * (1.-ei_abs2(sgnorm / delta)));
-    alpha = delta / qnorm * (1. - ei_abs2(sgnorm / delta)) / temp;
+    temp = temp - delta / qnorm * abs2(sgnorm / delta) + sqrt(abs2(temp - delta / qnorm) + (1.-abs2(delta / qnorm)) * (1.-abs2(sgnorm / delta)));
+    alpha = delta / qnorm * (1. - abs2(sgnorm / delta)) / temp;
 algo_end:
 
     /* form appropriate convex combination of the gauss-newton */
@@ -96,3 +97,4 @@ algo_end:
     x = temp * wa1 + alpha * x;
 }
 
+} // end namespace internal
diff --git a/unsupported/Eigen/src/NonLinearOptimization/fdjac1.h b/unsupported/Eigen/src/NonLinearOptimization/fdjac1.h
index 74cf53b90..887b76fa1 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/fdjac1.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/fdjac1.h
@@ -1,6 +1,7 @@
+namespace internal {
 
 template
-DenseIndex ei_fdjac1(
+DenseIndex fdjac1(
         const FunctorType &Functor,
         Matrix< Scalar, Dynamic, 1 >  &x,
         Matrix< Scalar, Dynamic, 1 >  &fvec,
@@ -25,13 +26,13 @@ DenseIndex ei_fdjac1(
     Matrix< Scalar, Dynamic, 1 >  wa1(n);
     Matrix< Scalar, Dynamic, 1 >  wa2(n);
 
-    eps = ei_sqrt(std::max(epsfcn,epsmch));
+    eps = sqrt(std::max(epsfcn,epsmch));
     msum = ml + mu + 1;
     if (msum >= n) {
         /* computation of dense approximate jacobian. */
         for (j = 0; j < n; ++j) {
             temp = x[j];
-            h = eps * ei_abs(temp);
+            h = eps * abs(temp);
             if (h == 0.)
                 h = eps;
             x[j] = temp + h;
@@ -47,7 +48,7 @@ DenseIndex ei_fdjac1(
         for (k = 0; k < msum; ++k) {
             for (j = k; (msum<0) ? (j>n): (jn): (j(0,j-mu);
@@ -68,3 +69,4 @@ DenseIndex ei_fdjac1(
     return 0;
 }
 
+} // end namespace internal
diff --git a/unsupported/Eigen/src/NonLinearOptimization/lmpar.h b/unsupported/Eigen/src/NonLinearOptimization/lmpar.h
index 27138de96..a6bbc50ba 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/lmpar.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/lmpar.h
@@ -1,6 +1,7 @@
+namespace internal {
 
 template 
-void ei_lmpar(
+void lmpar(
         Matrix< Scalar, Dynamic, Dynamic > &r,
         const VectorXi &ipvt,
         const Matrix< Scalar, Dynamic, 1 >  &diag,
@@ -106,10 +107,10 @@ void ei_lmpar(
         /* evaluate the function at the current value of par. */
         if (par == 0.)
             par = std::max(dwarf,Scalar(.001) * paru); /* Computing MAX */
-        wa1 = ei_sqrt(par)* diag;
+        wa1 = sqrt(par)* diag;
 
         Matrix< Scalar, Dynamic, 1 > sdiag(n);
-        ei_qrsolv(r, ipvt, wa1, qtb, x, sdiag);
+        qrsolv(r, ipvt, wa1, qtb, x, sdiag);
 
         wa2 = diag.cwiseProduct(x);
         dxnorm = wa2.blueNorm();
@@ -119,7 +120,7 @@ void ei_lmpar(
         /* if the function is small enough, accept the current value */
         /* of par. also test for the exceptional cases where parl */
         /* is zero or the number of iterations has reached 10. */
-        if (ei_abs(fp) <= Scalar(0.1) * delta || (parl == 0. && fp <= temp && temp < 0.) || iter == 10)
+        if (abs(fp) <= Scalar(0.1) * delta || (parl == 0. && fp <= temp && temp < 0.) || iter == 10)
             break;
 
         /* compute the newton correction. */
@@ -156,7 +157,7 @@ void ei_lmpar(
 }
 
 template 
-void ei_lmpar2(
+void lmpar2(
         const ColPivHouseholderQR > &qr,
         const Matrix< Scalar, Dynamic, 1 >  &diag,
         const Matrix< Scalar, Dynamic, 1 >  &qtb,
@@ -243,10 +244,10 @@ void ei_lmpar2(
         /* evaluate the function at the current value of par. */
         if (par == 0.)
             par = std::max(dwarf,Scalar(.001) * paru); /* Computing MAX */
-        wa1 = ei_sqrt(par)* diag;
+        wa1 = sqrt(par)* diag;
 
         Matrix< Scalar, Dynamic, 1 > sdiag(n);
-        ei_qrsolv(s, qr.colsPermutation().indices(), wa1, qtb, x, sdiag);
+        qrsolv(s, qr.colsPermutation().indices(), wa1, qtb, x, sdiag);
 
         wa2 = diag.cwiseProduct(x);
         dxnorm = wa2.blueNorm();
@@ -256,7 +257,7 @@ void ei_lmpar2(
         /* if the function is small enough, accept the current value */
         /* of par. also test for the exceptional cases where parl */
         /* is zero or the number of iterations has reached 10. */
-        if (ei_abs(fp) <= Scalar(0.1) * delta || (parl == 0. && fp <= temp && temp < 0.) || iter == 10)
+        if (abs(fp) <= Scalar(0.1) * delta || (parl == 0. && fp <= temp && temp < 0.) || iter == 10)
             break;
 
         /* compute the newton correction. */
@@ -286,3 +287,4 @@ void ei_lmpar2(
     return;
 }
 
+} // end namespace internal
diff --git a/unsupported/Eigen/src/NonLinearOptimization/qrsolv.h b/unsupported/Eigen/src/NonLinearOptimization/qrsolv.h
index 2a602fedf..cb1764a41 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/qrsolv.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/qrsolv.h
@@ -1,9 +1,10 @@
+namespace internal {
 
 // TODO : once qrsolv2 is removed, use ColPivHouseholderQR or PermutationMatrix instead of ipvt
 template 
-void ei_qrsolv(
+void qrsolv(
         Matrix< Scalar, Dynamic, Dynamic > &s,
-        // TODO : use a PermutationMatrix once ei_lmpar is no more:
+        // TODO : use a PermutationMatrix once lmpar is no more:
         const VectorXi &ipvt,
         const Matrix< Scalar, Dynamic, 1 >  &diag,
         const Matrix< Scalar, Dynamic, 1 >  &qtb,
@@ -83,3 +84,4 @@ void ei_qrsolv(
     for (j = 0; j < n; ++j) x[ipvt[j]] = wa[j];
 }
 
+} // end namespace internal
diff --git a/unsupported/Eigen/src/NonLinearOptimization/r1mpyq.h b/unsupported/Eigen/src/NonLinearOptimization/r1mpyq.h
index b2ea20d77..ffe505cd5 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/r1mpyq.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/r1mpyq.h
@@ -1,8 +1,9 @@
+namespace internal {
 
 // TODO : move this to GivensQR once there's such a thing in Eigen
 
 template 
-void ei_r1mpyq(DenseIndex m, DenseIndex n, Scalar *a, const std::vector > &v_givens, const std::vector > &w_givens)
+void r1mpyq(DenseIndex m, DenseIndex n, Scalar *a, const std::vector > &v_givens, const std::vector > &w_givens)
 {
     typedef DenseIndex Index;
 
@@ -22,3 +23,4 @@ void ei_r1mpyq(DenseIndex m, DenseIndex n, Scalar *a, const std::vector
-void ei_r1updt(
+void r1updt(
         Matrix< Scalar, Dynamic, Dynamic > &s,
         const Matrix< Scalar, Dynamic, 1> &u,
         std::vector > &v_givens,
@@ -18,7 +19,7 @@ void ei_r1updt(
     Scalar temp;
     JacobiRotation givens;
 
-    // ei_r1updt had a broader usecase, but we dont use it here. And, more
+    // r1updt had a broader usecase, but we dont use it here. And, more
     // importantly, we can not test it.
     assert(m==n);
     assert(u.size()==m);
@@ -88,3 +89,4 @@ void ei_r1updt(
     return;
 }
 
+} // end namespace internal
diff --git a/unsupported/Eigen/src/NonLinearOptimization/rwupdt.h b/unsupported/Eigen/src/NonLinearOptimization/rwupdt.h
index ec97b707a..96263f8c0 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/rwupdt.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/rwupdt.h
@@ -1,6 +1,7 @@
+namespace internal {
 
 template 
-void ei_rwupdt(
+void rwupdt(
         Matrix< Scalar, Dynamic, Dynamic >  &r,
         const Matrix< Scalar, Dynamic, 1>  &w,
         Matrix< Scalar, Dynamic, 1>  &b,
@@ -44,3 +45,4 @@ void ei_rwupdt(
     }
 }
 
+} // end namespace internal
\ No newline at end of file
diff --git a/unsupported/Eigen/src/NumericalDiff/NumericalDiff.h b/unsupported/Eigen/src/NumericalDiff/NumericalDiff.h
index e840dd461..dbf27c481 100644
--- a/unsupported/Eigen/src/NumericalDiff/NumericalDiff.h
+++ b/unsupported/Eigen/src/NumericalDiff/NumericalDiff.h
@@ -80,7 +80,7 @@ public:
         Scalar h;
         int nfev=0;
         const typename InputType::Index n = _x.size();
-        const Scalar eps = ei_sqrt((std::max(epsfcn,NumTraits::epsilon() )));
+        const Scalar eps = internal::sqrt((std::max(epsfcn,NumTraits::epsilon() )));
         ValueType val1, val2;
         InputType x = _x;
         // TODO : we should do this only if the size is not already known
@@ -102,7 +102,7 @@ public:
 
         // Function Body
         for (int j = 0; j < n; ++j) {
-            h = eps * ei_abs(x[j]);
+            h = eps * internal::abs(x[j]);
             if (h == 0.) {
                 h = eps;
             }
diff --git a/unsupported/Eigen/src/Polynomials/Companion.h b/unsupported/Eigen/src/Polynomials/Companion.h
index bbd9073b3..608951d3c 100644
--- a/unsupported/Eigen/src/Polynomials/Companion.h
+++ b/unsupported/Eigen/src/Polynomials/Companion.h
@@ -31,14 +31,16 @@
 
 #ifndef EIGEN_PARSED_BY_DOXYGEN
 
+namespace internal {
+
 template 
-T ei_radix(){ return 2; }
+T radix(){ return 2; }
 
 template 
-T ei_radix2(){ return ei_radix()*ei_radix(); }
+T radix2(){ return radix()*radix(); }
 
 template
-struct ei_decrement_if_fixed_size
+struct decrement_if_fixed_size
 {
   enum {
     ret = (Size == Dynamic) ? Dynamic : Size-1 };
@@ -47,14 +49,14 @@ struct ei_decrement_if_fixed_size
 #endif
 
 template< typename _Scalar, int _Deg >
-class ei_companion
+class companion
 {
   public:
     EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Deg==Dynamic ? Dynamic : _Deg)
 
     enum {
       Deg = _Deg,
-      Deg_1=ei_decrement_if_fixed_size::ret
+      Deg_1=decrement_if_fixed_size::ret
     };
 
     typedef _Scalar                                Scalar;
@@ -92,7 +94,7 @@ class ei_companion
     }
 
     template
-    ei_companion( const VectorType& poly ){
+    companion( const VectorType& poly ){
       setPolynomial( poly ); }
 
   public:
@@ -150,7 +152,7 @@ class ei_companion
 
 template< typename _Scalar, int _Deg >
 inline
-bool ei_companion<_Scalar,_Deg>::balanced( Scalar colNorm, Scalar rowNorm,
+bool companion<_Scalar,_Deg>::balanced( Scalar colNorm, Scalar rowNorm,
     bool& isBalanced, Scalar& colB, Scalar& rowB )
 {
   if( Scalar(0) == colNorm || Scalar(0) == rowNorm ){ return true; }
@@ -161,22 +163,22 @@ bool ei_companion<_Scalar,_Deg>::balanced( Scalar colNorm, Scalar rowNorm,
     // \f$ 2^{2\sigma-1} < rowNorm / colNorm \le 2^{2\sigma+1} \f$
     // then the balancing coefficient for the row is \f$ 1/2^{\sigma} \f$
     // and the balancing coefficient for the column is \f$ 2^{\sigma} \f$
-    rowB = rowNorm / ei_radix();
+    rowB = rowNorm / radix();
     colB = Scalar(1);
     const Scalar s = colNorm + rowNorm;
 
     while (colNorm < rowB)
     {
-      colB *= ei_radix();
-      colNorm *= ei_radix2();
+      colB *= radix();
+      colNorm *= radix2();
     }
 
-    rowB = rowNorm * ei_radix();
+    rowB = rowNorm * radix();
 
     while (colNorm >= rowB)
     {
-      colB /= ei_radix();
-      colNorm /= ei_radix2();
+      colB /= radix();
+      colNorm /= radix2();
     }
 
     //This line is used to avoid insubstantial balancing
@@ -193,7 +195,7 @@ bool ei_companion<_Scalar,_Deg>::balanced( Scalar colNorm, Scalar rowNorm,
 
 template< typename _Scalar, int _Deg >
 inline
-bool ei_companion<_Scalar,_Deg>::balancedR( Scalar colNorm, Scalar rowNorm,
+bool companion<_Scalar,_Deg>::balancedR( Scalar colNorm, Scalar rowNorm,
     bool& isBalanced, Scalar& colB, Scalar& rowB )
 {
   if( Scalar(0) == colNorm || Scalar(0) == rowNorm ){ return true; }
@@ -204,9 +206,9 @@ bool ei_companion<_Scalar,_Deg>::balancedR( Scalar colNorm, Scalar rowNorm,
      * of the row and column norm
      */
     const _Scalar q = colNorm/rowNorm;
-    if( !ei_isApprox( q, _Scalar(1) ) )
+    if( !isApprox( q, _Scalar(1) ) )
     {
-      rowB = ei_sqrt( colNorm/rowNorm );
+      rowB = sqrt( colNorm/rowNorm );
       colB = Scalar(1)/rowB;
 
       isBalanced = false;
@@ -219,7 +221,7 @@ bool ei_companion<_Scalar,_Deg>::balancedR( Scalar colNorm, Scalar rowNorm,
 
 
 template< typename _Scalar, int _Deg >
-void ei_companion<_Scalar,_Deg>::balance()
+void companion<_Scalar,_Deg>::balance()
 {
   EIGEN_STATIC_ASSERT( Deg == Dynamic || 1 < Deg, YOU_MADE_A_PROGRAMMING_MISTAKE );
   const Index deg   = m_monic.size();
@@ -234,8 +236,8 @@ void ei_companion<_Scalar,_Deg>::balance()
 
     //First row, first column excluding the diagonal
     //==============================================
-    colNorm = ei_abs(m_bl_diag[0]);
-    rowNorm = ei_abs(m_monic[0]);
+    colNorm = abs(m_bl_diag[0]);
+    rowNorm = abs(m_monic[0]);
 
     //Compute balancing of the row and the column
     if( !balanced( colNorm, rowNorm, hasConverged, colB, rowB ) )
@@ -249,10 +251,10 @@ void ei_companion<_Scalar,_Deg>::balance()
     for( Index i=1; i::balance()
     const Index ebl = m_bl_diag.size()-1;
     VectorBlock headMonic( m_monic, 0, deg_1 );
     colNorm = headMonic.array().abs().sum();
-    rowNorm = ei_abs( m_bl_diag[ebl] );
+    rowNorm = abs( m_bl_diag[ebl] );
 
     //Compute balancing of the row and the column
     if( !balanced( colNorm, rowNorm, hasConverged, colB, rowB ) )
@@ -279,5 +281,6 @@ void ei_companion<_Scalar,_Deg>::balance()
   }
 }
 
+} // end namespace internal
 
 #endif // EIGEN_COMPANION_H
diff --git a/unsupported/Eigen/src/Polynomials/PolynomialSolver.h b/unsupported/Eigen/src/Polynomials/PolynomialSolver.h
index ba14b5911..417b93df2 100644
--- a/unsupported/Eigen/src/Polynomials/PolynomialSolver.h
+++ b/unsupported/Eigen/src/Polynomials/PolynomialSolver.h
@@ -85,7 +85,7 @@ class PolynomialSolverBase
       bi_seq.clear();
       for(Index i=0; i
     void compute( const OtherPolynomial& poly )
     {
       assert( Scalar(0) != poly[poly.size()-1] );
-      ei_companion companion( poly );
+      internal::companion companion( poly );
       companion.balance();
       m_eigenSolver.compute( companion.denseMatrix() );
       m_roots = m_eigenSolver.eigenvalues();
diff --git a/unsupported/Eigen/src/Polynomials/PolynomialUtils.h b/unsupported/Eigen/src/Polynomials/PolynomialUtils.h
index d10b8f4dc..65942c52a 100644
--- a/unsupported/Eigen/src/Polynomials/PolynomialUtils.h
+++ b/unsupported/Eigen/src/Polynomials/PolynomialUtils.h
@@ -60,7 +60,7 @@ T poly_eval( const Polynomials& poly, const T& x )
 {
   typedef typename NumTraits::Real Real;
 
-  if( ei_abs2( x ) <= Real(1) ){
+  if( internal::abs2( x ) <= Real(1) ){
     return poly_eval_horner( poly, x ); }
   else
   {
@@ -95,7 +95,7 @@ typename NumTraits::Real cauchy_max_bound( const Po
   Real cb(0);
 
   for( DenseIndex i=0; i::Real cauchy_min_bound( const Po
   const Scalar inv_min_coeff = Scalar(1)/poly[i];
   Real cb(1);
   for( DenseIndex j=i+1; j::compute() {
     const size_t rows = m_lu.rows();
     const size_t cols = m_lu.cols();
 
-    ei_assert(rows == cols && "We do not (yet) support rectangular LU.");
-    ei_assert(!m_lu.IsRowMajor && "LU decomposition does not work with rowMajor Storage");
+    eigen_assert(rows == cols && "We do not (yet) support rectangular LU.");
+    eigen_assert(!m_lu.IsRowMajor && "LU decomposition does not work with rowMajor Storage");
 
     for (Index row = 0; row < rows; row++) {
         const double pivot = m_lu.coeffDiag(row);
@@ -198,8 +198,8 @@ void SkylineInplaceLU::computeRowMajor() {
     const size_t rows = m_lu.rows();
     const size_t cols = m_lu.cols();
 
-    ei_assert(rows == cols && "We do not (yet) support rectangular LU.");
-    ei_assert(m_lu.IsRowMajor && "You're trying to apply rowMajor decomposition on a ColMajor matrix !");
+    eigen_assert(rows == cols && "We do not (yet) support rectangular LU.");
+    eigen_assert(m_lu.IsRowMajor && "You're trying to apply rowMajor decomposition on a ColMajor matrix !");
 
     for (Index row = 0; row < rows; row++) {
         typename MatrixType::InnerLowerIterator llIt(m_lu, row);
diff --git a/unsupported/Eigen/src/Skyline/SkylineMatrix.h b/unsupported/Eigen/src/Skyline/SkylineMatrix.h
index 20fafafa8..31810df08 100644
--- a/unsupported/Eigen/src/Skyline/SkylineMatrix.h
+++ b/unsupported/Eigen/src/Skyline/SkylineMatrix.h
@@ -43,8 +43,9 @@
  *
  *
  */
+namespace internal {
 template
-struct ei_traits > {
+struct traits > {
     typedef _Scalar Scalar;
     typedef Sparse StorageKind;
 
@@ -57,6 +58,7 @@ struct ei_traits > {
         CoeffReadCost = NumTraits::ReadCost,
     };
 };
+}
 
 template
 class SkylineMatrix
@@ -158,8 +160,8 @@ public:
         const Index outer = IsRowMajor ? row : col;
         const Index inner = IsRowMajor ? col : row;
 
-        ei_assert(outer < outerSize());
-        ei_assert(inner < innerSize());
+        eigen_assert(outer < outerSize());
+        eigen_assert(inner < innerSize());
 
         if (outer == inner)
             return this->m_data.diag(outer);
@@ -207,8 +209,8 @@ public:
         const Index outer = IsRowMajor ? row : col;
         const Index inner = IsRowMajor ? col : row;
 
-        ei_assert(outer < outerSize());
-        ei_assert(inner < innerSize());
+        eigen_assert(outer < outerSize());
+        eigen_assert(inner < innerSize());
 
         if (outer == inner)
             return this->m_data.diag(outer);
@@ -217,34 +219,34 @@ public:
             if (col > row) //upper matrix
             {
                 const Index minOuterIndex = inner - m_data.upperProfile(inner);
-                ei_assert(outer >= minOuterIndex && "you try to acces a coeff that do not exist in the storage");
+                eigen_assert(outer >= minOuterIndex && "you try to acces a coeff that do not exist in the storage");
                 return this->m_data.upper(m_colStartIndex[inner] + outer - (inner - m_data.upperProfile(inner)));
             }
             if (col < row) //lower matrix
             {
                 const Index minInnerIndex = outer - m_data.lowerProfile(outer);
-                ei_assert(inner >= minInnerIndex && "you try to acces a coeff that do not exist in the storage");
+                eigen_assert(inner >= minInnerIndex && "you try to acces a coeff that do not exist in the storage");
                 return this->m_data.lower(m_rowStartIndex[outer] + inner - (outer - m_data.lowerProfile(outer)));
             }
         } else {
             if (outer > inner) //upper matrix
             {
                 const Index maxOuterIndex = inner + m_data.upperProfile(inner);
-                ei_assert(outer <= maxOuterIndex && "you try to acces a coeff that do not exist in the storage");
+                eigen_assert(outer <= maxOuterIndex && "you try to acces a coeff that do not exist in the storage");
                 return this->m_data.upper(m_colStartIndex[inner] + (outer - inner));
             }
             if (outer < inner) //lower matrix
             {
                 const Index maxInnerIndex = outer + m_data.lowerProfile(outer);
-                ei_assert(inner <= maxInnerIndex && "you try to acces a coeff that do not exist in the storage");
+                eigen_assert(inner <= maxInnerIndex && "you try to acces a coeff that do not exist in the storage");
                 return this->m_data.lower(m_rowStartIndex[outer] + (inner - outer));
             }
         }
     }
 
     inline Scalar coeffDiag(Index idx) const {
-        ei_assert(idx < outerSize());
-        ei_assert(idx < innerSize());
+        eigen_assert(idx < outerSize());
+        eigen_assert(idx < innerSize());
         return this->m_data.diag(idx);
     }
 
@@ -252,9 +254,9 @@ public:
         const Index outer = IsRowMajor ? row : col;
         const Index inner = IsRowMajor ? col : row;
 
-        ei_assert(outer < outerSize());
-        ei_assert(inner < innerSize());
-        ei_assert(inner != outer);
+        eigen_assert(outer < outerSize());
+        eigen_assert(inner < innerSize());
+        eigen_assert(inner != outer);
 
         if (IsRowMajor) {
             const Index minInnerIndex = outer - m_data.lowerProfile(outer);
@@ -276,9 +278,9 @@ public:
         const Index outer = IsRowMajor ? row : col;
         const Index inner = IsRowMajor ? col : row;
 
-        ei_assert(outer < outerSize());
-        ei_assert(inner < innerSize());
-        ei_assert(inner != outer);
+        eigen_assert(outer < outerSize());
+        eigen_assert(inner < innerSize());
+        eigen_assert(inner != outer);
 
         if (IsRowMajor) {
             const Index minOuterIndex = inner - m_data.upperProfile(inner);
@@ -296,8 +298,8 @@ public:
     }
 
     inline Scalar& coeffRefDiag(Index idx) {
-        ei_assert(idx < outerSize());
-        ei_assert(idx < innerSize());
+        eigen_assert(idx < outerSize());
+        eigen_assert(idx < innerSize());
         return this->m_data.diag(idx);
     }
 
@@ -305,17 +307,17 @@ public:
         const Index outer = IsRowMajor ? row : col;
         const Index inner = IsRowMajor ? col : row;
 
-        ei_assert(outer < outerSize());
-        ei_assert(inner < innerSize());
-        ei_assert(inner != outer);
+        eigen_assert(outer < outerSize());
+        eigen_assert(inner < innerSize());
+        eigen_assert(inner != outer);
 
         if (IsRowMajor) {
             const Index minInnerIndex = outer - m_data.lowerProfile(outer);
-            ei_assert(inner >= minInnerIndex && "you try to acces a coeff that do not exist in the storage");
+            eigen_assert(inner >= minInnerIndex && "you try to acces a coeff that do not exist in the storage");
             return this->m_data.lower(m_rowStartIndex[outer] + inner - (outer - m_data.lowerProfile(outer)));
         } else {
             const Index maxInnerIndex = outer + m_data.lowerProfile(outer);
-            ei_assert(inner <= maxInnerIndex && "you try to acces a coeff that do not exist in the storage");
+            eigen_assert(inner <= maxInnerIndex && "you try to acces a coeff that do not exist in the storage");
             return this->m_data.lower(m_rowStartIndex[outer] + (inner - outer));
         }
     }
@@ -324,9 +326,9 @@ public:
         const Index outer = IsRowMajor ? row : col;
         const Index inner = IsRowMajor ? col : row;
 
-        ei_assert(outer < outerSize());
-        ei_assert(inner < innerSize());
-        ei_assert(inner != outer);
+        eigen_assert(outer < outerSize());
+        eigen_assert(inner < innerSize());
+        eigen_assert(inner != outer);
 
         if (IsRowMajor) {
             const Index minInnerIndex = outer - m_data.lowerProfile(outer);
@@ -341,17 +343,17 @@ public:
         const Index outer = IsRowMajor ? row : col;
         const Index inner = IsRowMajor ? col : row;
 
-        ei_assert(outer < outerSize());
-        ei_assert(inner < innerSize());
-        ei_assert(inner != outer);
+        eigen_assert(outer < outerSize());
+        eigen_assert(inner < innerSize());
+        eigen_assert(inner != outer);
 
         if (IsRowMajor) {
             const Index minOuterIndex = inner - m_data.upperProfile(inner);
-            ei_assert(outer >= minOuterIndex && "you try to acces a coeff that do not exist in the storage");
+            eigen_assert(outer >= minOuterIndex && "you try to acces a coeff that do not exist in the storage");
             return this->m_data.upper(m_colStartIndex[inner] + outer - (inner - m_data.upperProfile(inner)));
         } else {
             const Index maxOuterIndex = inner + m_data.upperProfile(inner);
-            ei_assert(outer <= maxOuterIndex && "you try to acces a coeff that do not exist in the storage");
+            eigen_assert(outer <= maxOuterIndex && "you try to acces a coeff that do not exist in the storage");
             return this->m_data.upper(m_colStartIndex[inner] + (outer - inner));
         }
     }
@@ -360,9 +362,9 @@ public:
         const Index outer = IsRowMajor ? row : col;
         const Index inner = IsRowMajor ? col : row;
 
-        ei_assert(outer < outerSize());
-        ei_assert(inner < innerSize());
-        ei_assert(inner != outer);
+        eigen_assert(outer < outerSize());
+        eigen_assert(inner < innerSize());
+        eigen_assert(inner != outer);
 
         if (IsRowMajor) {
             const Index minOuterIndex = inner - m_data.upperProfile(inner);
@@ -412,8 +414,8 @@ public:
         const Index outer = IsRowMajor ? row : col;
         const Index inner = IsRowMajor ? col : row;
 
-        ei_assert(outer < outerSize());
-        ei_assert(inner < innerSize());
+        eigen_assert(outer < outerSize());
+        eigen_assert(inner < innerSize());
 
         if (outer == inner)
             return m_data.diag(col);
@@ -549,7 +551,7 @@ public:
             else
                 m_data.resize(rows(), cols(), rows(), m_colStartIndex[cols()] + 1, m_rowStartIndex[rows()] + 1);
 
-            //            ei_assert(rows() == cols() && "memory reorganisatrion only works with suare matrix");
+            //            eigen_assert(rows() == cols() && "memory reorganisatrion only works with suare matrix");
             //
             //            Scalar* newArray = new Scalar[m_colStartIndex[cols()] + 1 + m_rowStartIndex[rows()] + 1];
             //            Index dataIdx = 0;
@@ -601,7 +603,7 @@ public:
         const Index diagSize = rows > cols ? cols : rows;
         m_innerSize = IsRowMajor ? cols : rows;
 
-        ei_assert(rows == cols && "Skyline matrix must be square matrix");
+        eigen_assert(rows == cols && "Skyline matrix must be square matrix");
 
         if (diagSize % 2) { // diagSize is odd
             const Index k = (diagSize - 1) / 2;
diff --git a/unsupported/Eigen/src/Skyline/SkylineMatrixBase.h b/unsupported/Eigen/src/Skyline/SkylineMatrixBase.h
index 5f577de3d..4d0c2397c 100644
--- a/unsupported/Eigen/src/Skyline/SkylineMatrixBase.h
+++ b/unsupported/Eigen/src/Skyline/SkylineMatrixBase.h
@@ -39,26 +39,26 @@
 template class SkylineMatrixBase : public EigenBase {
 public:
 
-    typedef typename ei_traits::Scalar Scalar;
-    typedef typename ei_traits::StorageKind StorageKind;
-    typedef typename ei_index::type Index;
+    typedef typename internal::traits::Scalar Scalar;
+    typedef typename internal::traits::StorageKind StorageKind;
+    typedef typename internal::index::type Index;
 
     enum {
-        RowsAtCompileTime = ei_traits::RowsAtCompileTime,
+        RowsAtCompileTime = internal::traits::RowsAtCompileTime,
         /**< The number of rows at compile-time. This is just a copy of the value provided
          * by the \a Derived type. If a value is not known at compile-time,
          * it is set to the \a Dynamic constant.
          * \sa MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */
 
-        ColsAtCompileTime = ei_traits::ColsAtCompileTime,
+        ColsAtCompileTime = internal::traits::ColsAtCompileTime,
         /**< The number of columns at compile-time. This is just a copy of the value provided
          * by the \a Derived type. If a value is not known at compile-time,
          * it is set to the \a Dynamic constant.
          * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */
 
 
-        SizeAtCompileTime = (ei_size_at_compile_time::RowsAtCompileTime,
-        ei_traits::ColsAtCompileTime>::ret),
+        SizeAtCompileTime = (internal::size_at_compile_time::RowsAtCompileTime,
+        internal::traits::ColsAtCompileTime>::ret),
         /**< This is equal to the number of coefficients, i.e. the number of
          * rows times the number of columns, or to \a Dynamic if this is not
          * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
@@ -66,7 +66,7 @@ public:
         MaxRowsAtCompileTime = RowsAtCompileTime,
         MaxColsAtCompileTime = ColsAtCompileTime,
 
-        MaxSizeAtCompileTime = (ei_size_at_compile_time::ret),
 
         IsVectorAtCompileTime = RowsAtCompileTime == 1 || ColsAtCompileTime == 1,
@@ -75,12 +75,12 @@ public:
          * we are dealing with a column-vector (if there is only one column) or with
          * a row-vector (if there is only one row). */
 
-        Flags = ei_traits::Flags,
+        Flags = internal::traits::Flags,
         /**< This stores expression \ref flags flags which may or may not be inherited by new expressions
          * constructed from this one. See the \ref flags "list of flags".
          */
 
-        CoeffReadCost = ei_traits::CoeffReadCost,
+        CoeffReadCost = internal::traits::CoeffReadCost,
         /**< This is a rough measure of how expensive it is to read one coefficient from
          * this expression.
          */
@@ -212,8 +212,8 @@ public:
      * Notice that in the case of a plain matrix or vector (not an expression) this function just returns
      * a const reference, in order to avoid a useless copy.
      */
-    EIGEN_STRONG_INLINE const typename ei_eval::type eval() const {
-        return typename ei_eval::type(derived());
+    EIGEN_STRONG_INLINE const typename internal::eval::type eval() const {
+        return typename internal::eval::type(derived());
     }
 
 protected:
diff --git a/unsupported/Eigen/src/Skyline/SkylineProduct.h b/unsupported/Eigen/src/Skyline/SkylineProduct.h
index aabd07241..5a374743f 100644
--- a/unsupported/Eigen/src/Skyline/SkylineProduct.h
+++ b/unsupported/Eigen/src/Skyline/SkylineProduct.h
@@ -27,17 +27,17 @@
 
 template
 struct SkylineProductReturnType {
-    typedef const typename ei_nested::type LhsNested;
-    typedef const typename ei_nested::type RhsNested;
+    typedef const typename internal::nested::type LhsNested;
+    typedef const typename internal::nested::type RhsNested;
 
     typedef SkylineProduct Type;
 };
 
 template
-struct ei_traits > {
+struct internal::traits > {
     // clean the nested types:
-    typedef typename ei_cleantype::type _LhsNested;
-    typedef typename ei_cleantype::type _RhsNested;
+    typedef typename internal::cleantype::type _LhsNested;
+    typedef typename internal::cleantype::type _RhsNested;
     typedef typename _LhsNested::Scalar Scalar;
 
     enum {
@@ -65,29 +65,30 @@ struct ei_traits > {
         CoeffReadCost = Dynamic
     };
 
-    typedef typename ei_meta_if >,
             MatrixBase > >::ret Base;
 };
 
+namespace internal {
 template
-class SkylineProduct : ei_no_assignment_operator,
-public ei_traits >::Base {
+class SkylineProduct : no_assignment_operator,
+public traits >::Base {
 public:
 
     EIGEN_GENERIC_PUBLIC_INTERFACE(SkylineProduct)
 
 private:
 
-    typedef typename ei_traits::_LhsNested _LhsNested;
-    typedef typename ei_traits::_RhsNested _RhsNested;
+    typedef typename traits::_LhsNested _LhsNested;
+    typedef typename traits::_RhsNested _RhsNested;
 
 public:
 
     template
     EIGEN_STRONG_INLINE SkylineProduct(const Lhs& lhs, const Rhs& rhs)
     : m_lhs(lhs), m_rhs(rhs) {
-        ei_assert(lhs.cols() == rhs.rows());
+        eigen_assert(lhs.cols() == rhs.rows());
 
         enum {
             ProductIsValid = _LhsNested::ColsAtCompileTime == Dynamic
@@ -131,10 +132,10 @@ protected:
 // Note that here we force no inlining and separate the setZero() because GCC messes up otherwise
 
 template
-EIGEN_DONT_INLINE void ei_skyline_row_major_time_dense_product(const Lhs& lhs, const Rhs& rhs, Dest& dst) {
-    typedef typename ei_cleantype::type _Lhs;
-    typedef typename ei_cleantype::type _Rhs;
-    typedef typename ei_traits::Scalar Scalar;
+EIGEN_DONT_INLINE void skyline_row_major_time_dense_product(const Lhs& lhs, const Rhs& rhs, Dest& dst) {
+    typedef typename cleantype::type _Lhs;
+    typedef typename cleantype::type _Rhs;
+    typedef typename traits::Scalar Scalar;
 
     enum {
         LhsIsRowMajor = (_Lhs::Flags & RowMajorBit) == RowMajorBit,
@@ -194,10 +195,10 @@ EIGEN_DONT_INLINE void ei_skyline_row_major_time_dense_product(const Lhs& lhs, c
 }
 
 template
-EIGEN_DONT_INLINE void ei_skyline_col_major_time_dense_product(const Lhs& lhs, const Rhs& rhs, Dest& dst) {
-    typedef typename ei_cleantype::type _Lhs;
-    typedef typename ei_cleantype::type _Rhs;
-    typedef typename ei_traits::Scalar Scalar;
+EIGEN_DONT_INLINE void skyline_col_major_time_dense_product(const Lhs& lhs, const Rhs& rhs, Dest& dst) {
+    typedef typename cleantype::type _Lhs;
+    typedef typename cleantype::type _Rhs;
+    typedef typename traits::Scalar Scalar;
 
     enum {
         LhsIsRowMajor = (_Lhs::Flags & RowMajorBit) == RowMajorBit,
@@ -258,33 +259,35 @@ EIGEN_DONT_INLINE void ei_skyline_col_major_time_dense_product(const Lhs& lhs, c
 }
 
 template::Flags&RowMajorBit>
-        struct ei_skyline_product_selector;
+        int LhsStorageOrder = traits::Flags&RowMajorBit>
+        struct skyline_product_selector;
 
 template
-struct ei_skyline_product_selector {
-    typedef typename ei_traits::type>::Scalar Scalar;
+struct skyline_product_selector {
+    typedef typename traits::type>::Scalar Scalar;
 
     static void run(const Lhs& lhs, const Rhs& rhs, ResultType & res) {
-        ei_skyline_row_major_time_dense_product (lhs, rhs, res);
+        skyline_row_major_time_dense_product (lhs, rhs, res);
     }
 };
 
 template
-struct ei_skyline_product_selector {
-    typedef typename ei_traits::type>::Scalar Scalar;
+struct skyline_product_selector {
+    typedef typename traits::type>::Scalar Scalar;
 
     static void run(const Lhs& lhs, const Rhs& rhs, ResultType & res) {
-        ei_skyline_col_major_time_dense_product (lhs, rhs, res);
+        skyline_col_major_time_dense_product (lhs, rhs, res);
     }
 };
 
+} // end namespace internal
+
 // template
 // template
 // Derived & MatrixBase::lazyAssign(const SkylineProduct& product) {
-//     typedef typename ei_cleantype::type _Lhs;
-//     ei_skyline_product_selector::type,
-//             typename ei_cleantype::type,
+//     typedef typename internal::cleantype::type _Lhs;
+//     internal::skyline_product_selector::type,
+//             typename internal::cleantype::type,
 //             Derived>::run(product.lhs(), product.rhs(), derived());
 // 
 //     return derived();
diff --git a/unsupported/Eigen/src/Skyline/SkylineUtil.h b/unsupported/Eigen/src/Skyline/SkylineUtil.h
index 7781c33e7..e0512476f 100644
--- a/unsupported/Eigen/src/Skyline/SkylineUtil.h
+++ b/unsupported/Eigen/src/Skyline/SkylineUtil.h
@@ -64,11 +64,11 @@ EIGEN_STRONG_INLINE Derived& operator Op(const Other& scalar) \
 
 #define _EIGEN_SKYLINE_GENERIC_PUBLIC_INTERFACE(Derived, BaseClass) \
   typedef BaseClass Base; \
-  typedef typename Eigen::ei_traits::Scalar Scalar; \
+  typedef typename Eigen::internal::traits::Scalar Scalar; \
   typedef typename Eigen::NumTraits::Real RealScalar; \
-  typedef typename Eigen::ei_traits::StorageKind StorageKind; \
-  typedef typename Eigen::ei_index::type Index; \
-  enum {  Flags = Eigen::ei_traits::Flags, };
+  typedef typename Eigen::internal::traits::StorageKind StorageKind; \
+  typedef typename Eigen::internal::index::type Index; \
+  enum {  Flags = Eigen::internal::traits::Flags, };
 
 #define EIGEN_SKYLINE_GENERIC_PUBLIC_INTERFACE(Derived) \
   _EIGEN_SKYLINE_GENERIC_PUBLIC_INTERFACE(Derived, Eigen::SkylineMatrixBase)
@@ -79,20 +79,23 @@ template class DynamicSkylineMatrix;
 template class SkylineVector;
 template class MappedSkylineMatrix;
 
-template struct ei_skyline_product_mode;
-template::value> struct SkylineProductReturnType;
+namespace internal {
 
+template struct skyline_product_mode;
+template::value> struct SkylineProductReturnType;
 
-template class ei_eval
+template class eval
 {
-    typedef typename ei_traits::Scalar _Scalar;
+    typedef typename traits::Scalar _Scalar;
     enum {
-          _Flags = ei_traits::Flags
+          _Flags = traits::Flags
     };
 
   public:
     typedef SkylineMatrix<_Scalar, _Flags> type;
 };
 
+} // end namespace internal
+
 
 #endif // EIGEN_SKYLINEUTIL_H
diff --git a/unsupported/Eigen/src/SparseExtra/CholmodSupport.h b/unsupported/Eigen/src/SparseExtra/CholmodSupport.h
index 8b500062b..aee4ae00a 100644
--- a/unsupported/Eigen/src/SparseExtra/CholmodSupport.h
+++ b/unsupported/Eigen/src/SparseExtra/CholmodSupport.h
@@ -25,38 +25,39 @@
 #ifndef EIGEN_CHOLMODSUPPORT_H
 #define EIGEN_CHOLMODSUPPORT_H
 
+namespace internal {
 
 template
-void ei_cholmod_configure_matrix(CholmodType& mat)
+void cholmod_configure_matrix(CholmodType& mat)
 {
-  if (ei_is_same_type::ret)
+  if (is_same_type::ret)
   {
     mat.xtype = CHOLMOD_REAL;
     mat.dtype = CHOLMOD_SINGLE;
   }
-  else if (ei_is_same_type::ret)
+  else if (is_same_type::ret)
   {
     mat.xtype = CHOLMOD_REAL;
     mat.dtype = CHOLMOD_DOUBLE;
   }
-  else if (ei_is_same_type >::ret)
+  else if (is_same_type >::ret)
   {
     mat.xtype = CHOLMOD_COMPLEX;
     mat.dtype = CHOLMOD_SINGLE;
   }
-  else if (ei_is_same_type >::ret)
+  else if (is_same_type >::ret)
   {
     mat.xtype = CHOLMOD_COMPLEX;
     mat.dtype = CHOLMOD_DOUBLE;
   }
   else
   {
-    ei_assert(false && "Scalar type not supported by CHOLMOD");
+    eigen_assert(false && "Scalar type not supported by CHOLMOD");
   }
 }
 
 template
-cholmod_sparse ei_cholmod_map_eigen_to_sparse(_MatrixType& mat)
+cholmod_sparse cholmod_map_eigen_to_sparse(_MatrixType& mat)
 {
   typedef typename _MatrixType::Scalar Scalar;
   cholmod_sparse res;
@@ -73,7 +74,7 @@ cholmod_sparse ei_cholmod_map_eigen_to_sparse(_MatrixType& mat)
   res.dtype   = 0;
   res.stype   = -1;
 
-  ei_cholmod_configure_matrix(res);
+  cholmod_configure_matrix(res);
 
 
   if (_MatrixType::Flags & SelfAdjoint)
@@ -92,9 +93,9 @@ cholmod_sparse ei_cholmod_map_eigen_to_sparse(_MatrixType& mat)
 }
 
 template
-cholmod_dense ei_cholmod_map_eigen_to_dense(MatrixBase& mat)
+cholmod_dense cholmod_map_eigen_to_dense(MatrixBase& mat)
 {
-  EIGEN_STATIC_ASSERT((ei_traits::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+  EIGEN_STATIC_ASSERT((traits::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
   typedef typename Derived::Scalar Scalar;
 
   cholmod_dense res;
@@ -105,20 +106,20 @@ cholmod_dense ei_cholmod_map_eigen_to_dense(MatrixBase& mat)
   res.x      = mat.derived().data();
   res.z      = 0;
 
-  ei_cholmod_configure_matrix(res);
+  cholmod_configure_matrix(res);
 
   return res;
 }
 
 template
-MappedSparseMatrix ei_map_cholmod_sparse_to_eigen(cholmod_sparse& cm)
+MappedSparseMatrix map_cholmod_sparse_to_eigen(cholmod_sparse& cm)
 {
   return MappedSparseMatrix
          (cm.nrow, cm.ncol, reinterpret_cast(cm.p)[cm.ncol],
           reinterpret_cast(cm.p), reinterpret_cast(cm.i),reinterpret_cast(cm.x) );
 }
 
-
+} // end namespace internal
 
 template
 class SparseLLT<_MatrixType, Cholmod> : public SparseLLT<_MatrixType>
@@ -164,11 +165,11 @@ class SparseLLT<_MatrixType, Cholmod> : public SparseLLT<_MatrixType>
     bool solveInPlace(MatrixBase &b) const;
 
     template
-    inline const ei_solve_retval, Rhs>
+    inline const internal::solve_retval, Rhs>
     solve(const MatrixBase& b) const
     {
-      ei_assert(true && "SparseLLT is not initialized.");
-      return ei_solve_retval, Rhs>(*this, b.derived());
+      eigen_assert(true && "SparseLLT is not initialized.");
+      return internal::solve_retval, Rhs>(*this, b.derived());
     }
 
     void compute(const MatrixType& matrix);
@@ -192,8 +193,8 @@ class SparseLLT<_MatrixType, Cholmod> : public SparseLLT<_MatrixType>
 
 
 template
-  struct ei_solve_retval, Rhs>
-  : ei_solve_retval_base, Rhs>
+  struct internal::solve_retval, Rhs>
+  : internal::solve_retval_base, Rhs>
 {
   typedef SparseLLT<_MatrixType, Cholmod> SpLLTDecType;
   EIGEN_MAKE_SOLVE_HELPERS(SpLLTDecType,Rhs)
@@ -201,7 +202,7 @@ template
   template void evalTo(Dest& dst) const
   {
     //Index size = dec().cholmodFactor()->n;
-    ei_assert((Index)dec().cholmodFactor()->n==rhs().rows());
+    eigen_assert((Index)dec().cholmodFactor()->n==rhs().rows());
     
     cholmod_factor* cholmodFactor = const_cast(dec().cholmodFactor());
     cholmod_common* cholmodCommon = const_cast(dec().cholmodCommon());
@@ -211,7 +212,7 @@ template
     // Base::solveInPlace(b);
     // as long as our own triangular sparse solver is not fully optimal,
     // let's use CHOLMOD's one:
-    cholmod_dense cdb = ei_cholmod_map_eigen_to_dense(rhs().const_cast_derived());
+    cholmod_dense cdb = internal::cholmod_map_eigen_to_dense(rhs().const_cast_derived());
     cholmod_dense* x = cholmod_solve(CHOLMOD_A, cholmodFactor, &cdb, cholmodCommon);
 
     dst = Matrix::Map(reinterpret_cast(x->x), rhs().rows());  
@@ -235,7 +236,7 @@ void SparseLLT<_MatrixType,Cholmod>::compute(const _MatrixType& a)
     m_cholmodFactor = 0;
   }
 
-  cholmod_sparse A = ei_cholmod_map_eigen_to_sparse(const_cast<_MatrixType&>(a));
+  cholmod_sparse A = internal::cholmod_map_eigen_to_sparse(const_cast<_MatrixType&>(a));
 //   m_cholmod.supernodal = CHOLMOD_AUTO;
   // TODO
 //   if (m_flags&IncompleteFactorization)
@@ -271,11 +272,11 @@ SparseLLT<_MatrixType,Cholmod>::matrixL() const
 {
   if (m_status & MatrixLIsDirty)
   {
-    ei_assert(!(m_status & SupernodalFactorIsDirty));
+    eigen_assert(!(m_status & SupernodalFactorIsDirty));
 
     cholmod_sparse* cmRes = cholmod_factor_to_sparse(m_cholmodFactor, &m_cholmod);
     const_cast(m_matrix) = 
-      ei_map_cholmod_sparse_to_eigen(*cmRes);
+      internal::map_cholmod_sparse_to_eigen(*cmRes);
     free(cmRes);
 
     m_status = (m_status & ~MatrixLIsDirty);
@@ -291,7 +292,7 @@ template
 bool SparseLLT<_MatrixType,Cholmod>::solveInPlace(MatrixBase &b) const
 {
   //Index size = m_cholmodFactor->n;
-  ei_assert((Index)m_cholmodFactor->n==b.rows());
+  eigen_assert((Index)m_cholmodFactor->n==b.rows());
 
   // this uses Eigen's triangular sparse solver
   //   if (m_status & MatrixLIsDirty)
@@ -299,10 +300,10 @@ bool SparseLLT<_MatrixType,Cholmod>::solveInPlace(MatrixBase &b) const
   //   Base::solveInPlace(b);
   // as long as our own triangular sparse solver is not fully optimal,
   // let's use CHOLMOD's one:
-  cholmod_dense cdb = ei_cholmod_map_eigen_to_dense(b);
+  cholmod_dense cdb = internal::cholmod_map_eigen_to_dense(b);
 
   cholmod_dense* x = cholmod_solve(CHOLMOD_A, m_cholmodFactor, &cdb, &m_cholmod);
-  ei_assert(x && "Eigen: cholmod_solve failed.");
+  eigen_assert(x && "Eigen: cholmod_solve failed.");
 
   b = Matrix::Map(reinterpret_cast(x->x),b.rows());
   cholmod_free_dense(&x, &m_cholmod);
@@ -362,11 +363,11 @@ class SparseLDLT<_MatrixType,Cholmod> : public SparseLDLT<_MatrixType>
     void solveInPlace(MatrixBase &b) const;
 
     template
-    inline const ei_solve_retval, Rhs>
+    inline const internal::solve_retval, Rhs>
     solve(const MatrixBase& b) const
     {
-      ei_assert(true && "SparseLDLT is not initialized.");
-      return ei_solve_retval, Rhs>(*this, b.derived());
+      eigen_assert(true && "SparseLDLT is not initialized.");
+      return internal::solve_retval, Rhs>(*this, b.derived());
     }
 
     void compute(const _MatrixType& matrix);
@@ -392,8 +393,8 @@ class SparseLDLT<_MatrixType,Cholmod> : public SparseLDLT<_MatrixType>
 
 
 template
-  struct ei_solve_retval, Rhs>
-  : ei_solve_retval_base, Rhs>
+  struct internal::solve_retval, Rhs>
+  : internal::solve_retval_base, Rhs>
 {
   typedef SparseLDLT<_MatrixType, Cholmod> SpLDLTDecType;
   EIGEN_MAKE_SOLVE_HELPERS(SpLDLTDecType,Rhs)
@@ -401,7 +402,7 @@ template
   template void evalTo(Dest& dst) const
   {
     //Index size = dec().cholmodFactor()->n;
-    ei_assert((Index)dec().cholmodFactor()->n==rhs().rows());
+    eigen_assert((Index)dec().cholmodFactor()->n==rhs().rows());
     
     cholmod_factor* cholmodFactor = const_cast(dec().cholmodFactor());
     cholmod_common* cholmodCommon = const_cast(dec().cholmodCommon());
@@ -411,7 +412,7 @@ template
     // Base::solveInPlace(b);
     // as long as our own triangular sparse solver is not fully optimal,
     // let's use CHOLMOD's one:
-    cholmod_dense cdb = ei_cholmod_map_eigen_to_dense(rhs().const_cast_derived());
+    cholmod_dense cdb = internal::cholmod_map_eigen_to_dense(rhs().const_cast_derived());
     cholmod_dense* x = cholmod_solve(CHOLMOD_LDLt, cholmodFactor, &cdb, cholmodCommon);
 
     dst = Matrix::Map(reinterpret_cast(x->x), rhs().rows());  
@@ -434,7 +435,7 @@ void SparseLDLT<_MatrixType,Cholmod>::compute(const _MatrixType& a)
     m_cholmodFactor = 0;
   }
 
-  cholmod_sparse A = ei_cholmod_map_eigen_to_sparse(const_cast<_MatrixType&>(a));
+  cholmod_sparse A = internal::cholmod_map_eigen_to_sparse(const_cast<_MatrixType&>(a));
  
   //m_cholmod.supernodal = CHOLMOD_AUTO;
   m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
@@ -473,7 +474,7 @@ SparseLDLT<_MatrixType,Cholmod>::matrixL() const
 {
   if (m_status & MatrixLIsDirty)
   {
-    ei_assert(!(m_status & SupernodalFactorIsDirty));
+    eigen_assert(!(m_status & SupernodalFactorIsDirty));
 
     cholmod_sparse* cmRes = cholmod_factor_to_sparse(m_cholmodFactor, &m_cholmod);
     const_cast(m_matrix) = MappedSparseMatrix(*cmRes);
@@ -494,7 +495,7 @@ template
 void SparseLDLT<_MatrixType,Cholmod>::solveInPlace(MatrixBase &b) const
 {
   //Index size = m_cholmodFactor->n;
-  ei_assert((Index)m_cholmodFactor->n == b.rows());
+  eigen_assert((Index)m_cholmodFactor->n == b.rows());
 
   // this uses Eigen's triangular sparse solver
   //   if (m_status & MatrixLIsDirty)
@@ -502,7 +503,7 @@ void SparseLDLT<_MatrixType,Cholmod>::solveInPlace(MatrixBase &b) const
   //   Base::solveInPlace(b);
   // as long as our own triangular sparse solver is not fully optimal,
   // let's use CHOLMOD's one:
-  cholmod_dense cdb = ei_cholmod_map_eigen_to_dense(b);
+  cholmod_dense cdb = internal::cholmod_map_eigen_to_dense(b);
   cholmod_dense* x = cholmod_solve(CHOLMOD_A, m_cholmodFactor, &cdb, &m_cholmod);
   b = Matrix::Map(reinterpret_cast(x->x),b.rows());
   cholmod_free_dense(&x, &m_cholmod);
diff --git a/unsupported/Eigen/src/SparseExtra/RandomSetter.h b/unsupported/Eigen/src/SparseExtra/RandomSetter.h
index f81eb693d..4ea41af85 100644
--- a/unsupported/Eigen/src/SparseExtra/RandomSetter.h
+++ b/unsupported/Eigen/src/SparseExtra/RandomSetter.h
@@ -305,8 +305,8 @@ class RandomSetter
     /** \returns a reference to the coefficient at given coordinates \a row, \a col */
     Scalar& operator() (Index row, Index col)
     {
-      ei_assert(((!IsUpper) || (row<=col)) && "Invalid access to an upper triangular matrix");
-      ei_assert(((!IsLower) || (col<=row)) && "Invalid access to an upper triangular matrix");
+      eigen_assert(((!IsUpper) || (row<=col)) && "Invalid access to an upper triangular matrix");
+      eigen_assert(((!IsLower) || (col<=row)) && "Invalid access to an upper triangular matrix");
       const Index outer = SetterRowMajor ? row : col;
       const Index inner = SetterRowMajor ? col : row;
       const Index outerMajor = outer >> OuterPacketBits; // index of the packet/map
diff --git a/unsupported/Eigen/src/SparseExtra/SparseLDLT.h b/unsupported/Eigen/src/SparseExtra/SparseLDLT.h
index a852f2b0f..837d70295 100644
--- a/unsupported/Eigen/src/SparseExtra/SparseLDLT.h
+++ b/unsupported/Eigen/src/SparseExtra/SparseLDLT.h
@@ -99,7 +99,7 @@ class SparseLDLT
     SparseLDLT(int flags = 0)
       : m_flags(flags), m_status(0)
     {
-      ei_assert((MatrixType::Flags&RowMajorBit)==0);
+      eigen_assert((MatrixType::Flags&RowMajorBit)==0);
       m_precision = RealScalar(0.1) * Eigen::NumTraits::dummy_precision();
     }
 
@@ -108,7 +108,7 @@ class SparseLDLT
     SparseLDLT(const MatrixType& matrix, int flags = 0)
       : m_matrix(matrix.rows(), matrix.cols()), m_flags(flags), m_status(0)
     {
-      ei_assert((MatrixType::Flags&RowMajorBit)==0);
+      eigen_assert((MatrixType::Flags&RowMajorBit)==0);
       m_precision = RealScalar(0.1) * Eigen::NumTraits::dummy_precision();
       compute(matrix);
     }
@@ -166,11 +166,11 @@ class SparseLDLT
     bool solveInPlace(MatrixBase &b) const;
 
     template
-    inline const ei_solve_retval, Rhs>
+    inline const internal::solve_retval, Rhs>
     solve(const MatrixBase& b) const
     {
-      ei_assert(true && "SparseLDLT is not initialized.");
-      return ei_solve_retval, Rhs>(*this, b.derived());
+      eigen_assert(true && "SparseLDLT is not initialized.");
+      return internal::solve_retval, Rhs>(*this, b.derived());
     }
 
     inline Index cols() const { return m_matrix.cols(); }
@@ -193,13 +193,11 @@ class SparseLDLT
     bool m_succeeded;
 };
 
-
-
-
+namespace internal {
 
 template
-struct ei_solve_retval, Rhs>
-  : ei_solve_retval_base, Rhs>
+struct solve_retval, Rhs>
+  : solve_retval_base, Rhs>
 {
   typedef SparseLDLT<_MatrixType> SpLDLTDecType;
   EIGEN_MAKE_SOLVE_HELPERS(SpLDLTDecType,Rhs)
@@ -207,7 +205,7 @@ struct ei_solve_retval, Rhs>
   template void evalTo(Dest& dst) const
   {
     //Index size = dec().matrixL().rows();
-    ei_assert(dec().matrixL().rows()==rhs().rows());
+    eigen_assert(dec().matrixL().rows()==rhs().rows());
 
     Rhs b(rhs().rows(), rhs().cols());
     b = rhs();
@@ -225,7 +223,7 @@ struct ei_solve_retval, Rhs>
     
 };
 
-
+} // end namespace internal
 
 /** Computes / recomputes the LDLT decomposition of matrix \a a
   * using the default algorithm.
@@ -332,7 +330,7 @@ bool SparseLDLT<_MatrixType,Backend>::_numeric(const _MatrixType& a)
       Index i = Pinv ? Pinv[Ai[p]] : Ai[p]; /* get A(i,k) */
       if (i <= k)
       {
-        y[i] += ei_conj(Ax[p]);            /* scatter A(i,k) into Y (sum duplicates) */
+        y[i] += internal::conj(Ax[p]);            /* scatter A(i,k) into Y (sum duplicates) */
         Index len;
         for (len = 0; tags[i] != k; i = m_parent[i])
         {
@@ -355,9 +353,9 @@ bool SparseLDLT<_MatrixType,Backend>::_numeric(const _MatrixType& a)
       Index p2 = Lp[i] + m_nonZerosPerCol[i];
       Index p;
       for (p = Lp[i]; p < p2; ++p)
-        y[Li[p]] -= ei_conj(Lx[p]) * (yi);
+        y[Li[p]] -= internal::conj(Lx[p]) * (yi);
       Scalar l_ki = yi / m_diag[i];       /* the nonzero entry L(k,i) */
-      m_diag[k] -= l_ki * ei_conj(yi);
+      m_diag[k] -= l_ki * internal::conj(yi);
       Li[p] = k;                          /* store L(k,i) in column form of L */
       Lx[p] = (l_ki);
       ++m_nonZerosPerCol[i];              /* increment count of nonzeros in col i */
@@ -382,7 +380,7 @@ template
 bool SparseLDLT<_MatrixType, Backend>::solveInPlace(MatrixBase &b) const
 {
   //Index size = m_matrix.rows();
-  ei_assert(m_matrix.rows()==b.rows());
+  eigen_assert(m_matrix.rows()==b.rows());
   if (!m_succeeded)
     return false;
 
diff --git a/unsupported/Eigen/src/SparseExtra/SparseLLT.h b/unsupported/Eigen/src/SparseExtra/SparseLLT.h
index 5be914b6a..ac042217b 100644
--- a/unsupported/Eigen/src/SparseExtra/SparseLLT.h
+++ b/unsupported/Eigen/src/SparseExtra/SparseLLT.h
@@ -112,11 +112,11 @@ class SparseLLT
     bool solveInPlace(MatrixBase &b) const;
 
     template
-    inline const ei_solve_retval, Rhs>
+    inline const internal::solve_retval, Rhs>
     solve(const MatrixBase& b) const
     {
-      ei_assert(true && "SparseLLT is not initialized.");
-      return ei_solve_retval, Rhs>(*this, b.derived());
+      eigen_assert(true && "SparseLLT is not initialized.");
+      return internal::solve_retval, Rhs>(*this, b.derived());
     }
 
     inline Index cols() const { return m_matrix.cols(); }
@@ -134,13 +134,11 @@ class SparseLLT
 };
 
 
-
-
-
+namespace internal {
 
 template
-struct ei_solve_retval, Rhs>
-  : ei_solve_retval_base, Rhs>
+struct solve_retval, Rhs>
+  : solve_retval_base, Rhs>
 {
   typedef SparseLLT<_MatrixType> SpLLTDecType;
   EIGEN_MAKE_SOLVE_HELPERS(SpLLTDecType,Rhs)
@@ -148,7 +146,7 @@ struct ei_solve_retval, Rhs>
   template void evalTo(Dest& dst) const
   {
     const Index size = dec().matrixL().rows();
-    ei_assert(size==rhs().rows());
+    eigen_assert(size==rhs().rows());
     
     Rhs b(rhs().rows(), rhs().cols());
     b = rhs();
@@ -162,7 +160,7 @@ struct ei_solve_retval, Rhs>
     
 };
 
-
+} // end namespace internal
 
 
 /** Computes / recomputes the LLT decomposition of matrix \a a
@@ -184,7 +182,7 @@ void SparseLLT<_MatrixType,Backend>::compute(const _MatrixType& a)
   m_matrix.reserve(a.nonZeros()*2);
   for (Index j = 0; j < size; ++j)
   {
-    Scalar x = ei_real(a.coeff(j,j));
+    Scalar x = internal::real(a.coeff(j,j));
 
     // TODO better estimate of the density !
     tempVector.init(density>0.001? IsDense : IsSparse);
@@ -193,7 +191,7 @@ void SparseLLT<_MatrixType,Backend>::compute(const _MatrixType& a)
     // init with current matrix a
     {
       typename _MatrixType::InnerIterator it(a,j);
-      ei_assert(it.index()==j &&
+      eigen_assert(it.index()==j &&
         "matrix must has non zero diagonal entries and only the lower triangular part must be stored");
       ++it; // skip diagonal element
       for (; it; ++it)
@@ -207,7 +205,7 @@ void SparseLLT<_MatrixType,Backend>::compute(const _MatrixType& a)
       if (it && it.index()==j)
       {
         Scalar y = it.value();
-        x -= ei_abs2(y);
+        x -= internal::abs2(y);
         ++it; // skip j-th element, and process remaining column coefficients
         tempVector.restart();
         for (; it; ++it)
@@ -218,7 +216,7 @@ void SparseLLT<_MatrixType,Backend>::compute(const _MatrixType& a)
     }
     // copy the temporary vector to the respective m_matrix.col()
     // while scaling the result by 1/real(x)
-    RealScalar rx = ei_sqrt(ei_real(x));
+    RealScalar rx = internal::sqrt(internal::real(x));
     m_matrix.insert(j,j) = rx; // FIXME use insertBack
     Scalar y = Scalar(1)/rx;
     for (typename AmbiVector::Iterator it(tempVector, m_precision*rx); it; ++it)
@@ -236,7 +234,7 @@ template
 bool SparseLLT<_MatrixType, Backend>::solveInPlace(MatrixBase &b) const
 {
   const Index size = m_matrix.rows();
-  ei_assert(size==b.rows());
+  eigen_assert(size==b.rows());
 
   m_matrix.template triangularView().solveInPlace(b);
   m_matrix.adjoint().template triangularView().solveInPlace(b);
diff --git a/unsupported/Eigen/src/SparseExtra/SparseLU.h b/unsupported/Eigen/src/SparseExtra/SparseLU.h
index f6ced52c9..3d10dbbee 100644
--- a/unsupported/Eigen/src/SparseExtra/SparseLU.h
+++ b/unsupported/Eigen/src/SparseExtra/SparseLU.h
@@ -103,7 +103,7 @@ class SparseLU
 
     void setOrderingMethod(int m)
     {
-      ei_assert( (m&~OrderingMask) == 0 && m!=0 && "invalid ordering method");
+      eigen_assert( (m&~OrderingMask) == 0 && m!=0 && "invalid ordering method");
       m_flags = m_flags&~OrderingMask | m&OrderingMask;
     }
 
@@ -141,7 +141,7 @@ class SparseLU
 template
 void SparseLU<_MatrixType,Backend>::compute(const _MatrixType& )
 {
-  ei_assert(false && "not implemented yet");
+  eigen_assert(false && "not implemented yet");
 }
 
 /** Computes *x = U^-1 L^-1 b
@@ -156,7 +156,7 @@ template
 template
 bool SparseLU<_MatrixType,Backend>::solve(const MatrixBase &, MatrixBase* , const int ) const
 {
-  ei_assert(false && "not implemented yet");
+  eigen_assert(false && "not implemented yet");
   return false;
 }
 
diff --git a/unsupported/Eigen/src/SparseExtra/SuperLUSupport.h b/unsupported/Eigen/src/SparseExtra/SuperLUSupport.h
index 9453aabce..31a0ee509 100644
--- a/unsupported/Eigen/src/SparseExtra/SuperLUSupport.h
+++ b/unsupported/Eigen/src/SparseExtra/SuperLUSupport.h
@@ -126,7 +126,7 @@ struct SluMatrix : SuperMatrix
       Store = &storage;
     else
     {
-      ei_assert(false && "storage type not supported");
+      eigen_assert(false && "storage type not supported");
       Store = 0;
     }
   }
@@ -134,17 +134,17 @@ struct SluMatrix : SuperMatrix
   template
   void setScalarType()
   {
-    if (ei_is_same_type::ret)
+    if (internal::is_same_type::ret)
       Dtype = SLU_S;
-    else if (ei_is_same_type::ret)
+    else if (internal::is_same_type::ret)
       Dtype = SLU_D;
-    else if (ei_is_same_type >::ret)
+    else if (internal::is_same_type >::ret)
       Dtype = SLU_C;
-    else if (ei_is_same_type >::ret)
+    else if (internal::is_same_type >::ret)
       Dtype = SLU_Z;
     else
     {
-      ei_assert(false && "Scalar type not supported by SuperLU");
+      eigen_assert(false && "Scalar type not supported by SuperLU");
     }
   }
 
@@ -152,7 +152,7 @@ struct SluMatrix : SuperMatrix
   static SluMatrix Map(Matrix& mat)
   {
     typedef Matrix MatrixType;
-    ei_assert( ((Options&RowMajor)!=RowMajor) && "row-major dense matrices is not supported by SuperLU");
+    eigen_assert( ((Options&RowMajor)!=RowMajor) && "row-major dense matrices is not supported by SuperLU");
     SluMatrix res;
     res.setStorageType(SLU_DN);
     res.setScalarType();
@@ -198,7 +198,7 @@ struct SluMatrix : SuperMatrix
     if (MatrixType::Flags & Lower)
       res.Mtype = SLU_TRL;
     if (MatrixType::Flags & SelfAdjoint)
-      ei_assert(false && "SelfAdjoint matrix shape not supported by SuperLU");
+      eigen_assert(false && "SelfAdjoint matrix shape not supported by SuperLU");
     return res;
   }
 };
@@ -209,7 +209,7 @@ struct SluMatrixMapHelper >
   typedef Matrix MatrixType;
   static void run(MatrixType& mat, SluMatrix& res)
   {
-    ei_assert( ((Options&RowMajor)!=RowMajor) && "row-major dense matrices is not supported by SuperLU");
+    eigen_assert( ((Options&RowMajor)!=RowMajor) && "row-major dense matrices is not supported by SuperLU");
     res.setStorageType(SLU_DN);
     res.setScalarType();
     res.Mtype     = SLU_GE;
@@ -256,21 +256,23 @@ struct SluMatrixMapHelper >
     if (MatrixType::Flags & Lower)
       res.Mtype = SLU_TRL;
     if (MatrixType::Flags & SelfAdjoint)
-      ei_assert(false && "SelfAdjoint matrix shape not supported by SuperLU");
+      eigen_assert(false && "SelfAdjoint matrix shape not supported by SuperLU");
   }
 };
 
+namespace internal {
+
 template
-SluMatrix ei_asSluMatrix(MatrixType& mat)
+SluMatrix asSluMatrix(MatrixType& mat)
 {
   return SluMatrix::Map(mat);
 }
 
 /** View a Super LU matrix as an Eigen expression */
 template
-MappedSparseMatrix ei_map_superlu(SluMatrix& sluMat)
+MappedSparseMatrix map_superlu(SluMatrix& sluMat)
 {
-  ei_assert((Flags&RowMajor)==RowMajor && sluMat.Stype == SLU_NR
+  eigen_assert((Flags&RowMajor)==RowMajor && sluMat.Stype == SLU_NR
          || (Flags&ColMajor)==ColMajor && sluMat.Stype == SLU_NC);
 
   Index outerSize = (Flags&RowMajor)==RowMajor ? sluMat.ncol : sluMat.nrow;
@@ -280,6 +282,8 @@ MappedSparseMatrix ei_map_superlu(SluMatrix& sluMat)
     sluMat.storage.outerInd, sluMat.storage.innerInd, reinterpret_cast(sluMat.storage.values) );
 }
 
+} // end namespace internal
+
 template
 class SparseLU : public SparseLU
 {
@@ -393,7 +397,7 @@ void SparseLU::compute(const MatrixType& a)
         m_sluOptions.ColPerm = NATURAL;
   };
 
-  m_sluA = ei_asSluMatrix(m_matrix);
+  m_sluA = internal::asSluMatrix(m_matrix);
   memset(&m_sluL,0,sizeof m_sluL);
   memset(&m_sluU,0,sizeof m_sluU);
   //m_sluEqued = 'B';
@@ -471,7 +475,7 @@ bool SparseLU::solve(const MatrixBase &b,
 {
   const int size = m_matrix.rows();
   const int rhsCols = b.cols();
-  ei_assert(size==b.rows());
+  eigen_assert(size==b.rows());
 
   switch (transposed) {
       case SvNoTrans    :  m_sluOptions.Trans = NOTRANS; break;
@@ -637,7 +641,7 @@ typename SparseLU::Scalar SparseLU::dete
     if (m_u._outerIndexPtr()[j+1]-m_u._outerIndexPtr()[j] > 0)
     {
       int lastId = m_u._outerIndexPtr()[j+1]-1;
-      ei_assert(m_u._innerIndexPtr()[lastId]<=j);
+      eigen_assert(m_u._innerIndexPtr()[lastId]<=j);
       if (m_u._innerIndexPtr()[lastId]==j)
       {
         det *= m_u._valuePtr()[lastId];
diff --git a/unsupported/Eigen/src/SparseExtra/UmfPackSupport.h b/unsupported/Eigen/src/SparseExtra/UmfPackSupport.h
index 9d7e3e96e..4be1aca62 100644
--- a/unsupported/Eigen/src/SparseExtra/UmfPackSupport.h
+++ b/unsupported/Eigen/src/SparseExtra/UmfPackSupport.h
@@ -183,11 +183,11 @@ class SparseLU<_MatrixType,UmfPack> : public SparseLU<_MatrixType>
     bool solve(const MatrixBase &b, MatrixBase* x) const;
 
     template
-      inline const ei_solve_retval, Rhs>
+      inline const internal::solve_retval, Rhs>
     solve(const MatrixBase& b) const
     {
-      ei_assert(true && "SparseLU is not initialized.");
-      return ei_solve_retval, Rhs>(*this, b.derived());
+      eigen_assert(true && "SparseLU is not initialized.");
+      return internal::solve_retval, Rhs>(*this, b.derived());
     }
 
     void compute(const MatrixType& matrix);
@@ -197,7 +197,7 @@ class SparseLU<_MatrixType,UmfPack> : public SparseLU<_MatrixType>
 
     inline const MatrixType& matrixLU() const
     {
-      //ei_assert(m_isInitialized && "LU is not initialized.");
+      //eigen_assert(m_isInitialized && "LU is not initialized.");
       return *m_matrixRef;
     }
 
@@ -221,10 +221,11 @@ class SparseLU<_MatrixType,UmfPack> : public SparseLU<_MatrixType>
     mutable bool m_extractedDataAreDirty;
 };
 
+namespace internal {
 
 template
-  struct ei_solve_retval, Rhs>
-  : ei_solve_retval_base, Rhs>
+  struct solve_retval, Rhs>
+  : solve_retval_base, Rhs>
 {
   typedef SparseLU<_MatrixType, UmfPack> SpLUDecType;
   EIGEN_MAKE_SOLVE_HELPERS(SpLUDecType,Rhs)
@@ -233,8 +234,8 @@ template
   {
     const int rhsCols = rhs().cols();
 
-    ei_assert((Rhs::Flags&RowMajorBit)==0 && "UmfPack backend does not support non col-major rhs yet");
-    ei_assert((Dest::Flags&RowMajorBit)==0 && "UmfPack backend does not support non col-major result yet");
+    eigen_assert((Rhs::Flags&RowMajorBit)==0 && "UmfPack backend does not support non col-major rhs yet");
+    eigen_assert((Dest::Flags&RowMajorBit)==0 && "UmfPack backend does not support non col-major result yet");
 
     void* numeric = const_cast(dec().numeric());
 
@@ -244,13 +245,13 @@ template
  errorCode = umfpack_solve(UMFPACK_A,
          dec().matrixLU()._outerIndexPtr(), dec().matrixLU()._innerIndexPtr(), dec().matrixLU()._valuePtr(),
          &dst.col(j).coeffRef(0), &rhs().const_cast_derived().col(j).coeffRef(0), numeric, 0, 0);
- ei_assert(!errorCode && "UmfPack could not solve the system.");
+ eigen_assert(!errorCode && "UmfPack could not solve the system.");
       }
   }
     
 };
 
-
+} // end namespace internal
 
 template
 void SparseLU::compute(const MatrixType& a)
@@ -258,7 +259,7 @@ void SparseLU::compute(const MatrixType& a)
   typedef typename MatrixType::Index Index;
   const Index rows = a.rows();
   const Index cols = a.cols();
-  ei_assert((MatrixType::Flags&RowMajorBit)==0 && "Row major matrices are not supported yet");
+  eigen_assert((MatrixType::Flags&RowMajorBit)==0 && "Row major matrices are not supported yet");
 
   m_matrixRef = &a;
 
@@ -322,9 +323,9 @@ bool SparseLU::solve(const MatrixBase &b, MatrixBa
 {
   //const int size = m_matrix.rows();
   const int rhsCols = b.cols();
-//   ei_assert(size==b.rows());
-  ei_assert((BDerived::Flags&RowMajorBit)==0 && "UmfPack backend does not support non col-major rhs yet");
-  ei_assert((XDerived::Flags&RowMajorBit)==0 && "UmfPack backend does not support non col-major result yet");
+//   eigen_assert(size==b.rows());
+  eigen_assert((BDerived::Flags&RowMajorBit)==0 && "UmfPack backend does not support non col-major rhs yet");
+  eigen_assert((XDerived::Flags&RowMajorBit)==0 && "UmfPack backend does not support non col-major result yet");
 
   int errorCode;
   for (int j=0; j Box2d;
 
-Box2d ei_bounding_box(const Vector2d &v) { return Box2d(v, v); } //compute the bounding box of a single point
+Box2d internal::bounding_box(const Vector2d &v) { return Box2d(v, v); } //compute the bounding box of a single point
 
 struct PointPointMinimizer //how to compute squared distances between points and rectangles
 {
diff --git a/unsupported/doc/examples/PolynomialSolver1.cpp b/unsupported/doc/examples/PolynomialSolver1.cpp
index c875c9361..71e6b825f 100644
--- a/unsupported/doc/examples/PolynomialSolver1.cpp
+++ b/unsupported/doc/examples/PolynomialSolver1.cpp
@@ -49,5 +49,5 @@ int main()
   cout.precision(10);
   cout << "The last root in float then in double: " << psolvef.roots()[5] << "\t" << psolve6d.roots()[5] << endl;
   std::complex castedRoot( psolve6d.roots()[5].real(), psolve6d.roots()[5].imag() );
-  cout << "Norm of the difference: " << ei_abs( psolvef.roots()[5] - castedRoot ) << endl;
+  cout << "Norm of the difference: " << internal::abs( psolvef.roots()[5] - castedRoot ) << endl;
 }
diff --git a/unsupported/test/BVH.cpp b/unsupported/test/BVH.cpp
index 4abf7f5bd..ba5871e66 100644
--- a/unsupported/test/BVH.cpp
+++ b/unsupported/test/BVH.cpp
@@ -42,11 +42,15 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(double, Dim)
   double radius;
 };
 
+namespace Eigen {
+namespace internal {
 
-template AlignedBox ei_bounding_box(const Matrix &v) { return AlignedBox(v); }
-template AlignedBox ei_bounding_box(const Ball &b)
+template AlignedBox bounding_box(const Matrix &v) { return AlignedBox(v); }
+template AlignedBox bounding_box(const Ball &b)
 { return AlignedBox(b.center.array() - b.radius, b.center.array() + b.radius); }
 
+} // end namespace internal
+}
 
 template
 struct BallPointStuff //this class provides functions to be both an intersector and a minimizer, both for a ball and a point and for two trees
@@ -113,7 +117,7 @@ struct TreeTest
   {
     BallTypeList b;
     for(int i = 0; i < 500; ++i) {
-        b.push_back(BallType(VectorType::Random(), 0.5 * ei_random(0., 1.)));
+        b.push_back(BallType(VectorType::Random(), 0.5 * internal::random(0., 1.)));
     }
     KdBVH tree(b.begin(), b.end());
 
@@ -132,7 +136,7 @@ struct TreeTest
   {
     BallTypeList b;
     for(int i = 0; i < 500; ++i) {
-        b.push_back(BallType(VectorType::Random(), 0.01 * ei_random(0., 1.)));
+        b.push_back(BallType(VectorType::Random(), 0.01 * internal::random(0., 1.)));
     }
     KdBVH tree(b.begin(), b.end());
 
@@ -155,7 +159,7 @@ struct TreeTest
     VectorTypeList v;
 
     for(int i = 0; i < 50; ++i) {
-        b.push_back(BallType(VectorType::Random(), 0.5 * ei_random(0., 1.)));
+        b.push_back(BallType(VectorType::Random(), 0.5 * internal::random(0., 1.)));
         for(int j = 0; j < 3; ++j)
             v.push_back(VectorType::Random());
     }
@@ -180,7 +184,7 @@ struct TreeTest
     VectorTypeList v;
 
     for(int i = 0; i < 50; ++i) {
-        b.push_back(BallType(VectorType::Random(), 1e-7 + 1e-6 * ei_random(0., 1.)));
+        b.push_back(BallType(VectorType::Random(), 1e-7 + 1e-6 * internal::random(0., 1.)));
         for(int j = 0; j < 3; ++j)
             v.push_back(VectorType::Random());
     }
diff --git a/unsupported/test/NonLinearOptimization.cpp b/unsupported/test/NonLinearOptimization.cpp
index 851c534f6..196cf15e0 100644
--- a/unsupported/test/NonLinearOptimization.cpp
+++ b/unsupported/test/NonLinearOptimization.cpp
@@ -66,11 +66,11 @@ void testChkder()
   /*      checking the jacobian matrix. */
   x << 9.2e-1, 1.3e-1, 5.4e-1;
 
-  ei_chkder(x, fvec, fjac, xp, fvecp, 1, err);
+  internal::chkder(x, fvec, fjac, xp, fvecp, 1, err);
   fcn_chkder(x, fvec, fjac, 1);
   fcn_chkder(x, fvec, fjac, 2);
   fcn_chkder(xp, fvecp, fjac, 1);
-  ei_chkder(x, fvec, fjac, xp, fvecp, 2, err);
+  internal::chkder(x, fvec, fjac, xp, fvecp, 2, err);
 
   fvecp -= fvec;
 
@@ -220,7 +220,7 @@ void testLmder()
 
   // check covariance
   covfac = fnorm*fnorm/(m-n);
-  ei_covar(lm.fjac, lm.permutation.indices()); // TODO : move this as a function of lm
+  internal::covar(lm.fjac, lm.permutation.indices()); // TODO : move this as a function of lm
 
   MatrixXd cov_ref(n,n);
   cov_ref <<
@@ -611,7 +611,7 @@ void testLmdif()
 
   // check covariance
   covfac = fnorm*fnorm/(m-n);
-  ei_covar(lm.fjac, lm.permutation.indices()); // TODO : move this as a function of lm
+  internal::covar(lm.fjac, lm.permutation.indices()); // TODO : move this as a function of lm
 
   MatrixXd cov_ref(n,n);
   cov_ref <<
diff --git a/unsupported/test/alignedvector3.cpp b/unsupported/test/alignedvector3.cpp
index f4b6dd4d9..0b46ad561 100644
--- a/unsupported/test/alignedvector3.cpp
+++ b/unsupported/test/alignedvector3.cpp
@@ -28,8 +28,8 @@
 template
 void alignedvector3()
 {
-  Scalar s1 = ei_random();
-  Scalar s2 = ei_random();
+  Scalar s1 = internal::random();
+  Scalar s2 = internal::random();
   typedef Matrix RefType;
   typedef Matrix Mat33;
   typedef AlignedVector3 FastType;
diff --git a/unsupported/test/matrix_exponential.cpp b/unsupported/test/matrix_exponential.cpp
index 74b2634c8..17a0dadab 100644
--- a/unsupported/test/matrix_exponential.cpp
+++ b/unsupported/test/matrix_exponential.cpp
@@ -127,7 +127,7 @@ void randomTest(const MatrixType& m, double tol)
   MatrixType m1(rows, cols), m2(rows, cols), m3(rows, cols),
              identity = MatrixType::Identity(rows, rows);
 
-  typedef typename NumTraits::Scalar>::Real RealScalar;
+  typedef typename NumTraits::Scalar>::Real RealScalar;
 
   for(int i = 0; i < g_repeat; i++) {
     m1 = MatrixType::Random(rows, cols);
diff --git a/unsupported/test/matrix_function.cpp b/unsupported/test/matrix_function.cpp
index 3b4cbfec6..04167abfb 100644
--- a/unsupported/test/matrix_function.cpp
+++ b/unsupported/test/matrix_function.cpp
@@ -45,15 +45,15 @@ MatrixType randomMatrixWithRealEivals(const typename MatrixType::Index size)
   typedef typename MatrixType::RealScalar RealScalar;
   MatrixType diag = MatrixType::Zero(size, size);
   for (Index i = 0; i < size; ++i) {
-    diag(i, i) = Scalar(RealScalar(ei_random(0,2)))
-      + ei_random() * Scalar(RealScalar(0.01));
+    diag(i, i) = Scalar(RealScalar(internal::random(0,2)))
+      + internal::random() * Scalar(RealScalar(0.01));
   }
   MatrixType A = MatrixType::Random(size, size);
   HouseholderQR QRofA(A);
   return QRofA.householderQ().inverse() * diag * QRofA.householderQ();
 }
 
-template ::Scalar>::IsComplex>
+template ::Scalar>::IsComplex>
 struct randomMatrixWithImagEivals
 {
   // Returns a matrix with eigenvalues clustered around 0 and +/- i.
@@ -71,12 +71,12 @@ struct randomMatrixWithImagEivals
     MatrixType diag = MatrixType::Zero(size, size);
     Index i = 0;
     while (i < size) {
-      Index randomInt = ei_random(-1, 1);
+      Index randomInt = internal::random(-1, 1);
       if (randomInt == 0 || i == size-1) {
-        diag(i, i) = ei_random() * Scalar(0.01);
+        diag(i, i) = internal::random() * Scalar(0.01);
         ++i;
       } else {
-        Scalar alpha = Scalar(randomInt) + ei_random() * Scalar(0.01);
+        Scalar alpha = Scalar(randomInt) + internal::random() * Scalar(0.01);
         diag(i, i+1) = alpha;
         diag(i+1, i) = -alpha;
         i += 2;
@@ -100,8 +100,8 @@ struct randomMatrixWithImagEivals
     const Scalar imagUnit(0, 1);
     MatrixType diag = MatrixType::Zero(size, size);
     for (Index i = 0; i < size; ++i) {
-      diag(i, i) = Scalar(RealScalar(ei_random(-1, 1))) * imagUnit
-        + ei_random() * Scalar(RealScalar(0.01));
+      diag(i, i) = Scalar(RealScalar(internal::random(-1, 1))) * imagUnit
+        + internal::random() * Scalar(RealScalar(0.01));
     }
     MatrixType A = MatrixType::Random(size, size);
     HouseholderQR QRofA(A);
@@ -113,7 +113,7 @@ struct randomMatrixWithImagEivals
 template
 void testMatrixExponential(const MatrixType& A)
 {
-  typedef typename ei_traits::Scalar Scalar;
+  typedef typename internal::traits::Scalar Scalar;
   typedef typename NumTraits::Real RealScalar;
   typedef std::complex ComplexScalar;
 
diff --git a/unsupported/test/mpreal_support.cpp b/unsupported/test/mpreal_support.cpp
index 32570f092..4e8e583f0 100644
--- a/unsupported/test/mpreal_support.cpp
+++ b/unsupported/test/mpreal_support.cpp
@@ -17,7 +17,7 @@ void test_mpreal_support()
   std::cerr << "lowest =          " << NumTraits::lowest() << "\n";
 
   for(int i = 0; i < g_repeat; i++) {
-    int s = ei_random(1,100);
+    int s = Eigen::internal::random(1,100);
     MatrixXmp A = MatrixXmp::Random(s,s);
     MatrixXmp B = MatrixXmp::Random(s,s);
     MatrixXmp S = A.adjoint() * A;
diff --git a/unsupported/test/openglsupport.cpp b/unsupported/test/openglsupport.cpp
index a33e9950b..63e1b44eb 100644
--- a/unsupported/test/openglsupport.cpp
+++ b/unsupported/test/openglsupport.cpp
@@ -160,10 +160,10 @@ void test_openglsupport()
   VERIFY_MATRIX(glMultMatrix(md44), md44);
   
   // Quaternion
-  Quaterniond qd(AngleAxisd(ei_random(), Vector3d::Random()));
+  Quaterniond qd(AngleAxisd(internal::random(), Vector3d::Random()));
   VERIFY_MATRIX(glRotate(qd), Projective3d(qd).matrix());
   
-  Quaternionf qf(AngleAxisf(ei_random(), Vector3f::Random()));
+  Quaternionf qf(AngleAxisf(internal::random(), Vector3f::Random()));
   VERIFY_MATRIX(glRotate(qf), Projective3f(qf).matrix());
   
   // 3D Transform
@@ -222,10 +222,10 @@ void test_openglsupport()
     Vector3d vd3; vd3.setRandom();
     VERIFY_MATRIX(glScale(vd3), Projective3d(Scaling(vd3)).matrix());
     
-    UniformScaling usf(ei_random());
+    UniformScaling usf(internal::random());
     VERIFY_MATRIX(glScale(usf), Projective3f(usf).matrix());
     
-    UniformScaling usd(ei_random());
+    UniformScaling usd(internal::random());
     VERIFY_MATRIX(glScale(usd), Projective3d(usd).matrix());
   }
   
diff --git a/unsupported/test/polynomialsolver.cpp b/unsupported/test/polynomialsolver.cpp
index f6a574a60..8120ef3e3 100644
--- a/unsupported/test/polynomialsolver.cpp
+++ b/unsupported/test/polynomialsolver.cpp
@@ -33,15 +33,17 @@
 
 using namespace std;
 
+namespace Eigen {
+namespace internal {
 template
-struct ei_increment_if_fixed_size
+struct increment_if_fixed_size
 {
   enum {
     ret = (Size == Dynamic) ? Dynamic : Size+1
   };
 };
-
-
+}
+}
 
 
 template
@@ -72,7 +74,7 @@ bool aux_evalSolver( const POLYNOMIAL& pols, SOLVER& psolve )
   }
 
   #ifdef HAS_GSL
-  if (ei_is_same_type< Scalar, double>::ret)
+  if (internal::is_same_type< Scalar, double>::ret)
   {
     typedef GslTraits Gsl;
     RootsType gslRoots(deg);
@@ -104,7 +106,7 @@ bool aux_evalSolver( const POLYNOMIAL& pols, SOLVER& psolve )
   bool distinctModuli=true;
   for( size_t i=1; i() );
+    const Scalar psPrec = internal::sqrt( test_precision() );
 
     for( size_t i=0; i 0 ) );
     if( hasRealRoot ){
-      VERIFY( ei_isApprox( real_roots.array().abs().maxCoeff(), ei_abs(r), psPrec ) );  }
+      VERIFY( internal::isApprox( real_roots.array().abs().maxCoeff(), internal::abs(r), psPrec ) );  }
 
     //Test absSmallestRealRoot
     r = psolve.absSmallestRealRoot( hasRealRoot );
     VERIFY( hasRealRoot == (real_roots.size() > 0 ) );
     if( hasRealRoot ){
-      VERIFY( ei_isApprox( real_roots.array().abs().minCoeff(), ei_abs( r ), psPrec ) ); }
+      VERIFY( internal::isApprox( real_roots.array().abs().minCoeff(), internal::abs( r ), psPrec ) ); }
 
     //Test greatestRealRoot
     r = psolve.greatestRealRoot( hasRealRoot );
     VERIFY( hasRealRoot == (real_roots.size() > 0 ) );
     if( hasRealRoot ){
-      VERIFY( ei_isApprox( real_roots.array().maxCoeff(), r, psPrec ) ); }
+      VERIFY( internal::isApprox( real_roots.array().maxCoeff(), r, psPrec ) ); }
 
     //Test smallestRealRoot
     r = psolve.smallestRealRoot( hasRealRoot );
     VERIFY( hasRealRoot == (real_roots.size() > 0 ) );
     if( hasRealRoot ){
-    VERIFY( ei_isApprox( real_roots.array().minCoeff(), r, psPrec ) ); }
+    VERIFY( internal::isApprox( real_roots.array().minCoeff(), r, psPrec ) ); }
   }
 }
 
@@ -210,7 +212,7 @@ void evalSolverSugarFunction( const POLYNOMIAL& pols, const ROOTS& roots, const
 template
 void polynomialsolver(int deg)
 {
-  typedef ei_increment_if_fixed_size<_Deg>            Dim;
+  typedef internal::increment_if_fixed_size<_Deg>            Dim;
   typedef Matrix<_Scalar,Dim::ret,1>                  PolynomialType;
   typedef Matrix<_Scalar,_Deg,1>                      EvalRootsType;
 
@@ -219,7 +221,7 @@ void polynomialsolver(int deg)
   evalSolver<_Deg,PolynomialType>( pols );
 
   cout << "Hard cases" << endl;
-  _Scalar multipleRoot = ei_random<_Scalar>();
+  _Scalar multipleRoot = internal::random<_Scalar>();
   EvalRootsType allRoots = EvalRootsType::Constant(deg,multipleRoot);
   roots_to_monicPolynomial( allRoots, pols );
   evalSolver<_Deg,PolynomialType>( pols );
@@ -250,7 +252,7 @@ template void polynomialsolver_scalar()
   CALL_SUBTEST_8( (polynomialsolver<_Scalar,8>(8)) );
 
   CALL_SUBTEST_9( (polynomialsolver<_Scalar,Dynamic>(
-          ei_random(9,45)
+          internal::random(9,45)
           )) );
 }
 
diff --git a/unsupported/test/polynomialutils.cpp b/unsupported/test/polynomialutils.cpp
index 7f93c2f0d..7ff913c37 100644
--- a/unsupported/test/polynomialutils.cpp
+++ b/unsupported/test/polynomialutils.cpp
@@ -28,18 +28,22 @@
 
 using namespace std;
 
+namespace Eigen {
+namespace internal {
 template
-struct ei_increment_if_fixed_size
+struct increment_if_fixed_size
 {
   enum {
     ret = (Size == Dynamic) ? Dynamic : Size+1
   };
 };
+}
+}
 
 template
 void realRoots_to_monicPolynomial_test(int deg)
 {
-  typedef ei_increment_if_fixed_size<_Deg>            Dim;
+  typedef internal::increment_if_fixed_size<_Deg>            Dim;
   typedef Matrix<_Scalar,Dim::ret,1>                  PolynomialType;
   typedef Matrix<_Scalar,_Deg,1>                      EvalRootsType;
 
@@ -68,7 +72,7 @@ template void realRoots_to_monicPolynomial_scalar()
   CALL_SUBTEST_8( (realRoots_to_monicPolynomial_test<_Scalar,17>(17)) );
 
   CALL_SUBTEST_9( (realRoots_to_monicPolynomial_test<_Scalar,Dynamic>(
-          ei_random(18,26) )) );
+          internal::random(18,26) )) );
 }
 
 
@@ -77,7 +81,7 @@ template void realRoots_to_monicPolynomial_scalar()
 template
 void CauchyBounds(int deg)
 {
-  typedef ei_increment_if_fixed_size<_Deg>            Dim;
+  typedef internal::increment_if_fixed_size<_Deg>            Dim;
   typedef Matrix<_Scalar,Dim::ret,1>                  PolynomialType;
   typedef Matrix<_Scalar,_Deg,1>                      EvalRootsType;
 
@@ -109,7 +113,7 @@ template void CauchyBounds_scalar()
   CALL_SUBTEST_8( (CauchyBounds<_Scalar,17>(17)) );
 
   CALL_SUBTEST_9( (CauchyBounds<_Scalar,Dynamic>(
-          ei_random(18,26) )) );
+          internal::random(18,26) )) );
 }
 
 void test_polynomialutils()
diff --git a/unsupported/test/sparse_extra.cpp b/unsupported/test/sparse_extra.cpp
index 6cf1f50c4..84dfbdda6 100644
--- a/unsupported/test/sparse_extra.cpp
+++ b/unsupported/test/sparse_extra.cpp
@@ -35,7 +35,7 @@ bool test_random_setter(SparseMatrix& sm, const DenseType& ref,
     std::vector remaining = nonzeroCoords;
     while(!remaining.empty())
     {
-      int i = ei_random(0,static_cast(remaining.size())-1);
+      int i = internal::random(0,static_cast(remaining.size())-1);
       w(remaining[i].x(),remaining[i].y()) = ref.coeff(remaining[i].x(),remaining[i].y());
       remaining[i] = remaining.back();
       remaining.pop_back();
@@ -51,7 +51,7 @@ bool test_random_setter(DynamicSparseMatrix& sm, const DenseType& ref, const
   std::vector remaining = nonzeroCoords;
   while(!remaining.empty())
   {
-    int i = ei_random(0,static_cast(remaining.size())-1);
+    int i = internal::random(0,static_cast(remaining.size())-1);
     sm.coeffRef(remaining[i].x(),remaining[i].y()) = ref.coeff(remaining[i].x(),remaining[i].y());
     remaining[i] = remaining.back();
     remaining.pop_back();
@@ -87,7 +87,7 @@ template void sparse_extra(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 >::ret)
+    if(internal::is_same_type >::ret)
       VERIFY_RAISES_ASSERT( m.coeffRef(zeroCoords[0].x(),zeroCoords[0].y()) = 5 );
   }
   VERIFY_IS_APPROX(m, refMat);
@@ -105,7 +105,7 @@ template void sparse_extra(const SparseMatrixType& re
 //     std::vector remaining = nonzeroCoords;
 //     while(!remaining.empty())
 //     {
-//       int i = ei_random(0,remaining.size()-1);
+//       int i = internal::random(0,remaining.size()-1);
 //       w->coeffRef(remaining[i].x(),remaining[i].y()) = refMat.coeff(remaining[i].x(),remaining[i].y());
 //       remaining[i] = remaining.back();
 //       remaining.pop_back();
diff --git a/unsupported/test/sparse_ldlt.cpp b/unsupported/test/sparse_ldlt.cpp
index 5af4b77b4..275839670 100644
--- a/unsupported/test/sparse_ldlt.cpp
+++ b/unsupported/test/sparse_ldlt.cpp
@@ -43,7 +43,7 @@ template void sparse_ldlt(int rows, int cols)
 
   initSparse(density, refMat2, m2, ForceNonZeroDiag|MakeUpperTriangular, 0, 0);
   for(int i=0; i().ldlt().solve(b);
   typedef SparseMatrix SparseSelfAdjointMatrix;
@@ -85,7 +85,7 @@ void test_sparse_ldlt()
 {
   for(int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(sparse_ldlt(8, 8) );
-    int s = ei_random(1,300);
+    int s = internal::random(1,300);
     CALL_SUBTEST_2(sparse_ldlt >(s,s) );
     CALL_SUBTEST_1(sparse_ldlt(s,s) );
   }
diff --git a/unsupported/test/sparse_llt.cpp b/unsupported/test/sparse_llt.cpp
index 72a8382a1..2ec850ea0 100644
--- a/unsupported/test/sparse_llt.cpp
+++ b/unsupported/test/sparse_llt.cpp
@@ -45,7 +45,7 @@ template void sparse_llt(int rows, int cols)
     initSparse(density, refMat2, m2, ForceNonZeroDiag|MakeLowerTriangular, 0, 0);
 
     for(int i=0; i().llt().solve(b);
     if (!NumTraits::IsComplex)
@@ -78,7 +78,7 @@ void test_sparse_llt()
 {
   for(int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(sparse_llt(8, 8) );
-    int s = ei_random(1,300);
+    int s = internal::random(1,300);
     CALL_SUBTEST_2(sparse_llt >(s,s) );
     CALL_SUBTEST_1(sparse_llt(s,s) );
   }
diff --git a/unsupported/test/sparse_lu.cpp b/unsupported/test/sparse_lu.cpp
index 75aa7a924..e693499bb 100644
--- a/unsupported/test/sparse_lu.cpp
+++ b/unsupported/test/sparse_lu.cpp
@@ -109,7 +109,7 @@ void test_sparse_lu()
 {
   for(int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1(sparse_lu(8, 8) );
-    int s = ei_random(1,300);
+    int s = internal::random(1,300);
     CALL_SUBTEST_2(sparse_lu >(s,s) );
     CALL_SUBTEST_1(sparse_lu(s,s) );
   }
-- 
cgit v1.2.3