diff options
| author |  Benoit Jacob <jacob.benoit.1@gmail.com> | 2010-10-25 10:15:22 -0400 |
|---|---|---|
| committer | Benoit Jacob <jacob.benoit.1@gmail.com> | 2010-10-25 10:15:22 -0400 |
| commit | 4716040703be1ee906439385d20475dcddad5ce3 (patch) | |
| tree | 8efd3cf3007d8360e66f38e2d280127cbb70daa6 | |
| parent | ca85a1f6c5fc33ac382aa2d7ba2da63d55d3223e (diff) | |
bug #86 : use internal:: namespace instead of ei_ prefix
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<typename MatrixType, int UpLo> struct LDLT_Traits; +} /** \ingroup cholesky_Module * @@ -74,7 +76,7 @@ template<typename _MatrixType, int _UpLo> class LDLT typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime> TranspositionType; typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationType; - typedef LDLT_Traits<MatrixType,UpLo> Traits; + typedef internal::LDLT_Traits<MatrixType,UpLo> Traits; /** \brief Default Constructor. * @@ -108,14 +110,14 @@ template<typename _MatrixType, int _UpLo> 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<typename _MatrixType, int _UpLo> 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<MatrixType,0> 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<typename _MatrixType, int _UpLo> class LDLT * \sa solveInPlace(), MatrixBase::ldlt() */ template<typename Rhs> - inline const ei_solve_retval<LDLT, Rhs> + inline const internal::solve_retval<LDLT, Rhs> solve(const MatrixBase<Rhs>& 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<LDLT, Rhs>(*this, b.derived()); + return internal::solve_retval<LDLT, Rhs>(*this, b.derived()); } template<typename Derived> @@ -175,7 +177,7 @@ template<typename _MatrixType, int _UpLo> 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<typename _MatrixType, int _UpLo> class LDLT bool m_isInitialized; }; -template<int UpLo> struct ei_ldlt_inplace; +namespace internal { + +template<int UpLo> struct ldlt_inplace; -template<> struct ei_ldlt_inplace<Lower> +template<> struct ldlt_inplace<Lower> { template<typename MatrixType, typename TranspositionType, typename Workspace> static bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, int* sign=0) @@ -209,14 +213,14 @@ template<> struct ei_ldlt_inplace<Lower> 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<Lower> // 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<Scalar>::epsilon() * biggest_in_corner); + cutoff = abs(NumTraits<Scalar>::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<Lower> for(int i=k+1;i<index_of_biggest_in_corner;++i) { Scalar tmp = mat.coeffRef(i,k); - mat.coeffRef(i,k) = ei_conj(mat.coeffRef(index_of_biggest_in_corner,i)); - mat.coeffRef(index_of_biggest_in_corner,i) = ei_conj(tmp); + mat.coeffRef(i,k) = conj(mat.coeffRef(index_of_biggest_in_corner,i)); + mat.coeffRef(index_of_biggest_in_corner,i) = conj(tmp); } if(NumTraits<Scalar>::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<Lower> 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<Lower> } }; -template<> struct ei_ldlt_inplace<Upper> +template<> struct ldlt_inplace<Upper> { template<typename MatrixType, typename TranspositionType, typename Workspace> static EIGEN_STRONG_INLINE bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, int* sign=0) { Transpose<MatrixType> matt(mat); - return ei_ldlt_inplace<Lower>::unblocked(matt, transpositions, temp, sign); + return ldlt_inplace<Lower>::unblocked(matt, transpositions, temp, sign); } }; @@ -316,12 +320,14 @@ template<typename MatrixType> struct LDLT_Traits<MatrixType,Upper> 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<typename MatrixType, int _UpLo> LDLT<MatrixType,_UpLo>& LDLT<MatrixType,_UpLo>::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<MatrixType,_UpLo>& LDLT<MatrixType,_UpLo>::compute(const MatrixType& a) m_isInitialized = false; m_temporary.resize(size); - ei_ldlt_inplace<UpLo>::unblocked(m_matrix, m_transpositions, m_temporary, &m_sign); + internal::ldlt_inplace<UpLo>::unblocked(m_matrix, m_transpositions, m_temporary, &m_sign); m_isInitialized = true; return *this; } +namespace internal { template<typename _MatrixType, int _UpLo, typename Rhs> -struct ei_solve_retval<LDLT<_MatrixType,_UpLo>, Rhs> - : ei_solve_retval_base<LDLT<_MatrixType,_UpLo>, Rhs> +struct solve_retval<LDLT<_MatrixType,_UpLo>, Rhs> + : solve_retval_base<LDLT<_MatrixType,_UpLo>, Rhs> { typedef LDLT<_MatrixType,_UpLo> LDLTType; EIGEN_MAKE_SOLVE_HELPERS(LDLTType,Rhs) template<typename Dest> 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<LDLT<_MatrixType,_UpLo>, Rhs> dst = dec().transpositionsP().transpose() * dst; } }; +} /** \internal use x = ldlt_object.solve(x); * @@ -380,9 +388,9 @@ template<typename MatrixType,int _UpLo> template<typename Derived> bool LDLT<MatrixType,_UpLo>::solveInPlace(MatrixBase<Derived> &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<MatrixType,_UpLo>::solveInPlace(MatrixBase<Derived> &bAndX) const template<typename MatrixType, int _UpLo> MatrixType LDLT<MatrixType,_UpLo>::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<typename MatrixType, int UpLo> struct LLT_Traits; +} /** \ingroup cholesky_Module * @@ -68,12 +70,12 @@ template<typename _MatrixType, int _UpLo> class LLT typedef typename MatrixType::Index Index; enum { - PacketSize = ei_packet_traits<Scalar>::size, + PacketSize = internal::packet_traits<Scalar>::size, AlignmentMask = int(PacketSize)-1, UpLo = _UpLo }; - typedef LLT_Traits<MatrixType,UpLo> Traits; + typedef internal::LLT_Traits<MatrixType,UpLo> Traits; /** * \brief Default Constructor. @@ -102,14 +104,14 @@ template<typename _MatrixType, int _UpLo> 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<typename _MatrixType, int _UpLo> class LLT * \sa solveInPlace(), MatrixBase::llt() */ template<typename Rhs> - inline const ei_solve_retval<LLT, Rhs> + inline const internal::solve_retval<LLT, Rhs> solve(const MatrixBase<Rhs>& 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<LLT, Rhs>(*this, b.derived()); + return internal::solve_retval<LLT, Rhs>(*this, b.derived()); } template<typename Derived> @@ -144,7 +146,7 @@ template<typename _MatrixType, int _UpLo> 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<typename _MatrixType, int _UpLo> 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<typename _MatrixType, int _UpLo> class LLT ComputationInfo m_info; }; -template<int UpLo> struct ei_llt_inplace; +namespace internal { + +template<int UpLo> struct llt_inplace; -template<> struct ei_llt_inplace<Lower> +template<> struct llt_inplace<Lower> { template<typename MatrixType> static bool unblocked(MatrixType& mat) @@ -185,7 +189,7 @@ template<> struct ei_llt_inplace<Lower> 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<Lower> Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k); Block<MatrixType,Dynamic,Dynamic> 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<Lower> 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<Lower> } }; -template<> struct ei_llt_inplace<Upper> +template<> struct llt_inplace<Upper> { template<typename MatrixType> static EIGEN_STRONG_INLINE bool unblocked(MatrixType& mat) { Transpose<MatrixType> matt(mat); - return ei_llt_inplace<Lower>::unblocked(matt); + return llt_inplace<Lower>::unblocked(matt); } template<typename MatrixType> static EIGEN_STRONG_INLINE bool blocked(MatrixType& mat) { Transpose<MatrixType> matt(mat); - return ei_llt_inplace<Lower>::blocked(matt); + return llt_inplace<Lower>::blocked(matt); } }; @@ -262,7 +266,7 @@ template<typename MatrixType> struct LLT_Traits<MatrixType,Lower> 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<Lower>::blocked(m); } + { return llt_inplace<Lower>::blocked(m); } }; template<typename MatrixType> struct LLT_Traits<MatrixType,Upper> @@ -272,9 +276,11 @@ template<typename MatrixType> struct LLT_Traits<MatrixType,Upper> 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<Upper>::blocked(m); } + { return llt_inplace<Upper>::blocked(m); } }; +} // end namespace internal + /** Computes / recomputes the Cholesky decomposition A = LL^* = U^*U of \a matrix * * @@ -295,9 +301,10 @@ LLT<MatrixType,_UpLo>& LLT<MatrixType,_UpLo>::compute(const MatrixType& a) return *this; } +namespace internal { template<typename _MatrixType, int UpLo, typename Rhs> -struct ei_solve_retval<LLT<_MatrixType, UpLo>, Rhs> - : ei_solve_retval_base<LLT<_MatrixType, UpLo>, Rhs> +struct solve_retval<LLT<_MatrixType, UpLo>, Rhs> + : solve_retval_base<LLT<_MatrixType, UpLo>, Rhs> { typedef LLT<_MatrixType,UpLo> LLTType; EIGEN_MAKE_SOLVE_HELPERS(LLTType,Rhs) @@ -308,6 +315,7 @@ struct ei_solve_retval<LLT<_MatrixType, UpLo>, Rhs> dec().solveInPlace(dst); } }; +} /** \internal use x = llt_object.solve(x); * @@ -326,8 +334,8 @@ template<typename MatrixType, int _UpLo> template<typename Derived> void LLT<MatrixType,_UpLo>::solveInPlace(MatrixBase<Derived> &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<MatrixType,_UpLo>::solveInPlace(MatrixBase<Derived> &bAndX) const template<typename MatrixType, int _UpLo> MatrixType LLT<MatrixType,_UpLo>::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<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> -struct ei_traits<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > : ei_traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > +struct traits<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > : traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > { typedef ArrayXpr XprKind; typedef ArrayBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > XprBase; }; +} template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> class Array @@ -60,7 +62,7 @@ class Array protected: template <typename Derived, typename OtherDerived, bool IsVector> - 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<typename MatrixType, typename OtherDerived, bool SwapPointers> - 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<typename Derived> 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<Derived,typename ei_traits<Derived>::Scalar, - typename NumTraits<typename ei_traits<Derived>::Scalar>::Real>::operator*; + using internal::special_scalar_op_base<Derived,typename internal::traits<Derived>::Scalar, + typename NumTraits<typename internal::traits<Derived>::Scalar>::Real>::operator*; - typedef typename ei_traits<Derived>::StorageKind StorageKind; - typedef typename ei_traits<Derived>::Index Index; - typedef typename ei_traits<Derived>::Scalar Scalar; - typedef typename ei_packet_traits<Scalar>::type PacketScalar; + typedef typename internal::traits<Derived>::StorageKind StorageKind; + typedef typename internal::traits<Derived>::Index Index; + typedef typename internal::traits<Derived>::Scalar Scalar; + typedef typename internal::packet_traits<Scalar>::type PacketScalar; typedef typename NumTraits<Scalar>::Real RealScalar; typedef DenseBase<Derived> Base; @@ -99,17 +99,17 @@ template<typename Derived> 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<typename ei_traits<Derived>::Scalar, - ei_traits<Derived>::RowsAtCompileTime, - ei_traits<Derived>::ColsAtCompileTime, - AutoAlign | (ei_traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor), - ei_traits<Derived>::MaxRowsAtCompileTime, - ei_traits<Derived>::MaxColsAtCompileTime + typedef Array<typename internal::traits<Derived>::Scalar, + internal::traits<Derived>::RowsAtCompileTime, + internal::traits<Derived>::ColsAtCompileTime, + AutoAlign | (internal::traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor), + internal::traits<Derived>::MaxRowsAtCompileTime, + internal::traits<Derived>::MaxColsAtCompileTime > PlainObject; /** \internal Represents a matrix with all coefficients equal to one another*/ - typedef CwiseNullaryOp<ei_scalar_constant_op<Scalar>,Derived> ConstantReturnType; + typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,Derived> ConstantReturnType; #endif // not EIGEN_PARSED_BY_DOXYGEN #define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::ArrayBase @@ -129,7 +129,7 @@ template<typename Derived> class ArrayBase */ Derived& operator=(const ArrayBase& other) { - return ei_assign_selector<Derived,Derived>::run(derived(), other.derived()); + return internal::assign_selector<Derived,Derived>::run(derived(), other.derived()); } Derived& operator+=(const Scalar& scalar) @@ -185,7 +185,7 @@ template<typename OtherDerived> EIGEN_STRONG_INLINE Derived & ArrayBase<Derived>::operator-=(const ArrayBase<OtherDerived> &other) { - SelfCwiseBinaryOp<ei_scalar_difference_op<Scalar>, Derived, OtherDerived> tmp(derived()); + SelfCwiseBinaryOp<internal::scalar_difference_op<Scalar>, Derived, OtherDerived> tmp(derived()); tmp = other; return derived(); } @@ -199,7 +199,7 @@ template<typename OtherDerived> EIGEN_STRONG_INLINE Derived & ArrayBase<Derived>::operator+=(const ArrayBase<OtherDerived>& other) { - SelfCwiseBinaryOp<ei_scalar_sum_op<Scalar>, Derived, OtherDerived> tmp(derived()); + SelfCwiseBinaryOp<internal::scalar_sum_op<Scalar>, Derived, OtherDerived> tmp(derived()); tmp = other.derived(); return derived(); } @@ -213,7 +213,7 @@ template<typename OtherDerived> EIGEN_STRONG_INLINE Derived & ArrayBase<Derived>::operator*=(const ArrayBase<OtherDerived>& other) { - SelfCwiseBinaryOp<ei_scalar_product_op<Scalar>, Derived, OtherDerived> tmp(derived()); + SelfCwiseBinaryOp<internal::scalar_product_op<Scalar>, Derived, OtherDerived> tmp(derived()); tmp = other.derived(); return derived(); } @@ -227,7 +227,7 @@ template<typename OtherDerived> EIGEN_STRONG_INLINE Derived & ArrayBase<Derived>::operator/=(const ArrayBase<OtherDerived>& other) { - SelfCwiseBinaryOp<ei_scalar_quotient_op<Scalar>, Derived, OtherDerived> tmp(derived()); + SelfCwiseBinaryOp<internal::scalar_quotient_op<Scalar>, 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<typename ExpressionType> -struct ei_traits<ArrayWrapper<ExpressionType> > - : public ei_traits<typename ei_cleantype<typename ExpressionType::Nested>::type > +struct traits<ArrayWrapper<ExpressionType> > + : public traits<typename cleantype<typename ExpressionType::Nested>::type > { typedef ArrayXpr XprKind; }; +} template<typename ExpressionType> class ArrayWrapper : public ArrayBase<ArrayWrapper<ExpressionType> > @@ -50,7 +53,7 @@ class ArrayWrapper : public ArrayBase<ArrayWrapper<ExpressionType> > EIGEN_DENSE_PUBLIC_INTERFACE(ArrayWrapper) EIGEN_INHERIT_ASSIGNMENT_OPERATORS(ArrayWrapper) - typedef typename ei_nested<ExpressionType>::type NestedExpressionType; + typedef typename internal::nested<ExpressionType>::type NestedExpressionType; inline ArrayWrapper(const ExpressionType& matrix) : m_expression(matrix) {} @@ -121,12 +124,14 @@ class ArrayWrapper : public ArrayBase<ArrayWrapper<ExpressionType> > * \sa MatrixBase::matrix(), class ArrayWrapper */ +namespace internal { template<typename ExpressionType> -struct ei_traits<MatrixWrapper<ExpressionType> > - : public ei_traits<typename ei_cleantype<typename ExpressionType::Nested>::type > +struct traits<MatrixWrapper<ExpressionType> > + : public traits<typename cleantype<typename ExpressionType::Nested>::type > { typedef MatrixXpr XprKind; }; +} template<typename ExpressionType> class MatrixWrapper : public MatrixBase<MatrixWrapper<ExpressionType> > @@ -136,7 +141,7 @@ class MatrixWrapper : public MatrixBase<MatrixWrapper<ExpressionType> > EIGEN_DENSE_PUBLIC_INTERFACE(MatrixWrapper) EIGEN_INHERIT_ASSIGNMENT_OPERATORS(MatrixWrapper) - typedef typename ei_nested<ExpressionType>::type NestedExpressionType; + typedef typename internal::nested<ExpressionType>::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 <typename Derived, typename OtherDerived> -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<typename Derived::Scalar>::size + PacketSize = packet_traits<typename Derived::Scalar>::size }; enum { @@ -143,7 +145,7 @@ public: ************************/ template<typename Derived1, typename Derived2, int Index, int Stop> -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<Derived1, Derived2, Index+1, Stop>::run(dst, src); + assign_DefaultTraversal_CompleteUnrolling<Derived1, Derived2, Index+1, Stop>::run(dst, src); } }; template<typename Derived1, typename Derived2, int Stop> -struct ei_assign_DefaultTraversal_CompleteUnrolling<Derived1, Derived2, Stop, Stop> +struct assign_DefaultTraversal_CompleteUnrolling<Derived1, Derived2, Stop, Stop> { EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &) {} }; template<typename Derived1, typename Derived2, int Index, int Stop> -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<Derived1, Derived2, Index+1, Stop>::run(dst, src, outer); + assign_DefaultTraversal_InnerUnrolling<Derived1, Derived2, Index+1, Stop>::run(dst, src, outer); } }; template<typename Derived1, typename Derived2, int Stop> -struct ei_assign_DefaultTraversal_InnerUnrolling<Derived1, Derived2, Stop, Stop> +struct assign_DefaultTraversal_InnerUnrolling<Derived1, Derived2, Stop, Stop> { EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &, int) {} }; @@ -184,17 +186,17 @@ struct ei_assign_DefaultTraversal_InnerUnrolling<Derived1, Derived2, Stop, Stop> ***********************/ template<typename Derived1, typename Derived2, int Index, int Stop> -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<Derived1, Derived2, Index+1, Stop>::run(dst, src); + assign_LinearTraversal_CompleteUnrolling<Derived1, Derived2, Index+1, Stop>::run(dst, src); } }; template<typename Derived1, typename Derived2, int Stop> -struct ei_assign_LinearTraversal_CompleteUnrolling<Derived1, Derived2, Stop, Stop> +struct assign_LinearTraversal_CompleteUnrolling<Derived1, Derived2, Stop, Stop> { EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &) {} }; @@ -204,41 +206,41 @@ struct ei_assign_LinearTraversal_CompleteUnrolling<Derived1, Derived2, Stop, Sto **************************/ template<typename Derived1, typename Derived2, int Index, int Stop> -struct ei_assign_innervec_CompleteUnrolling +struct assign_innervec_CompleteUnrolling { enum { outer = Index / Derived1::InnerSizeAtCompileTime, inner = Index % Derived1::InnerSizeAtCompileTime, - JointAlignment = ei_assign_traits<Derived1,Derived2>::JointAlignment + JointAlignment = assign_traits<Derived1,Derived2>::JointAlignment }; EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { dst.template copyPacketByOuterInner<Derived2, Aligned, JointAlignment>(outer, inner, src); - ei_assign_innervec_CompleteUnrolling<Derived1, Derived2, - Index+ei_packet_traits<typename Derived1::Scalar>::size, Stop>::run(dst, src); + assign_innervec_CompleteUnrolling<Derived1, Derived2, + Index+packet_traits<typename Derived1::Scalar>::size, Stop>::run(dst, src); } }; template<typename Derived1, typename Derived2, int Stop> -struct ei_assign_innervec_CompleteUnrolling<Derived1, Derived2, Stop, Stop> +struct assign_innervec_CompleteUnrolling<Derived1, Derived2, Stop, Stop> { EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &) {} }; template<typename Derived1, typename Derived2, int Index, int Stop> -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<Derived2, Aligned, Aligned>(outer, Index, src); - ei_assign_innervec_InnerUnrolling<Derived1, Derived2, - Index+ei_packet_traits<typename Derived1::Scalar>::size, Stop>::run(dst, src, outer); + assign_innervec_InnerUnrolling<Derived1, Derived2, + Index+packet_traits<typename Derived1::Scalar>::size, Stop>::run(dst, src, outer); } }; template<typename Derived1, typename Derived2, int Stop> -struct ei_assign_innervec_InnerUnrolling<Derived1, Derived2, Stop, Stop> +struct assign_innervec_InnerUnrolling<Derived1, Derived2, Stop, Stop> { EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &, int) {} }; @@ -248,22 +250,22 @@ struct ei_assign_innervec_InnerUnrolling<Derived1, Derived2, Stop, Stop> ***************************************************************************/ template<typename Derived1, typename Derived2, - int Traversal = ei_assign_traits<Derived1, Derived2>::Traversal, - int Unrolling = ei_assign_traits<Derived1, Derived2>::Unrolling> -struct ei_assign_impl; + int Traversal = assign_traits<Derived1, Derived2>::Traversal, + int Unrolling = assign_traits<Derived1, Derived2>::Unrolling> +struct assign_impl; /************************ *** Default traversal *** ************************/ template<typename Derived1, typename Derived2, int Unrolling> -struct ei_assign_impl<Derived1, Derived2, InvalidTraversal, Unrolling> +struct assign_impl<Derived1, Derived2, InvalidTraversal, Unrolling> { inline static void run(Derived1 &, const Derived2 &) { } }; template<typename Derived1, typename Derived2> -struct ei_assign_impl<Derived1, Derived2, DefaultTraversal, NoUnrolling> +struct assign_impl<Derived1, Derived2, DefaultTraversal, NoUnrolling> { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -277,24 +279,24 @@ struct ei_assign_impl<Derived1, Derived2, DefaultTraversal, NoUnrolling> }; template<typename Derived1, typename Derived2> -struct ei_assign_impl<Derived1, Derived2, DefaultTraversal, CompleteUnrolling> +struct assign_impl<Derived1, Derived2, DefaultTraversal, CompleteUnrolling> { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { - ei_assign_DefaultTraversal_CompleteUnrolling<Derived1, Derived2, 0, Derived1::SizeAtCompileTime> + assign_DefaultTraversal_CompleteUnrolling<Derived1, Derived2, 0, Derived1::SizeAtCompileTime> ::run(dst, src); } }; template<typename Derived1, typename Derived2> -struct ei_assign_impl<Derived1, Derived2, DefaultTraversal, InnerUnrolling> +struct assign_impl<Derived1, Derived2, DefaultTraversal, InnerUnrolling> { 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<Derived1, Derived2, 0, Derived1::InnerSizeAtCompileTime> + assign_DefaultTraversal_InnerUnrolling<Derived1, Derived2, 0, Derived1::InnerSizeAtCompileTime> ::run(dst, src, outer); } }; @@ -304,7 +306,7 @@ struct ei_assign_impl<Derived1, Derived2, DefaultTraversal, InnerUnrolling> ***********************/ template<typename Derived1, typename Derived2> -struct ei_assign_impl<Derived1, Derived2, LinearTraversal, NoUnrolling> +struct assign_impl<Derived1, Derived2, LinearTraversal, NoUnrolling> { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -316,11 +318,11 @@ struct ei_assign_impl<Derived1, Derived2, LinearTraversal, NoUnrolling> }; template<typename Derived1, typename Derived2> -struct ei_assign_impl<Derived1, Derived2, LinearTraversal, CompleteUnrolling> +struct assign_impl<Derived1, Derived2, LinearTraversal, CompleteUnrolling> { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { - ei_assign_LinearTraversal_CompleteUnrolling<Derived1, Derived2, 0, Derived1::SizeAtCompileTime> + assign_LinearTraversal_CompleteUnrolling<Derived1, Derived2, 0, Derived1::SizeAtCompileTime> ::run(dst, src); } }; @@ -330,14 +332,14 @@ struct ei_assign_impl<Derived1, Derived2, LinearTraversal, CompleteUnrolling> **************************/ template<typename Derived1, typename Derived2> -struct ei_assign_impl<Derived1, Derived2, InnerVectorizedTraversal, NoUnrolling> +struct assign_impl<Derived1, Derived2, InnerVectorizedTraversal, NoUnrolling> { 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<typename Derived1::Scalar>::size; + const Index packetSize = packet_traits<typename Derived1::Scalar>::size; for(Index outer = 0; outer < outerSize; ++outer) for(Index inner = 0; inner < innerSize; inner+=packetSize) dst.template copyPacketByOuterInner<Derived2, Aligned, Aligned>(outer, inner, src); @@ -345,24 +347,24 @@ struct ei_assign_impl<Derived1, Derived2, InnerVectorizedTraversal, NoUnrolling> }; template<typename Derived1, typename Derived2> -struct ei_assign_impl<Derived1, Derived2, InnerVectorizedTraversal, CompleteUnrolling> +struct assign_impl<Derived1, Derived2, InnerVectorizedTraversal, CompleteUnrolling> { EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { - ei_assign_innervec_CompleteUnrolling<Derived1, Derived2, 0, Derived1::SizeAtCompileTime> + assign_innervec_CompleteUnrolling<Derived1, Derived2, 0, Derived1::SizeAtCompileTime> ::run(dst, src); } }; template<typename Derived1, typename Derived2> -struct ei_assign_impl<Derived1, Derived2, InnerVectorizedTraversal, InnerUnrolling> +struct assign_impl<Derived1, Derived2, InnerVectorizedTraversal, InnerUnrolling> { 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<Derived1, Derived2, 0, Derived1::InnerSizeAtCompileTime> + assign_innervec_InnerUnrolling<Derived1, Derived2, 0, Derived1::InnerSizeAtCompileTime> ::run(dst, src, outer); } }; @@ -372,14 +374,14 @@ struct ei_assign_impl<Derived1, Derived2, InnerVectorizedTraversal, InnerUnrolli ***************************/ template <bool IsAligned = false> -struct ei_unaligned_assign_impl +struct unaligned_assign_impl { template <typename Derived, typename OtherDerived> static EIGEN_STRONG_INLINE void run(const Derived&, OtherDerived&, typename Derived::Index, typename Derived::Index) {} }; template <> -struct ei_unaligned_assign_impl<false> +struct unaligned_assign_impl<false> { // 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<false> }; template<typename Derived1, typename Derived2> -struct ei_assign_impl<Derived1, Derived2, LinearVectorizedTraversal, NoUnrolling> +struct assign_impl<Derived1, Derived2, LinearVectorizedTraversal, NoUnrolling> { 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<typename Derived1::Scalar> PacketTraits; + typedef packet_traits<typename Derived1::Scalar> PacketTraits; enum { packetSize = PacketTraits::size, - dstAlignment = PacketTraits::AlignedOnScalar ? Aligned : int(ei_assign_traits<Derived1,Derived2>::DstIsAligned) , - srcAlignment = ei_assign_traits<Derived1,Derived2>::JointAlignment + dstAlignment = PacketTraits::AlignedOnScalar ? Aligned : int(assign_traits<Derived1,Derived2>::DstIsAligned) , + srcAlignment = assign_traits<Derived1,Derived2>::JointAlignment }; - const Index alignedStart = ei_assign_traits<Derived1,Derived2>::DstIsAligned ? 0 - : ei_first_aligned(&dst.coeffRef(0), size); + const Index alignedStart = assign_traits<Derived1,Derived2>::DstIsAligned ? 0 + : first_aligned(&dst.coeffRef(0), size); const Index alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize; - ei_unaligned_assign_impl<ei_assign_traits<Derived1,Derived2>::DstIsAligned!=0>::run(src,dst,0,alignedStart); + unaligned_assign_impl<assign_traits<Derived1,Derived2>::DstIsAligned!=0>::run(src,dst,0,alignedStart); for(Index index = alignedStart; index < alignedEnd; index += packetSize) { dst.template copyPacket<Derived2, dstAlignment, srcAlignment>(index, src); } - ei_unaligned_assign_impl<>::run(src,dst,alignedEnd,size); + unaligned_assign_impl<>::run(src,dst,alignedEnd,size); } }; template<typename Derived1, typename Derived2> -struct ei_assign_impl<Derived1, Derived2, LinearVectorizedTraversal, CompleteUnrolling> +struct assign_impl<Derived1, Derived2, LinearVectorizedTraversal, CompleteUnrolling> { typedef typename Derived1::Index Index; EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src) { enum { size = Derived1::SizeAtCompileTime, - packetSize = ei_packet_traits<typename Derived1::Scalar>::size, + packetSize = packet_traits<typename Derived1::Scalar>::size, alignedSize = (size/packetSize)*packetSize }; - ei_assign_innervec_CompleteUnrolling<Derived1, Derived2, 0, alignedSize>::run(dst, src); - ei_assign_DefaultTraversal_CompleteUnrolling<Derived1, Derived2, alignedSize, size>::run(dst, src); + assign_innervec_CompleteUnrolling<Derived1, Derived2, 0, alignedSize>::run(dst, src); + assign_DefaultTraversal_CompleteUnrolling<Derived1, Derived2, alignedSize, size>::run(dst, src); } }; @@ -444,24 +446,24 @@ struct ei_assign_impl<Derived1, Derived2, LinearVectorizedTraversal, CompleteUnr ***************************/ template<typename Derived1, typename Derived2> -struct ei_assign_impl<Derived1, Derived2, SliceVectorizedTraversal, NoUnrolling> +struct assign_impl<Derived1, Derived2, SliceVectorizedTraversal, NoUnrolling> { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) { - typedef ei_packet_traits<typename Derived1::Scalar> PacketTraits; + typedef packet_traits<typename Derived1::Scalar> PacketTraits; enum { packetSize = PacketTraits::size, alignable = PacketTraits::AlignedOnScalar, - dstAlignment = alignable ? Aligned : int(ei_assign_traits<Derived1,Derived2>::DstIsAligned) , - srcAlignment = ei_assign_traits<Derived1,Derived2>::JointAlignment + dstAlignment = alignable ? Aligned : int(assign_traits<Derived1,Derived2>::DstIsAligned) , + srcAlignment = assign_traits<Derived1,Derived2>::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<Derived1,Derived2>::DstIsAligned) ? 0 - : ei_first_aligned(&dst.coeffRef(0,0), innerSize); + Index alignedStart = ((!alignable) || assign_traits<Derived1,Derived2>::DstIsAligned) ? 0 + : first_aligned(&dst.coeffRef(0,0), innerSize); for(Index outer = 0; outer < outerSize; ++outer) { @@ -483,6 +485,8 @@ struct ei_assign_impl<Derived1, Derived2, SliceVectorizedTraversal, NoUnrolling> } }; +} // end namespace internal + /*************************************************************************** * Part 4 : implementation of DenseBase methods ***************************************************************************/ @@ -493,26 +497,26 @@ EIGEN_STRONG_INLINE Derived& DenseBase<Derived> ::lazyAssign(const DenseBase<OtherDerived>& other) { enum{ - SameType = ei_is_same_type<typename Derived::Scalar,typename OtherDerived::Scalar>::ret + SameType = internal::is_same_type<typename Derived::Scalar,typename OtherDerived::Scalar>::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<Derived, OtherDerived>::debug(); + internal::assign_traits<Derived, OtherDerived>::debug(); #endif - ei_assert(rows() == other.rows() && cols() == other.cols()); - ei_assign_impl<Derived, OtherDerived, int(SameType) ? int(ei_assign_traits<Derived, OtherDerived>::Traversal) - : int(InvalidTraversal)>::run(derived(),other.derived()); + eigen_assert(rows() == other.rows() && cols() == other.cols()); + internal::assign_impl<Derived, OtherDerived, int(SameType) ? int(internal::assign_traits<Derived, OtherDerived>::Traversal) + : int(InvalidTraversal)>::run(derived(),other.derived()); #ifndef EIGEN_NO_DEBUG checkTransposeAliasing(other.derived()); #endif return derived(); } +namespace internal { + template<typename Derived, typename OtherDerived, bool EvalBeforeAssigning = (int(OtherDerived::Flags) & EvalBeforeAssigningBit) != 0, bool NeedToTranspose = Derived::IsVectorAtCompileTime @@ -522,49 +526,51 @@ template<typename Derived, typename OtherDerived, // revert to || as soon as not needed anymore. (int(Derived::ColsAtCompileTime) == 1 && int(OtherDerived::RowsAtCompileTime) == 1)) && int(Derived::SizeAtCompileTime) != 1> -struct ei_assign_selector; +struct assign_selector; template<typename Derived, typename OtherDerived> -struct ei_assign_selector<Derived,OtherDerived,false,false> { +struct assign_selector<Derived,OtherDerived,false,false> { EIGEN_STRONG_INLINE static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.derived()); } }; template<typename Derived, typename OtherDerived> -struct ei_assign_selector<Derived,OtherDerived,true,false> { +struct assign_selector<Derived,OtherDerived,true,false> { EIGEN_STRONG_INLINE static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.eval()); } }; template<typename Derived, typename OtherDerived> -struct ei_assign_selector<Derived,OtherDerived,false,true> { +struct assign_selector<Derived,OtherDerived,false,true> { EIGEN_STRONG_INLINE static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.transpose()); } }; template<typename Derived, typename OtherDerived> -struct ei_assign_selector<Derived,OtherDerived,true,true> { +struct assign_selector<Derived,OtherDerived,true,true> { EIGEN_STRONG_INLINE static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.transpose().eval()); } }; +} // end namespace internal + template<typename Derived> template<typename OtherDerived> EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator=(const DenseBase<OtherDerived>& other) { - return ei_assign_selector<Derived,OtherDerived>::run(derived(), other.derived()); + return internal::assign_selector<Derived,OtherDerived>::run(derived(), other.derived()); } template<typename Derived> EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator=(const DenseBase& other) { - return ei_assign_selector<Derived,Derived>::run(derived(), other.derived()); + return internal::assign_selector<Derived,Derived>::run(derived(), other.derived()); } template<typename Derived> EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const MatrixBase& other) { - return ei_assign_selector<Derived,Derived>::run(derived(), other.derived()); + return internal::assign_selector<Derived,Derived>::run(derived(), other.derived()); } template<typename Derived> template <typename OtherDerived> EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const DenseBase<OtherDerived>& other) { - return ei_assign_selector<Derived,OtherDerived>::run(derived(), other.derived()); + return internal::assign_selector<Derived,OtherDerived>::run(derived(), other.derived()); } template<typename Derived> 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<typename _Scalar, int Rows, int Cols, int Supers, int Subs, int Options> -struct ei_traits<BandMatrix<_Scalar,Rows,Cols,Supers,Subs,Options> > +struct traits<BandMatrix<_Scalar,Rows,Cols,Supers,Subs,Options> > { typedef _Scalar Scalar; typedef Dense StorageKind; @@ -58,6 +60,7 @@ struct ei_traits<BandMatrix<_Scalar,Rows,Cols,Supers,Subs,Options> > Flags = LvalueBit }; }; +} template<typename _Scalar, int Rows, int Cols, int Supers, int Subs, int Options> class BandMatrix : public EigenBase<BandMatrix<_Scalar,Rows,Cols,Supers,Subs,Options> > @@ -65,14 +68,14 @@ class BandMatrix : public EigenBase<BandMatrix<_Scalar,Rows,Cols,Supers,Subs,Opt public: enum { - Flags = ei_traits<BandMatrix>::Flags, - CoeffReadCost = ei_traits<BandMatrix>::CoeffReadCost, - RowsAtCompileTime = ei_traits<BandMatrix>::RowsAtCompileTime, - ColsAtCompileTime = ei_traits<BandMatrix>::ColsAtCompileTime, - MaxRowsAtCompileTime = ei_traits<BandMatrix>::MaxRowsAtCompileTime, - MaxColsAtCompileTime = ei_traits<BandMatrix>::MaxColsAtCompileTime + Flags = internal::traits<BandMatrix>::Flags, + CoeffReadCost = internal::traits<BandMatrix>::CoeffReadCost, + RowsAtCompileTime = internal::traits<BandMatrix>::RowsAtCompileTime, + ColsAtCompileTime = internal::traits<BandMatrix>::ColsAtCompileTime, + MaxRowsAtCompileTime = internal::traits<BandMatrix>::MaxRowsAtCompileTime, + MaxColsAtCompileTime = internal::traits<BandMatrix>::MaxColsAtCompileTime }; - typedef typename ei_traits<BandMatrix>::Scalar Scalar; + typedef typename internal::traits<BandMatrix>::Scalar Scalar; typedef Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime> DenseMatrixType; typedef typename DenseMatrixType::Index Index; @@ -144,8 +147,8 @@ class BandMatrix : public EigenBase<BandMatrix<_Scalar,Rows,Cols,Supers,Subs,Opt : EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime, ColsAtCompileTime - ActualIndex)) }; typedef Block<DataType,1, DiagonalSize> BuildType; - typedef typename ei_meta_if<Conjugate, - CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>,BuildType >, + typedef typename internal::meta_if<Conjugate, + CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>,BuildType >, BuildType>::ret Type; }; @@ -164,14 +167,14 @@ class BandMatrix : public EigenBase<BandMatrix<_Scalar,Rows,Cols,Supers,Subs,Opt /** \returns a vector expression of the \a i -th sub or super diagonal */ inline Block<DataType,1,Dynamic> 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<DataType,1,Dynamic>(m_data, supers()-i, std::max<Index>(0,i), 1, diagonalLength(i)); } /** \returns a vector expression of the \a i -th sub or super diagonal */ inline const Block<DataType,1,Dynamic> 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<DataType,1,Dynamic>(m_data, supers()-i, std::max<Index>(0,i), 1, diagonalLength(i)); } @@ -199,9 +202,9 @@ class BandMatrix : public EigenBase<BandMatrix<_Scalar,Rows,Cols,Supers,Subs,Opt { return i<0 ? std::min(cols(),rows()+i) : std::min(rows(),cols()-i); } DataType m_data; - ei_variable_if_dynamic<Index, Rows> m_rows; - ei_variable_if_dynamic<Index, Supers> m_supers; - ei_variable_if_dynamic<Index, Subs> m_subs; + internal::variable_if_dynamic<Index, Rows> m_rows; + internal::variable_if_dynamic<Index, Supers> m_supers; + internal::variable_if_dynamic<Index, Subs> 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<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool HasDirectAccess> -struct ei_traits<Block<XprType, BlockRows, BlockCols, InnerPanel, HasDirectAccess> > : ei_traits<XprType> +struct traits<Block<XprType, BlockRows, BlockCols, InnerPanel, HasDirectAccess> > : traits<XprType> { - typedef typename ei_traits<XprType>::Scalar Scalar; - typedef typename ei_traits<XprType>::StorageKind StorageKind; - typedef typename ei_traits<XprType>::XprKind XprKind; - typedef typename ei_nested<XprType>::type XprTypeNested; - typedef typename ei_unref<XprTypeNested>::type _XprTypeNested; + typedef typename traits<XprType>::Scalar Scalar; + typedef typename traits<XprType>::StorageKind StorageKind; + typedef typename traits<XprType>::XprKind XprKind; + typedef typename nested<XprType>::type XprTypeNested; + typedef typename unref<XprTypeNested>::type _XprTypeNested; enum{ - MatrixRows = ei_traits<XprType>::RowsAtCompileTime, - MatrixCols = ei_traits<XprType>::ColsAtCompileTime, + MatrixRows = traits<XprType>::RowsAtCompileTime, + MatrixCols = traits<XprType>::ColsAtCompileTime, RowsAtCompileTime = MatrixRows == 0 ? 0 : BlockRows, ColsAtCompileTime = MatrixCols == 0 ? 0 : BlockCols, MaxRowsAtCompileTime = BlockRows==0 ? 0 : RowsAtCompileTime != Dynamic ? int(RowsAtCompileTime) - : int(ei_traits<XprType>::MaxRowsAtCompileTime), + : int(traits<XprType>::MaxRowsAtCompileTime), MaxColsAtCompileTime = BlockCols==0 ? 0 : ColsAtCompileTime != Dynamic ? int(ColsAtCompileTime) - : int(ei_traits<XprType>::MaxColsAtCompileTime), - XprTypeIsRowMajor = (int(ei_traits<XprType>::Flags)&RowMajorBit) != 0, + : int(traits<XprType>::MaxColsAtCompileTime), + XprTypeIsRowMajor = (int(traits<XprType>::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<XprType>::ret) - : int(ei_outer_stride_at_compile_time<XprType>::ret), + ? int(inner_stride_at_compile_time<XprType>::ret) + : int(outer_stride_at_compile_time<XprType>::ret), OuterStrideAtCompileTime = HasSameStorageOrderAsXprType - ? int(ei_outer_stride_at_compile_time<XprType>::ret) - : int(ei_inner_stride_at_compile_time<XprType>::ret), - MaskPacketAccessBit = (InnerSize == Dynamic || (InnerSize % ei_packet_traits<Scalar>::size) == 0) + ? int(outer_stride_at_compile_time<XprType>::ret) + : int(inner_stride_at_compile_time<XprType>::ret), + MaskPacketAccessBit = (InnerSize == Dynamic || (InnerSize % packet_traits<Scalar>::size) == 0) && (InnerStrideAtCompileTime == 1) ? PacketAccessBit : 0, - MaskAlignedBit = (InnerPanel && (OuterStrideAtCompileTime!=Dynamic) && ((OuterStrideAtCompileTime % ei_packet_traits<Scalar>::size) == 0)) ? AlignedBit : 0, + MaskAlignedBit = (InnerPanel && (OuterStrideAtCompileTime!=Dynamic) && ((OuterStrideAtCompileTime % packet_traits<Scalar>::size) == 0)) ? AlignedBit : 0, FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1) ? LinearAccessBit : 0, - Flags0 = ei_traits<XprType>::Flags & (HereditaryBits | MaskPacketAccessBit | LvalueBit | DirectAccessBit | MaskAlignedBit), + Flags0 = traits<XprType>::Flags & (HereditaryBits | MaskPacketAccessBit | LvalueBit | DirectAccessBit | MaskAlignedBit), Flags1 = Flags0 | FlagsLinearAccessBit, Flags = (Flags1 & ~RowMajorBit) | (IsRowMajor ? RowMajorBit : 0) }; }; +} template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool HasDirectAccess> class Block - : public ei_dense_xpr_base<Block<XprType, BlockRows, BlockCols, InnerPanel, HasDirectAccess> >::type + : public internal::dense_xpr_base<Block<XprType, BlockRows, BlockCols, InnerPanel, HasDirectAccess> >::type { public: - typedef typename ei_dense_xpr_base<Block>::type Base; + typedef typename internal::dense_xpr_base<Block>::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(Block) class InnerIterator; @@ -123,7 +126,7 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool H m_blockRows(BlockRows==1 ? 1 : xpr.rows()), m_blockCols(BlockCols==1 ? 1 : xpr.cols()) { - ei_assert( (i>=0) && ( + eigen_assert( (i>=0) && ( ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && i<xpr.rows()) ||((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && i<xpr.cols()))); } @@ -135,7 +138,7 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool H m_blockRows(BlockRows), m_blockCols(BlockCols) { EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE) - 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()); } @@ -147,9 +150,9 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool H : m_xpr(xpr), m_startRow(startRow), m_startCol(startCol), m_blockRows(blockRows), m_blockCols(blockCols) { - 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()); } @@ -223,10 +226,10 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool H protected: const typename XprType::Nested m_xpr; - const ei_variable_if_dynamic<Index, XprType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow; - const ei_variable_if_dynamic<Index, XprType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol; - const ei_variable_if_dynamic<Index, RowsAtCompileTime> m_blockRows; - const ei_variable_if_dynamic<Index, ColsAtCompileTime> m_blockCols; + const internal::variable_if_dynamic<Index, XprType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow; + const internal::variable_if_dynamic<Index, XprType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol; + const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_blockRows; + const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_blockCols; }; /** \internal */ @@ -251,7 +254,7 @@ class Block<XprType,BlockRows,BlockCols, InnerPanel,true> BlockCols==1 ? 1 : xpr.cols()), m_xpr(xpr) { - ei_assert( (i>=0) && ( + eigen_assert( (i>=0) && ( ((BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) && i<xpr.rows()) ||((BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) && i<xpr.cols()))); init(); @@ -262,7 +265,7 @@ class Block<XprType,BlockRows,BlockCols, InnerPanel,true> 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<XprType,BlockRows,BlockCols, InnerPanel,true> : 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<XprType,BlockRows,BlockCols, InnerPanel,true> /** \sa MapBase::innerStride() */ inline Index innerStride() const { - return ei_traits<Block>::HasSameStorageOrderAsXprType + return internal::traits<Block>::HasSameStorageOrderAsXprType ? m_xpr.innerStride() : m_xpr.outerStride(); } @@ -314,7 +317,7 @@ class Block<XprType,BlockRows,BlockCols, InnerPanel,true> protected: void init() { - m_outerStride = ei_traits<Block>::HasSameStorageOrderAsXprType + m_outerStride = internal::traits<Block>::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<typename Derived, int UnrollCount> -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<Derived, UnrollCount-1>::run(mat) && mat.coeff(row, col); + return all_unroller<Derived, UnrollCount-1>::run(mat) && mat.coeff(row, col); } }; template<typename Derived> -struct ei_all_unroller<Derived, 1> +struct all_unroller<Derived, 1> { inline static bool run(const Derived &mat) { return mat.coeff(0, 0); } }; template<typename Derived> -struct ei_all_unroller<Derived, Dynamic> +struct all_unroller<Derived, Dynamic> { inline static bool run(const Derived &) { return false; } }; template<typename Derived, int UnrollCount> -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<Derived, UnrollCount-1>::run(mat) || mat.coeff(row, col); + return any_unroller<Derived, UnrollCount-1>::run(mat) || mat.coeff(row, col); } }; template<typename Derived> -struct ei_any_unroller<Derived, 1> +struct any_unroller<Derived, 1> { inline static bool run(const Derived &mat) { return mat.coeff(0, 0); } }; template<typename Derived> -struct ei_any_unroller<Derived, Dynamic> +struct any_unroller<Derived, Dynamic> { 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<Derived>::all() const && SizeAtCompileTime * (CoeffReadCost + NumTraits<Scalar>::AddCost) <= EIGEN_UNROLLING_LIMIT }; if(unroll) - return ei_all_unroller<Derived, + return internal::all_unroller<Derived, unroll ? int(SizeAtCompileTime) : Dynamic >::run(derived()); else @@ -120,7 +124,7 @@ inline bool DenseBase<Derived>::any() const && SizeAtCompileTime * (CoeffReadCost + NumTraits<Scalar>::AddCost) <= EIGEN_UNROLLING_LIMIT }; if(unroll) - return ei_any_unroller<Derived, + return internal::any_unroller<Derived, unroll ? int(SizeAtCompileTime) : Dynamic >::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<m_xpr.rows() + eigen_assert(m_row<m_xpr.rows() && "Too many rows passed to comma initializer (operator<<)"); } - ei_assert(m_col<m_xpr.cols() + eigen_assert(m_col<m_xpr.cols() && "Too many coefficients passed to comma initializer (operator<<)"); - ei_assert(m_currentBlockRows==1); + eigen_assert(m_currentBlockRows==1); m_xpr.coeffRef(m_row, m_col++) = s; return *this; } @@ -83,12 +83,12 @@ struct CommaInitializer m_row+=m_currentBlockRows; m_col = 0; m_currentBlockRows = other.rows(); - ei_assert(m_row+m_currentBlockRows<=m_xpr.rows() + eigen_assert(m_row+m_currentBlockRows<=m_xpr.rows() && "Too many rows passed to comma initializer (operator<<)"); } - ei_assert(m_col<m_xpr.cols() + eigen_assert(m_col<m_xpr.cols() && "Too many coefficients passed to comma initializer (operator<<)"); - ei_assert(m_currentBlockRows==other.rows()); + eigen_assert(m_currentBlockRows==other.rows()); if (OtherDerived::SizeAtCompileTime != Dynamic) m_xpr.template block<OtherDerived::RowsAtCompileTime != Dynamic ? OtherDerived::RowsAtCompileTime : 1, OtherDerived::ColsAtCompileTime != Dynamic ? OtherDerived::ColsAtCompileTime : 1> @@ -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<OtherDerived> &,const CustomBinaryOp &) const, class CwiseUnaryOp, class CwiseNullaryOp */ + +namespace internal { template<typename BinaryOp, typename Lhs, typename Rhs> -struct ei_traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > +struct traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > { - // we must not inherit from ei_traits<Lhs> since it has + // we must not inherit from traits<Lhs> since it has // the potential to cause problems with MSVC - typedef typename ei_cleantype<Lhs>::type Ancestor; - typedef typename ei_traits<Ancestor>::XprKind XprKind; + typedef typename cleantype<Lhs>::type Ancestor; + typedef typename traits<Ancestor>::XprKind XprKind; enum { - RowsAtCompileTime = ei_traits<Ancestor>::RowsAtCompileTime, - ColsAtCompileTime = ei_traits<Ancestor>::ColsAtCompileTime, - MaxRowsAtCompileTime = ei_traits<Ancestor>::MaxRowsAtCompileTime, - MaxColsAtCompileTime = ei_traits<Ancestor>::MaxColsAtCompileTime + RowsAtCompileTime = traits<Ancestor>::RowsAtCompileTime, + ColsAtCompileTime = traits<Ancestor>::ColsAtCompileTime, + MaxRowsAtCompileTime = traits<Ancestor>::MaxRowsAtCompileTime, + MaxColsAtCompileTime = traits<Ancestor>::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<typename ei_traits<Lhs>::StorageKind, - typename ei_traits<Rhs>::StorageKind>::ret StorageKind; - typedef typename ei_promote_index_type<typename ei_traits<Lhs>::Index, - typename ei_traits<Rhs>::Index>::type Index; + typedef typename promote_storage_type<typename traits<Lhs>::StorageKind, + typename traits<Rhs>::StorageKind>::ret StorageKind; + typedef typename promote_index_type<typename traits<Lhs>::Index, + typename traits<Rhs>::Index>::type Index; typedef typename Lhs::Nested LhsNested; typedef typename Rhs::Nested RhsNested; - typedef typename ei_unref<LhsNested>::type _LhsNested; - typedef typename ei_unref<RhsNested>::type _RhsNested; + typedef typename unref<LhsNested>::type _LhsNested; + typedef typename unref<RhsNested>::type _RhsNested; enum { LhsCoeffReadCost = _LhsNested::CoeffReadCost, RhsCoeffReadCost = _RhsNested::CoeffReadCost, LhsFlags = _LhsNested::Flags, RhsFlags = _RhsNested::Flags, - SameType = ei_is_same_type<typename _LhsNested::Scalar,typename _RhsNested::Scalar>::ret, + SameType = is_same_type<typename _LhsNested::Scalar,typename _RhsNested::Scalar>::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<BinaryOp>::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0) + | (functor_traits<BinaryOp>::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0) ) ) ), Flags = (Flags0 & ~RowMajorBit) | (LhsFlags & RowMajorBit), - CoeffReadCost = LhsCoeffReadCost + RhsCoeffReadCost + ei_functor_traits<BinaryOp>::Cost + CoeffReadCost = LhsCoeffReadCost + RhsCoeffReadCost + functor_traits<BinaryOp>::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<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > // 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<BINOP>::ret \ - ? int(ei_is_same_type<typename NumTraits<LHS>::Real, typename NumTraits<RHS>::Real>::ret) \ - : int(ei_is_same_type<LHS, RHS>::ret)), \ + EIGEN_STATIC_ASSERT((internal::functor_allows_mixing_real_and_complex<BINOP>::ret \ + ? int(internal::is_same_type<typename NumTraits<LHS>::Real, typename NumTraits<RHS>::Real>::ret) \ + : int(internal::is_same_type<LHS, RHS>::ret)), \ YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) template<typename BinaryOp, typename Lhs, typename Rhs, typename StorageKind> class CwiseBinaryOpImpl; template<typename BinaryOp, typename Lhs, typename Rhs> -class CwiseBinaryOp : ei_no_assignment_operator, +class CwiseBinaryOp : internal::no_assignment_operator, public CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, - typename ei_promote_storage_type<typename ei_traits<Lhs>::StorageKind, - typename ei_traits<Rhs>::StorageKind>::ret> + typename internal::promote_storage_type<typename internal::traits<Lhs>::StorageKind, + typename internal::traits<Rhs>::StorageKind>::ret> { public: typedef typename CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, - typename ei_promote_storage_type<typename ei_traits<Lhs>::StorageKind, - typename ei_traits<Rhs>::StorageKind>::ret>::Base Base; + typename internal::promote_storage_type<typename internal::traits<Lhs>::StorageKind, + typename internal::traits<Rhs>::StorageKind>::ret>::Base Base; EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseBinaryOp) - typedef typename ei_nested<Lhs>::type LhsNested; - typedef typename ei_nested<Rhs>::type RhsNested; - typedef typename ei_unref<LhsNested>::type _LhsNested; - typedef typename ei_unref<RhsNested>::type _RhsNested; + typedef typename internal::nested<Lhs>::type LhsNested; + typedef typename internal::nested<Rhs>::type RhsNested; + typedef typename internal::unref<LhsNested>::type _LhsNested; + typedef typename internal::unref<RhsNested>::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<typename ei_cleantype<LhsNested>::type>::RowsAtCompileTime==Dynamic) + if (internal::traits<typename internal::cleantype<LhsNested>::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<typename ei_cleantype<LhsNested>::type>::ColsAtCompileTime==Dynamic) + if (internal::traits<typename internal::cleantype<LhsNested>::type>::ColsAtCompileTime==Dynamic) return m_rhs.cols(); else return m_lhs.cols(); @@ -171,12 +174,12 @@ class CwiseBinaryOp : ei_no_assignment_operator, template<typename BinaryOp, typename Lhs, typename Rhs> class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Dense> - : public ei_dense_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type + : public internal::dense_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type { typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> Derived; public: - typedef typename ei_dense_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type Base; + typedef typename internal::dense_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type Base; EIGEN_DENSE_PUBLIC_INTERFACE( Derived ) EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const @@ -215,7 +218,7 @@ template<typename OtherDerived> EIGEN_STRONG_INLINE Derived & MatrixBase<Derived>::operator-=(const MatrixBase<OtherDerived> &other) { - SelfCwiseBinaryOp<ei_scalar_difference_op<Scalar>, Derived, OtherDerived> tmp(derived()); + SelfCwiseBinaryOp<internal::scalar_difference_op<Scalar>, Derived, OtherDerived> tmp(derived()); tmp = other.derived(); return derived(); } @@ -229,7 +232,7 @@ template<typename OtherDerived> EIGEN_STRONG_INLINE Derived & MatrixBase<Derived>::operator+=(const MatrixBase<OtherDerived>& other) { - SelfCwiseBinaryOp<ei_scalar_sum_op<Scalar>, Derived, OtherDerived> tmp(derived()); + SelfCwiseBinaryOp<internal::scalar_sum_op<Scalar>, 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<typename NullaryOp, typename PlainObjectType> -struct ei_traits<CwiseNullaryOp<NullaryOp, PlainObjectType> > : ei_traits<PlainObjectType> +struct traits<CwiseNullaryOp<NullaryOp, PlainObjectType> > : traits<PlainObjectType> { enum { - Flags = (ei_traits<PlainObjectType>::Flags + Flags = (traits<PlainObjectType>::Flags & ( HereditaryBits - | (ei_functor_has_linear_access<NullaryOp>::ret ? LinearAccessBit : 0) - | (ei_functor_traits<NullaryOp>::PacketAccess ? PacketAccessBit : 0))) - | (ei_functor_traits<NullaryOp>::IsRepeatable ? 0 : EvalBeforeNestingBit), - CoeffReadCost = ei_functor_traits<NullaryOp>::Cost + | (functor_has_linear_access<NullaryOp>::ret ? LinearAccessBit : 0) + | (functor_traits<NullaryOp>::PacketAccess ? PacketAccessBit : 0))) + | (functor_traits<NullaryOp>::IsRepeatable ? 0 : EvalBeforeNestingBit), + CoeffReadCost = functor_traits<NullaryOp>::Cost }; }; +} template<typename NullaryOp, typename PlainObjectType> -class CwiseNullaryOp : ei_no_assignment_operator, - public ei_dense_xpr_base< CwiseNullaryOp<NullaryOp, PlainObjectType> >::type +class CwiseNullaryOp : internal::no_assignment_operator, + public internal::dense_xpr_base< CwiseNullaryOp<NullaryOp, PlainObjectType> >::type { public: - typedef typename ei_dense_xpr_base<CwiseNullaryOp>::type Base; + typedef typename internal::dense_xpr_base<CwiseNullaryOp>::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<Index, RowsAtCompileTime> m_rows; - const ei_variable_if_dynamic<Index, ColsAtCompileTime> m_cols; + const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows; + const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_cols; const NullaryOp m_functor; }; @@ -185,7 +188,7 @@ template<typename Derived> EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType DenseBase<Derived>::Constant(Index rows, Index cols, const Scalar& value) { - return DenseBase<Derived>::NullaryExpr(rows, cols, ei_scalar_constant_op<Scalar>(value)); + return DenseBase<Derived>::NullaryExpr(rows, cols, internal::scalar_constant_op<Scalar>(value)); } /** \returns an expression of a constant matrix of value \a value @@ -207,7 +210,7 @@ template<typename Derived> EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType DenseBase<Derived>::Constant(Index size, const Scalar& value) { - return DenseBase<Derived>::NullaryExpr(size, ei_scalar_constant_op<Scalar>(value)); + return DenseBase<Derived>::NullaryExpr(size, internal::scalar_constant_op<Scalar>(value)); } /** \returns an expression of a constant matrix of value \a value @@ -224,7 +227,7 @@ EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType DenseBase<Derived>::Constant(const Scalar& value) { EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) - return DenseBase<Derived>::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, ei_scalar_constant_op<Scalar>(value)); + return DenseBase<Derived>::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_constant_op<Scalar>(value)); } /** @@ -247,7 +250,7 @@ EIGEN_STRONG_INLINE const typename DenseBase<Derived>::SequentialLinSpacedReturn DenseBase<Derived>::LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high) { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) - return DenseBase<Derived>::NullaryExpr(size, ei_linspaced_op<Scalar,false>(low,high,size)); + return DenseBase<Derived>::NullaryExpr(size, internal::linspaced_op<Scalar,false>(low,high,size)); } /** @@ -260,7 +263,7 @@ DenseBase<Derived>::LinSpaced(Sequential_t, const Scalar& low, const Scalar& hig { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) - return DenseBase<Derived>::NullaryExpr(Derived::SizeAtCompileTime, ei_linspaced_op<Scalar,false>(low,high,Derived::SizeAtCompileTime)); + return DenseBase<Derived>::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op<Scalar,false>(low,high,Derived::SizeAtCompileTime)); } /** @@ -280,7 +283,7 @@ EIGEN_STRONG_INLINE const typename DenseBase<Derived>::RandomAccessLinSpacedRetu DenseBase<Derived>::LinSpaced(Index size, const Scalar& low, const Scalar& high) { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) - return DenseBase<Derived>::NullaryExpr(size, ei_linspaced_op<Scalar,true>(low,high,size)); + return DenseBase<Derived>::NullaryExpr(size, internal::linspaced_op<Scalar,true>(low,high,size)); } /** @@ -293,7 +296,7 @@ DenseBase<Derived>::LinSpaced(const Scalar& low, const Scalar& high) { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) - return DenseBase<Derived>::NullaryExpr(Derived::SizeAtCompileTime, ei_linspaced_op<Scalar,true>(low,high,Derived::SizeAtCompileTime)); + return DenseBase<Derived>::NullaryExpr(Derived::SizeAtCompileTime, internal::linspaced_op<Scalar,true>(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<Derived>::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<typename Derived> EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setLinSpaced(Index size, const Scalar& low, const Scalar& high) { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) - return derived() = Derived::NullaryExpr(size, ei_linspaced_op<Scalar,false>(low,high,size)); + return derived() = Derived::NullaryExpr(size, internal::linspaced_op<Scalar,false>(low,high,size)); } // zero: @@ -469,7 +472,7 @@ bool DenseBase<Derived>::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<Scalar>(1), prec)) + if(!internal::isMuchSmallerThan(this->coeff(i, j), static_cast<Scalar>(1), prec)) return false; return true; } @@ -668,7 +671,7 @@ template<typename Derived> EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::IdentityReturnType MatrixBase<Derived>::Identity(Index rows, Index cols) { - return DenseBase<Derived>::NullaryExpr(rows, cols, ei_scalar_identity_op<Scalar>()); + return DenseBase<Derived>::NullaryExpr(rows, cols, internal::scalar_identity_op<Scalar>()); } /** \returns an expression of the identity matrix (not necessarily square). @@ -686,7 +689,7 @@ EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::IdentityReturnType MatrixBase<Derived>::Identity() { EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) - return MatrixBase<Derived>::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, ei_scalar_identity_op<Scalar>()); + return MatrixBase<Derived>::NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_identity_op<Scalar>()); } /** \returns true if *this is approximately equal to the identity matrix @@ -708,12 +711,12 @@ bool MatrixBase<Derived>::isIdentity { if(i == j) { - if(!ei_isApprox(this->coeff(i, j), static_cast<Scalar>(1), prec)) + if(!internal::isApprox(this->coeff(i, j), static_cast<Scalar>(1), prec)) return false; } else { - if(!ei_isMuchSmallerThan(this->coeff(i, j), static_cast<RealScalar>(1), prec)) + if(!internal::isMuchSmallerThan(this->coeff(i, j), static_cast<RealScalar>(1), prec)) return false; } } @@ -721,8 +724,10 @@ bool MatrixBase<Derived>::isIdentity return true; } +namespace internal { + template<typename Derived, bool Big = (Derived::SizeAtCompileTime>=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<typename Derived> -struct ei_setIdentity_impl<Derived, true> +struct setIdentity_impl<Derived, true> { typedef typename Derived::Index Index; static EIGEN_STRONG_INLINE Derived& run(Derived& m) @@ -743,6 +748,8 @@ struct ei_setIdentity_impl<Derived, true> } }; +} // 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<Derived, true> template<typename Derived> EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setIdentity() { - return ei_setIdentity_impl<Derived>::run(derived()); + return internal::setIdentity_impl<Derived>::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<typename UnaryOp, typename XprType> -struct ei_traits<CwiseUnaryOp<UnaryOp, XprType> > - : ei_traits<XprType> +struct traits<CwiseUnaryOp<UnaryOp, XprType> > + : traits<XprType> { - typedef typename ei_result_of< + typedef typename result_of< UnaryOp(typename XprType::Scalar) >::type Scalar; typedef typename XprType::Nested XprTypeNested; - typedef typename ei_unref<XprTypeNested>::type _XprTypeNested; + typedef typename unref<XprTypeNested>::type _XprTypeNested; enum { Flags = _XprTypeNested::Flags & ( HereditaryBits | LinearAccessBit | AlignedBit - | (ei_functor_traits<UnaryOp>::PacketAccess ? PacketAccessBit : 0)), - CoeffReadCost = _XprTypeNested::CoeffReadCost + ei_functor_traits<UnaryOp>::Cost + | (functor_traits<UnaryOp>::PacketAccess ? PacketAccessBit : 0)), + CoeffReadCost = _XprTypeNested::CoeffReadCost + functor_traits<UnaryOp>::Cost }; }; +} template<typename UnaryOp, typename XprType, typename StorageKind> class CwiseUnaryOpImpl; template<typename UnaryOp, typename XprType> -class CwiseUnaryOp : ei_no_assignment_operator, - public CwiseUnaryOpImpl<UnaryOp, XprType, typename ei_traits<XprType>::StorageKind> +class CwiseUnaryOp : internal::no_assignment_operator, + public CwiseUnaryOpImpl<UnaryOp, XprType, typename internal::traits<XprType>::StorageKind> { public: - typedef typename CwiseUnaryOpImpl<UnaryOp, XprType,typename ei_traits<XprType>::StorageKind>::Base Base; + typedef typename CwiseUnaryOpImpl<UnaryOp, XprType,typename internal::traits<XprType>::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<typename XprType::Nested>::type& + const typename internal::cleantype<typename XprType::Nested>::type& nestedExpression() const { return m_xpr; } /** \returns the nested expression */ - typename ei_cleantype<typename XprType::Nested>::type& + typename internal::cleantype<typename XprType::Nested>::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<typename UnaryOp, typename XprType> class CwiseUnaryOpImpl<UnaryOp,XprType,Dense> - : public ei_dense_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type + : public internal::dense_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type { public: typedef CwiseUnaryOp<UnaryOp, XprType> Derived; - typedef typename ei_dense_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type Base; + typedef typename internal::dense_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::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<typename ViewOp, typename MatrixType> -struct ei_traits<CwiseUnaryView<ViewOp, MatrixType> > - : ei_traits<MatrixType> +struct traits<CwiseUnaryView<ViewOp, MatrixType> > + : traits<MatrixType> { - typedef typename ei_result_of< - ViewOp(typename ei_traits<MatrixType>::Scalar) + typedef typename result_of< + ViewOp(typename traits<MatrixType>::Scalar) >::type Scalar; typedef typename MatrixType::Nested MatrixTypeNested; - typedef typename ei_cleantype<MatrixTypeNested>::type _MatrixTypeNested; + typedef typename cleantype<MatrixTypeNested>::type _MatrixTypeNested; enum { - Flags = (ei_traits<_MatrixTypeNested>::Flags & (HereditaryBits | LvalueBit | LinearAccessBit | DirectAccessBit)), - CoeffReadCost = ei_traits<_MatrixTypeNested>::CoeffReadCost + ei_functor_traits<ViewOp>::Cost, - MatrixTypeInnerStride = ei_inner_stride_at_compile_time<MatrixType>::ret, + Flags = (traits<_MatrixTypeNested>::Flags & (HereditaryBits | LvalueBit | LinearAccessBit | DirectAccessBit)), + CoeffReadCost = traits<_MatrixTypeNested>::CoeffReadCost + functor_traits<ViewOp>::Cost, + MatrixTypeInnerStride = inner_stride_at_compile_time<MatrixType>::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<MatrixType>::Scalar) / sizeof(Scalar)), - OuterStrideAtCompileTime = ei_outer_stride_at_compile_time<MatrixType>::ret + * int(sizeof(typename traits<MatrixType>::Scalar) / sizeof(Scalar)), + OuterStrideAtCompileTime = outer_stride_at_compile_time<MatrixType>::ret }; }; +} template<typename ViewOp, typename MatrixType, typename StorageKind> class CwiseUnaryViewImpl; template<typename ViewOp, typename MatrixType> -class CwiseUnaryView : ei_no_assignment_operator, - public CwiseUnaryViewImpl<ViewOp, MatrixType, typename ei_traits<MatrixType>::StorageKind> +class CwiseUnaryView : internal::no_assignment_operator, + public CwiseUnaryViewImpl<ViewOp, MatrixType, typename internal::traits<MatrixType>::StorageKind> { public: - typedef typename CwiseUnaryViewImpl<ViewOp, MatrixType,typename ei_traits<MatrixType>::StorageKind>::Base Base; + typedef typename CwiseUnaryViewImpl<ViewOp, MatrixType,typename internal::traits<MatrixType>::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<typename MatrixType::Nested>::type& + const typename internal::cleantype<typename MatrixType::Nested>::type& nestedExpression() const { return m_matrix; } /** \returns the nested expression */ - typename ei_cleantype<typename MatrixType::Nested>::type& + typename internal::cleantype<typename MatrixType::Nested>::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<MatrixType>::type m_matrix; + const typename internal::nested<MatrixType>::type m_matrix; ViewOp m_functor; }; template<typename ViewOp, typename MatrixType> class CwiseUnaryViewImpl<ViewOp,MatrixType,Dense> - : public ei_dense_xpr_base< CwiseUnaryView<ViewOp, MatrixType> >::type + : public internal::dense_xpr_base< CwiseUnaryView<ViewOp, MatrixType> >::type { public: typedef CwiseUnaryView<ViewOp, MatrixType> Derived; - typedef typename ei_dense_xpr_base< CwiseUnaryView<ViewOp, MatrixType> >::type Base; + typedef typename internal::dense_xpr_base< CwiseUnaryView<ViewOp, MatrixType> >::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(Derived) inline Index innerStride() const { - return derived().nestedExpression().innerStride() * sizeof(typename ei_traits<MatrixType>::Scalar) / sizeof(Scalar); + return derived().nestedExpression().innerStride() * sizeof(typename internal::traits<MatrixType>::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<typename Derived> class DenseBase #ifndef EIGEN_PARSED_BY_DOXYGEN - : public ei_special_scalar_op_base<Derived,typename ei_traits<Derived>::Scalar, - typename NumTraits<typename ei_traits<Derived>::Scalar>::Real> + : public internal::special_scalar_op_base<Derived,typename internal::traits<Derived>::Scalar, + typename NumTraits<typename internal::traits<Derived>::Scalar>::Real> #else : public DenseCoeffsBase<Derived> #endif // not EIGEN_PARSED_BY_DOXYGEN { public: - using ei_special_scalar_op_base<Derived,typename ei_traits<Derived>::Scalar, - typename NumTraits<typename ei_traits<Derived>::Scalar>::Real>::operator*; + using internal::special_scalar_op_base<Derived,typename internal::traits<Derived>::Scalar, + typename NumTraits<typename internal::traits<Derived>::Scalar>::Real>::operator*; class InnerIterator; - typedef typename ei_traits<Derived>::StorageKind StorageKind; - typedef typename ei_traits<Derived>::Index Index; /**< The type of indices */ - typedef typename ei_traits<Derived>::Scalar Scalar; - typedef typename ei_packet_traits<Scalar>::type PacketScalar; + typedef typename internal::traits<Derived>::StorageKind StorageKind; + typedef typename internal::traits<Derived>::Index Index; /**< The type of indices */ + typedef typename internal::traits<Derived>::Scalar Scalar; + typedef typename internal::packet_traits<Scalar>::type PacketScalar; typedef typename NumTraits<Scalar>::Real RealScalar; typedef DenseCoeffsBase<Derived> Base; @@ -93,26 +93,26 @@ template<typename Derived> class DenseBase enum { - RowsAtCompileTime = ei_traits<Derived>::RowsAtCompileTime, + RowsAtCompileTime = internal::traits<Derived>::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<Derived>::ColsAtCompileTime, + ColsAtCompileTime = internal::traits<Derived>::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<ei_traits<Derived>::RowsAtCompileTime, - ei_traits<Derived>::ColsAtCompileTime>::ret), + SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime, + internal::traits<Derived>::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<Derived>::MaxRowsAtCompileTime, + MaxRowsAtCompileTime = internal::traits<Derived>::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<typename Derived> class DenseBase * \sa RowsAtCompileTime, MaxColsAtCompileTime, MaxSizeAtCompileTime */ - MaxColsAtCompileTime = ei_traits<Derived>::MaxColsAtCompileTime, + MaxColsAtCompileTime = internal::traits<Derived>::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<typename Derived> class DenseBase * \sa ColsAtCompileTime, MaxRowsAtCompileTime, MaxSizeAtCompileTime */ - MaxSizeAtCompileTime = (ei_size_at_compile_time<ei_traits<Derived>::MaxRowsAtCompileTime, - ei_traits<Derived>::MaxColsAtCompileTime>::ret), + MaxSizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::MaxRowsAtCompileTime, + internal::traits<Derived>::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<typename Derived> class DenseBase * \sa SizeAtCompileTime, MaxRowsAtCompileTime, MaxColsAtCompileTime */ - IsVectorAtCompileTime = ei_traits<Derived>::MaxRowsAtCompileTime == 1 - || ei_traits<Derived>::MaxColsAtCompileTime == 1, + IsVectorAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime == 1 + || internal::traits<Derived>::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<Derived>::Flags, + Flags = internal::traits<Derived>::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<typename Derived> class DenseBase InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? SizeAtCompileTime : int(IsRowMajor) ? ColsAtCompileTime : RowsAtCompileTime, - CoeffReadCost = ei_traits<Derived>::CoeffReadCost, + CoeffReadCost = internal::traits<Derived>::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<Derived>::ret, - OuterStrideAtCompileTime = ei_outer_stride_at_compile_time<Derived>::ret + InnerStrideAtCompileTime = internal::inner_stride_at_compile_time<Derived>::ret, + OuterStrideAtCompileTime = internal::outer_stride_at_compile_time<Derived>::ret }; /** \returns the number of nonzero coefficients which is in practice the number @@ -209,7 +209,7 @@ template<typename Derived> 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<typename Derived> 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<ei_scalar_constant_op<Scalar>,Derived> ConstantReturnType; + typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,Derived> ConstantReturnType; /** \internal Represents a vector with linearly spaced coefficients that allows sequential access only. */ - typedef CwiseNullaryOp<ei_linspaced_op<Scalar,false>,Derived> SequentialLinSpacedReturnType; + typedef CwiseNullaryOp<internal::linspaced_op<Scalar,false>,Derived> SequentialLinSpacedReturnType; /** \internal Represents a vector with linearly spaced coefficients that allows random access. */ - typedef CwiseNullaryOp<ei_linspaced_op<Scalar,true>,Derived> RandomAccessLinSpacedReturnType; + typedef CwiseNullaryOp<internal::linspaced_op<Scalar,true>,Derived> RandomAccessLinSpacedReturnType; /** \internal the return type of MatrixBase::eigenvalues() */ - typedef Matrix<typename NumTraits<typename ei_traits<Derived>::Scalar>::Real, ei_traits<Derived>::ColsAtCompileTime, 1> EigenvaluesReturnType; + typedef Matrix<typename NumTraits<typename internal::traits<Derived>::Scalar>::Real, internal::traits<Derived>::ColsAtCompileTime, 1> EigenvaluesReturnType; #endif // not EIGEN_PARSED_BY_DOXYGEN @@ -381,12 +381,12 @@ template<typename Derived> 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<Derived>::type eval() const + EIGEN_STRONG_INLINE const typename internal::eval<Derived>::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<Derived>::type(derived()); + return typename internal::eval<Derived>::type(derived()); } template<typename OtherDerived> @@ -395,8 +395,8 @@ template<typename Derived> class DenseBase inline const NestByValue<Derived> nestByValue() const; inline const ForceAlignedAccess<Derived> forceAlignedAccess() const; inline ForceAlignedAccess<Derived> forceAlignedAccess(); - template<bool Enable> inline const typename ei_meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret forceAlignedAccessIf() const; - template<bool Enable> inline typename ei_meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret forceAlignedAccessIf(); + template<bool Enable> inline const typename internal::meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret forceAlignedAccessIf() const; + template<bool Enable> inline typename internal::meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret forceAlignedAccessIf(); Scalar sum() const; Scalar mean() const; @@ -404,17 +404,17 @@ template<typename Derived> class DenseBase Scalar prod() const; - typename ei_traits<Derived>::Scalar minCoeff() const; - typename ei_traits<Derived>::Scalar maxCoeff() const; + typename internal::traits<Derived>::Scalar minCoeff() const; + typename internal::traits<Derived>::Scalar maxCoeff() const; - typename ei_traits<Derived>::Scalar minCoeff(Index* row, Index* col) const; - typename ei_traits<Derived>::Scalar maxCoeff(Index* row, Index* col) const; + typename internal::traits<Derived>::Scalar minCoeff(Index* row, Index* col) const; + typename internal::traits<Derived>::Scalar maxCoeff(Index* row, Index* col) const; - typename ei_traits<Derived>::Scalar minCoeff(Index* index) const; - typename ei_traits<Derived>::Scalar maxCoeff(Index* index) const; + typename internal::traits<Derived>::Scalar minCoeff(Index* index) const; + typename internal::traits<Derived>::Scalar maxCoeff(Index* index) const; template<typename BinaryOp> - typename ei_result_of<BinaryOp(typename ei_traits<Derived>::Scalar)>::type + typename internal::result_of<BinaryOp(typename internal::traits<Derived>::Scalar)>::type redux(const BinaryOp& func) const; template<typename Visitor> @@ -433,9 +433,9 @@ template<typename Derived> class DenseBase const VectorwiseOp<Derived,Vertical> colwise() const; VectorwiseOp<Derived,Vertical> colwise(); - static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random(Index rows, Index cols); - static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random(Index size); - static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random(); + static const CwiseNullaryOp<internal::scalar_random_op<Scalar>,Derived> Random(Index rows, Index cols); + static const CwiseNullaryOp<internal::scalar_random_op<Scalar>,Derived> Random(Index size); + static const CwiseNullaryOp<internal::scalar_random_op<Scalar>,Derived> Random(); template<typename ThenDerived,typename ElseDerived> const Select<Derived,ThenDerived,ElseDerived> @@ -482,7 +482,7 @@ template<typename Derived> class DenseBase // disable the use of evalTo for dense objects with a nice compilation error template<typename Dest> inline void evalTo(Dest& ) const { - EIGEN_STATIC_ASSERT((ei_is_same_type<Dest,void>::ret),THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS); + EIGEN_STATIC_ASSERT((internal::is_same_type<Dest,void>::ret),THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS); } protected: @@ -493,7 +493,7 @@ template<typename Derived> 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<Flags>::ret, + EIGEN_STATIC_ASSERT(internal::are_flags_consistent<Flags>::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<typename Derived> class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived> { public: - typedef typename ei_traits<Derived>::StorageKind StorageKind; - typedef typename ei_traits<Derived>::Index Index; - typedef typename ei_traits<Derived>::Scalar Scalar; - typedef typename ei_packet_traits<Scalar>::type PacketScalar; - typedef typename ei_meta_if<bool(ei_traits<Derived>::Flags&LvalueBit), + typedef typename internal::traits<Derived>::StorageKind StorageKind; + typedef typename internal::traits<Derived>::Index Index; + typedef typename internal::traits<Derived>::Scalar Scalar; + typedef typename internal::packet_traits<Scalar>::type PacketScalar; + typedef typename internal::meta_if<bool(internal::traits<Derived>::Flags&LvalueBit), const Scalar&, - typename ei_meta_if<ei_is_arithmetic<Scalar>::ret, Scalar, const Scalar>::ret + typename internal::meta_if<internal::is_arithmetic<Scalar>::ret, Scalar, const Scalar>::ret >::ret CoeffReturnType; - typedef typename ei_makeconst_return_type<typename ei_packet_traits<Scalar>::type>::type PacketReturnType; + typedef typename internal::makeconst_return_type<typename internal::packet_traits<Scalar>::type>::type PacketReturnType; typedef EigenBase<Derived> Base; using Base::rows; @@ -88,7 +88,7 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived> */ 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<Derived,ReadOnlyAccessors> : public EigenBase<Derived> */ 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<Derived,ReadOnlyAccessors> : public EigenBase<Derived> 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<Derived,ReadOnlyAccessors> : public EigenBase<Derived> { 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<Derived,ReadOnlyAccessors> : public EigenBase<Derived> 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<Derived,ReadOnlyAccessors> : public EigenBase<Derived> template<int LoadMode> 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<LoadMode>(row,col); } @@ -224,7 +224,7 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived> template<int LoadMode> 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<LoadMode>(index); } @@ -267,10 +267,10 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, typedef DenseCoeffsBase<Derived, ReadOnlyAccessors> Base; - typedef typename ei_traits<Derived>::StorageKind StorageKind; - typedef typename ei_traits<Derived>::Index Index; - typedef typename ei_traits<Derived>::Scalar Scalar; - typedef typename ei_packet_traits<Scalar>::type PacketScalar; + typedef typename internal::traits<Derived>::StorageKind StorageKind; + typedef typename internal::traits<Derived>::Index Index; + typedef typename internal::traits<Derived>::Scalar Scalar; + typedef typename internal::packet_traits<Scalar>::type PacketScalar; typedef typename NumTraits<Scalar>::Real RealScalar; using Base::coeff; @@ -303,7 +303,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, */ EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col) { - ei_internal_assert(row >= 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<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, EIGEN_STRONG_INLINE Scalar& operator()(Index row, Index col) { - ei_assert(row >= 0 && row < rows() + eigen_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); return derived().coeffRef(row, col); } @@ -347,7 +347,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { - ei_internal_assert(index >= 0 && index < size()); + eigen_internal_assert(index >= 0 && index < size()); return derived().coeffRef(index); } @@ -363,7 +363,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, { 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().coeffRef(index); } @@ -379,7 +379,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, EIGEN_STRONG_INLINE Scalar& operator()(Index index) { - ei_assert(index >= 0 && index < size()); + eigen_assert(index >= 0 && index < size()); return derived().coeffRef(index); } @@ -414,9 +414,9 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, template<int StoreMode> EIGEN_STRONG_INLINE void writePacket - (Index row, Index col, const typename ei_packet_traits<Scalar>::type& x) + (Index row, Index col, const typename internal::packet_traits<Scalar>::type& x) { - ei_internal_assert(row >= 0 && row < rows() + eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); derived().template writePacket<StoreMode>(row,col,x); } @@ -424,7 +424,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, template<int StoreMode> EIGEN_STRONG_INLINE void writePacketByOuterInner - (Index outer, Index inner, const typename ei_packet_traits<Scalar>::type& x) + (Index outer, Index inner, const typename internal::packet_traits<Scalar>::type& x) { writePacket<StoreMode>(rowIndexByOuterInner(outer, inner), colIndexByOuterInner(outer, inner), @@ -442,9 +442,9 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, template<int StoreMode> EIGEN_STRONG_INLINE void writePacket - (Index index, const typename ei_packet_traits<Scalar>::type& x) + (Index index, const typename internal::packet_traits<Scalar>::type& x) { - ei_internal_assert(index >= 0 && index < size()); + eigen_internal_assert(index >= 0 && index < size()); derived().template writePacket<StoreMode>(index,x); } @@ -461,7 +461,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, template<typename OtherDerived> EIGEN_STRONG_INLINE void copyCoeff(Index row, Index col, const DenseBase<OtherDerived>& 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<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, template<typename OtherDerived> EIGEN_STRONG_INLINE void copyCoeff(Index index, const DenseBase<OtherDerived>& 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<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, template<typename OtherDerived, int StoreMode, int LoadMode> EIGEN_STRONG_INLINE void copyPacket(Index row, Index col, const DenseBase<OtherDerived>& other) { - ei_internal_assert(row >= 0 && row < rows() + eigen_internal_assert(row >= 0 && row < rows() && col >= 0 && col < cols()); derived().template writePacket<StoreMode>(row, col, other.derived().template packet<LoadMode>(row, col)); @@ -519,7 +519,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived, template<typename OtherDerived, int StoreMode, int LoadMode> EIGEN_STRONG_INLINE void copyPacket(Index index, const DenseBase<OtherDerived>& other) { - ei_internal_assert(index >= 0 && index < size()); + eigen_internal_assert(index >= 0 && index < size()); derived().template writePacket<StoreMode>(index, other.derived().template packet<LoadMode>(index)); } @@ -553,8 +553,8 @@ class DenseCoeffsBase<Derived, DirectAccessors> : public DenseCoeffsBase<Derived public: typedef DenseCoeffsBase<Derived, WriteAccessors> Base; - typedef typename ei_traits<Derived>::Index Index; - typedef typename ei_traits<Derived>::Scalar Scalar; + typedef typename internal::traits<Derived>::Index Index; + typedef typename internal::traits<Derived>::Scalar Scalar; typedef typename NumTraits<Scalar>::Real RealScalar; using Base::rows; @@ -606,57 +606,61 @@ class DenseCoeffsBase<Derived, DirectAccessors> : public DenseCoeffsBase<Derived } }; +namespace internal { + template<typename Derived, bool JustReturnZero> -struct ei_first_aligned_impl +struct first_aligned_impl { inline static typename Derived::Index run(const Derived&) { return 0; } }; template<typename Derived> -struct ei_first_aligned_impl<Derived, false> +struct first_aligned_impl<Derived, false> { 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<typename Derived> -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 <Derived, (Derived::Flags & AlignedBit) || !(Derived::Flags & DirectAccessBit)> ::run(m); } -template<typename Derived, bool HasDirectAccess = ei_has_direct_access<Derived>::ret> -struct ei_inner_stride_at_compile_time +template<typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret> +struct inner_stride_at_compile_time { - enum { ret = ei_traits<Derived>::InnerStrideAtCompileTime }; + enum { ret = traits<Derived>::InnerStrideAtCompileTime }; }; template<typename Derived> -struct ei_inner_stride_at_compile_time<Derived, false> +struct inner_stride_at_compile_time<Derived, false> { enum { ret = 0 }; }; -template<typename Derived, bool HasDirectAccess = ei_has_direct_access<Derived>::ret> -struct ei_outer_stride_at_compile_time +template<typename Derived, bool HasDirectAccess = has_direct_access<Derived>::ret> +struct outer_stride_at_compile_time { - enum { ret = ei_traits<Derived>::OuterStrideAtCompileTime }; + enum { ret = traits<Derived>::OuterStrideAtCompileTime }; }; template<typename Derived> -struct ei_outer_stride_at_compile_time<Derived, false> +struct outer_stride_at_compile_time<Derived, false> { 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 <typename T, int Size, int MatrixOptions, int Alignment = (MatrixOptions&DontAlign) ? 0 : (((Size*sizeof(T))%16)==0) ? 16 : 0 > -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<size_t>(array) & sizemask) == 0 \ + eigen_assert((reinterpret_cast<size_t>(array) & sizemask) == 0 \ && "this assertion is explained here: " \ "http://eigen.tuxfamily.org/dox/UnalignedArrayAssert.html" \ " **** READ THIS WEB PAGE !!! ****"); #endif template <typename T, int Size, int MatrixOptions> -struct ei_matrix_array<T, Size, MatrixOptions, 16> +struct matrix_array<T, Size, MatrixOptions, 16> { 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 <typename T, int MatrixOptions, int Alignment> -struct ei_matrix_array<T, 0, MatrixOptions, Alignment> +struct matrix_array<T, 0, MatrixOptions, Alignment> { 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<typename T, int Size, int _Rows, int _Cols, int _Options> class DenseSt // purely fixed-size matrix template<typename T, int Size, int _Rows, int _Cols, int _Options> class DenseStorage { - ei_matrix_array<T,Size,_Options> m_data; + internal::matrix_array<T,Size,_Options> 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<typename T, int _Rows, int _Cols, int _Options> class DenseStorage<T, 0 { public: inline explicit DenseStorage() {} - inline DenseStorage(ei_constructor_without_unaligned_array_assert) {} + inline DenseStorage(internal::constructor_without_unaligned_array_assert) {} inline DenseStorage(DenseIndex,DenseIndex,DenseIndex) {} inline void swap(DenseStorage& ) {} inline static DenseIndex rows(void) {return _Rows;} @@ -127,13 +131,13 @@ template<typename T, int _Rows, int _Cols, int _Options> class DenseStorage<T, 0 // dynamic-size matrix with fixed-size storage template<typename T, int Size, int _Options> class DenseStorage<T, Size, Dynamic, Dynamic, _Options> { - ei_matrix_array<T,Size,_Options> m_data; + internal::matrix_array<T,Size,_Options> 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<typename T, int Size, int _Options> class DenseStorage<T, Size, Dynamic // dynamic-size matrix with fixed-size storage and fixed width template<typename T, int Size, int _Cols, int _Options> class DenseStorage<T, Size, Dynamic, _Cols, _Options> { - ei_matrix_array<T,Size,_Options> m_data; + internal::matrix_array<T,Size,_Options> 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<typename T, int Size, int _Cols, int _Options> class DenseStorage<T, Si // dynamic-size matrix with fixed-size storage and fixed height template<typename T, int Size, int _Rows, int _Options> class DenseStorage<T, Size, _Rows, Dynamic, _Options> { - ei_matrix_array<T,Size,_Options> m_data; + internal::matrix_array<T,Size,_Options> 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<typename T, int _Options> class DenseStorage<T, Dynamic, Dynamic, Dynam DenseIndex m_cols; public: inline explicit DenseStorage() : m_data(0), m_rows(0), m_cols(0) {} - inline DenseStorage(ei_constructor_without_unaligned_array_assert) + inline DenseStorage(internal::constructor_without_unaligned_array_assert) : m_data(0), m_rows(0), m_cols(0) {} inline DenseStorage(DenseIndex size, DenseIndex rows, DenseIndex cols) - : m_data(ei_conditional_aligned_new<T,(_Options&DontAlign)==0>(size)), m_rows(rows), m_cols(cols) + : m_data(internal::conditional_aligned_new<T,(_Options&DontAlign)==0>(size)), m_rows(rows), m_cols(cols) { EIGEN_INT_DEBUG_MATRIX_CTOR } - inline ~DenseStorage() { ei_conditional_aligned_delete<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols); } + inline ~DenseStorage() { internal::conditional_aligned_delete<T,(_Options&DontAlign)==0>(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<T,(_Options&DontAlign)==0>(m_data, size, m_rows*m_cols); + m_data = internal::conditional_aligned_realloc_new<T,(_Options&DontAlign)==0>(m_data, size, m_rows*m_cols); m_rows = rows; m_cols = cols; } @@ -211,9 +215,9 @@ template<typename T, int _Options> class DenseStorage<T, Dynamic, Dynamic, Dynam { if(size != m_rows*m_cols) { - ei_conditional_aligned_delete<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols); + internal::conditional_aligned_delete<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols); if (size) - m_data = ei_conditional_aligned_new<T,(_Options&DontAlign)==0>(size); + m_data = internal::conditional_aligned_new<T,(_Options&DontAlign)==0>(size); else m_data = 0; EIGEN_INT_DEBUG_MATRIX_CTOR @@ -232,25 +236,25 @@ template<typename T, int _Rows, int _Options> class DenseStorage<T, Dynamic, _Ro DenseIndex m_cols; public: inline explicit DenseStorage() : m_data(0), m_cols(0) {} - inline DenseStorage(ei_constructor_without_unaligned_array_assert) : m_data(0), m_cols(0) {} - inline DenseStorage(DenseIndex size, DenseIndex, DenseIndex cols) : m_data(ei_conditional_aligned_new<T,(_Options&DontAlign)==0>(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<T,(_Options&DontAlign)==0>(size)), m_cols(cols) { EIGEN_INT_DEBUG_MATRIX_CTOR } - inline ~DenseStorage() { ei_conditional_aligned_delete<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols); } + inline ~DenseStorage() { internal::conditional_aligned_delete<T,(_Options&DontAlign)==0>(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<T,(_Options&DontAlign)==0>(m_data, size, _Rows*m_cols); + m_data = internal::conditional_aligned_realloc_new<T,(_Options&DontAlign)==0>(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<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols); + internal::conditional_aligned_delete<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols); if (size) - m_data = ei_conditional_aligned_new<T,(_Options&DontAlign)==0>(size); + m_data = internal::conditional_aligned_new<T,(_Options&DontAlign)==0>(size); else m_data = 0; EIGEN_INT_DEBUG_MATRIX_CTOR @@ -268,25 +272,25 @@ template<typename T, int _Cols, int _Options> class DenseStorage<T, Dynamic, Dyn DenseIndex m_rows; public: inline explicit DenseStorage() : m_data(0), m_rows(0) {} - inline DenseStorage(ei_constructor_without_unaligned_array_assert) : m_data(0), m_rows(0) {} - inline DenseStorage(DenseIndex size, DenseIndex rows, DenseIndex) : m_data(ei_conditional_aligned_new<T,(_Options&DontAlign)==0>(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<T,(_Options&DontAlign)==0>(size)), m_rows(rows) { EIGEN_INT_DEBUG_MATRIX_CTOR } - inline ~DenseStorage() { ei_conditional_aligned_delete<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows); } + inline ~DenseStorage() { internal::conditional_aligned_delete<T,(_Options&DontAlign)==0>(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<T,(_Options&DontAlign)==0>(m_data, size, m_rows*_Cols); + m_data = internal::conditional_aligned_realloc_new<T,(_Options&DontAlign)==0>(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<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows); + internal::conditional_aligned_delete<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows); if (size) - m_data = ei_conditional_aligned_new<T,(_Options&DontAlign)==0>(size); + m_data = internal::conditional_aligned_new<T,(_Options&DontAlign)==0>(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<typename MatrixType, int DiagIndex> -struct ei_traits<Diagonal<MatrixType,DiagIndex> > - : ei_traits<MatrixType> +struct traits<Diagonal<MatrixType,DiagIndex> > + : traits<MatrixType> { - typedef typename ei_nested<MatrixType>::type MatrixTypeNested; - typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested; + typedef typename nested<MatrixType>::type MatrixTypeNested; + typedef typename unref<MatrixTypeNested>::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<Diagonal<MatrixType,DiagIndex> > MaxColsAtCompileTime = 1, Flags = (unsigned int)_MatrixTypeNested::Flags & (HereditaryBits | LinearAccessBit | LvalueBit | DirectAccessBit) & ~RowMajorBit, CoeffReadCost = _MatrixTypeNested::CoeffReadCost, - MatrixTypeOuterStride = ei_outer_stride_at_compile_time<MatrixType>::ret, + MatrixTypeOuterStride = outer_stride_at_compile_time<MatrixType>::ret, InnerStrideAtCompileTime = MatrixTypeOuterStride == Dynamic ? Dynamic : MatrixTypeOuterStride+1, OuterStrideAtCompileTime = 0 }; }; +} template<typename MatrixType, int DiagIndex> class Diagonal - : public ei_dense_xpr_base< Diagonal<MatrixType,DiagIndex> >::type + : public internal::dense_xpr_base< Diagonal<MatrixType,DiagIndex> >::type { public: - typedef typename ei_dense_xpr_base<Diagonal>::type Base; + typedef typename internal::dense_xpr_base<Diagonal>::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<typename MatrixType, int DiagIndex> class Diagonal protected: const typename MatrixType::Nested m_matrix; - const ei_variable_if_dynamic<Index, DiagIndex> m_index; + const internal::variable_if_dynamic<Index, DiagIndex> 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<typename Derived> class DiagonalBase : public EigenBase<Derived> { public: - typedef typename ei_traits<Derived>::DiagonalVectorType DiagonalVectorType; + typedef typename internal::traits<Derived>::DiagonalVectorType DiagonalVectorType; typedef typename DiagonalVectorType::Scalar Scalar; - typedef typename ei_traits<Derived>::StorageKind StorageKind; - typedef typename ei_traits<Derived>::Index Index; + typedef typename internal::traits<Derived>::StorageKind StorageKind; + typedef typename internal::traits<Derived>::Index Index; enum { RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime, @@ -70,7 +70,7 @@ class DiagonalBase : public EigenBase<Derived> const DiagonalProduct<MatrixDerived, Derived, OnTheLeft> operator*(const MatrixBase<MatrixDerived> &matrix) const; - inline const DiagonalWrapper<CwiseUnaryOp<ei_scalar_inverse_op<Scalar>, DiagonalVectorType> > + inline const DiagonalWrapper<CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, DiagonalVectorType> > inverse() const { return diagonal().cwiseInverse(); @@ -98,9 +98,11 @@ void DiagonalBase<Derived>::evalTo(MatrixBase<DenseDerived> &other) const * * \sa class DiagonalWrapper */ + +namespace internal { template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime> -struct ei_traits<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> > - : ei_traits<Matrix<_Scalar,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> > +struct traits<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> > + : traits<Matrix<_Scalar,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> > { typedef Matrix<_Scalar,SizeAtCompileTime,1,0,MaxSizeAtCompileTime,1> DiagonalVectorType; typedef Dense StorageKind; @@ -109,18 +111,18 @@ struct ei_traits<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> Flags = LvalueBit }; }; - +} template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime> class DiagonalMatrix : public DiagonalBase<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> > { public: #ifndef EIGEN_PARSED_BY_DOXYGEN - typedef typename ei_traits<DiagonalMatrix>::DiagonalVectorType DiagonalVectorType; + typedef typename internal::traits<DiagonalMatrix>::DiagonalVectorType DiagonalVectorType; typedef const DiagonalMatrix& Nested; typedef _Scalar Scalar; - typedef typename ei_traits<DiagonalMatrix>::StorageKind StorageKind; - typedef typename ei_traits<DiagonalMatrix>::Index Index; + typedef typename internal::traits<DiagonalMatrix>::StorageKind StorageKind; + typedef typename internal::traits<DiagonalMatrix>::Index Index; #endif protected: @@ -204,8 +206,10 @@ class DiagonalMatrix * * \sa class DiagonalMatrix, class DiagonalBase, MatrixBase::asDiagonal() */ + +namespace internal { template<typename _DiagonalVectorType> -struct ei_traits<DiagonalWrapper<_DiagonalVectorType> > +struct traits<DiagonalWrapper<_DiagonalVectorType> > { typedef _DiagonalVectorType DiagonalVectorType; typedef typename DiagonalVectorType::Scalar Scalar; @@ -216,13 +220,14 @@ struct ei_traits<DiagonalWrapper<_DiagonalVectorType> > ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime, MaxRowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime, MaxColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime, - Flags = ei_traits<DiagonalVectorType>::Flags & LvalueBit + Flags = traits<DiagonalVectorType>::Flags & LvalueBit }; }; +} template<typename _DiagonalVectorType> class DiagonalWrapper - : public DiagonalBase<DiagonalWrapper<_DiagonalVectorType> >, ei_no_assignment_operator + : public DiagonalBase<DiagonalWrapper<_DiagonalVectorType> >, internal::no_assignment_operator { public: #ifndef EIGEN_PARSED_BY_DOXYGEN @@ -265,21 +270,20 @@ MatrixBase<Derived>::asDiagonal() const * \sa asDiagonal() */ template<typename Derived> -bool MatrixBase<Derived>::isDiagonal -(RealScalar prec) const +bool MatrixBase<Derived>::isDiagonal(RealScalar prec) const { if(cols() != rows()) return false; RealScalar maxAbsOnDiagonal = static_cast<RealScalar>(-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<typename MatrixType, typename DiagonalType, int ProductOrder> -struct ei_traits<DiagonalProduct<MatrixType, DiagonalType, ProductOrder> > - : ei_traits<MatrixType> +struct traits<DiagonalProduct<MatrixType, DiagonalType, ProductOrder> > + : traits<MatrixType> { - typedef typename ei_scalar_product_traits<typename MatrixType::Scalar, typename DiagonalType::Scalar>::ReturnType Scalar; + typedef typename scalar_product_traits<typename MatrixType::Scalar, typename DiagonalType::Scalar>::ReturnType Scalar; enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime, @@ -40,7 +41,7 @@ struct ei_traits<DiagonalProduct<MatrixType, DiagonalType, ProductOrder> > _StorageOrder = MatrixType::Flags & RowMajorBit ? RowMajor : ColMajor, _PacketOnDiag = !((int(_StorageOrder) == RowMajor && int(ProductOrder) == OnTheLeft) ||(int(_StorageOrder) == ColMajor && int(ProductOrder) == OnTheRight)), - _SameTypes = ei_is_same_type<typename MatrixType::Scalar, typename DiagonalType::Scalar>::ret, + _SameTypes = is_same_type<typename MatrixType::Scalar, typename DiagonalType::Scalar>::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<DiagonalProduct<MatrixType, DiagonalType, ProductOrder> > CoeffReadCost = NumTraits<Scalar>::MulCost + MatrixType::CoeffReadCost + DiagonalType::DiagonalVectorType::CoeffReadCost }; }; +} template<typename MatrixType, typename DiagonalType, int ProductOrder> -class DiagonalProduct : ei_no_assignment_operator, +class DiagonalProduct : internal::no_assignment_operator, public MatrixBase<DiagonalProduct<MatrixType, DiagonalType, ProductOrder> > { 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<LoadMode>(row,col,indexInDiagonalVector,typename ei_meta_if< + return packet_impl<LoadMode>(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<int LoadMode> - 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<LoadMode>(row, col), - ei_pset1<PacketScalar>(m_diagonal.diagonal().coeff(id))); + return internal::pmul(m_matrix.template packet<LoadMode>(row, col), + internal::pset1<PacketScalar>(m_diagonal.diagonal().coeff(id))); } template<int LoadMode> - 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<LoadMode>(row, col), + return internal::pmul(m_matrix.template packet<LoadMode>(row, col), m_diagonal.diagonal().template packet<DiagonalVectorPacketLoadMode>(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<typename T, typename U, // revert to || as soon as not needed anymore. (int(T::ColsAtCompileTime) == 1 && int(U::RowsAtCompileTime) == 1)) > -struct ei_dot_nocheck +struct dot_nocheck { - static inline typename ei_traits<T>::Scalar run(const MatrixBase<T>& a, const MatrixBase<U>& b) + static inline typename traits<T>::Scalar run(const MatrixBase<T>& a, const MatrixBase<U>& b) { - return a.template binaryExpr<ei_scalar_conj_product_op<typename ei_traits<T>::Scalar> >(b).sum(); + return a.template binaryExpr<scalar_conj_product_op<typename traits<T>::Scalar> >(b).sum(); } }; template<typename T, typename U> -struct ei_dot_nocheck<T, U, true> +struct dot_nocheck<T, U, true> { - static inline typename ei_traits<T>::Scalar run(const MatrixBase<T>& a, const MatrixBase<U>& b) + static inline typename traits<T>::Scalar run(const MatrixBase<T>& a, const MatrixBase<U>& b) { - return a.transpose().template binaryExpr<ei_scalar_conj_product_op<typename ei_traits<T>::Scalar> >(b).sum(); + return a.transpose().template binaryExpr<scalar_conj_product_op<typename traits<T>::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<T, U, true> */ template<typename Derived> template<typename OtherDerived> -typename ei_traits<Derived>::Scalar +typename internal::traits<Derived>::Scalar MatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& 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<Scalar, typename OtherDerived::Scalar>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type<Scalar, typename OtherDerived::Scalar>::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<Derived,OtherDerived>::run(*this, other); + return internal::dot_nocheck<Derived,OtherDerived>::run(*this, other); } //---------- implementation of L2 norm and related functions ---------- @@ -87,9 +91,9 @@ MatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const * \sa dot(), norm() */ template<typename Derived> -EIGEN_STRONG_INLINE typename NumTraits<typename ei_traits<Derived>::Scalar>::Real MatrixBase<Derived>::squaredNorm() const +EIGEN_STRONG_INLINE typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::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<typename ei_traits<Derived>::Scalar>::Rea * \sa dot(), squaredNorm() */ template<typename Derived> -inline typename NumTraits<typename ei_traits<Derived>::Scalar>::Real MatrixBase<Derived>::norm() const +inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::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<typename Derived> inline const typename MatrixBase<Derived>::PlainObject MatrixBase<Derived>::normalized() const { - typedef typename ei_nested<Derived>::type Nested; - typedef typename ei_unref<Nested>::type _Nested; + typedef typename internal::nested<Derived>::type Nested; + typedef typename internal::unref<Nested>::type _Nested; _Nested n(derived()); return n / n.norm(); } @@ -132,43 +136,47 @@ inline void MatrixBase<Derived>::normalize() //---------- implementation of other norms ---------- +namespace internal { + template<typename Derived, int p> -struct ei_lpNorm_selector +struct lpNorm_selector { - typedef typename NumTraits<typename ei_traits<Derived>::Scalar>::Real RealScalar; + typedef typename NumTraits<typename traits<Derived>::Scalar>::Real RealScalar; inline static RealScalar run(const MatrixBase<Derived>& 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<typename Derived> -struct ei_lpNorm_selector<Derived, 1> +struct lpNorm_selector<Derived, 1> { - inline static typename NumTraits<typename ei_traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& m) + inline static typename NumTraits<typename traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& m) { return m.cwiseAbs().sum(); } }; template<typename Derived> -struct ei_lpNorm_selector<Derived, 2> +struct lpNorm_selector<Derived, 2> { - inline static typename NumTraits<typename ei_traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& m) + inline static typename NumTraits<typename traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& m) { return m.norm(); } }; template<typename Derived> -struct ei_lpNorm_selector<Derived, Infinity> +struct lpNorm_selector<Derived, Infinity> { - inline static typename NumTraits<typename ei_traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& m) + inline static typename NumTraits<typename traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& 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<Derived, Infinity> */ template<typename Derived> template<int p> -inline typename NumTraits<typename ei_traits<Derived>::Scalar>::Real +inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::lpNorm() const { - return ei_lpNorm_selector<Derived, p>::run(*this); + return internal::lpNorm_selector<Derived, p>::run(*this); } //---------- implementation of isOrthogonal / isUnitary ---------- @@ -196,9 +204,9 @@ template<typename OtherDerived> bool MatrixBase<Derived>::isOrthogonal (const MatrixBase<OtherDerived>& other, RealScalar prec) const { - typename ei_nested<Derived,2>::type nested(derived()); - typename ei_nested<OtherDerived,2>::type otherNested(other.derived()); - return ei_abs2(nested.dot(otherNested)) <= prec * prec * nested.squaredNorm() * otherNested.squaredNorm(); + typename internal::nested<Derived,2>::type nested(derived()); + typename internal::nested<OtherDerived,2>::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<Derived>::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<RealScalar>(1), prec)) + if(!internal::isApprox(nested.col(i).squaredNorm(), static_cast<RealScalar>(1), prec)) return false; for(Index j = 0; j < i; ++j) - if(!ei_isMuchSmallerThan(nested.col(i).dot(nested.col(j)), static_cast<Scalar>(1), prec)) + if(!internal::isMuchSmallerThan(nested.col(i).dot(nested.col(j)), static_cast<Scalar>(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<typename Derived> struct EigenBase { -// typedef typename ei_plain_matrix_type<Derived>::type PlainObject; +// typedef typename internal::plain_matrix_type<Derived>::type PlainObject; - typedef typename ei_traits<Derived>::StorageKind StorageKind; - typedef typename ei_traits<Derived>::Index Index; + typedef typename internal::traits<Derived>::StorageKind StorageKind; + typedef typename internal::traits<Derived>::Index Index; /** \returns a reference to the derived object */ Derived& derived() { return *static_cast<Derived*>(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<typename ExpressionType, unsigned int Added, unsigned int Removed> -struct ei_traits<Flagged<ExpressionType, Added, Removed> > : ei_traits<ExpressionType> +struct traits<Flagged<ExpressionType, Added, Removed> > : traits<ExpressionType> { enum { Flags = (ExpressionType::Flags | Added) & ~Removed }; }; +} template<typename ExpressionType, unsigned int Added, unsigned int Removed> class Flagged : public MatrixBase<Flagged<ExpressionType, Added, Removed> > @@ -53,7 +56,7 @@ template<typename ExpressionType, unsigned int Added, unsigned int Removed> clas typedef MatrixBase<Flagged> Base; EIGEN_DENSE_PUBLIC_INTERFACE(Flagged) - typedef typename ei_meta_if<ei_must_nest_by_value<ExpressionType>::ret, + typedef typename internal::meta_if<internal::must_nest_by_value<ExpressionType>::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<typename ExpressionType> -struct ei_traits<ForceAlignedAccess<ExpressionType> > : public ei_traits<ExpressionType> +struct traits<ForceAlignedAccess<ExpressionType> > : public traits<ExpressionType> {}; +} template<typename ExpressionType> class ForceAlignedAccess - : public ei_dense_xpr_base< ForceAlignedAccess<ExpressionType> >::type + : public internal::dense_xpr_base< ForceAlignedAccess<ExpressionType> >::type { public: - typedef typename ei_dense_xpr_base<ForceAlignedAccess>::type Base; + typedef typename internal::dense_xpr_base<ForceAlignedAccess>::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(ForceAlignedAccess) inline ForceAlignedAccess(const ExpressionType& matrix) : m_expression(matrix) {} @@ -134,7 +137,7 @@ MatrixBase<Derived>::forceAlignedAccess() */ template<typename Derived> template<bool Enable> -inline typename ei_makeconst<typename ei_meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret>::type +inline typename internal::makeconst<typename internal::meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret>::type MatrixBase<Derived>::forceAlignedAccessIf() const { return derived(); @@ -145,7 +148,7 @@ MatrixBase<Derived>::forceAlignedAccessIf() const */ template<typename Derived> template<bool Enable> -inline typename ei_meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret +inline typename internal::meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret MatrixBase<Derived>::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<typename Scalar> struct ei_scalar_sum_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_sum_op) +template<typename Scalar> 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<typename Packet> EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const - { return ei_padd(a,b); } + { return internal::padd(a,b); } template<typename Packet> EIGEN_STRONG_INLINE const Scalar predux(const Packet& a) const - { return ei_predux(a); } + { return internal::predux(a); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_sum_op<Scalar> > { +struct functor_traits<scalar_sum_op<Scalar> > { enum { Cost = NumTraits<Scalar>::AddCost, - PacketAccess = ei_packet_traits<Scalar>::HasAdd + PacketAccess = packet_traits<Scalar>::HasAdd }; }; @@ -55,47 +57,47 @@ struct ei_functor_traits<ei_scalar_sum_op<Scalar> > { * * \sa class CwiseBinaryOp, Cwise::operator*(), class VectorwiseOp, MatrixBase::redux() */ -template<typename LhsScalar,typename RhsScalar> struct ei_scalar_product_op { +template<typename LhsScalar,typename RhsScalar> struct scalar_product_op { enum { - Vectorizable = ei_is_same_type<LhsScalar,RhsScalar>::ret && ei_packet_traits<LhsScalar>::HasMul && ei_packet_traits<RhsScalar>::HasMul + Vectorizable = is_same_type<LhsScalar,RhsScalar>::ret && packet_traits<LhsScalar>::HasMul && packet_traits<RhsScalar>::HasMul }; - typedef typename ei_scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type; - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_product_op) + typedef typename scalar_product_traits<LhsScalar,RhsScalar>::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<typename Packet> EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const - { return ei_pmul(a,b); } + { return internal::pmul(a,b); } template<typename Packet> EIGEN_STRONG_INLINE const result_type predux(const Packet& a) const - { return ei_predux_mul(a); } + { return internal::predux_mul(a); } }; template<typename LhsScalar,typename RhsScalar> -struct ei_functor_traits<ei_scalar_product_op<LhsScalar,RhsScalar> > { +struct functor_traits<scalar_product_op<LhsScalar,RhsScalar> > { enum { Cost = (NumTraits<LhsScalar>::MulCost + NumTraits<RhsScalar>::MulCost)/2, // rough estimate! - PacketAccess = ei_scalar_product_op<LhsScalar,RhsScalar>::Vectorizable + PacketAccess = scalar_product_op<LhsScalar,RhsScalar>::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<typename Scalar> struct ei_scalar_conj_product_op { +template<typename Scalar> struct scalar_conj_product_op { enum { Conj = NumTraits<Scalar>::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<Scalar,Scalar,Conj,false>().pmul(a,b); } + { return conj_helper<Scalar,Scalar,Conj,false>().pmul(a,b); } template<typename Packet> EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const - { return ei_conj_helper<Packet,Packet,Conj,false>().pmul(a,b); } + { return conj_helper<Packet,Packet,Conj,false>().pmul(a,b); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_conj_product_op<Scalar> > { +struct functor_traits<scalar_conj_product_op<Scalar> > { enum { Cost = NumTraits<Scalar>::MulCost, - PacketAccess = ei_packet_traits<Scalar>::HasMul + PacketAccess = packet_traits<Scalar>::HasMul }; }; @@ -104,21 +106,21 @@ struct ei_functor_traits<ei_scalar_conj_product_op<Scalar> > { * * \sa class CwiseBinaryOp, MatrixBase::cwiseMin, class VectorwiseOp, MatrixBase::minCoeff() */ -template<typename Scalar> struct ei_scalar_min_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_min_op) +template<typename Scalar> 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<typename Packet> EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const - { return ei_pmin(a,b); } + { return internal::pmin(a,b); } template<typename Packet> EIGEN_STRONG_INLINE const Scalar predux(const Packet& a) const - { return ei_predux_min(a); } + { return internal::predux_min(a); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_min_op<Scalar> > { +struct functor_traits<scalar_min_op<Scalar> > { enum { Cost = NumTraits<Scalar>::AddCost, - PacketAccess = ei_packet_traits<Scalar>::HasMin + PacketAccess = packet_traits<Scalar>::HasMin }; }; @@ -127,21 +129,21 @@ struct ei_functor_traits<ei_scalar_min_op<Scalar> > { * * \sa class CwiseBinaryOp, MatrixBase::cwiseMax, class VectorwiseOp, MatrixBase::maxCoeff() */ -template<typename Scalar> struct ei_scalar_max_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_max_op) +template<typename Scalar> 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<typename Packet> EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const - { return ei_pmax(a,b); } + { return internal::pmax(a,b); } template<typename Packet> EIGEN_STRONG_INLINE const Scalar predux(const Packet& a) const - { return ei_predux_max(a); } + { return internal::predux_max(a); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_max_op<Scalar> > { +struct functor_traits<scalar_max_op<Scalar> > { enum { Cost = NumTraits<Scalar>::AddCost, - PacketAccess = ei_packet_traits<Scalar>::HasMax + PacketAccess = packet_traits<Scalar>::HasMax }; }; @@ -150,19 +152,19 @@ struct ei_functor_traits<ei_scalar_max_op<Scalar> > { * * \sa MatrixBase::stableNorm(), class Redux */ -template<typename Scalar> struct ei_scalar_hypot_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_hypot_op) +template<typename Scalar> struct scalar_hypot_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_hypot_op) // typedef typename NumTraits<Scalar>::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<typename Scalar> -struct ei_functor_traits<ei_scalar_hypot_op<Scalar> > { +struct functor_traits<scalar_hypot_op<Scalar> > { enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess=0 }; }; @@ -173,18 +175,18 @@ struct ei_functor_traits<ei_scalar_hypot_op<Scalar> > { * * \sa class CwiseBinaryOp, MatrixBase::operator- */ -template<typename Scalar> struct ei_scalar_difference_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_difference_op) +template<typename Scalar> 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<typename Packet> EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const - { return ei_psub(a,b); } + { return internal::psub(a,b); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_difference_op<Scalar> > { +struct functor_traits<scalar_difference_op<Scalar> > { enum { Cost = NumTraits<Scalar>::AddCost, - PacketAccess = ei_packet_traits<Scalar>::HasSub + PacketAccess = packet_traits<Scalar>::HasSub }; }; @@ -193,18 +195,18 @@ struct ei_functor_traits<ei_scalar_difference_op<Scalar> > { * * \sa class CwiseBinaryOp, Cwise::operator/() */ -template<typename Scalar> struct ei_scalar_quotient_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_quotient_op) +template<typename Scalar> 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<typename Packet> EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const - { return ei_pdiv(a,b); } + { return internal::pdiv(a,b); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_quotient_op<Scalar> > { +struct functor_traits<scalar_quotient_op<Scalar> > { enum { Cost = 2 * NumTraits<Scalar>::MulCost, - PacketAccess = ei_packet_traits<Scalar>::HasDiv + PacketAccess = packet_traits<Scalar>::HasDiv }; }; @@ -215,18 +217,18 @@ struct ei_functor_traits<ei_scalar_quotient_op<Scalar> > { * * \sa class CwiseUnaryOp, MatrixBase::operator- */ -template<typename Scalar> struct ei_scalar_opposite_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_opposite_op) +template<typename Scalar> struct scalar_opposite_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_opposite_op) EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return -a; } template<typename Packet> EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const - { return ei_pnegate(a); } + { return internal::pnegate(a); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_opposite_op<Scalar> > +struct functor_traits<scalar_opposite_op<Scalar> > { enum { Cost = NumTraits<Scalar>::AddCost, - PacketAccess = ei_packet_traits<Scalar>::HasNegate }; + PacketAccess = packet_traits<Scalar>::HasNegate }; }; /** \internal @@ -234,20 +236,20 @@ struct ei_functor_traits<ei_scalar_opposite_op<Scalar> > * * \sa class CwiseUnaryOp, Cwise::abs */ -template<typename Scalar> struct ei_scalar_abs_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_abs_op) +template<typename Scalar> struct scalar_abs_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_abs_op) typedef typename NumTraits<Scalar>::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<typename Packet> EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const - { return ei_pabs(a); } + { return internal::pabs(a); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_abs_op<Scalar> > +struct functor_traits<scalar_abs_op<Scalar> > { enum { Cost = NumTraits<Scalar>::AddCost, - PacketAccess = ei_packet_traits<Scalar>::HasAbs + PacketAccess = packet_traits<Scalar>::HasAbs }; }; @@ -256,35 +258,35 @@ struct ei_functor_traits<ei_scalar_abs_op<Scalar> > * * \sa class CwiseUnaryOp, Cwise::abs2 */ -template<typename Scalar> struct ei_scalar_abs2_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_abs2_op) +template<typename Scalar> struct scalar_abs2_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_abs2_op) typedef typename NumTraits<Scalar>::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<typename Packet> EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const - { return ei_pmul(a,a); } + { return internal::pmul(a,a); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_abs2_op<Scalar> > -{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = ei_packet_traits<Scalar>::HasAbs2 }; }; +struct functor_traits<scalar_abs2_op<Scalar> > +{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasAbs2 }; }; /** \internal * \brief Template functor to compute the conjugate of a complex value * * \sa class CwiseUnaryOp, MatrixBase::conjugate() */ -template<typename Scalar> 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<typename Scalar> 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<typename Packet> - 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<typename Scalar> -struct ei_functor_traits<ei_scalar_conjugate_op<Scalar> > +struct functor_traits<scalar_conjugate_op<Scalar> > { enum { Cost = NumTraits<Scalar>::IsComplex ? NumTraits<Scalar>::AddCost : 0, - PacketAccess = ei_packet_traits<Scalar>::HasConj + PacketAccess = packet_traits<Scalar>::HasConj }; }; @@ -294,14 +296,14 @@ struct ei_functor_traits<ei_scalar_conjugate_op<Scalar> > * \sa class CwiseUnaryOp, MatrixBase::cast() */ template<typename Scalar, typename NewType> -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<Scalar, NewType>(a); } + EIGEN_STRONG_INLINE const NewType operator() (const Scalar& a) const { return cast<Scalar, NewType>(a); } }; template<typename Scalar, typename NewType> -struct ei_functor_traits<ei_scalar_cast_op<Scalar,NewType> > -{ enum { Cost = ei_is_same_type<Scalar, NewType>::ret ? 0 : NumTraits<NewType>::AddCost, PacketAccess = false }; }; +struct functor_traits<scalar_cast_op<Scalar,NewType> > +{ enum { Cost = is_same_type<Scalar, NewType>::ret ? 0 : NumTraits<NewType>::AddCost, PacketAccess = false }; }; /** \internal * \brief Template functor to extract the real part of a complex @@ -309,13 +311,13 @@ struct ei_functor_traits<ei_scalar_cast_op<Scalar,NewType> > * \sa class CwiseUnaryOp, MatrixBase::real() */ template<typename Scalar> -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<Scalar>::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<typename Scalar> -struct ei_functor_traits<ei_scalar_real_op<Scalar> > +struct functor_traits<scalar_real_op<Scalar> > { enum { Cost = 0, PacketAccess = false }; }; /** \internal @@ -324,13 +326,13 @@ struct ei_functor_traits<ei_scalar_real_op<Scalar> > * \sa class CwiseUnaryOp, MatrixBase::imag() */ template<typename Scalar> -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<Scalar>::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<typename Scalar> -struct ei_functor_traits<ei_scalar_imag_op<Scalar> > +struct functor_traits<scalar_imag_op<Scalar> > { enum { Cost = 0, PacketAccess = false }; }; /** \internal @@ -339,13 +341,13 @@ struct ei_functor_traits<ei_scalar_imag_op<Scalar> > * \sa class CwiseUnaryOp, MatrixBase::real() */ template<typename Scalar> -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<Scalar>::Real result_type; - EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return ei_real_ref(*const_cast<Scalar*>(&a)); } + EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return real_ref(*const_cast<Scalar*>(&a)); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_real_ref_op<Scalar> > +struct functor_traits<scalar_real_ref_op<Scalar> > { enum { Cost = 0, PacketAccess = false }; }; /** \internal @@ -354,13 +356,13 @@ struct ei_functor_traits<ei_scalar_real_ref_op<Scalar> > * \sa class CwiseUnaryOp, MatrixBase::imag() */ template<typename Scalar> -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<Scalar>::Real result_type; - EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return ei_imag_ref(*const_cast<Scalar*>(&a)); } + EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return imag_ref(*const_cast<Scalar*>(&a)); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_imag_ref_op<Scalar> > +struct functor_traits<scalar_imag_ref_op<Scalar> > { enum { Cost = 0, PacketAccess = false }; }; /** \internal @@ -369,15 +371,15 @@ struct ei_functor_traits<ei_scalar_imag_ref_op<Scalar> > * * \sa class CwiseUnaryOp, Cwise::exp() */ -template<typename Scalar> 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<Scalar>::type Packet; - inline Packet packetOp(const Packet& a) const { return ei_pexp(a); } +template<typename Scalar> 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<Scalar>::type Packet; + inline Packet packetOp(const Packet& a) const { return internal::pexp(a); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_exp_op<Scalar> > -{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = ei_packet_traits<Scalar>::HasExp }; }; +struct functor_traits<scalar_exp_op<Scalar> > +{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasExp }; }; /** \internal * @@ -385,81 +387,81 @@ struct ei_functor_traits<ei_scalar_exp_op<Scalar> > * * \sa class CwiseUnaryOp, Cwise::log() */ -template<typename Scalar> 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<Scalar>::type Packet; - inline Packet packetOp(const Packet& a) const { return ei_plog(a); } +template<typename Scalar> 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<Scalar>::type Packet; + inline Packet packetOp(const Packet& a) const { return internal::plog(a); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_log_op<Scalar> > -{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = ei_packet_traits<Scalar>::HasLog }; }; +struct functor_traits<scalar_log_op<Scalar> > +{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::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<typename Scalar> -struct ei_scalar_multiple_op { - typedef typename ei_packet_traits<Scalar>::type Packet; +struct scalar_multiple_op { + typedef typename packet_traits<Scalar>::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<Packet>(m_other)); } - typename ei_makeconst<typename NumTraits<Scalar>::Nested>::type m_other; + { return internal::pmul(a, pset1<Packet>(m_other)); } + typename makeconst<typename NumTraits<Scalar>::Nested>::type m_other; }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_multiple_op<Scalar> > -{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = ei_packet_traits<Scalar>::HasMul }; }; +struct functor_traits<scalar_multiple_op<Scalar> > +{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; }; template<typename Scalar1, typename Scalar2> -struct ei_scalar_multiple2_op { - typedef typename ei_scalar_product_traits<Scalar1,Scalar2>::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<Scalar1,Scalar2>::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<typename NumTraits<Scalar2>::Nested>::type m_other; + typename makeconst<typename NumTraits<Scalar2>::Nested>::type m_other; }; template<typename Scalar1,typename Scalar2> -struct ei_functor_traits<ei_scalar_multiple2_op<Scalar1,Scalar2> > +struct functor_traits<scalar_multiple2_op<Scalar1,Scalar2> > { enum { Cost = NumTraits<Scalar1>::MulCost, PacketAccess = false }; }; template<typename Scalar, bool IsInteger> -struct ei_scalar_quotient1_impl { - typedef typename ei_packet_traits<Scalar>::type Packet; +struct scalar_quotient1_impl { + typedef typename packet_traits<Scalar>::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<Scalar>(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<Scalar>(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<Packet>(m_other)); } + { return internal::pmul(a, pset1<Packet>(m_other)); } const Scalar m_other; }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_quotient1_impl<Scalar,false> > -{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = ei_packet_traits<Scalar>::HasMul }; }; +struct functor_traits<scalar_quotient1_impl<Scalar,false> > +{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; }; template<typename Scalar> -struct ei_scalar_quotient1_impl<Scalar,true> { +struct scalar_quotient1_impl<Scalar,true> { // 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<typename NumTraits<Scalar>::Nested>::type m_other; + typename makeconst<typename NumTraits<Scalar>::Nested>::type m_other; }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_quotient1_impl<Scalar,true> > +struct functor_traits<scalar_quotient1_impl<Scalar,true> > { enum { Cost = 2 * NumTraits<Scalar>::MulCost, PacketAccess = false }; }; /** \internal @@ -471,43 +473,43 @@ struct ei_functor_traits<ei_scalar_quotient1_impl<Scalar,true> > * \sa class CwiseUnaryOp, MatrixBase::operator/ */ template<typename Scalar> -struct ei_scalar_quotient1_op : ei_scalar_quotient1_impl<Scalar, NumTraits<Scalar>::IsInteger > { - EIGEN_STRONG_INLINE ei_scalar_quotient1_op(const Scalar& other) - : ei_scalar_quotient1_impl<Scalar, NumTraits<Scalar>::IsInteger >(other) {} +struct scalar_quotient1_op : scalar_quotient1_impl<Scalar, NumTraits<Scalar>::IsInteger > { + EIGEN_STRONG_INLINE scalar_quotient1_op(const Scalar& other) + : scalar_quotient1_impl<Scalar, NumTraits<Scalar>::IsInteger >(other) {} }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_quotient1_op<Scalar> > -: ei_functor_traits<ei_scalar_quotient1_impl<Scalar, NumTraits<Scalar>::IsInteger> > +struct functor_traits<scalar_quotient1_op<Scalar> > +: functor_traits<scalar_quotient1_impl<Scalar, NumTraits<Scalar>::IsInteger> > {}; // nullary functors template<typename Scalar> -struct ei_scalar_constant_op { - typedef typename ei_packet_traits<Scalar>::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<Scalar>::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<typename Index> EIGEN_STRONG_INLINE const Scalar operator() (Index, Index = 0) const { return m_other; } template<typename Index> - EIGEN_STRONG_INLINE const Packet packetOp(Index, Index = 0) const { return ei_pset1<Packet>(m_other); } + EIGEN_STRONG_INLINE const Packet packetOp(Index, Index = 0) const { return internal::pset1<Packet>(m_other); } const Scalar m_other; }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_constant_op<Scalar> > +struct functor_traits<scalar_constant_op<Scalar> > // FIXME replace this packet test by a safe one -{ enum { Cost = 1, PacketAccess = ei_packet_traits<Scalar>::Vectorizable, IsRepeatable = true }; }; +{ enum { Cost = 1, PacketAccess = packet_traits<Scalar>::Vectorizable, IsRepeatable = true }; }; -template<typename Scalar> struct ei_scalar_identity_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_identity_op) +template<typename Scalar> struct scalar_identity_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_identity_op) template<typename Index> EIGEN_STRONG_INLINE const Scalar operator() (Index row, Index col) const { return row==col ? Scalar(1) : Scalar(0); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_identity_op<Scalar> > +struct functor_traits<scalar_identity_op<Scalar> > { enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = false, IsRepeatable = true }; }; -template <typename Scalar, bool RandomAccess> struct ei_linspaced_op_impl; +template <typename Scalar, bool RandomAccess> struct linspaced_op_impl; // linear access for packet ops: // 1) initialization @@ -515,19 +517,19 @@ template <typename Scalar, bool RandomAccess> struct ei_linspaced_op_impl; // 2) each step // base += [size*step, ..., size*step] template <typename Scalar> -struct ei_linspaced_op_impl<Scalar,false> +struct linspaced_op_impl<Scalar,false> { - typedef typename ei_packet_traits<Scalar>::type Packet; + typedef typename packet_traits<Scalar>::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<Packet>(ei_packet_traits<Scalar>::size*step)), - m_base(ei_padd(ei_pset1<Packet>(low),ei_pmul(ei_pset1<Packet>(step),ei_plset<Scalar>(-ei_packet_traits<Scalar>::size)))) {} + m_packetStep(pset1<Packet>(packet_traits<Scalar>::size*step)), + m_base(padd(pset1<Packet>(low),pmul(pset1<Packet>(step),plset<Scalar>(-packet_traits<Scalar>::size)))) {} template<typename Index> EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return m_low+i*m_step; } template<typename Index> - 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<Scalar,false> // 1) each step // [low, ..., low] + ( [step, ..., step] * ( [i, ..., i] + [0, ..., size] ) ) template <typename Scalar> -struct ei_linspaced_op_impl<Scalar,true> +struct linspaced_op_impl<Scalar,true> { - typedef typename ei_packet_traits<Scalar>::type Packet; + typedef typename packet_traits<Scalar>::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<Packet>(m_low)), m_stepPacket(ei_pset1<Packet>(m_step)), m_interPacket(ei_plset<Scalar>(0)) {} + m_lowPacket(pset1<Packet>(m_low)), m_stepPacket(pset1<Packet>(m_step)), m_interPacket(plset<Scalar>(0)) {} template<typename Index> EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return m_low+i*m_step; } template<typename Index> EIGEN_STRONG_INLINE const Packet packetOp(Index i) const - { return ei_padd(m_lowPacket, ei_pmul(m_stepPacket, ei_padd(ei_pset1<Packet>(i),m_interPacket))); } + { return internal::padd(m_lowPacket, pmul(m_stepPacket, padd(pset1<Packet>(i),m_interPacket))); } const Scalar m_low; const Scalar m_step; @@ -566,13 +568,13 @@ struct ei_linspaced_op_impl<Scalar,true> // 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 <typename Scalar, bool RandomAccess = true> struct ei_linspaced_op; -template <typename Scalar, bool RandomAccess> struct ei_functor_traits< ei_linspaced_op<Scalar,RandomAccess> > -{ enum { Cost = 1, PacketAccess = ei_packet_traits<Scalar>::HasSetLinear, IsRepeatable = true }; }; -template <typename Scalar, bool RandomAccess> struct ei_linspaced_op +template <typename Scalar, bool RandomAccess = true> struct linspaced_op; +template <typename Scalar, bool RandomAccess> struct functor_traits< linspaced_op<Scalar,RandomAccess> > +{ enum { Cost = 1, PacketAccess = packet_traits<Scalar>::HasSetLinear, IsRepeatable = true }; }; +template <typename Scalar, bool RandomAccess> struct linspaced_op { - typedef typename ei_packet_traits<Scalar>::type Packet; - ei_linspaced_op(Scalar low, Scalar high, int num_steps) : impl(low, (high-low)/(num_steps-1)) {} + typedef typename packet_traits<Scalar>::type Packet; + linspaced_op(Scalar low, Scalar high, int num_steps) : impl(low, (high-low)/(num_steps-1)) {} template<typename Index> EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return impl(i); } @@ -582,7 +584,7 @@ template <typename Scalar, bool RandomAccess> struct ei_linspaced_op template<typename Index> 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 <typename Scalar, bool RandomAccess> struct ei_linspaced_op template<typename Index> 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<Scalar,RandomAccess> impl; + const linspaced_op_impl<Scalar,RandomAccess> 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<typename Functor> struct ei_functor_has_linear_access { enum { ret = 1 }; }; -template<typename Scalar> struct ei_functor_has_linear_access<ei_scalar_identity_op<Scalar> > { enum { ret = 0 }; }; +// scalar_identity_op. +// FIXME move this to functor_traits adding a functor_default +template<typename Functor> struct functor_has_linear_access { enum { ret = 1 }; }; +template<typename Scalar> struct functor_has_linear_access<scalar_identity_op<Scalar> > { 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<float>. -// FIXME move this to ei_functor_traits adding a ei_functor_default -template<typename Functor> struct ei_functor_allows_mixing_real_and_complex { enum { ret = 0 }; }; -template<typename LhsScalar,typename RhsScalar> struct ei_functor_allows_mixing_real_and_complex<ei_scalar_product_op<LhsScalar,RhsScalar> > { enum { ret = 1 }; }; +// FIXME move this to functor_traits adding a functor_default +template<typename Functor> struct functor_allows_mixing_real_and_complex { enum { ret = 0 }; }; +template<typename LhsScalar,typename RhsScalar> struct functor_allows_mixing_real_and_complex<scalar_product_op<LhsScalar,RhsScalar> > { 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<typename Scalar> -struct ei_scalar_add_op { - typedef typename ei_packet_traits<Scalar>::type Packet; +struct scalar_add_op { + typedef typename packet_traits<Scalar>::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<Packet>(m_other)); } + { return internal::padd(a, pset1<Packet>(m_other)); } const Scalar m_other; }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_add_op<Scalar> > -{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = ei_packet_traits<Scalar>::HasAdd }; }; +struct functor_traits<scalar_add_op<Scalar> > +{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = packet_traits<Scalar>::HasAdd }; }; /** \internal * \brief Template functor to compute the square root of a scalar * \sa class CwiseUnaryOp, Cwise::sqrt() */ -template<typename Scalar> 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<Scalar>::type Packet; - inline Packet packetOp(const Packet& a) const { return ei_psqrt(a); } +template<typename Scalar> 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<Scalar>::type Packet; + inline Packet packetOp(const Packet& a) const { return internal::psqrt(a); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_sqrt_op<Scalar> > +struct functor_traits<scalar_sqrt_op<Scalar> > { enum { Cost = 5 * NumTraits<Scalar>::MulCost, - PacketAccess = ei_packet_traits<Scalar>::HasSqrt + PacketAccess = packet_traits<Scalar>::HasSqrt }; }; @@ -660,18 +662,18 @@ struct ei_functor_traits<ei_scalar_sqrt_op<Scalar> > * \brief Template functor to compute the cosine of a scalar * \sa class CwiseUnaryOp, Cwise::cos() */ -template<typename Scalar> 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<Scalar>::type Packet; - inline Packet packetOp(const Packet& a) const { return ei_pcos(a); } +template<typename Scalar> 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<Scalar>::type Packet; + inline Packet packetOp(const Packet& a) const { return internal::pcos(a); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_cos_op<Scalar> > +struct functor_traits<scalar_cos_op<Scalar> > { enum { Cost = 5 * NumTraits<Scalar>::MulCost, - PacketAccess = ei_packet_traits<Scalar>::HasCos + PacketAccess = packet_traits<Scalar>::HasCos }; }; @@ -679,18 +681,18 @@ struct ei_functor_traits<ei_scalar_cos_op<Scalar> > * \brief Template functor to compute the sine of a scalar * \sa class CwiseUnaryOp, Cwise::sin() */ -template<typename Scalar> 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<Scalar>::type Packet; - inline Packet packetOp(const Packet& a) const { return ei_psin(a); } +template<typename Scalar> 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<Scalar>::type Packet; + inline Packet packetOp(const Packet& a) const { return internal::psin(a); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_sin_op<Scalar> > +struct functor_traits<scalar_sin_op<Scalar> > { enum { Cost = 5 * NumTraits<Scalar>::MulCost, - PacketAccess = ei_packet_traits<Scalar>::HasSin + PacketAccess = packet_traits<Scalar>::HasSin }; }; @@ -699,15 +701,15 @@ struct ei_functor_traits<ei_scalar_sin_op<Scalar> > * \sa class CwiseUnaryOp, Cwise::pow */ template<typename Scalar> -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<typename Scalar> -struct ei_functor_traits<ei_scalar_pow_op<Scalar> > +struct functor_traits<scalar_pow_op<Scalar> > { enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false }; }; /** \internal @@ -715,155 +717,157 @@ struct ei_functor_traits<ei_scalar_pow_op<Scalar> > * \sa class CwiseUnaryOp, Cwise::inverse() */ template<typename Scalar> -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<typename Packet> inline const Packet packetOp(const Packet& a) const - { return ei_pdiv(ei_pset1<Packet>(Scalar(1)),a); } + { return internal::pdiv(pset1<Packet>(Scalar(1)),a); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_inverse_op<Scalar> > -{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = ei_packet_traits<Scalar>::HasDiv }; }; +struct functor_traits<scalar_inverse_op<Scalar> > +{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasDiv }; }; /** \internal * \brief Template functor to compute the square of a scalar * \sa class CwiseUnaryOp, Cwise::square() */ template<typename Scalar> -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<typename Packet> inline const Packet packetOp(const Packet& a) const - { return ei_pmul(a,a); } + { return internal::pmul(a,a); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_square_op<Scalar> > -{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = ei_packet_traits<Scalar>::HasMul }; }; +struct functor_traits<scalar_square_op<Scalar> > +{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; }; /** \internal * \brief Template functor to compute the cube of a scalar * \sa class CwiseUnaryOp, Cwise::cube() */ template<typename Scalar> -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<typename Packet> inline const Packet packetOp(const Packet& a) const - { return ei_pmul(a,ei_pmul(a,a)); } + { return internal::pmul(a,pmul(a,a)); } }; template<typename Scalar> -struct ei_functor_traits<ei_scalar_cube_op<Scalar> > -{ enum { Cost = 2*NumTraits<Scalar>::MulCost, PacketAccess = ei_packet_traits<Scalar>::HasMul }; }; +struct functor_traits<scalar_cube_op<Scalar> > +{ enum { Cost = 2*NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasMul }; }; // default functor traits for STL functors: template<typename T> -struct ei_functor_traits<std::multiplies<T> > +struct functor_traits<std::multiplies<T> > { enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::divides<T> > +struct functor_traits<std::divides<T> > { enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::plus<T> > +struct functor_traits<std::plus<T> > { enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::minus<T> > +struct functor_traits<std::minus<T> > { enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::negate<T> > +struct functor_traits<std::negate<T> > { enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::logical_or<T> > +struct functor_traits<std::logical_or<T> > { enum { Cost = 1, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::logical_and<T> > +struct functor_traits<std::logical_and<T> > { enum { Cost = 1, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::logical_not<T> > +struct functor_traits<std::logical_not<T> > { enum { Cost = 1, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::greater<T> > +struct functor_traits<std::greater<T> > { enum { Cost = 1, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::less<T> > +struct functor_traits<std::less<T> > { enum { Cost = 1, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::greater_equal<T> > +struct functor_traits<std::greater_equal<T> > { enum { Cost = 1, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::less_equal<T> > +struct functor_traits<std::less_equal<T> > { enum { Cost = 1, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::equal_to<T> > +struct functor_traits<std::equal_to<T> > { enum { Cost = 1, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::not_equal_to<T> > +struct functor_traits<std::not_equal_to<T> > { enum { Cost = 1, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::binder2nd<T> > -{ enum { Cost = ei_functor_traits<T>::Cost, PacketAccess = false }; }; +struct functor_traits<std::binder2nd<T> > +{ enum { Cost = functor_traits<T>::Cost, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::binder1st<T> > -{ enum { Cost = ei_functor_traits<T>::Cost, PacketAccess = false }; }; +struct functor_traits<std::binder1st<T> > +{ enum { Cost = functor_traits<T>::Cost, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::unary_negate<T> > -{ enum { Cost = 1 + ei_functor_traits<T>::Cost, PacketAccess = false }; }; +struct functor_traits<std::unary_negate<T> > +{ enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess = false }; }; template<typename T> -struct ei_functor_traits<std::binary_negate<T> > -{ enum { Cost = 1 + ei_functor_traits<T>::Cost, PacketAccess = false }; }; +struct functor_traits<std::binary_negate<T> > +{ enum { Cost = 1 + functor_traits<T>::Cost, PacketAccess = false }; }; #ifdef EIGEN_STDEXT_SUPPORT template<typename T0,typename T1> -struct ei_functor_traits<std::project1st<T0,T1> > +struct functor_traits<std::project1st<T0,T1> > { enum { Cost = 0, PacketAccess = false }; }; template<typename T0,typename T1> -struct ei_functor_traits<std::project2nd<T0,T1> > +struct functor_traits<std::project2nd<T0,T1> > { enum { Cost = 0, PacketAccess = false }; }; template<typename T0,typename T1> -struct ei_functor_traits<std::select2nd<std::pair<T0,T1> > > +struct functor_traits<std::select2nd<std::pair<T0,T1> > > { enum { Cost = 0, PacketAccess = false }; }; template<typename T0,typename T1> -struct ei_functor_traits<std::select1st<std::pair<T0,T1> > > +struct functor_traits<std::select1st<std::pair<T0,T1> > > { enum { Cost = 0, PacketAccess = false }; }; template<typename T0,typename T1> -struct ei_functor_traits<std::unary_compose<T0,T1> > -{ enum { Cost = ei_functor_traits<T0>::Cost + ei_functor_traits<T1>::Cost, PacketAccess = false }; }; +struct functor_traits<std::unary_compose<T0,T1> > +{ enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost, PacketAccess = false }; }; template<typename T0,typename T1,typename T2> -struct ei_functor_traits<std::binary_compose<T0,T1,T2> > -{ enum { Cost = ei_functor_traits<T0>::Cost + ei_functor_traits<T1>::Cost + ei_functor_traits<T2>::Cost, PacketAccess = false }; }; +struct functor_traits<std::binary_compose<T0,T1,T2> > +{ enum { Cost = functor_traits<T0>::Cost + functor_traits<T1>::Cost + functor_traits<T2>::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<typename Derived> template<typename OtherDerived> @@ -54,10 +52,10 @@ bool DenseBase<Derived>::isApprox( RealScalar prec ) const { - const typename ei_nested<Derived,2>::type nested(derived()); - const typename ei_nested<OtherDerived,2>::type otherNested(other.derived()); -// std::cerr << typeid(Derived).name() << " => " << typeid(typename ei_nested<Derived,2>::type).name() << "\n"; -// std::cerr << typeid(OtherDerived).name() << " => " << typeid(typename ei_nested<OtherDerived,2>::type).name() << "\n"; + const typename internal::nested<Derived,2>::type nested(derived()); + const typename internal::nested<OtherDerived,2>::type otherNested(other.derived()); +// std::cerr << typeid(Derived).name() << " => " << typeid(typename internal::nested<Derived,2>::type).name() << "\n"; +// std::cerr << typeid(OtherDerived).name() << " => " << typeid(typename internal::nested<OtherDerived,2>::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<Derived>::isMuchSmallerThan( return derived().cwiseAbs2().sum() <= prec * prec * other.derived().cwiseAbs2().sum(); } -#else - -template<typename Derived, typename OtherDerived=Derived, bool IsVector=Derived::IsVectorAtCompileTime> -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<typename Derived> -template<typename OtherDerived> -bool DenseBase<Derived>::isApprox( - const DenseBase<OtherDerived>& other, - RealScalar prec -) const -{ - return ei_fuzzy_selector<Derived,OtherDerived>::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<OtherDerived>&, RealScalar) const - */ -template<typename Derived> -bool DenseBase<Derived>::isMuchSmallerThan( - const typename NumTraits<Scalar>::Real& other, - RealScalar prec -) const -{ - return ei_fuzzy_selector<Derived>::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<typename Derived> -template<typename OtherDerived> -bool DenseBase<Derived>::isMuchSmallerThan( - const DenseBase<OtherDerived>& other, - RealScalar prec -) const -{ - return ei_fuzzy_selector<Derived,OtherDerived>::isMuchSmallerThan(derived(), other.derived(), prec); -} - - -template<typename Derived, typename OtherDerived> -struct ei_fuzzy_selector<Derived,OtherDerived,true> -{ - 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<typename Derived, typename OtherDerived> -struct ei_fuzzy_selector<Derived,OtherDerived,false> -{ - 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<typename T> struct ei_packet_traits : ei_default_packet_traits +template<typename T> struct packet_traits : default_packet_traits { typedef T type; enum { @@ -103,92 +105,92 @@ template<typename T> struct ei_packet_traits : ei_default_packet_traits /** \internal \returns a + b (coeff-wise) */ template<typename Packet> inline Packet -ei_padd(const Packet& a, +padd(const Packet& a, const Packet& b) { return a+b; } /** \internal \returns a - b (coeff-wise) */ template<typename Packet> inline Packet -ei_psub(const Packet& a, +psub(const Packet& a, const Packet& b) { return a-b; } /** \internal \returns -a (coeff-wise) */ template<typename Packet> inline Packet -ei_pnegate(const Packet& a) { return -a; } +pnegate(const Packet& a) { return -a; } /** \internal \returns conj(a) (coeff-wise) */ template<typename Packet> 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<typename Packet> inline Packet -ei_pmul(const Packet& a, +pmul(const Packet& a, const Packet& b) { return a*b; } /** \internal \returns a / b (coeff-wise) */ template<typename Packet> 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<typename Packet> 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<typename Packet> 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<typename Packet> 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<typename Packet> 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<typename Packet> 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<typename Packet> 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<typename Packet> 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<typename Packet> inline Packet -ei_pload(const typename ei_unpacket_traits<Packet>::type* from) { return *from; } +pload(const typename unpacket_traits<Packet>::type* from) { return *from; } /** \internal \returns a packet version of \a *from, (un-aligned load) */ template<typename Packet> inline Packet -ei_ploadu(const typename ei_unpacket_traits<Packet>::type* from) { return *from; } +ploadu(const typename unpacket_traits<Packet>::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<typename Packet> inline Packet -ei_ploaddup(const typename ei_unpacket_traits<Packet>::type* from) { return *from; } +ploaddup(const typename unpacket_traits<Packet>::type* from) { return *from; } /** \internal \returns a packet with constant coefficients \a a, e.g.: (a,a,a,a) */ template<typename Packet> inline Packet -ei_pset1(const typename ei_unpacket_traits<Packet>::type& a) { return a; } +pset1(const typename unpacket_traits<Packet>::type& a) { return a; } /** \internal \brief Returns a packet with coefficients (a,a+1,...,a+packet_size-1). */ -template<typename Scalar> inline typename ei_packet_traits<Scalar>::type -ei_plset(const Scalar& a) { return a; } +template<typename Scalar> inline typename packet_traits<Scalar>::type +plset(const Scalar& a) { return a; } /** \internal copy the packet \a from to \a *to, \a to must be 16 bytes aligned */ -template<typename Scalar, typename Packet> inline void ei_pstore(Scalar* to, const Packet& from) +template<typename Scalar, typename Packet> inline void pstore(Scalar* to, const Packet& from) { (*to) = from; } /** \internal copy the packet \a from to \a *to, (un-aligned store) */ -template<typename Scalar, typename Packet> inline void ei_pstoreu(Scalar* to, const Packet& from) +template<typename Scalar, typename Packet> inline void pstoreu(Scalar* to, const Packet& from) { (*to) = from; } /** \internal tries to do cache prefetching of \a addr */ -template<typename Scalar> inline void ei_prefetch(const Scalar* addr) +template<typename Scalar> 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<typename Packet> inline typename ei_unpacket_traits<Packet>::type ei_pfirst(const Packet& a) +template<typename Packet> inline typename unpacket_traits<Packet>::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<typename Packet> 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<typename Packet> inline typename ei_unpacket_traits<Packet>::type ei_predux(const Packet& a) +template<typename Packet> inline typename unpacket_traits<Packet>::type predux(const Packet& a) { return a; } /** \internal \returns the product of the elements of \a a*/ -template<typename Packet> inline typename ei_unpacket_traits<Packet>::type ei_predux_mul(const Packet& a) +template<typename Packet> inline typename unpacket_traits<Packet>::type predux_mul(const Packet& a) { return a; } /** \internal \returns the min of the elements of \a a*/ -template<typename Packet> inline typename ei_unpacket_traits<Packet>::type ei_predux_min(const Packet& a) +template<typename Packet> inline typename unpacket_traits<Packet>::type predux_min(const Packet& a) { return a; } /** \internal \returns the max of the elements of \a a*/ -template<typename Packet> inline typename ei_unpacket_traits<Packet>::type ei_predux_max(const Packet& a) +template<typename Packet> inline typename unpacket_traits<Packet>::type predux_max(const Packet& a) { return a; } /** \internal \returns the reversed elements of \a a*/ -template<typename Packet> inline Packet ei_preverse(const Packet& a) +template<typename Packet> inline Packet preverse(const Packet& a) { return a; } /************************** @@ -229,23 +231,23 @@ template<typename Packet> inline Packet ei_preverse(const Packet& a) /** \internal \returns the sin of \a a (coeff-wise) */ template<typename Packet> 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<typename Packet> 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<typename Packet> 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<typename Packet> 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<typename Packet> 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<typename Packet> 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<typename Packet, int LoadMode> -inline Packet ei_ploadt(const typename ei_unpacket_traits<Packet>::type* from) +inline Packet ploadt(const typename unpacket_traits<Packet>::type* from) { if(LoadMode == Aligned) - return ei_pload<Packet>(from); + return pload<Packet>(from); else - return ei_ploadu<Packet>(from); + return ploadu<Packet>(from); } /** \internal copy the packet \a from to \a *to. * If StoreMode equals Aligned, \a to must be 16 bytes aligned */ template<typename Scalar, typename Packet, int LoadMode> -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<int Offset,typename PacketType> -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<int Offset,typename PacketType> -inline void ei_palign(PacketType& first, const PacketType& second) +inline void palign(PacketType& first, const PacketType& second) { - ei_palign_impl<Offset,PacketType>::run(first,second); + palign_impl<Offset,PacketType>::run(first,second); } /*************************************************************************** * Fast complex products (GCC generates a function call which is very slow) ***************************************************************************/ -template<> inline std::complex<float> ei_pmul(const std::complex<float>& a, const std::complex<float>& b) -{ return std::complex<float>(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<float> pmul(const std::complex<float>& a, const std::complex<float>& b) +{ return std::complex<float>(real(a)*real(b) - imag(a)*imag(b), imag(a)*real(b) + real(a)*imag(b)); } + +template<> inline std::complex<double> pmul(const std::complex<double>& a, const std::complex<double>& b) +{ return std::complex<double>(real(a)*real(b) - imag(a)*imag(b), imag(a)*real(b) + real(a)*imag(b)); } -template<> inline std::complex<double> ei_pmul(const std::complex<double>& a, const std::complex<double>& b) -{ return std::complex<double>(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<typename Derived> \ - inline const Eigen::CwiseUnaryOp<Eigen::FUNCTOR<typename Derived::Scalar>, Derived> \ + inline const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, Derived> \ NAME(const Eigen::ArrayBase<Derived>& x) { \ return x.derived(); \ } @@ -38,7 +38,7 @@ template<typename Derived> \ struct NAME##_retval<ArrayBase<Derived> > \ { \ - typedef const Eigen::CwiseUnaryOp<Eigen::FUNCTOR<typename Derived::Scalar>, Derived> type; \ + typedef const Eigen::CwiseUnaryOp<Eigen::internal::FUNCTOR<typename Derived::Scalar>, Derived> type; \ }; \ template<typename Derived> \ struct NAME##_impl<ArrayBase<Derived> > \ @@ -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<typename Derived> - inline const Eigen::CwiseUnaryOp<Eigen::ei_scalar_pow_op<typename Derived::Scalar>, Derived> + inline const Eigen::CwiseUnaryOp<Eigen::internal::scalar_pow_op<typename Derived::Scalar>, Derived> pow(const Eigen::ArrayBase<Derived>& 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<typename Derived> +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<Derived>::format(const IOFormat& fmt) const return WithFormat<Derived>(derived(), fmt); } +namespace internal { + template<typename Scalar, bool IsInteger> -struct ei_significant_decimals_default_impl +struct significant_decimals_default_impl { typedef typename NumTraits<Scalar>::Real RealScalar; static inline int run() { - return ei_cast<RealScalar,int>(std::ceil(-ei_log(NumTraits<RealScalar>::epsilon())/ei_log(RealScalar(10)))); + return cast<RealScalar,int>(std::ceil(-log(NumTraits<RealScalar>::epsilon())/log(RealScalar(10)))); } }; template<typename Scalar> -struct ei_significant_decimals_default_impl<Scalar, true> +struct significant_decimals_default_impl<Scalar, true> { static inline int run() { @@ -148,14 +155,14 @@ struct ei_significant_decimals_default_impl<Scalar, true> }; template<typename Scalar> -struct ei_significant_decimals_impl - : ei_significant_decimals_default_impl<Scalar, NumTraits<Scalar>::IsInteger> +struct significant_decimals_impl + : significant_decimals_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; /** \internal * print the matrix \a _m to the output stream \a s using the output format \a fmt */ template<typename Derived> -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<Scalar>::run(); + explicit_precision = significant_decimals_impl<Scalar>::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<Derived> & 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<typename PlainObjectType, int MapOptions, typename StrideType> -struct ei_traits<Map<PlainObjectType, MapOptions, StrideType> > - : public ei_traits<PlainObjectType> +struct traits<Map<PlainObjectType, MapOptions, StrideType> > + : public traits<PlainObjectType> { typedef typename PlainObjectType::Index Index; typedef typename PlainObjectType::Scalar Scalar; @@ -99,7 +101,7 @@ struct ei_traits<Map<PlainObjectType, MapOptions, StrideType> > || HasNoOuterStride || ( OuterStrideAtCompileTime!=Dynamic && ((static_cast<int>(sizeof(Scalar))*OuterStrideAtCompileTime)%16)==0 ) ), - Flags0 = ei_traits<PlainObjectType>::Flags, + Flags0 = traits<PlainObjectType>::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<Map<PlainObjectType, MapOptions, StrideType> > private: enum { Options }; // Expressions don't support Options }; +} template<typename PlainObjectType, int MapOptions, typename StrideType> class Map : public MapBase<Map<PlainObjectType, MapOptions, StrideType> > 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<typename Derived> class MapBase - : public ei_dense_xpr_base<Derived>::type + : public internal::dense_xpr_base<Derived>::type { public: - typedef typename ei_dense_xpr_base<Derived>::type Base; + typedef typename internal::dense_xpr_base<Derived>::type Base; enum { - RowsAtCompileTime = ei_traits<Derived>::RowsAtCompileTime, - ColsAtCompileTime = ei_traits<Derived>::ColsAtCompileTime, + RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime, + ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime, SizeAtCompileTime = Base::SizeAtCompileTime }; - typedef typename ei_traits<Derived>::StorageKind StorageKind; - typedef typename ei_traits<Derived>::Index Index; - typedef typename ei_traits<Derived>::Scalar Scalar; - typedef typename ei_packet_traits<Scalar>::type PacketScalar; + typedef typename internal::traits<Derived>::StorageKind StorageKind; + typedef typename internal::traits<Derived>::Index Index; + typedef typename internal::traits<Derived>::Scalar Scalar; + typedef typename internal::packet_traits<Scalar>::type PacketScalar; typedef typename NumTraits<Scalar>::Real RealScalar; using Base::derived; @@ -111,40 +111,40 @@ template<typename Derived> class MapBase inline const Scalar& coeff(Index index) const { - ei_assert(Derived::IsVectorAtCompileTime || (ei_traits<Derived>::Flags & LinearAccessBit)); + eigen_assert(Derived::IsVectorAtCompileTime || (internal::traits<Derived>::Flags & LinearAccessBit)); return m_data[index * innerStride()]; } inline Scalar& coeffRef(Index index) { - ei_assert(Derived::IsVectorAtCompileTime || (ei_traits<Derived>::Flags & LinearAccessBit)); + eigen_assert(Derived::IsVectorAtCompileTime || (internal::traits<Derived>::Flags & LinearAccessBit)); return const_cast<Scalar*>(m_data)[index * innerStride()]; } template<int LoadMode> inline PacketScalar packet(Index row, Index col) const { - return ei_ploadt<PacketScalar, LoadMode> + return internal::ploadt<PacketScalar, LoadMode> (m_data + (col * colStride() + row * rowStride())); } template<int LoadMode> inline PacketScalar packet(Index index) const { - return ei_ploadt<PacketScalar, LoadMode>(m_data + index * innerStride()); + return internal::ploadt<PacketScalar, LoadMode>(m_data + index * innerStride()); } template<int StoreMode> inline void writePacket(Index row, Index col, const PacketScalar& x) { - ei_pstoret<Scalar, PacketScalar, StoreMode> + internal::pstoret<Scalar, PacketScalar, StoreMode> (const_cast<Scalar*>(m_data) + (col * colStride() + row * rowStride()), x); } template<int StoreMode> inline void writePacket(Index index, const PacketScalar& x) { - ei_pstoret<Scalar, PacketScalar, StoreMode> + internal::pstoret<Scalar, PacketScalar, StoreMode> (const_cast<Scalar*>(m_data) + index * innerStride(), x); } @@ -160,15 +160,15 @@ template<typename Derived> 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<typename Derived> class MapBase void checkSanity() const { - EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(ei_traits<Derived>::Flags&PacketAccessBit, - ei_inner_stride_at_compile_time<Derived>::ret==1), + EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(internal::traits<Derived>::Flags&PacketAccessBit, + internal::inner_stride_at_compile_time<Derived>::ret==1), PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1); - ei_assert(EIGEN_IMPLIES(ei_traits<Derived>::Flags&AlignedBit, (size_t(m_data) % (sizeof(Scalar)*ei_packet_traits<Scalar>::size)) == 0) + eigen_assert(EIGEN_IMPLIES(internal::traits<Derived>::Flags&AlignedBit, (size_t(m_data) % (sizeof(Scalar)*internal::packet_traits<Scalar>::size)) == 0) && "data is not aligned"); } const Scalar* EIGEN_RESTRICT m_data; - const ei_variable_if_dynamic<Index, RowsAtCompileTime> m_rows; - const ei_variable_if_dynamic<Index, ColsAtCompileTime> m_cols; + const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows; + const internal::variable_if_dynamic<Index, ColsAtCompileTime> 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<T>::type is a typedef for it. - * - otherwise, ei_global_math_functions_filtering_base<T>::type is a typedef for T. + * global_math_functions_filtering_base<T>::type is a typedef for it. + * - otherwise, global_math_functions_filtering_base<T>::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<Derived>. - * So we must make sure to use ei_sin_impl<ArrayBase<Derived> > and not ei_sin_impl<Derived>, 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<Derived>. + * So we must make sure to use sin_impl<ArrayBase<Derived> > and not sin_impl<Derived>, 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<typename T, typename dummy = void> -struct ei_global_math_functions_filtering_base +struct global_math_functions_filtering_base { typedef T type; }; -template<typename T> struct ei_always_void { typedef void type; }; +template<typename T> struct always_void { typedef void type; }; template<typename T> -struct ei_global_math_functions_filtering_base +struct global_math_functions_filtering_base <T, - typename ei_always_void<typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl>::type + typename always_void<typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl>::type > { typedef typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl type; }; -#define EIGEN_MATHFUNC_IMPL(func, scalar) ei_##func##_impl<typename ei_global_math_functions_filtering_base<scalar>::type> -#define EIGEN_MATHFUNC_RETVAL(func, scalar) typename ei_##func##_retval<typename ei_global_math_functions_filtering_base<scalar>::type>::type +#define EIGEN_MATHFUNC_IMPL(func, scalar) func##_impl<typename global_math_functions_filtering_base<scalar>::type> +#define EIGEN_MATHFUNC_RETVAL(func, scalar) typename func##_retval<typename global_math_functions_filtering_base<scalar>::type>::type /**************************************************************************** -* Implementation of ei_real * +* Implementation of real * ****************************************************************************/ template<typename Scalar> -struct ei_real_impl +struct real_impl { typedef typename NumTraits<Scalar>::Real RealScalar; static inline RealScalar run(const Scalar& x) @@ -81,7 +83,7 @@ struct ei_real_impl }; template<typename RealScalar> -struct ei_real_impl<std::complex<RealScalar> > +struct real_impl<std::complex<RealScalar> > { static inline RealScalar run(const std::complex<RealScalar>& x) { @@ -90,23 +92,23 @@ struct ei_real_impl<std::complex<RealScalar> > }; template<typename Scalar> -struct ei_real_retval +struct real_retval { typedef typename NumTraits<Scalar>::Real type; }; template<typename Scalar> -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<typename Scalar> -struct ei_imag_impl +struct imag_impl { typedef typename NumTraits<Scalar>::Real RealScalar; static inline RealScalar run(const Scalar&) @@ -116,7 +118,7 @@ struct ei_imag_impl }; template<typename RealScalar> -struct ei_imag_impl<std::complex<RealScalar> > +struct imag_impl<std::complex<RealScalar> > { static inline RealScalar run(const std::complex<RealScalar>& x) { @@ -125,23 +127,23 @@ struct ei_imag_impl<std::complex<RealScalar> > }; template<typename Scalar> -struct ei_imag_retval +struct imag_retval { typedef typename NumTraits<Scalar>::Real type; }; template<typename Scalar> -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<typename Scalar> -struct ei_real_ref_impl +struct real_ref_impl { typedef typename NumTraits<Scalar>::Real RealScalar; static inline RealScalar& run(Scalar& x) @@ -155,29 +157,29 @@ struct ei_real_ref_impl }; template<typename Scalar> -struct ei_real_ref_retval +struct real_ref_retval { typedef typename NumTraits<Scalar>::Real & type; }; template<typename Scalar> -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<Scalar>::run(x); + return real_ref_impl<Scalar>::run(x); } template<typename Scalar> -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<typename Scalar, bool IsComplex> -struct ei_imag_ref_default_impl +struct imag_ref_default_impl { typedef typename NumTraits<Scalar>::Real RealScalar; static inline RealScalar& run(Scalar& x) @@ -191,7 +193,7 @@ struct ei_imag_ref_default_impl }; template<typename Scalar> -struct ei_imag_ref_default_impl<Scalar, false> +struct imag_ref_default_impl<Scalar, false> { static inline Scalar run(Scalar&) { @@ -204,32 +206,32 @@ struct ei_imag_ref_default_impl<Scalar, false> }; template<typename Scalar> -struct ei_imag_ref_impl : ei_imag_ref_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {}; +struct imag_ref_impl : imag_ref_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {}; template<typename Scalar> -struct ei_imag_ref_retval +struct imag_ref_retval { typedef typename NumTraits<Scalar>::Real & type; }; template<typename Scalar> -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<Scalar>::run(x); + return imag_ref_impl<Scalar>::run(x); } template<typename Scalar> -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<typename Scalar> -struct ei_conj_impl +struct conj_impl { static inline Scalar run(const Scalar& x) { @@ -238,7 +240,7 @@ struct ei_conj_impl }; template<typename RealScalar> -struct ei_conj_impl<std::complex<RealScalar> > +struct conj_impl<std::complex<RealScalar> > { static inline std::complex<RealScalar> run(const std::complex<RealScalar>& x) { @@ -247,23 +249,23 @@ struct ei_conj_impl<std::complex<RealScalar> > }; template<typename Scalar> -struct ei_conj_retval +struct conj_retval { typedef Scalar type; }; template<typename Scalar> -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<typename Scalar> -struct ei_abs_impl +struct abs_impl { typedef typename NumTraits<Scalar>::Real RealScalar; static inline RealScalar run(const Scalar& x) @@ -273,23 +275,23 @@ struct ei_abs_impl }; template<typename Scalar> -struct ei_abs_retval +struct abs_retval { typedef typename NumTraits<Scalar>::Real type; }; template<typename Scalar> -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<typename Scalar> -struct ei_abs2_impl +struct abs2_impl { typedef typename NumTraits<Scalar>::Real RealScalar; static inline RealScalar run(const Scalar& x) @@ -299,7 +301,7 @@ struct ei_abs2_impl }; template<typename RealScalar> -struct ei_abs2_impl<std::complex<RealScalar> > +struct abs2_impl<std::complex<RealScalar> > { static inline RealScalar run(const std::complex<RealScalar>& x) { @@ -308,92 +310,92 @@ struct ei_abs2_impl<std::complex<RealScalar> > }; template<typename Scalar> -struct ei_abs2_retval +struct abs2_retval { typedef typename NumTraits<Scalar>::Real type; }; template<typename Scalar> -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<typename Scalar, bool IsComplex> -struct ei_norm1_default_impl +struct norm1_default_impl { typedef typename NumTraits<Scalar>::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<typename Scalar> -struct ei_norm1_default_impl<Scalar, false> +struct norm1_default_impl<Scalar, false> { static inline Scalar run(const Scalar& x) { - return ei_abs(x); + return abs(x); } }; template<typename Scalar> -struct ei_norm1_impl : ei_norm1_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {}; +struct norm1_impl : norm1_default_impl<Scalar, NumTraits<Scalar>::IsComplex> {}; template<typename Scalar> -struct ei_norm1_retval +struct norm1_retval { typedef typename NumTraits<Scalar>::Real type; }; template<typename Scalar> -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<typename Scalar> -struct ei_hypot_impl +struct hypot_impl { typedef typename NumTraits<Scalar>::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<typename Scalar> -struct ei_hypot_retval +struct hypot_retval { typedef typename NumTraits<Scalar>::Real type; }; template<typename Scalar> -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<typename OldType, typename NewType> -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<typename OldType, typename NewType> -inline NewType ei_cast(const OldType& x) +inline NewType cast(const OldType& x) { - return ei_cast_impl<OldType, NewType>::run(x); + return cast_impl<OldType, NewType>::run(x); } /**************************************************************************** -* Implementation of ei_sqrt * +* Implementation of sqrt * ****************************************************************************/ template<typename Scalar, bool IsInteger> -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<typename Scalar> -struct ei_sqrt_default_impl<Scalar, true> +struct sqrt_default_impl<Scalar, true> { static inline Scalar run(const Scalar&) { @@ -433,26 +435,26 @@ struct ei_sqrt_default_impl<Scalar, true> }; template<typename Scalar> -struct ei_sqrt_impl : ei_sqrt_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; +struct sqrt_impl : sqrt_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; template<typename Scalar> -struct ei_sqrt_retval +struct sqrt_retval { typedef Scalar type; }; template<typename Scalar> -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<typename Scalar, bool IsInteger> -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<typename Scalar> -struct ei_exp_default_impl<Scalar, true> +struct exp_default_impl<Scalar, true> { static inline Scalar run(const Scalar&) { @@ -471,26 +473,26 @@ struct ei_exp_default_impl<Scalar, true> }; template<typename Scalar> -struct ei_exp_impl : ei_exp_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; +struct exp_impl : exp_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; template<typename Scalar> -struct ei_exp_retval +struct exp_retval { typedef Scalar type; }; template<typename Scalar> -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<typename Scalar, bool IsInteger> -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<typename Scalar> -struct ei_cos_default_impl<Scalar, true> +struct cos_default_impl<Scalar, true> { static inline Scalar run(const Scalar&) { @@ -509,26 +511,26 @@ struct ei_cos_default_impl<Scalar, true> }; template<typename Scalar> -struct ei_cos_impl : ei_cos_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; +struct cos_impl : cos_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; template<typename Scalar> -struct ei_cos_retval +struct cos_retval { typedef Scalar type; }; template<typename Scalar> -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<typename Scalar, bool IsInteger> -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<typename Scalar> -struct ei_sin_default_impl<Scalar, true> +struct sin_default_impl<Scalar, true> { static inline Scalar run(const Scalar&) { @@ -547,26 +549,26 @@ struct ei_sin_default_impl<Scalar, true> }; template<typename Scalar> -struct ei_sin_impl : ei_sin_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; +struct sin_impl : sin_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; template<typename Scalar> -struct ei_sin_retval +struct sin_retval { typedef Scalar type; }; template<typename Scalar> -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<typename Scalar, bool IsInteger> -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<typename Scalar> -struct ei_log_default_impl<Scalar, true> +struct log_default_impl<Scalar, true> { static inline Scalar run(const Scalar&) { @@ -585,26 +587,26 @@ struct ei_log_default_impl<Scalar, true> }; template<typename Scalar> -struct ei_log_impl : ei_log_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; +struct log_impl : log_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; template<typename Scalar> -struct ei_log_retval +struct log_retval { typedef Scalar type; }; template<typename Scalar> -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<typename Scalar, bool IsInteger> -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<typename Scalar> -struct ei_atan2_default_impl<Scalar, true> +struct atan2_default_impl<Scalar, true> { static inline Scalar run(const Scalar&, const Scalar&) { @@ -624,26 +626,26 @@ struct ei_atan2_default_impl<Scalar, true> }; template<typename Scalar> -struct ei_atan2_impl : ei_atan2_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; +struct atan2_impl : atan2_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; template<typename Scalar> -struct ei_atan2_retval +struct atan2_retval { typedef Scalar type; }; template<typename Scalar> -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<typename Scalar, bool IsInteger> -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<typename Scalar> -struct ei_pow_default_impl<Scalar, true> +struct pow_default_impl<Scalar, true> { static inline Scalar run(Scalar x, Scalar y) { Scalar res = 1; - ei_assert(!NumTraits<Scalar>::IsSigned || y >= 0); + eigen_assert(!NumTraits<Scalar>::IsSigned || y >= 0); if(y & 1) res *= x; y >>= 1; while(y) @@ -672,43 +674,43 @@ struct ei_pow_default_impl<Scalar, true> }; template<typename Scalar> -struct ei_pow_impl : ei_pow_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; +struct pow_impl : pow_default_impl<Scalar, NumTraits<Scalar>::IsInteger> {}; template<typename Scalar> -struct ei_pow_retval +struct pow_retval { typedef Scalar type; }; template<typename Scalar> -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<typename Scalar, bool IsComplex, bool IsInteger> -struct ei_random_default_impl {}; +struct random_default_impl {}; template<typename Scalar> -struct ei_random_impl : ei_random_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {}; +struct random_impl : random_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {}; template<typename Scalar> -struct ei_random_retval +struct random_retval { typedef Scalar type; }; -template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) ei_random(const Scalar& x, const Scalar& y); -template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) ei_random(); +template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y); +template<typename Scalar> inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(); template<typename Scalar> -struct ei_random_default_impl<Scalar, false, false> +struct random_default_impl<Scalar, false, false> { static inline Scalar run(const Scalar& x, const Scalar& y) { @@ -721,7 +723,7 @@ struct ei_random_default_impl<Scalar, false, false> }; template<typename Scalar> -struct ei_random_default_impl<Scalar, false, true> +struct random_default_impl<Scalar, false, true> { static inline Scalar run(const Scalar& x, const Scalar& y) { @@ -734,28 +736,28 @@ struct ei_random_default_impl<Scalar, false, true> }; template<typename Scalar> -struct ei_random_default_impl<Scalar, true, false> +struct random_default_impl<Scalar, true, false> { 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<Scalar>::Real RealScalar; - return Scalar(ei_random<RealScalar>(), ei_random<RealScalar>()); + return Scalar(random<RealScalar>(), random<RealScalar>()); } }; template<typename Scalar> -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<typename Scalar> -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<typename Scalar, bool IsComplex, bool IsInteger> -struct ei_scalar_fuzzy_default_impl {}; +struct scalar_fuzzy_default_impl {}; template<typename Scalar> -struct ei_scalar_fuzzy_default_impl<Scalar, false, false> +struct scalar_fuzzy_default_impl<Scalar, false, false> { typedef typename NumTraits<Scalar>::Real RealScalar; template<typename OtherScalar> 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<Scalar, false, false> }; template<typename Scalar> -struct ei_scalar_fuzzy_default_impl<Scalar, false, true> +struct scalar_fuzzy_default_impl<Scalar, false, true> { typedef typename NumTraits<Scalar>::Real RealScalar; template<typename OtherScalar> @@ -808,57 +810,57 @@ struct ei_scalar_fuzzy_default_impl<Scalar, false, true> }; template<typename Scalar> -struct ei_scalar_fuzzy_default_impl<Scalar, true, false> +struct scalar_fuzzy_default_impl<Scalar, true, false> { typedef typename NumTraits<Scalar>::Real RealScalar; template<typename OtherScalar> 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<typename Scalar> -struct ei_scalar_fuzzy_impl : ei_scalar_fuzzy_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {}; +struct scalar_fuzzy_impl : scalar_fuzzy_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> {}; template<typename Scalar, typename OtherScalar> -inline bool ei_isMuchSmallerThan(const Scalar& x, const OtherScalar& y, +inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y, typename NumTraits<Scalar>::Real precision = NumTraits<Scalar>::dummy_precision()) { - return ei_scalar_fuzzy_impl<Scalar>::template isMuchSmallerThan<OtherScalar>(x, y, precision); + return scalar_fuzzy_impl<Scalar>::template isMuchSmallerThan<OtherScalar>(x, y, precision); } template<typename Scalar> -inline bool ei_isApprox(const Scalar& x, const Scalar& y, +inline bool isApprox(const Scalar& x, const Scalar& y, typename NumTraits<Scalar>::Real precision = NumTraits<Scalar>::dummy_precision()) { - return ei_scalar_fuzzy_impl<Scalar>::isApprox(x, y, precision); + return scalar_fuzzy_impl<Scalar>::isApprox(x, y, precision); } template<typename Scalar> -inline bool ei_isApproxOrLessThan(const Scalar& x, const Scalar& y, +inline bool isApproxOrLessThan(const Scalar& x, const Scalar& y, typename NumTraits<Scalar>::Real precision = NumTraits<Scalar>::dummy_precision()) { - return ei_scalar_fuzzy_impl<Scalar>::isApproxOrLessThan(x, y, precision); + return scalar_fuzzy_impl<Scalar>::isApproxOrLessThan(x, y, precision); } /****************************************** *** The special case of the bool type *** ******************************************/ -template<> struct ei_random_impl<bool> +template<> struct random_impl<bool> { static inline bool run() { - return ei_random<int>(0,1)==0 ? false : true; + return random<int>(0,1)==0 ? false : true; } }; -template<> struct ei_scalar_fuzzy_impl<bool> +template<> struct scalar_fuzzy_impl<bool> { static inline bool isApprox(bool x, bool y, bool) { @@ -866,4 +868,6 @@ template<> struct ei_scalar_fuzzy_impl<bool> } }; +} // 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<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> -struct ei_traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > +struct traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > { typedef _Scalar Scalar; typedef Dense StorageKind; @@ -121,13 +123,14 @@ struct ei_traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > 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<Scalar>::ReadCost, Options = _Options, InnerStrideAtCompileTime = 1, OuterStrideAtCompileTime = (Options&RowMajor) ? ColsAtCompileTime : RowsAtCompileTime }; }; +} template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> 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 <typename Derived, typename OtherDerived, bool IsVector> - 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<typename Derived> class MatrixBase public: #ifndef EIGEN_PARSED_BY_DOXYGEN typedef MatrixBase StorageBaseType; - typedef typename ei_traits<Derived>::StorageKind StorageKind; - typedef typename ei_traits<Derived>::Index Index; - typedef typename ei_traits<Derived>::Scalar Scalar; - typedef typename ei_packet_traits<Scalar>::type PacketScalar; + typedef typename internal::traits<Derived>::StorageKind StorageKind; + typedef typename internal::traits<Derived>::Index Index; + typedef typename internal::traits<Derived>::Scalar Scalar; + typedef typename internal::packet_traits<Scalar>::type PacketScalar; typedef typename NumTraits<Scalar>::Real RealScalar; typedef DenseBase<Derived> Base; @@ -115,30 +115,30 @@ template<typename Derived> 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<typename ei_traits<Derived>::Scalar, - ei_traits<Derived>::RowsAtCompileTime, - ei_traits<Derived>::ColsAtCompileTime, - AutoAlign | (ei_traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor), - ei_traits<Derived>::MaxRowsAtCompileTime, - ei_traits<Derived>::MaxColsAtCompileTime + typedef Matrix<typename internal::traits<Derived>::Scalar, + internal::traits<Derived>::RowsAtCompileTime, + internal::traits<Derived>::ColsAtCompileTime, + AutoAlign | (internal::traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor), + internal::traits<Derived>::MaxRowsAtCompileTime, + internal::traits<Derived>::MaxColsAtCompileTime > PlainObject; #ifndef EIGEN_PARSED_BY_DOXYGEN /** \internal Represents a matrix with all coefficients equal to one another*/ - typedef CwiseNullaryOp<ei_scalar_constant_op<Scalar>,Derived> ConstantReturnType; + typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,Derived> ConstantReturnType; /** \internal the return type of MatrixBase::adjoint() */ - typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex, - CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Eigen::Transpose<Derived> >, + typedef typename internal::meta_if<NumTraits<Scalar>::IsComplex, + CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, Eigen::Transpose<Derived> >, Transpose<Derived> >::ret AdjointReturnType; /** \internal Return type of eigenvalues() */ - typedef Matrix<std::complex<RealScalar>, ei_traits<Derived>::ColsAtCompileTime, 1, ColMajor> EigenvaluesReturnType; + typedef Matrix<std::complex<RealScalar>, internal::traits<Derived>::ColsAtCompileTime, 1, ColMajor> EigenvaluesReturnType; /** \internal the return type of identity */ - typedef CwiseNullaryOp<ei_scalar_identity_op<Scalar>,Derived> IdentityReturnType; + typedef CwiseNullaryOp<internal::scalar_identity_op<Scalar>,Derived> IdentityReturnType; /** \internal the return type of unit vectors */ - typedef Block<CwiseNullaryOp<ei_scalar_identity_op<Scalar>, SquareMatrixType>, - ei_traits<Derived>::RowsAtCompileTime, - ei_traits<Derived>::ColsAtCompileTime> BasisReturnType; + typedef Block<CwiseNullaryOp<internal::scalar_identity_op<Scalar>, SquareMatrixType>, + internal::traits<Derived>::RowsAtCompileTime, + internal::traits<Derived>::ColsAtCompileTime> BasisReturnType; #endif // not EIGEN_PARSED_BY_DOXYGEN #define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::MatrixBase @@ -277,8 +277,8 @@ template<typename Derived> class MatrixBase inline const ForceAlignedAccess<Derived> forceAlignedAccess() const; inline ForceAlignedAccess<Derived> forceAlignedAccess(); - template<bool Enable> inline typename ei_makeconst<typename ei_meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret>::type forceAlignedAccessIf() const; - template<bool Enable> inline typename ei_meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret forceAlignedAccessIf(); + template<bool Enable> inline typename internal::makeconst<typename internal::meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret>::type forceAlignedAccessIf() const; + template<bool Enable> inline typename internal::meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret forceAlignedAccessIf(); Scalar trace() const; @@ -299,7 +299,7 @@ template<typename Derived> class MatrixBase const FullPivLU<PlainObject> fullPivLu() const; const PartialPivLU<PlainObject> partialPivLu() const; const PartialPivLU<PlainObject> lu() const; - const ei_inverse_impl<Derived> inverse() const; + const internal::inverse_impl<Derived> inverse() const; template<typename ResultType> void computeInverseAndDetWithCheck( ResultType& inverse, @@ -346,9 +346,9 @@ template<typename Derived> class MatrixBase SizeMinusOne = SizeAtCompileTime==Dynamic ? Dynamic : SizeAtCompileTime-1 }; typedef Block<Derived, - ei_traits<Derived>::ColsAtCompileTime==1 ? SizeMinusOne : 1, - ei_traits<Derived>::ColsAtCompileTime==1 ? 1 : SizeMinusOne> StartMinusOne; - typedef CwiseUnaryOp<ei_scalar_quotient1_op<typename ei_traits<Derived>::Scalar>, + internal::traits<Derived>::ColsAtCompileTime==1 ? SizeMinusOne : 1, + internal::traits<Derived>::ColsAtCompileTime==1 ? 1 : SizeMinusOne> StartMinusOne; + typedef CwiseUnaryOp<internal::scalar_quotient1_op<typename internal::traits<Derived>::Scalar>, StartMinusOne > HNormalizedReturnType; HNormalizedReturnType hnormalized() const; @@ -383,7 +383,7 @@ template<typename Derived> class MatrixBase ///////// MatrixFunctions module ///////// - typedef typename ei_stem_function<Scalar>::type StemFunction; + typedef typename internal::stem_function<Scalar>::type StemFunction; const MatrixExponentialReturnValue<Derived> exp() const; const MatrixFunctionReturnValue<Derived> matrixFunction(StemFunction f) const; const MatrixFunctionReturnValue<Derived> 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<typename ExpressionType> -struct ei_traits<NestByValue<ExpressionType> > : public ei_traits<ExpressionType> +struct traits<NestByValue<ExpressionType> > : public traits<ExpressionType> {}; +} template<typename ExpressionType> class NestByValue - : public ei_dense_xpr_base< NestByValue<ExpressionType> >::type + : public internal::dense_xpr_base< NestByValue<ExpressionType> >::type { public: - typedef typename ei_dense_xpr_base<NestByValue>::type Base; + typedef typename internal::dense_xpr_base<NestByValue>::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<typename OtherDerived> EIGEN_STRONG_INLINE ExpressionType& operator=(const StorageBase<OtherDerived>& other) - { return ei_assign_selector<ExpressionType,OtherDerived,false>::run(m_expression,other.derived()); } + { return internal::assign_selector<ExpressionType,OtherDerived,false>::run(m_expression,other.derived()); } /** \sa MatrixBase::operator+= */ template<typename OtherDerived> EIGEN_STRONG_INLINE ExpressionType& operator+=(const StorageBase<OtherDerived>& other) { - typedef SelfCwiseBinaryOp<ei_scalar_sum_op<Scalar>, ExpressionType, OtherDerived> SelfAdder; + typedef SelfCwiseBinaryOp<internal::scalar_sum_op<Scalar>, ExpressionType, OtherDerived> SelfAdder; SelfAdder tmp(m_expression); - typedef typename ei_nested<OtherDerived>::type OtherDerivedNested; - typedef typename ei_cleantype<OtherDerivedNested>::type _OtherDerivedNested; - ei_assign_selector<SelfAdder,_OtherDerivedNested,false>::run(tmp,OtherDerivedNested(other.derived())); + typedef typename internal::nested<OtherDerived>::type OtherDerivedNested; + typedef typename internal::cleantype<OtherDerivedNested>::type _OtherDerivedNested; + internal::assign_selector<SelfAdder,_OtherDerivedNested,false>::run(tmp,OtherDerivedNested(other.derived())); return m_expression; } @@ -69,11 +69,11 @@ class NoAlias template<typename OtherDerived> EIGEN_STRONG_INLINE ExpressionType& operator-=(const StorageBase<OtherDerived>& other) { - typedef SelfCwiseBinaryOp<ei_scalar_difference_op<Scalar>, ExpressionType, OtherDerived> SelfAdder; + typedef SelfCwiseBinaryOp<internal::scalar_difference_op<Scalar>, ExpressionType, OtherDerived> SelfAdder; SelfAdder tmp(m_expression); - typedef typename ei_nested<OtherDerived>::type OtherDerivedNested; - typedef typename ei_cleantype<OtherDerivedNested>::type _OtherDerivedNested; - ei_assign_selector<SelfAdder,_OtherDerivedNested,false>::run(tmp,OtherDerivedNested(other.derived())); + typedef typename internal::nested<OtherDerived>::type OtherDerivedNested; + typedef typename internal::cleantype<OtherDerivedNested>::type _OtherDerivedNested; + internal::assign_selector<SelfAdder,_OtherDerivedNested,false>::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<typename T> struct GenericNumTraits }; typedef T Real; - typedef typename ei_meta_if< + typedef typename internal::meta_if< IsInteger, - typename ei_meta_if<sizeof(T)<=2, float, double>::ret, + typename internal::meta_if<sizeof(T)<=2, float, double>::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<typename PermutationType, typename MatrixType, int Side, bool Transposed=false> struct ei_permut_matrix_product_retval; + +namespace internal { + +template<typename PermutationType, typename MatrixType, int Side, bool Transposed=false> struct permut_matrix_product_retval; template<int SizeAtCompileTime, int MaxSizeAtCompileTime> -struct ei_traits<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> > - : ei_traits<Matrix<int,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> > +struct traits<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> > + : traits<Matrix<int,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> > {}; +} // end namespace internal + template<int SizeAtCompileTime, int MaxSizeAtCompileTime> class PermutationMatrix : public EigenBase<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> > { public: #ifndef EIGEN_PARSED_BY_DOXYGEN - typedef ei_traits<PermutationMatrix> Traits; + typedef internal::traits<PermutationMatrix> Traits; typedef Matrix<int,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> DenseMatrixType; enum { @@ -211,7 +216,7 @@ class PermutationMatrix : public EigenBase<PermutationMatrix<SizeAtCompileTime, */ PermutationMatrix& applyTranspositionOnTheLeft(Index i, Index j) { - ei_assert(i>=0 && j>=0 && i<m_indices.size() && j<m_indices.size()); + eigen_assert(i>=0 && j>=0 && i<m_indices.size() && j<m_indices.size()); for(Index k = 0; k < m_indices.size(); ++k) { if(m_indices.coeff(k) == i) m_indices.coeffRef(k) = j; @@ -230,7 +235,7 @@ class PermutationMatrix : public EigenBase<PermutationMatrix<SizeAtCompileTime, */ PermutationMatrix& applyTranspositionOnTheRight(Index i, Index j) { - ei_assert(i>=0 && j>=0 && i<m_indices.size() && j<m_indices.size()); + eigen_assert(i>=0 && j>=0 && i<m_indices.size() && j<m_indices.size()); std::swap(m_indices.coeffRef(i), m_indices.coeffRef(j)); return *this; } @@ -262,7 +267,7 @@ class PermutationMatrix : public EigenBase<PermutationMatrix<SizeAtCompileTime, PermutationMatrix(Product_t, const PermutationMatrix& lhs, const PermutationMatrix& rhs) : m_indices(lhs.m_indices.size()) { - ei_assert(lhs.cols() == rhs.rows()); + eigen_assert(lhs.cols() == rhs.rows()); for (int i=0; i<rows();++i) m_indices.coeffRef(i) = lhs.m_indices.coeff(rhs.m_indices.coeff(i)); } #endif @@ -301,11 +306,11 @@ class PermutationMatrix : public EigenBase<PermutationMatrix<SizeAtCompileTime, /** \returns the matrix with the permutation applied to the columns. */ template<typename Derived, int SizeAtCompileTime, int MaxSizeAtCompileTime> -inline const ei_permut_matrix_product_retval<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime>, Derived, OnTheRight> +inline const internal::permut_matrix_product_retval<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime>, Derived, OnTheRight> operator*(const MatrixBase<Derived>& matrix, const PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> &permutation) { - return ei_permut_matrix_product_retval + return internal::permut_matrix_product_retval <PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime>, Derived, OnTheRight> (permutation, matrix.derived()); } @@ -313,29 +318,31 @@ operator*(const MatrixBase<Derived>& matrix, /** \returns the matrix with the permutation applied to the rows. */ template<typename Derived, int SizeAtCompileTime, int MaxSizeAtCompileTime> -inline const ei_permut_matrix_product_retval +inline const internal::permut_matrix_product_retval <PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime>, Derived, OnTheLeft> operator*(const PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> &permutation, const MatrixBase<Derived>& matrix) { - return ei_permut_matrix_product_retval + return internal::permut_matrix_product_retval <PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime>, Derived, OnTheLeft> (permutation, matrix.derived()); } +namespace internal { + template<typename PermutationType, typename MatrixType, int Side, bool Transposed> -struct ei_traits<ei_permut_matrix_product_retval<PermutationType, MatrixType, Side, Transposed> > +struct traits<permut_matrix_product_retval<PermutationType, MatrixType, Side, Transposed> > { typedef typename MatrixType::PlainObject ReturnType; }; template<typename PermutationType, typename MatrixType, int Side, bool Transposed> -struct ei_permut_matrix_product_retval - : public ReturnByValue<ei_permut_matrix_product_retval<PermutationType, MatrixType, Side, Transposed> > +struct permut_matrix_product_retval + : public ReturnByValue<permut_matrix_product_retval<PermutationType, MatrixType, Side, Transposed> > { - typedef typename ei_cleantype<typename MatrixType::Nested>::type MatrixTypeNestedCleaned; + typedef typename cleantype<typename MatrixType::Nested>::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<MatrixTypeNestedCleaned,Dest>::ret && ei_extract_data(dst) == ei_extract_data(m_matrix)) + if(is_same_type<MatrixTypeNestedCleaned,Dest>::ret && extract_data(dst) == extract_data(m_matrix)) { // apply the permutation inplace Matrix<bool,PermutationType::RowsAtCompileTime,1,0,PermutationType::MaxRowsAtCompileTime> mask(m_permutation.size()); @@ -396,10 +403,12 @@ struct ei_permut_matrix_product_retval /* Template partial specialization for transposed/inverse permutations */ template<int SizeAtCompileTime, int MaxSizeAtCompileTime> -struct ei_traits<Transpose<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> > > - : ei_traits<Matrix<int,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> > +struct traits<Transpose<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> > > + : traits<Matrix<int,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> > {}; +} // end namespace internal + template<int SizeAtCompileTime, int MaxSizeAtCompileTime> class Transpose<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> > : public EigenBase<Transpose<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> > > @@ -409,7 +418,7 @@ class Transpose<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> > public: #ifndef EIGEN_PARSED_BY_DOXYGEN - typedef ei_traits<PermutationType> Traits; + typedef internal::traits<PermutationType> Traits; typedef Matrix<int,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> DenseMatrixType; enum { @@ -446,19 +455,19 @@ class Transpose<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime> > /** \returns the matrix with the inverse permutation applied to the columns. */ template<typename Derived> friend - inline const ei_permut_matrix_product_retval<PermutationType, Derived, OnTheRight, true> + inline const internal::permut_matrix_product_retval<PermutationType, Derived, OnTheRight, true> operator*(const MatrixBase<Derived>& matrix, const Transpose& trPerm) { - return ei_permut_matrix_product_retval<PermutationType, Derived, OnTheRight, true>(trPerm.m_permutation, matrix.derived()); + return internal::permut_matrix_product_retval<PermutationType, Derived, OnTheRight, true>(trPerm.m_permutation, matrix.derived()); } /** \returns the matrix with the inverse permutation applied to the rows. */ template<typename Derived> - inline const ei_permut_matrix_product_retval<PermutationType, Derived, OnTheLeft, true> + inline const internal::permut_matrix_product_retval<PermutationType, Derived, OnTheLeft, true> operator*(const MatrixBase<Derived>& matrix) const { - return ei_permut_matrix_product_retval<PermutationType, Derived, OnTheLeft, true>(m_permutation, matrix.derived()); + return internal::permut_matrix_product_retval<PermutationType, Derived, OnTheLeft, true>(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 <typename Derived, typename OtherDerived = Derived, bool IsVector = static_cast<bool>(Derived::IsVectorAtCompileTime)> struct ei_conservative_resize_like_impl; -template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> struct ei_matrix_swap_impl; +namespace internal { + +template <typename Derived, typename OtherDerived = Derived, bool IsVector = static_cast<bool>(Derived::IsVectorAtCompileTime)> struct conservative_resize_like_impl; + +template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> struct matrix_swap_impl; + +} // end namespace internal /** * \brief %Dense storage base class for matrices and arrays. * \sa \ref TopicClassHierarchy */ template<typename Derived> -class PlainObjectBase : public ei_dense_xpr_base<Derived>::type +class PlainObjectBase : public internal::dense_xpr_base<Derived>::type { public: - enum { Options = ei_traits<Derived>::Options }; - typedef typename ei_dense_xpr_base<Derived>::type Base; + enum { Options = internal::traits<Derived>::Options }; + typedef typename internal::dense_xpr_base<Derived>::type Base; - typedef typename ei_traits<Derived>::StorageKind StorageKind; - typedef typename ei_traits<Derived>::Index Index; - typedef typename ei_traits<Derived>::Scalar Scalar; - typedef typename ei_packet_traits<Scalar>::type PacketScalar; + typedef typename internal::traits<Derived>::StorageKind StorageKind; + typedef typename internal::traits<Derived>::Index Index; + typedef typename internal::traits<Derived>::Scalar Scalar; + typedef typename internal::packet_traits<Scalar>::type PacketScalar; typedef typename NumTraits<Scalar>::Real RealScalar; using Base::RowsAtCompileTime; @@ -109,7 +114,7 @@ class PlainObjectBase : public ei_dense_xpr_base<Derived>::type template<int LoadMode> EIGEN_STRONG_INLINE PacketScalar packet(Index row, Index col) const { - return ei_ploadt<PacketScalar, LoadMode> + return internal::ploadt<PacketScalar, LoadMode> (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<Derived>::type template<int LoadMode> EIGEN_STRONG_INLINE PacketScalar packet(Index index) const { - return ei_ploadt<PacketScalar, LoadMode>(m_storage.data() + index); + return internal::ploadt<PacketScalar, LoadMode>(m_storage.data() + index); } template<int StoreMode> EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketScalar& x) { - ei_pstoret<Scalar, PacketScalar, StoreMode> + internal::pstoret<Scalar, PacketScalar, StoreMode> (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<Derived>::type template<int StoreMode> EIGEN_STRONG_INLINE void writePacket(Index index, const PacketScalar& x) { - ei_pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, x); + internal::pstoret<Scalar, PacketScalar, StoreMode>(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<Derived>::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<Derived>::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<Derived>::type */ EIGEN_STRONG_INLINE void conservativeResize(Index rows, Index cols) { - ei_conservative_resize_like_impl<Derived>::run(*this, rows, cols); + internal::conservative_resize_like_impl<Derived>::run(*this, rows, cols); } EIGEN_STRONG_INLINE void conservativeResize(Index rows, NoChange_t) @@ -286,13 +291,13 @@ class PlainObjectBase : public ei_dense_xpr_base<Derived>::type */ EIGEN_STRONG_INLINE void conservativeResize(Index size) { - ei_conservative_resize_like_impl<Derived>::run(*this, size); + internal::conservative_resize_like_impl<Derived>::run(*this, size); } template<typename OtherDerived> EIGEN_STRONG_INLINE void conservativeResizeLike(const DenseBase<OtherDerived>& other) { - ei_conservative_resize_like_impl<Derived,OtherDerived>::run(*this, other); + internal::conservative_resize_like_impl<Derived,OtherDerived>::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<Derived>::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<Derived>::type EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase<OtherDerived>& 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<Derived>::type template<typename OtherDerived> EIGEN_STRONG_INLINE Derived& _set(const DenseBase<OtherDerived>& other) { - _set_selector(other.derived(), typename ei_meta_if<static_cast<bool>(int(OtherDerived::Flags) & EvalBeforeAssigningBit), ei_meta_true, ei_meta_false>::ret()); + _set_selector(other.derived(), typename internal::meta_if<static_cast<bool>(int(OtherDerived::Flags) & EvalBeforeAssigningBit), internal::meta_true, internal::meta_false>::ret()); return this->derived(); } template<typename OtherDerived> - 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<typename OtherDerived> - 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<Derived>::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<Derived,OtherDerived,false>::run(this->derived(), other.derived()); + return internal::assign_selector<Derived,OtherDerived,false>::run(this->derived(), other.derived()); } template<typename T0, typename T1> - EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename ei_enable_if<Base::SizeAtCompileTime!=2,T0>::type* = 0) + EIGEN_STRONG_INLINE void _init2(Index rows, Index cols, typename internal::enable_if<Base::SizeAtCompileTime!=2,T0>::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<typename T0, typename T1> - EIGEN_STRONG_INLINE void _init2(const Scalar& x, const Scalar& y, typename ei_enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0) + EIGEN_STRONG_INLINE void _init2(const Scalar& x, const Scalar& y, typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::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<Derived>::type } template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> - 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<Derived>::type template<typename OtherDerived> void _swap(DenseBase<OtherDerived> EIGEN_REF_TO_TEMPORARY other) { - enum { SwapPointers = ei_is_same_type<Derived, OtherDerived>::ret && Base::SizeAtCompileTime==Dynamic }; - ei_matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.const_cast_derived()); + enum { SwapPointers = internal::is_same_type<Derived, OtherDerived>::ret && Base::SizeAtCompileTime==Dynamic }; + internal::matrix_swap_impl<Derived, OtherDerived, bool(SwapPointers)>::run(this->derived(), other.const_cast_derived()); } public: @@ -529,7 +534,7 @@ class PlainObjectBase : public ei_dense_xpr_base<Derived>::type }; template <typename Derived, typename OtherDerived, bool IsVector> -struct ei_conservative_resize_like_impl +struct internal::conservative_resize_like_impl { typedef typename Derived::Index Index; static void run(DenseBase<Derived>& _this, Index rows, Index cols) @@ -588,8 +593,10 @@ struct ei_conservative_resize_like_impl } }; +namespace internal { + template <typename Derived, typename OtherDerived> -struct ei_conservative_resize_like_impl<Derived,OtherDerived,true> +struct conservative_resize_like_impl<Derived,OtherDerived,true> { typedef typename Derived::Index Index; static void run(DenseBase<Derived>& _this, Index size) @@ -615,7 +622,7 @@ struct ei_conservative_resize_like_impl<Derived,OtherDerived,true> }; template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> -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<typename MatrixTypeA, typename MatrixTypeB> -struct ei_matrix_swap_impl<MatrixTypeA, MatrixTypeB, true> +struct matrix_swap_impl<MatrixTypeA, MatrixTypeB, true> { static inline void run(MatrixTypeA& a, MatrixTypeB& b) { @@ -632,4 +639,6 @@ struct ei_matrix_swap_impl<MatrixTypeA, MatrixTypeB, true> } }; +} // 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<OtherDerived>&) */ -template<typename Lhs, typename Rhs, int ProductType = ei_product_type<Lhs,Rhs>::value> +template<typename Lhs, typename Rhs, int ProductType = internal::product_type<Lhs,Rhs>::value> class GeneralProduct; -template<int Rows, int Cols, int Depth> struct ei_product_type_selector; - enum { Large = 2, Small = 3 }; -template<typename Lhs, typename Rhs> struct ei_product_type +namespace internal { + +template<int Rows, int Cols, int Depth> struct product_type_selector; + +template<typename Lhs, typename Rhs> struct product_type { - typedef typename ei_cleantype<Lhs>::type _Lhs; - typedef typename ei_cleantype<Rhs>::type _Rhs; + typedef typename cleantype<Lhs>::type _Lhs; + typedef typename cleantype<Rhs>::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<rows_select, cols_select, depth_select> product_type_selector; + typedef product_type_selector<rows_select, cols_select, depth_select> 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<int M, int N> struct ei_product_type_selector<M,N,1> { enum { ret = OuterProduct }; }; -template<int Depth> 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<Small,1, Small> { enum { ret = CoeffBasedProductMode }; }; -template<> struct ei_product_type_selector<1, Small,Small> { enum { ret = CoeffBasedProductMode }; }; -template<> struct ei_product_type_selector<Small,Small,Small> { enum { ret = CoeffBasedProductMode }; }; -template<> struct ei_product_type_selector<Small, Small, 1> { enum { ret = LazyCoeffBasedProductMode }; }; -template<> struct ei_product_type_selector<Small, Large, 1> { enum { ret = LazyCoeffBasedProductMode }; }; -template<> struct ei_product_type_selector<Large, Small, 1> { 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<Large,1, Small> { enum { ret = CoeffBasedProductMode }; }; -template<> struct ei_product_type_selector<Large,1, Large> { enum { ret = GemvProduct }; }; -template<> struct ei_product_type_selector<Small,1, Large> { enum { ret = CoeffBasedProductMode }; }; -template<> struct ei_product_type_selector<Small,Small,Large> { enum { ret = GemmProduct }; }; -template<> struct ei_product_type_selector<Large,Small,Large> { enum { ret = GemmProduct }; }; -template<> struct ei_product_type_selector<Small,Large,Large> { enum { ret = GemmProduct }; }; -template<> struct ei_product_type_selector<Large,Large,Large> { enum { ret = GemmProduct }; }; -template<> struct ei_product_type_selector<Large,Small,Small> { enum { ret = GemmProduct }; }; -template<> struct ei_product_type_selector<Small,Large,Small> { enum { ret = GemmProduct }; }; -template<> struct ei_product_type_selector<Large,Large,Small> { enum { ret = GemmProduct }; }; +template<int M, int N> struct product_type_selector<M,N,1> { enum { ret = OuterProduct }; }; +template<int Depth> 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<Small,1, Small> { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector<1, Small,Small> { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector<Small,Small,Small> { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector<Small, Small, 1> { enum { ret = LazyCoeffBasedProductMode }; }; +template<> struct product_type_selector<Small, Large, 1> { enum { ret = LazyCoeffBasedProductMode }; }; +template<> struct product_type_selector<Large, Small, 1> { 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<Large,1, Small> { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector<Large,1, Large> { enum { ret = GemvProduct }; }; +template<> struct product_type_selector<Small,1, Large> { enum { ret = CoeffBasedProductMode }; }; +template<> struct product_type_selector<Small,Small,Large> { enum { ret = GemmProduct }; }; +template<> struct product_type_selector<Large,Small,Large> { enum { ret = GemmProduct }; }; +template<> struct product_type_selector<Small,Large,Large> { enum { ret = GemmProduct }; }; +template<> struct product_type_selector<Large,Large,Large> { enum { ret = GemmProduct }; }; +template<> struct product_type_selector<Large,Small,Small> { enum { ret = GemmProduct }; }; +template<> struct product_type_selector<Small,Large,Small> { enum { ret = GemmProduct }; }; +template<> struct product_type_selector<Large,Large,Small> { enum { ret = GemmProduct }; }; + +} // end namespace internal /** \class ProductReturnType * \ingroup Core_Module @@ -127,7 +132,7 @@ template<> struct ei_product_type_selector<Large,Large,Small> { 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<Lhs,Rhs>::Type @@ -141,8 +146,8 @@ template<typename Lhs, typename Rhs, int ProductType> struct ProductReturnType { // TODO use the nested type to reduce instanciations ???? -// typedef typename ei_nested<Lhs,Rhs::ColsAtCompileTime>::type LhsNested; -// typedef typename ei_nested<Rhs,Lhs::RowsAtCompileTime>::type RhsNested; +// typedef typename internal::nested<Lhs,Rhs::ColsAtCompileTime>::type LhsNested; +// typedef typename internal::nested<Rhs,Lhs::RowsAtCompileTime>::type RhsNested; typedef GeneralProduct<Lhs/*Nested*/, Rhs/*Nested*/, ProductType> Type; }; @@ -150,16 +155,16 @@ struct ProductReturnType template<typename Lhs, typename Rhs> struct ProductReturnType<Lhs,Rhs,CoeffBasedProductMode> { - typedef typename ei_nested<Lhs, Rhs::ColsAtCompileTime, typename ei_plain_matrix_type<Lhs>::type >::type LhsNested; - typedef typename ei_nested<Rhs, Lhs::RowsAtCompileTime, typename ei_plain_matrix_type<Rhs>::type >::type RhsNested; + typedef typename internal::nested<Lhs, Rhs::ColsAtCompileTime, typename internal::plain_matrix_type<Lhs>::type >::type LhsNested; + typedef typename internal::nested<Rhs, Lhs::RowsAtCompileTime, typename internal::plain_matrix_type<Rhs>::type >::type RhsNested; typedef CoeffBasedProduct<LhsNested, RhsNested, EvalBeforeAssigningBit | EvalBeforeNestingBit> Type; }; template<typename Lhs, typename Rhs> struct ProductReturnType<Lhs,Rhs,LazyCoeffBasedProductMode> { - typedef typename ei_nested<Lhs, Rhs::ColsAtCompileTime, typename ei_plain_matrix_type<Lhs>::type >::type LhsNested; - typedef typename ei_nested<Rhs, Lhs::RowsAtCompileTime, typename ei_plain_matrix_type<Rhs>::type >::type RhsNested; + typedef typename internal::nested<Lhs, Rhs::ColsAtCompileTime, typename internal::plain_matrix_type<Lhs>::type >::type LhsNested; + typedef typename internal::nested<Rhs, Lhs::RowsAtCompileTime, typename internal::plain_matrix_type<Rhs>::type >::type RhsNested; typedef CoeffBasedProduct<LhsNested, RhsNested, NestByRefBit> Type; }; @@ -179,21 +184,25 @@ struct LazyProductReturnType : public ProductReturnType<Lhs,Rhs,LazyCoeffBasedPr // product ends up to a row-vector times col-vector product... To tackle this use // case, we could have a specialization for Block<MatrixType,1,1> with: operator=(Scalar x); +namespace internal { + template<typename Lhs, typename Rhs> -struct ei_traits<GeneralProduct<Lhs,Rhs,InnerProduct> > - : ei_traits<Matrix<typename ei_scalar_product_traits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType,1,1> > +struct traits<GeneralProduct<Lhs,Rhs,InnerProduct> > + : traits<Matrix<typename scalar_product_traits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType,1,1> > {}; +} + template<typename Lhs, typename Rhs> class GeneralProduct<Lhs, Rhs, InnerProduct> - : ei_no_assignment_operator, - public Matrix<typename ei_scalar_product_traits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType,1,1> + : internal::no_assignment_operator, + public Matrix<typename internal::scalar_product_traits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType,1,1> { - typedef Matrix<typename ei_scalar_product_traits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType,1,1> Base; + typedef Matrix<typename internal::scalar_product_traits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType,1,1> Base; public: GeneralProduct(const Lhs& lhs, const Rhs& rhs) { - EIGEN_STATIC_ASSERT((ei_is_same_type<typename Lhs::RealScalar, typename Rhs::RealScalar>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type<typename Lhs::RealScalar, typename Rhs::RealScalar>::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<Lhs, Rhs, InnerProduct> /*********************************************************************** * Implementation of Outer Vector Vector Product ***********************************************************************/ -template<int StorageOrder> struct ei_outer_product_selector; + +namespace internal { +template<int StorageOrder> struct outer_product_selector; template<typename Lhs, typename Rhs> -struct ei_traits<GeneralProduct<Lhs,Rhs,OuterProduct> > - : ei_traits<ProductBase<GeneralProduct<Lhs,Rhs,OuterProduct>, Lhs, Rhs> > +struct traits<GeneralProduct<Lhs,Rhs,OuterProduct> > + : traits<ProductBase<GeneralProduct<Lhs,Rhs,OuterProduct>, Lhs, Rhs> > {}; +} + template<typename Lhs, typename Rhs> class GeneralProduct<Lhs, Rhs, OuterProduct> : public ProductBase<GeneralProduct<Lhs,Rhs,OuterProduct>, Lhs, Rhs> @@ -226,17 +239,19 @@ class GeneralProduct<Lhs, Rhs, OuterProduct> GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs) { - EIGEN_STATIC_ASSERT((ei_is_same_type<typename Lhs::RealScalar, typename Rhs::RealScalar>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type<typename Lhs::RealScalar, typename Rhs::RealScalar>::ret), YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) } template<typename Dest> 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<ColMajor> { +namespace internal { + +template<> struct outer_product_selector<ColMajor> { template<typename ProductType, typename Dest> 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<ColMajor> { } }; -template<> struct ei_outer_product_selector<RowMajor> { +template<> struct outer_product_selector<RowMajor> { template<typename ProductType, typename Dest> 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<RowMajor> { } }; +} // end namespace internal + /*********************************************************************** * Implementation of General Matrix Vector Product ***********************************************************************/ @@ -271,13 +288,17 @@ template<> struct ei_outer_product_selector<RowMajor> { * 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<typename Lhs, typename Rhs> -struct ei_traits<GeneralProduct<Lhs,Rhs,GemvProduct> > - : ei_traits<ProductBase<GeneralProduct<Lhs,Rhs,GemvProduct>, Lhs, Rhs> > +struct traits<GeneralProduct<Lhs,Rhs,GemvProduct> > + : traits<ProductBase<GeneralProduct<Lhs,Rhs,GemvProduct>, Lhs, Rhs> > {}; template<int Side, int StorageOrder, bool BlasCompatible> -struct ei_gemv_selector; +struct gemv_selector; + +} // end namespace internal template<typename Lhs, typename Rhs> class GeneralProduct<Lhs, Rhs, GemvProduct> @@ -291,37 +312,39 @@ class GeneralProduct<Lhs, Rhs, GemvProduct> GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs) { -// EIGEN_STATIC_ASSERT((ei_is_same_type<typename Lhs::Scalar, typename Rhs::Scalar>::ret), +// EIGEN_STATIC_ASSERT((internal::is_same_type<typename Lhs::Scalar, typename Rhs::Scalar>::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<int(Side)==OnTheRight,_LhsNested,_RhsNested>::ret MatrixType; + typedef typename internal::meta_if<int(Side)==OnTheRight,_LhsNested,_RhsNested>::ret MatrixType; template<typename Dest> void scaleAndAddTo(Dest& dst, Scalar alpha) const { - ei_assert(m_lhs.rows() == dst.rows() && m_rhs.cols() == dst.cols()); - ei_gemv_selector<Side,(int(MatrixType::Flags)&RowMajorBit) ? RowMajor : ColMajor, - bool(ei_blas_traits<MatrixType>::HasUsableDirectAccess)>::run(*this, dst, alpha); + eigen_assert(m_lhs.rows() == dst.rows() && m_rhs.cols() == dst.cols()); + internal::gemv_selector<Side,(int(MatrixType::Flags)&RowMajorBit) ? RowMajor : ColMajor, + bool(internal::blas_traits<MatrixType>::HasUsableDirectAccess)>::run(*this, dst, alpha); } }; +namespace internal { + // The vector is on the left => transposition template<int StorageOrder, bool BlasCompatible> -struct ei_gemv_selector<OnTheLeft,StorageOrder,BlasCompatible> +struct gemv_selector<OnTheLeft,StorageOrder,BlasCompatible> { template<typename ProductType, typename Dest> static void run(const ProductType& prod, Dest& dest, typename ProductType::Scalar alpha) { Transpose<Dest> destT(dest); enum { OtherStorageOrder = StorageOrder == RowMajor ? ColMajor : RowMajor }; - ei_gemv_selector<OnTheRight,OtherStorageOrder,BlasCompatible> + gemv_selector<OnTheRight,OtherStorageOrder,BlasCompatible> ::run(GeneralProduct<Transpose<typename ProductType::_RhsNested>,Transpose<typename ProductType::_LhsNested>, GemvProduct> (prod.rhs().transpose(), prod.lhs().transpose()), destT, alpha); } }; -template<> struct ei_gemv_selector<OnTheRight,ColMajor,true> +template<> struct gemv_selector<OnTheRight,ColMajor,true> { template<typename ProductType, typename Dest> static void run(const ProductType& prod, Dest& dest, typename ProductType::Scalar alpha) @@ -344,15 +367,15 @@ template<> struct ei_gemv_selector<OnTheRight,ColMajor,true> * RhsBlasTraits::extractScalarFactor(prod.rhs()); enum { - // FIXME find a way to allow an inner stride on the result if ei_packet_traits<Scalar>::size==1 + // FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1 EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime==1, ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::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<ResScalar,RhsScalar>::run(actualAlpha); + RhsScalar compatibleAlpha = get_factor<ResScalar,RhsScalar>::run(actualAlpha); ResScalar* actualDest; if (evalToDest) @@ -371,7 +394,7 @@ template<> struct ei_gemv_selector<OnTheRight,ColMajor,true> MappedDest(actualDest, dest.size()) = dest; } - ei_general_matrix_vector_product + general_matrix_vector_product <Index,LhsScalar,ColMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsBlasTraits::NeedToConjugate>::run( actualLhs.rows(), actualLhs.cols(), &actualLhs.const_cast_derived().coeffRef(0,0), actualLhs.outerStride(), @@ -390,7 +413,7 @@ template<> struct ei_gemv_selector<OnTheRight,ColMajor,true> } }; -template<> struct ei_gemv_selector<OnTheRight,RowMajor,true> +template<> struct gemv_selector<OnTheRight,RowMajor,true> { template<typename ProductType, typename Dest> static void run(const ProductType& prod, Dest& dest, typename ProductType::Scalar alpha) @@ -412,9 +435,9 @@ template<> struct ei_gemv_selector<OnTheRight,RowMajor,true> * RhsBlasTraits::extractScalarFactor(prod.rhs()); enum { - // FIXME I think here we really have to check for ei_packet_traits<Scalar>::size==1 + // FIXME I think here we really have to check for packet_traits<Scalar>::size==1 // because in this case it is fine to have an inner stride - DirectlyUseRhs = ((ei_packet_traits<RhsScalar>::size==1) || (_ActualRhsType::Flags&ActualPacketAccessBit)) + DirectlyUseRhs = ((packet_traits<RhsScalar>::size==1) || (_ActualRhsType::Flags&ActualPacketAccessBit)) && (!(_ActualRhsType::Flags & RowMajorBit)) }; @@ -427,7 +450,7 @@ template<> struct ei_gemv_selector<OnTheRight,RowMajor,true> Map<typename _ActualRhsType::PlainObject>(rhs_data, actualRhs.size()) = actualRhs; } - ei_general_matrix_vector_product + general_matrix_vector_product <Index,LhsScalar,RowMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsBlasTraits::NeedToConjugate>::run( actualLhs.rows(), actualLhs.cols(), &actualLhs.const_cast_derived().coeffRef(0,0), actualLhs.outerStride(), @@ -439,7 +462,7 @@ template<> struct ei_gemv_selector<OnTheRight,RowMajor,true> } }; -template<> struct ei_gemv_selector<OnTheRight,ColMajor,false> +template<> struct gemv_selector<OnTheRight,ColMajor,false> { template<typename ProductType, typename Dest> static void run(const ProductType& prod, Dest& dest, typename ProductType::Scalar alpha) @@ -452,7 +475,7 @@ template<> struct ei_gemv_selector<OnTheRight,ColMajor,false> } }; -template<> struct ei_gemv_selector<OnTheRight,RowMajor,false> +template<> struct gemv_selector<OnTheRight,RowMajor,false> { template<typename ProductType, typename Dest> static void run(const ProductType& prod, Dest& dest, typename ProductType::Scalar alpha) @@ -465,6 +488,8 @@ template<> struct ei_gemv_selector<OnTheRight,RowMajor,false> } }; +} // end namespace internal + /*************************************************************************** * Implementation of matrix base methods ***************************************************************************/ @@ -500,7 +525,7 @@ MatrixBase<Derived>::operator*(const MatrixBase<OtherDerived> &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<Derived,OtherDerived>::debug(); + internal::product_type<Derived,OtherDerived>::debug(); #endif return typename ProductReturnType<Derived,OtherDerived>::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<typename Derived, typename _Lhs, typename _Rhs> -struct ei_traits<ProductBase<Derived,_Lhs,_Rhs> > +struct traits<ProductBase<Derived,_Lhs,_Rhs> > { typedef MatrixXpr XprKind; - typedef typename ei_cleantype<_Lhs>::type Lhs; - typedef typename ei_cleantype<_Rhs>::type Rhs; - typedef typename ei_scalar_product_traits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType Scalar; - typedef typename ei_promote_storage_type<typename ei_traits<Lhs>::StorageKind, - typename ei_traits<Rhs>::StorageKind>::ret StorageKind; - typedef typename ei_promote_index_type<typename ei_traits<Lhs>::Index, - typename ei_traits<Rhs>::Index>::type Index; + typedef typename cleantype<_Lhs>::type Lhs; + typedef typename cleantype<_Rhs>::type Rhs; + typedef typename scalar_product_traits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType Scalar; + typedef typename promote_storage_type<typename traits<Lhs>::StorageKind, + typename traits<Rhs>::StorageKind>::ret StorageKind; + typedef typename promote_index_type<typename traits<Lhs>::Index, + typename traits<Rhs>::Index>::type Index; enum { - RowsAtCompileTime = ei_traits<Lhs>::RowsAtCompileTime, - ColsAtCompileTime = ei_traits<Rhs>::ColsAtCompileTime, - MaxRowsAtCompileTime = ei_traits<Lhs>::MaxRowsAtCompileTime, - MaxColsAtCompileTime = ei_traits<Rhs>::MaxColsAtCompileTime, + RowsAtCompileTime = traits<Lhs>::RowsAtCompileTime, + ColsAtCompileTime = traits<Rhs>::ColsAtCompileTime, + MaxRowsAtCompileTime = traits<Lhs>::MaxRowsAtCompileTime, + MaxColsAtCompileTime = traits<Rhs>::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<Derived, Lhs, Rhs > Base; \ @@ -77,16 +80,16 @@ class ProductBase : public MatrixBase<Derived> EIGEN_DENSE_PUBLIC_INTERFACE(ProductBase) protected: typedef typename Lhs::Nested LhsNested; - typedef typename ei_cleantype<LhsNested>::type _LhsNested; - typedef ei_blas_traits<_LhsNested> LhsBlasTraits; + typedef typename internal::cleantype<LhsNested>::type _LhsNested; + typedef internal::blas_traits<_LhsNested> LhsBlasTraits; typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType; - typedef typename ei_cleantype<ActualLhsType>::type _ActualLhsType; + typedef typename internal::cleantype<ActualLhsType>::type _ActualLhsType; typedef typename Rhs::Nested RhsNested; - typedef typename ei_cleantype<RhsNested>::type _RhsNested; - typedef ei_blas_traits<_RhsNested> RhsBlasTraits; + typedef typename internal::cleantype<RhsNested>::type _RhsNested; + typedef internal::blas_traits<_RhsNested> RhsBlasTraits; typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType; - typedef typename ei_cleantype<ActualRhsType>::type _ActualRhsType; + typedef typename internal::cleantype<ActualRhsType>::type _ActualRhsType; // Diagonal of a product: no need to evaluate the arguments because they are going to be evaluated only once typedef CoeffBasedProduct<LhsNested, RhsNested, 0> FullyLazyCoeffBaseProductType; @@ -98,7 +101,7 @@ class ProductBase : public MatrixBase<Derived> 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<Derived> // 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<typename Lhs, typename Rhs, int Mode, int N, typename PlainObject> -struct ei_nested<GeneralProduct<Lhs,Rhs,Mode>, N, PlainObject> +struct nested<GeneralProduct<Lhs,Rhs,Mode>, N, PlainObject> { typedef PlainObject const& type; }; +} template<typename NestedProduct> class ScaledProduct; @@ -178,7 +183,7 @@ operator*(const ProductBase<Derived,Lhs,Rhs>& prod, typename Derived::Scalar x) { return ScaledProduct<Derived>(prod.derived(), x); } template<typename Derived,typename Lhs,typename Rhs> -typename ei_enable_if<!ei_is_same_type<typename Derived::Scalar,typename Derived::RealScalar>::ret, +typename internal::enable_if<!internal::is_same_type<typename Derived::Scalar,typename Derived::RealScalar>::ret, const ScaledProduct<Derived> >::type operator*(const ProductBase<Derived,Lhs,Rhs>& prod, typename Derived::RealScalar x) { return ScaledProduct<Derived>(prod.derived(), x); } @@ -190,20 +195,21 @@ operator*(typename Derived::Scalar x,const ProductBase<Derived,Lhs,Rhs>& prod) { return ScaledProduct<Derived>(prod.derived(), x); } template<typename Derived,typename Lhs,typename Rhs> -typename ei_enable_if<!ei_is_same_type<typename Derived::Scalar,typename Derived::RealScalar>::ret, +typename internal::enable_if<!internal::is_same_type<typename Derived::Scalar,typename Derived::RealScalar>::ret, const ScaledProduct<Derived> >::type operator*(typename Derived::RealScalar x,const ProductBase<Derived,Lhs,Rhs>& prod) { return ScaledProduct<Derived>(prod.derived(), x); } - +namespace internal { template<typename NestedProduct> -struct ei_traits<ScaledProduct<NestedProduct> > - : ei_traits<ProductBase<ScaledProduct<NestedProduct>, +struct traits<ScaledProduct<NestedProduct> > + : traits<ProductBase<ScaledProduct<NestedProduct>, typename NestedProduct::_LhsNested, typename NestedProduct::_RhsNested> > { - typedef typename ei_traits<NestedProduct>::StorageKind StorageKind; + typedef typename traits<NestedProduct>::StorageKind StorageKind; }; +} template<typename NestedProduct> 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<typename Scalar> struct ei_scalar_random_op { - EIGEN_EMPTY_STRUCT_CTOR(ei_scalar_random_op) +namespace internal { + +template<typename Scalar> struct scalar_random_op { + EIGEN_EMPTY_STRUCT_CTOR(scalar_random_op) template<typename Index> - inline const Scalar operator() (Index, Index = 0) const { return ei_random<Scalar>(); } + inline const Scalar operator() (Index, Index = 0) const { return random<Scalar>(); } }; + template<typename Scalar> -struct ei_functor_traits<ei_scalar_random_op<Scalar> > +struct functor_traits<scalar_random_op<Scalar> > { enum { Cost = 5 * NumTraits<Scalar>::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<ei_scalar_random_op<Scalar> > * \sa MatrixBase::setRandom(), MatrixBase::Random(Index), MatrixBase::Random() */ template<typename Derived> -inline const CwiseNullaryOp<ei_scalar_random_op<typename ei_traits<Derived>::Scalar>, Derived> +inline const CwiseNullaryOp<internal::scalar_random_op<typename internal::traits<Derived>::Scalar>, Derived> DenseBase<Derived>::Random(Index rows, Index cols) { - return NullaryExpr(rows, cols, ei_scalar_random_op<Scalar>()); + return NullaryExpr(rows, cols, internal::scalar_random_op<Scalar>()); } /** \returns a random vector expression @@ -80,10 +85,10 @@ DenseBase<Derived>::Random(Index rows, Index cols) * \sa MatrixBase::setRandom(), MatrixBase::Random(Index,Index), MatrixBase::Random() */ template<typename Derived> -inline const CwiseNullaryOp<ei_scalar_random_op<typename ei_traits<Derived>::Scalar>, Derived> +inline const CwiseNullaryOp<internal::scalar_random_op<typename internal::traits<Derived>::Scalar>, Derived> DenseBase<Derived>::Random(Index size) { - return NullaryExpr(size, ei_scalar_random_op<Scalar>()); + return NullaryExpr(size, internal::scalar_random_op<Scalar>()); } /** \returns a fixed-size random matrix or vector expression @@ -101,10 +106,10 @@ DenseBase<Derived>::Random(Index size) * \sa MatrixBase::setRandom(), MatrixBase::Random(Index,Index), MatrixBase::Random(Index) */ template<typename Derived> -inline const CwiseNullaryOp<ei_scalar_random_op<typename ei_traits<Derived>::Scalar>, Derived> +inline const CwiseNullaryOp<internal::scalar_random_op<typename internal::traits<Derived>::Scalar>, Derived> DenseBase<Derived>::Random() { - return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, ei_scalar_random_op<Scalar>()); + return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, internal::scalar_random_op<Scalar>()); } /** 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<typename Func, typename Derived> -struct ei_redux_traits +struct redux_traits { public: enum { - PacketSize = ei_packet_traits<typename Derived::Scalar>::size, + PacketSize = packet_traits<typename Derived::Scalar>::size, InnerMaxSize = int(Derived::IsRowMajor) ? Derived::MaxColsAtCompileTime : Derived::MaxRowsAtCompileTime @@ -47,7 +49,7 @@ public: enum { MightVectorize = (int(Derived::Flags)&ActualPacketAccessBit) - && (ei_functor_traits<Func>::PacketAccess), + && (functor_traits<Func>::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<Func>::Cost == Dynamic) + || (Derived::SizeAtCompileTime!=1 && functor_traits<Func>::Cost == Dynamic) ) ? Dynamic : Derived::SizeAtCompileTime * Derived::CoeffReadCost - + (Derived::SizeAtCompileTime-1) * ei_functor_traits<Func>::Cost, + + (Derived::SizeAtCompileTime-1) * functor_traits<Func>::Cost, UnrollingLimit = EIGEN_UNROLLING_LIMIT * (int(Traversal) == int(DefaultTraversal) ? 1 : int(PacketSize)) }; @@ -85,7 +87,7 @@ public: /*** no vectorization ***/ template<typename Func, typename Derived, int Start, int Length> -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<Func, Derived, Start, HalfLength>::run(mat,func), - ei_redux_novec_unroller<Func, Derived, Start+HalfLength, Length-HalfLength>::run(mat,func)); + return func(redux_novec_unroller<Func, Derived, Start, HalfLength>::run(mat,func), + redux_novec_unroller<Func, Derived, Start+HalfLength, Length-HalfLength>::run(mat,func)); } }; template<typename Func, typename Derived, int Start> -struct ei_redux_novec_unroller<Func, Derived, Start, 1> +struct redux_novec_unroller<Func, Derived, Start, 1> { enum { outer = Start / Derived::InnerSizeAtCompileTime, @@ -120,7 +122,7 @@ struct ei_redux_novec_unroller<Func, Derived, Start, 1> // to prevent false warnings regarding failed inlining though // for 0 length run() will never be called at all. template<typename Func, typename Derived, int Start> -struct ei_redux_novec_unroller<Func, Derived, Start, 0> +struct redux_novec_unroller<Func, Derived, Start, 0> { 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<Func, Derived, Start, 0> /*** vectorization ***/ template<typename Func, typename Derived, int Start, int Length> -struct ei_redux_vec_unroller +struct redux_vec_unroller { enum { - PacketSize = ei_packet_traits<typename Derived::Scalar>::size, + PacketSize = packet_traits<typename Derived::Scalar>::size, HalfLength = Length/2 }; typedef typename Derived::Scalar Scalar; - typedef typename ei_packet_traits<Scalar>::type PacketScalar; + typedef typename packet_traits<Scalar>::type PacketScalar; EIGEN_STRONG_INLINE static PacketScalar run(const Derived &mat, const Func& func) { return func.packetOp( - ei_redux_vec_unroller<Func, Derived, Start, HalfLength>::run(mat,func), - ei_redux_vec_unroller<Func, Derived, Start+HalfLength, Length-HalfLength>::run(mat,func) ); + redux_vec_unroller<Func, Derived, Start, HalfLength>::run(mat,func), + redux_vec_unroller<Func, Derived, Start+HalfLength, Length-HalfLength>::run(mat,func) ); } }; template<typename Func, typename Derived, int Start> -struct ei_redux_vec_unroller<Func, Derived, Start, 1> +struct redux_vec_unroller<Func, Derived, Start, 1> { enum { - index = Start * ei_packet_traits<typename Derived::Scalar>::size, + index = Start * packet_traits<typename Derived::Scalar>::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<Scalar>::type PacketScalar; + typedef typename packet_traits<Scalar>::type PacketScalar; EIGEN_STRONG_INLINE static PacketScalar run(const Derived &mat, const Func&) { @@ -171,19 +173,19 @@ struct ei_redux_vec_unroller<Func, Derived, Start, 1> ***************************************************************************/ template<typename Func, typename Derived, - int Traversal = ei_redux_traits<Func, Derived>::Traversal, - int Unrolling = ei_redux_traits<Func, Derived>::Unrolling + int Traversal = redux_traits<Func, Derived>::Traversal, + int Unrolling = redux_traits<Func, Derived>::Unrolling > -struct ei_redux_impl; +struct redux_impl; template<typename Func, typename Derived> -struct ei_redux_impl<Func, Derived, DefaultTraversal, NoUnrolling> +struct redux_impl<Func, Derived, DefaultTraversal, NoUnrolling> { 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<Func, Derived, DefaultTraversal, NoUnrolling> }; template<typename Func, typename Derived> -struct ei_redux_impl<Func,Derived, DefaultTraversal, CompleteUnrolling> - : public ei_redux_novec_unroller<Func,Derived, 0, Derived::SizeAtCompileTime> +struct redux_impl<Func,Derived, DefaultTraversal, CompleteUnrolling> + : public redux_novec_unroller<Func,Derived, 0, Derived::SizeAtCompileTime> {}; template<typename Func, typename Derived> -struct ei_redux_impl<Func, Derived, LinearVectorizedTraversal, NoUnrolling> +struct redux_impl<Func, Derived, LinearVectorizedTraversal, NoUnrolling> { typedef typename Derived::Scalar Scalar; - typedef typename ei_packet_traits<Scalar>::type PacketScalar; + typedef typename packet_traits<Scalar>::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<Scalar>::size; - const Index alignedStart = ei_first_aligned(mat); + eigen_assert(size && "you are using an empty matrix"); + const Index packetSize = packet_traits<Scalar>::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<Func, Derived, LinearVectorizedTraversal, NoUnrolling> }; template<typename Func, typename Derived> -struct ei_redux_impl<Func, Derived, SliceVectorizedTraversal, NoUnrolling> +struct redux_impl<Func, Derived, SliceVectorizedTraversal, NoUnrolling> { typedef typename Derived::Scalar Scalar; - typedef typename ei_packet_traits<Scalar>::type PacketScalar; + typedef typename packet_traits<Scalar>::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<Scalar>::size + packetSize = packet_traits<Scalar>::size }; const Index packetedInnerSize = ((innerSize)/packetSize)*packetSize; Scalar res; @@ -277,7 +279,7 @@ struct ei_redux_impl<Func, Derived, SliceVectorizedTraversal, NoUnrolling> 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<Func, Derived, DefaultTraversal, NoUnrolling>::run(mat, func); + res = redux_impl<Func, Derived, DefaultTraversal, NoUnrolling>::run(mat, func); } return res; @@ -285,25 +287,31 @@ struct ei_redux_impl<Func, Derived, SliceVectorizedTraversal, NoUnrolling> }; template<typename Func, typename Derived> -struct ei_redux_impl<Func, Derived, LinearVectorizedTraversal, CompleteUnrolling> +struct redux_impl<Func, Derived, LinearVectorizedTraversal, CompleteUnrolling> { typedef typename Derived::Scalar Scalar; - typedef typename ei_packet_traits<Scalar>::type PacketScalar; + typedef typename packet_traits<Scalar>::type PacketScalar; enum { - PacketSize = ei_packet_traits<Scalar>::size, + PacketSize = packet_traits<Scalar>::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<Func, Derived, 0, Size / PacketSize>::run(mat,func)); + eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix"); + Scalar res = func.predux(redux_vec_unroller<Func, Derived, 0, Size / PacketSize>::run(mat,func)); if (VectorizedSize != Size) - res = func(res,ei_redux_novec_unroller<Func, Derived, VectorizedSize, Size-VectorizedSize>::run(mat,func)); + res = func(res,redux_novec_unroller<Func, Derived, VectorizedSize, Size-VectorizedSize>::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<Func, Derived, LinearVectorizedTraversal, CompleteUnrolling */ template<typename Derived> template<typename Func> -EIGEN_STRONG_INLINE typename ei_result_of<Func(typename ei_traits<Derived>::Scalar)>::type +EIGEN_STRONG_INLINE typename internal::result_of<Func(typename internal::traits<Derived>::Scalar)>::type DenseBase<Derived>::redux(const Func& func) const { - typedef typename ei_cleantype<typename Derived::Nested>::type ThisNested; - return ei_redux_impl<Func, ThisNested> + typedef typename internal::cleantype<typename Derived::Nested>::type ThisNested; + return internal::redux_impl<Func, ThisNested> ::run(derived(), func); } /** \returns the minimum of all coefficients of *this */ template<typename Derived> -EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar +EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar DenseBase<Derived>::minCoeff() const { - return this->redux(Eigen::ei_scalar_min_op<Scalar>()); + return this->redux(Eigen::internal::scalar_min_op<Scalar>()); } /** \returns the maximum of all coefficients of *this */ template<typename Derived> -EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar +EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar DenseBase<Derived>::maxCoeff() const { - return this->redux(Eigen::ei_scalar_max_op<Scalar>()); + return this->redux(Eigen::internal::scalar_max_op<Scalar>()); } /** \returns the sum of all coefficients of *this @@ -345,12 +353,12 @@ DenseBase<Derived>::maxCoeff() const * \sa trace(), prod(), mean() */ template<typename Derived> -EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar +EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar DenseBase<Derived>::sum() const { if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0)) return Scalar(0); - return this->redux(Eigen::ei_scalar_sum_op<Scalar>()); + return this->redux(Eigen::internal::scalar_sum_op<Scalar>()); } /** \returns the mean of all coefficients of *this @@ -358,10 +366,10 @@ DenseBase<Derived>::sum() const * \sa trace(), prod(), sum() */ template<typename Derived> -EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar +EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar DenseBase<Derived>::mean() const { - return Scalar(this->redux(Eigen::ei_scalar_sum_op<Scalar>())) / Scalar(this->size()); + return Scalar(this->redux(Eigen::internal::scalar_sum_op<Scalar>())) / Scalar(this->size()); } /** \returns the product of all coefficients of *this @@ -372,12 +380,12 @@ DenseBase<Derived>::mean() const * \sa sum(), mean(), trace() */ template<typename Derived> -EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar +EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar DenseBase<Derived>::prod() const { if(SizeAtCompileTime==0 || (SizeAtCompileTime==Dynamic && size()==0)) return Scalar(1); - return this->redux(Eigen::ei_scalar_product_op<Scalar>()); + return this->redux(Eigen::internal::scalar_product_op<Scalar>()); } /** \returns the trace of \c *this, i.e. the sum of the coefficients on the main diagonal. @@ -387,7 +395,7 @@ DenseBase<Derived>::prod() const * \sa diagonal(), sum() */ template<typename Derived> -EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar +EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar MatrixBase<Derived>::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<typename MatrixType,int RowFactor,int ColFactor> -struct ei_traits<Replicate<MatrixType,RowFactor,ColFactor> > - : ei_traits<MatrixType> +struct traits<Replicate<MatrixType,RowFactor,ColFactor> > + : traits<MatrixType> { typedef typename MatrixType::Scalar Scalar; - typedef typename ei_traits<MatrixType>::StorageKind StorageKind; - typedef typename ei_traits<MatrixType>::XprKind XprKind; - typedef typename ei_nested<MatrixType>::type MatrixTypeNested; - typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested; + typedef typename traits<MatrixType>::StorageKind StorageKind; + typedef typename traits<MatrixType>::XprKind XprKind; + typedef typename nested<MatrixType>::type MatrixTypeNested; + typedef typename unref<MatrixTypeNested>::type _MatrixTypeNested; enum { RowsAtCompileTime = RowFactor==Dynamic || int(MatrixType::RowsAtCompileTime)==Dynamic ? Dynamic @@ -65,29 +67,30 @@ struct ei_traits<Replicate<MatrixType,RowFactor,ColFactor> > CoeffReadCost = _MatrixTypeNested::CoeffReadCost }; }; +} template<typename MatrixType,int RowFactor,int ColFactor> class Replicate - : public ei_dense_xpr_base< Replicate<MatrixType,RowFactor,ColFactor> >::type + : public internal::dense_xpr_base< Replicate<MatrixType,RowFactor,ColFactor> >::type { public: - typedef typename ei_dense_xpr_base<Replicate>::type Base; + typedef typename internal::dense_xpr_base<Replicate>::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(Replicate) template<typename OriginalMatrixType> inline explicit Replicate(const OriginalMatrixType& matrix) : m_matrix(matrix), m_rowFactor(RowFactor), m_colFactor(ColFactor) { - EIGEN_STATIC_ASSERT((ei_is_same_type<MatrixType,OriginalMatrixType>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type<MatrixType,OriginalMatrixType>::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<typename OriginalMatrixType> 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<MatrixType,OriginalMatrixType>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type<MatrixType,OriginalMatrixType>::ret), THE_MATRIX_OR_EXPRESSION_THAT_YOU_PASSED_DOES_NOT_HAVE_THE_EXPECTED_TYPE) } @@ -97,10 +100,10 @@ template<typename MatrixType,int RowFactor,int ColFactor> 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<MatrixType>::RowsAtCompileTime==1 ? 0 + const Index actual_row = internal::traits<MatrixType>::RowsAtCompileTime==1 ? 0 : RowFactor==1 ? row : row%m_matrix.rows(); - const Index actual_col = ei_traits<MatrixType>::ColsAtCompileTime==1 ? 0 + const Index actual_col = internal::traits<MatrixType>::ColsAtCompileTime==1 ? 0 : ColFactor==1 ? col : col%m_matrix.cols(); @@ -109,10 +112,10 @@ template<typename MatrixType,int RowFactor,int ColFactor> class Replicate template<int LoadMode> inline PacketScalar packet(Index row, Index col) const { - const Index actual_row = ei_traits<MatrixType>::RowsAtCompileTime==1 ? 0 + const Index actual_row = internal::traits<MatrixType>::RowsAtCompileTime==1 ? 0 : RowFactor==1 ? row : row%m_matrix.rows(); - const Index actual_col = ei_traits<MatrixType>::ColsAtCompileTime==1 ? 0 + const Index actual_col = internal::traits<MatrixType>::ColsAtCompileTime==1 ? 0 : ColFactor==1 ? col : col%m_matrix.cols(); @@ -122,8 +125,8 @@ template<typename MatrixType,int RowFactor,int ColFactor> class Replicate protected: const typename MatrixType::Nested m_matrix; - const ei_variable_if_dynamic<Index, RowFactor> m_rowFactor; - const ei_variable_if_dynamic<Index, ColFactor> m_colFactor; + const internal::variable_if_dynamic<Index, RowFactor> m_rowFactor; + const internal::variable_if_dynamic<Index, ColFactor> 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<typename Derived> -struct ei_traits<ReturnByValue<Derived> > - : public ei_traits<typename ei_traits<Derived>::ReturnType> +struct traits<ReturnByValue<Derived> > + : public traits<typename traits<Derived>::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<typename ei_traits<Derived>::ReturnType>::Flags + Flags = (traits<typename traits<Derived>::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<typename Derived,int n,typename PlainObject> -struct ei_nested<ReturnByValue<Derived>, n, PlainObject> +struct nested<ReturnByValue<Derived>, n, PlainObject> { - typedef typename ei_traits<Derived>::ReturnType type; + typedef typename traits<Derived>::ReturnType type; }; +} // end namespace internal + template<typename Derived> class ReturnByValue - : public ei_dense_xpr_base< ReturnByValue<Derived> >::type + : public internal::dense_xpr_base< ReturnByValue<Derived> >::type { public: - typedef typename ei_traits<Derived>::ReturnType ReturnType; + typedef typename internal::traits<Derived>::ReturnType ReturnType; - typedef typename ei_dense_xpr_base<ReturnByValue>::type Base; + typedef typename internal::dense_xpr_base<ReturnByValue>::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(ReturnByValue) template<typename Dest> 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<typename MatrixType, int Direction> -struct ei_traits<Reverse<MatrixType, Direction> > - : ei_traits<MatrixType> +struct traits<Reverse<MatrixType, Direction> > + : traits<MatrixType> { typedef typename MatrixType::Scalar Scalar; - typedef typename ei_traits<MatrixType>::StorageKind StorageKind; - typedef typename ei_traits<MatrixType>::XprKind XprKind; - typedef typename ei_nested<MatrixType>::type MatrixTypeNested; - typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested; + typedef typename traits<MatrixType>::StorageKind StorageKind; + typedef typename traits<MatrixType>::XprKind XprKind; + typedef typename nested<MatrixType>::type MatrixTypeNested; + typedef typename unref<MatrixTypeNested>::type _MatrixTypeNested; enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime, @@ -65,21 +68,24 @@ struct ei_traits<Reverse<MatrixType, Direction> > }; }; -template<typename PacketScalar, bool ReversePacket> struct ei_reverse_packet_cond +template<typename PacketScalar, bool ReversePacket> 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<typename PacketScalar> struct ei_reverse_packet_cond<PacketScalar,false> + +template<typename PacketScalar> struct reverse_packet_cond<PacketScalar,false> { static inline PacketScalar run(const PacketScalar& x) { return x; } }; +} // end namespace internal + template<typename MatrixType, int Direction> class Reverse - : public ei_dense_xpr_base< Reverse<MatrixType, Direction> >::type + : public internal::dense_xpr_base< Reverse<MatrixType, Direction> >::type { public: - typedef typename ei_dense_xpr_base<Reverse>::type Base; + typedef typename internal::dense_xpr_base<Reverse>::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(Reverse) using Base::IsRowMajor; @@ -89,7 +95,7 @@ template<typename MatrixType, int Direction> class Reverse protected: enum { - PacketSize = ei_packet_traits<Scalar>::size, + PacketSize = internal::packet_traits<Scalar>::size, IsColMajor = !IsRowMajor, ReverseRow = (Direction == Vertical) || (Direction == BothDirections), ReverseCol = (Direction == Horizontal) || (Direction == BothDirections), @@ -99,7 +105,7 @@ template<typename MatrixType, int Direction> class Reverse || ((Direction == Vertical) && IsColMajor) || ((Direction == Horizontal) && IsRowMajor) }; - typedef ei_reverse_packet_cond<PacketScalar,ReversePacket> reverse_packet; + typedef internal::reverse_packet_cond<PacketScalar,ReversePacket> reverse_packet; public: inline Reverse(const MatrixType& matrix) : m_matrix(matrix) { } @@ -116,7 +122,7 @@ template<typename MatrixType, int Direction> 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<typename MatrixType, int Direction> 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<typename MatrixType, int Direction> class Reverse template<int LoadMode> inline const PacketScalar packet(Index index) const { - return ei_preverse(m_matrix.template packet<LoadMode>( m_matrix.size() - index - PacketSize )); + return internal::preverse(m_matrix.template packet<LoadMode>( m_matrix.size() - index - PacketSize )); } template<int LoadMode> inline void writePacket(Index index, const PacketScalar& x) { - m_matrix.const_cast_derived().template writePacket<LoadMode>(m_matrix.size() - index - PacketSize, ei_preverse(x)); + m_matrix.const_cast_derived().template writePacket<LoadMode>(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<ThenDerived>&, const DenseBase<ElseDerived>&) const */ +namespace internal { template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> -struct ei_traits<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> > - : ei_traits<ThenMatrixType> +struct traits<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> > + : traits<ThenMatrixType> { - typedef typename ei_traits<ThenMatrixType>::Scalar Scalar; + typedef typename traits<ThenMatrixType>::Scalar Scalar; typedef Dense StorageKind; - typedef typename ei_traits<ThenMatrixType>::XprKind XprKind; + typedef typename traits<ThenMatrixType>::XprKind XprKind; typedef typename ConditionMatrixType::Nested ConditionMatrixNested; typedef typename ThenMatrixType::Nested ThenMatrixNested; typedef typename ElseMatrixType::Nested ElseMatrixNested; @@ -56,19 +57,20 @@ struct ei_traits<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> > MaxRowsAtCompileTime = ConditionMatrixType::MaxRowsAtCompileTime, MaxColsAtCompileTime = ConditionMatrixType::MaxColsAtCompileTime, Flags = (unsigned int)ThenMatrixType::Flags & ElseMatrixType::Flags & HereditaryBits, - CoeffReadCost = ei_traits<typename ei_cleantype<ConditionMatrixNested>::type>::CoeffReadCost - + EIGEN_SIZE_MAX(ei_traits<typename ei_cleantype<ThenMatrixNested>::type>::CoeffReadCost, - ei_traits<typename ei_cleantype<ElseMatrixNested>::type>::CoeffReadCost) + CoeffReadCost = traits<typename cleantype<ConditionMatrixNested>::type>::CoeffReadCost + + EIGEN_SIZE_MAX(traits<typename cleantype<ThenMatrixNested>::type>::CoeffReadCost, + traits<typename cleantype<ElseMatrixNested>::type>::CoeffReadCost) }; }; +} template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> -class Select : ei_no_assignment_operator, - public ei_dense_xpr_base< Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >::type +class Select : internal::no_assignment_operator, + public internal::dense_xpr_base< Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >::type { public: - typedef typename ei_dense_xpr_base<Select>::type Base; + typedef typename internal::dense_xpr_base<Select>::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<typename MatrixType, unsigned int UpLo> -struct ei_traits<SelfAdjointView<MatrixType, UpLo> > : ei_traits<MatrixType> +struct traits<SelfAdjointView<MatrixType, UpLo> > : traits<MatrixType> { - typedef typename ei_nested<MatrixType>::type MatrixTypeNested; - typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested; + typedef typename nested<MatrixType>::type MatrixTypeNested; + typedef typename unref<MatrixTypeNested>::type _MatrixTypeNested; typedef MatrixType ExpressionType; enum { Mode = UpLo | SelfAdjoint, @@ -53,6 +55,7 @@ struct ei_traits<SelfAdjointView<MatrixType, UpLo> > : ei_traits<MatrixType> CoeffReadCost = _MatrixTypeNested::CoeffReadCost }; }; +} template <typename Lhs, int LhsMode, bool LhsIsVector, typename Rhs, int RhsMode, bool RhsIsVector> @@ -67,17 +70,17 @@ template<typename MatrixType, unsigned int UpLo> class SelfAdjointView typedef TriangularBase<SelfAdjointView> Base; /** \brief The type of coefficients in this matrix */ - typedef typename ei_traits<SelfAdjointView>::Scalar Scalar; + typedef typename internal::traits<SelfAdjointView>::Scalar Scalar; typedef typename MatrixType::Index Index; enum { - Mode = ei_traits<SelfAdjointView>::Mode + Mode = internal::traits<SelfAdjointView>::Mode }; typedef typename MatrixType::PlainObject PlainObject; inline SelfAdjointView(const MatrixType& matrix) : m_matrix(matrix) - { ei_assert(ei_are_flags_consistent<Mode>::ret); } + { eigen_assert(internal::are_flags_consistent<Mode>::ret); } inline Index rows() const { return m_matrix.rows(); } inline Index cols() const { return m_matrix.cols(); } @@ -164,7 +167,7 @@ template<typename MatrixType, unsigned int UpLo> class SelfAdjointView /** Real part of #Scalar */ typedef typename NumTraits<Scalar>::Real RealScalar; /** Return type of eigenvalues() */ - typedef Matrix<RealScalar, ei_traits<MatrixType>::ColsAtCompileTime, 1> EigenvaluesReturnType; + typedef Matrix<RealScalar, internal::traits<MatrixType>::ColsAtCompileTime, 1> EigenvaluesReturnType; EigenvaluesReturnType eigenvalues() const; RealScalar operatorNorm() const; @@ -175,16 +178,18 @@ template<typename MatrixType, unsigned int UpLo> class SelfAdjointView // template<typename OtherDerived, typename MatrixType, unsigned int UpLo> -// ei_selfadjoint_matrix_product_returntype<OtherDerived,SelfAdjointView<MatrixType,UpLo> > +// internal::selfadjoint_matrix_product_returntype<OtherDerived,SelfAdjointView<MatrixType,UpLo> > // operator*(const MatrixBase<OtherDerived>& lhs, const SelfAdjointView<MatrixType,UpLo>& rhs) // { -// return ei_matrix_selfadjoint_product_returntype<OtherDerived,SelfAdjointView<MatrixType,UpLo> >(lhs.derived(),rhs); +// return internal::matrix_selfadjoint_product_returntype<OtherDerived,SelfAdjointView<MatrixType,UpLo> >(lhs.derived(),rhs); // } // selfadjoint to dense matrix +namespace internal { + template<typename Derived1, typename Derived2, int UnrollCount, bool ClearOpposite> -struct ei_triangular_assignment_selector<Derived1, Derived2, (SelfAdjoint|Upper), UnrollCount, ClearOpposite> +struct triangular_assignment_selector<Derived1, Derived2, (SelfAdjoint|Upper), UnrollCount, ClearOpposite> { enum { col = (UnrollCount-1) / Derived1::RowsAtCompileTime, @@ -193,23 +198,23 @@ struct ei_triangular_assignment_selector<Derived1, Derived2, (SelfAdjoint|Upper) inline static void run(Derived1 &dst, const Derived2 &src) { - ei_triangular_assignment_selector<Derived1, Derived2, (SelfAdjoint|Upper), UnrollCount-1, ClearOpposite>::run(dst, src); + triangular_assignment_selector<Derived1, Derived2, (SelfAdjoint|Upper), UnrollCount-1, ClearOpposite>::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<typename Derived1, typename Derived2, bool ClearOpposite> -struct ei_triangular_assignment_selector<Derived1, Derived2, SelfAdjoint|Upper, 0, ClearOpposite> +struct triangular_assignment_selector<Derived1, Derived2, SelfAdjoint|Upper, 0, ClearOpposite> { inline static void run(Derived1 &, const Derived2 &) {} }; template<typename Derived1, typename Derived2, int UnrollCount, bool ClearOpposite> -struct ei_triangular_assignment_selector<Derived1, Derived2, (SelfAdjoint|Lower), UnrollCount, ClearOpposite> +struct triangular_assignment_selector<Derived1, Derived2, (SelfAdjoint|Lower), UnrollCount, ClearOpposite> { enum { col = (UnrollCount-1) / Derived1::RowsAtCompileTime, @@ -218,23 +223,23 @@ struct ei_triangular_assignment_selector<Derived1, Derived2, (SelfAdjoint|Lower) inline static void run(Derived1 &dst, const Derived2 &src) { - ei_triangular_assignment_selector<Derived1, Derived2, (SelfAdjoint|Lower), UnrollCount-1, ClearOpposite>::run(dst, src); + triangular_assignment_selector<Derived1, Derived2, (SelfAdjoint|Lower), UnrollCount-1, ClearOpposite>::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<typename Derived1, typename Derived2, bool ClearOpposite> -struct ei_triangular_assignment_selector<Derived1, Derived2, SelfAdjoint|Lower, 0, ClearOpposite> +struct triangular_assignment_selector<Derived1, Derived2, SelfAdjoint|Lower, 0, ClearOpposite> { inline static void run(Derived1 &, const Derived2 &) {} }; template<typename Derived1, typename Derived2, bool ClearOpposite> -struct ei_triangular_assignment_selector<Derived1, Derived2, SelfAdjoint|Upper, Dynamic, ClearOpposite> +struct triangular_assignment_selector<Derived1, Derived2, SelfAdjoint|Upper, Dynamic, ClearOpposite> { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -244,7 +249,7 @@ struct ei_triangular_assignment_selector<Derived1, Derived2, SelfAdjoint|Upper, for(Index i = 0; i < j; ++i) { dst.copyCoeff(i, j, src); - dst.coeffRef(j,i) = ei_conj(dst.coeff(i,j)); + dst.coeffRef(j,i) = conj(dst.coeff(i,j)); } dst.copyCoeff(j, j, src); } @@ -252,7 +257,7 @@ struct ei_triangular_assignment_selector<Derived1, Derived2, SelfAdjoint|Upper, }; template<typename Derived1, typename Derived2, bool ClearOpposite> -struct ei_triangular_assignment_selector<Derived1, Derived2, SelfAdjoint|Lower, Dynamic, ClearOpposite> +struct triangular_assignment_selector<Derived1, Derived2, SelfAdjoint|Lower, Dynamic, ClearOpposite> { inline static void run(Derived1 &dst, const Derived2 &src) { @@ -262,13 +267,15 @@ struct ei_triangular_assignment_selector<Derived1, Derived2, SelfAdjoint|Lower, for(Index j = 0; j < i; ++j) { dst.copyCoeff(i, j, src); - dst.coeffRef(j,i) = ei_conj(dst.coeff(i,j)); + dst.coeffRef(j,i) = conj(dst.coeff(i,j)); } dst.copyCoeff(i, i, src); } } }; +} // end namespace internal + /*************************************************************************** * Implementation of MatrixBase methods ***************************************************************************/ diff --git a/Eigen/src/Core/SelfCwiseBinaryOp.h b/Eigen/src/Core/SelfCwiseBinaryOp.h index f77589747..9a649c1ee 100644 --- a/Eigen/src/Core/SelfCwiseBinaryOp.h +++ b/Eigen/src/Core/SelfCwiseBinaryOp.h @@ -39,28 +39,31 @@ * * \sa class SwapWrapper for a similar trick. */ + +namespace internal { template<typename BinaryOp, typename Lhs, typename Rhs> -struct ei_traits<SelfCwiseBinaryOp<BinaryOp,Lhs,Rhs> > - : ei_traits<CwiseBinaryOp<BinaryOp,Lhs,Rhs> > +struct traits<SelfCwiseBinaryOp<BinaryOp,Lhs,Rhs> > + : traits<CwiseBinaryOp<BinaryOp,Lhs,Rhs> > { enum { // Note that it is still a good idea to preserve the DirectAccessBit // so that assign can correctly align the data. - Flags = ei_traits<CwiseBinaryOp<BinaryOp,Lhs,Rhs> >::Flags | (Lhs::Flags&DirectAccessBit) | (Lhs::Flags&LvalueBit), + Flags = traits<CwiseBinaryOp<BinaryOp,Lhs,Rhs> >::Flags | (Lhs::Flags&DirectAccessBit) | (Lhs::Flags&LvalueBit), OuterStrideAtCompileTime = Lhs::OuterStrideAtCompileTime, InnerStrideAtCompileTime = Lhs::InnerStrideAtCompileTime }; }; +} template<typename BinaryOp, typename Lhs, typename Rhs> class SelfCwiseBinaryOp - : public ei_dense_xpr_base< SelfCwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type + : public internal::dense_xpr_base< SelfCwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type { public: - typedef typename ei_dense_xpr_base<SelfCwiseBinaryOp>::type Base; + typedef typename internal::dense_xpr_base<SelfCwiseBinaryOp>::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(SelfCwiseBinaryOp) - typedef typename ei_packet_traits<Scalar>::type Packet; + typedef typename internal::packet_traits<Scalar>::type Packet; inline SelfCwiseBinaryOp(Lhs& xpr, const BinaryOp& func = BinaryOp()) : m_matrix(xpr), m_functor(func) {} @@ -88,7 +91,7 @@ template<typename BinaryOp, typename Lhs, typename Rhs> class SelfCwiseBinaryOp void copyCoeff(Index row, Index col, const DenseBase<OtherDerived>& 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<typename BinaryOp, typename Lhs, typename Rhs> class SelfCwiseBinaryOp void copyCoeff(Index index, const DenseBase<OtherDerived>& 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<typename BinaryOp, typename Lhs, typename Rhs> class SelfCwiseBinaryOp void copyPacket(Index row, Index col, const DenseBase<OtherDerived>& 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<StoreMode>(row, col, m_functor.packetOp(m_matrix.template packet<StoreMode>(row, col),_other.template packet<LoadMode>(row, col)) ); @@ -117,7 +120,7 @@ template<typename BinaryOp, typename Lhs, typename Rhs> class SelfCwiseBinaryOp void copyPacket(Index index, const DenseBase<OtherDerived>& 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<StoreMode>(index, m_functor.packetOp(m_matrix.template packet<StoreMode>(index),_other.template packet<LoadMode>(index)) ); } @@ -131,10 +134,10 @@ template<typename BinaryOp, typename Lhs, typename Rhs> class SelfCwiseBinaryOp EIGEN_CHECK_BINARY_COMPATIBILIY(BinaryOp,typename Lhs::Scalar,typename RhsDerived::Scalar); #ifdef EIGEN_DEBUG_ASSIGN - ei_assign_traits<SelfCwiseBinaryOp, RhsDerived>::debug(); + internal::assign_traits<SelfCwiseBinaryOp, RhsDerived>::debug(); #endif - ei_assert(rows() == rhs.rows() && cols() == rhs.cols()); - ei_assign_impl<SelfCwiseBinaryOp, RhsDerived>::run(*this,rhs.derived()); + eigen_assert(rows() == rhs.rows() && cols() == rhs.cols()); + internal::assign_impl<SelfCwiseBinaryOp, RhsDerived>::run(*this,rhs.derived()); #ifndef EIGEN_NO_DEBUG this->checkTransposeAliasing(rhs.derived()); #endif @@ -146,7 +149,7 @@ template<typename BinaryOp, typename Lhs, typename Rhs> class SelfCwiseBinaryOp // at first... SelfCwiseBinaryOp& operator=(const Rhs& _rhs) { - typename ei_nested<Rhs>::type rhs(_rhs); + typename internal::nested<Rhs>::type rhs(_rhs); return Base::operator=(rhs); } @@ -162,7 +165,7 @@ template<typename Derived> inline Derived& DenseBase<Derived>::operator*=(const Scalar& other) { typedef typename Derived::PlainObject PlainObject; - SelfCwiseBinaryOp<ei_scalar_product_op<Scalar>, Derived, typename PlainObject::ConstantReturnType> tmp(derived()); + SelfCwiseBinaryOp<internal::scalar_product_op<Scalar>, Derived, typename PlainObject::ConstantReturnType> tmp(derived()); tmp = PlainObject::Constant(rows(),cols(),other); return derived(); } @@ -170,9 +173,9 @@ inline Derived& DenseBase<Derived>::operator*=(const Scalar& other) template<typename Derived> inline Derived& DenseBase<Derived>::operator/=(const Scalar& other) { - typedef typename ei_meta_if<NumTraits<Scalar>::IsInteger, - ei_scalar_quotient_op<Scalar>, - ei_scalar_product_op<Scalar> >::ret BinOp; + typedef typename internal::meta_if<NumTraits<Scalar>::IsInteger, + internal::scalar_quotient_op<Scalar>, + internal::scalar_product_op<Scalar> >::ret BinOp; typedef typename Derived::PlainObject PlainObject; SelfCwiseBinaryOp<BinOp, Derived, typename PlainObject::ConstantReturnType> tmp(derived()); tmp = PlainObject::Constant(rows(),cols(), NumTraits<Scalar>::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<typename Lhs, typename Rhs, int Side> -class ei_trsolve_traits +class trsolve_traits { private: enum { @@ -43,19 +45,19 @@ class ei_trsolve_traits template<typename Lhs, typename Rhs, int Side, // can be OnTheLeft/OnTheRight int Mode, // can be Upper/Lower | UnitDiag - int Unrolling = ei_trsolve_traits<Lhs,Rhs,Side>::Unrolling, + int Unrolling = trsolve_traits<Lhs,Rhs,Side>::Unrolling, int StorageOrder = (int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor, - int RhsVectors = ei_trsolve_traits<Lhs,Rhs,Side>::RhsVectors + int RhsVectors = trsolve_traits<Lhs,Rhs,Side>::RhsVectors > -struct ei_triangular_solver_selector; +struct triangular_solver_selector; // forward and backward substitution, row-major, rhs is a vector template<typename Lhs, typename Rhs, int Mode> -struct ei_triangular_solver_selector<Lhs,Rhs,OnTheLeft,Mode,NoUnrolling,RowMajor,1> +struct triangular_solver_selector<Lhs,Rhs,OnTheLeft,Mode,NoUnrolling,RowMajor,1> { typedef typename Lhs::Scalar LhsScalar; typedef typename Rhs::Scalar RhsScalar; - typedef ei_blas_traits<Lhs> LhsProductTraits; + typedef blas_traits<Lhs> LhsProductTraits; typedef typename LhsProductTraits::ExtractType ActualLhsType; typedef typename Lhs::Index Index; enum { @@ -82,7 +84,7 @@ struct ei_triangular_solver_selector<Lhs,Rhs,OnTheLeft,Mode,NoUnrolling,RowMajor Index startRow = IsLower ? pi : pi-actualPanelWidth; Index startCol = IsLower ? 0 : pi; - ei_general_matrix_vector_product<Index,LhsScalar,RowMajor,LhsProductTraits::NeedToConjugate,RhsScalar,false>::run( + general_matrix_vector_product<Index,LhsScalar,RowMajor,LhsProductTraits::NeedToConjugate,RhsScalar,false>::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<Lhs,Rhs,OnTheLeft,Mode,NoUnrolling,RowMajor // forward and backward substitution, column-major, rhs is a vector template<typename Lhs, typename Rhs, int Mode> -struct ei_triangular_solver_selector<Lhs,Rhs,OnTheLeft,Mode,NoUnrolling,ColMajor,1> +struct triangular_solver_selector<Lhs,Rhs,OnTheLeft,Mode,NoUnrolling,ColMajor,1> { typedef typename Lhs::Scalar LhsScalar; typedef typename Rhs::Scalar RhsScalar; - typedef ei_blas_traits<Lhs> LhsProductTraits; + typedef blas_traits<Lhs> LhsProductTraits; typedef typename LhsProductTraits::ExtractType ActualLhsType; typedef typename Lhs::Index Index; enum { @@ -148,7 +150,7 @@ struct ei_triangular_solver_selector<Lhs,Rhs,OnTheLeft,Mode,NoUnrolling,ColMajor // let's directly call the low level product function because: // 1 - it is faster to compile // 2 - it is slighlty faster at runtime - ei_general_matrix_vector_product<Index,LhsScalar,ColMajor,LhsProductTraits::NeedToConjugate,RhsScalar,false>::run( + general_matrix_vector_product<Index,LhsScalar,ColMajor,LhsProductTraits::NeedToConjugate,RhsScalar,false>::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<Lhs,Rhs,OnTheLeft,Mode,NoUnrolling,ColMajor // transpose OnTheRight cases for vectors template<typename Lhs, typename Rhs, int Mode, int Unrolling, int StorageOrder> -struct ei_triangular_solver_selector<Lhs,Rhs,OnTheRight,Mode,Unrolling,StorageOrder,1> +struct triangular_solver_selector<Lhs,Rhs,OnTheRight,Mode,Unrolling,StorageOrder,1> { static void run(const Lhs& lhs, Rhs& rhs) { Transpose<Rhs> rhsTr(rhs); Transpose<Lhs> lhsTr(lhs); - ei_triangular_solver_selector<Transpose<Lhs>,Transpose<Rhs>,OnTheLeft,TriangularView<Lhs,Mode>::TransposeMode>::run(lhsTr,rhsTr); + triangular_solver_selector<Transpose<Lhs>,Transpose<Rhs>,OnTheLeft,TriangularView<Lhs,Mode>::TransposeMode>::run(lhsTr,rhsTr); } }; template <typename Scalar, typename Index, int Side, int Mode, bool Conjugate, int TriStorageOrder, int OtherStorageOrder> -struct ei_triangular_solve_matrix; +struct triangular_solve_matrix; // the rhs is a matrix template<typename Lhs, typename Rhs, int Side, int Mode, int StorageOrder> -struct ei_triangular_solver_selector<Lhs,Rhs,Side,Mode,NoUnrolling,StorageOrder,Dynamic> +struct triangular_solver_selector<Lhs,Rhs,Side,Mode,NoUnrolling,StorageOrder,Dynamic> { typedef typename Rhs::Scalar Scalar; typedef typename Rhs::Index Index; - typedef ei_blas_traits<Lhs> LhsProductTraits; + typedef blas_traits<Lhs> LhsProductTraits; typedef typename LhsProductTraits::DirectLinearAccessType ActualLhsType; static void run(const Lhs& lhs, Rhs& rhs) { const ActualLhsType actualLhs = LhsProductTraits::extract(lhs); - ei_triangular_solve_matrix<Scalar,Index,Side,Mode,LhsProductTraits::NeedToConjugate,StorageOrder, + triangular_solve_matrix<Scalar,Index,Side,Mode,LhsProductTraits::NeedToConjugate,StorageOrder, (Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor> ::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<Lhs,Rhs,Side,Mode,NoUnrolling,StorageOrder, template<typename Lhs, typename Rhs, int Mode, int Index, int Size, bool Stop = Index==Size> -struct ei_triangular_solver_unroller; +struct triangular_solver_unroller; template<typename Lhs, typename Rhs, int Mode, int Index, int Size> -struct ei_triangular_solver_unroller<Lhs,Rhs,Mode,Index,Size,false> { +struct triangular_solver_unroller<Lhs,Rhs,Mode,Index,Size,false> { enum { IsLower = ((Mode&Lower)==Lower), I = IsLower ? Index : Size - Index - 1, @@ -213,21 +215,23 @@ struct ei_triangular_solver_unroller<Lhs,Rhs,Mode,Index,Size,false> { if(!(Mode & UnitDiag)) rhs.coeffRef(I) /= lhs.coeff(I,I); - ei_triangular_solver_unroller<Lhs,Rhs,Mode,Index+1,Size>::run(lhs,rhs); + triangular_solver_unroller<Lhs,Rhs,Mode,Index+1,Size>::run(lhs,rhs); } }; template<typename Lhs, typename Rhs, int Mode, int Index, int Size> -struct ei_triangular_solver_unroller<Lhs,Rhs,Mode,Index,Size,true> { +struct triangular_solver_unroller<Lhs,Rhs,Mode,Index,Size,true> { static void run(const Lhs&, Rhs&) {} }; template<typename Lhs, typename Rhs, int Mode, int StorageOrder> -struct ei_triangular_solver_selector<Lhs,Rhs,OnTheLeft,Mode,CompleteUnrolling,StorageOrder,1> { +struct triangular_solver_selector<Lhs,Rhs,OnTheLeft,Mode,CompleteUnrolling,StorageOrder,1> { static void run(const Lhs& lhs, Rhs& rhs) - { ei_triangular_solver_unroller<Lhs,Rhs,Mode,0,Rhs::SizeAtCompileTime>::run(lhs,rhs); } + { triangular_solver_unroller<Lhs,Rhs,Mode,0,Rhs::SizeAtCompileTime>::run(lhs,rhs); } }; +} // end namespace internal + /*************************************************************************** * TriangularView methods ***************************************************************************/ @@ -246,17 +250,17 @@ template<int Side, typename OtherDerived> void TriangularView<MatrixType,Mode>::solveInPlace(const MatrixBase<OtherDerived>& _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<OtherDerived>::Flags & RowMajorBit && OtherDerived::IsVectorAtCompileTime }; - typedef typename ei_meta_if<copy, - typename ei_plain_matrix_type_column_major<OtherDerived>::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<OtherDerived>::Flags & RowMajorBit && OtherDerived::IsVectorAtCompileTime }; + typedef typename internal::meta_if<copy, + typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::ret OtherCopy; OtherCopy otherCopy(other); - ei_triangular_solver_selector<MatrixType, typename ei_unref<OtherCopy>::type, + internal::triangular_solver_selector<MatrixType, typename internal::unref<OtherCopy>::type, Side, Mode>::run(nestedExpression(), otherCopy); if (copy) @@ -296,10 +300,10 @@ void TriangularView<MatrixType,Mode>::solveInPlace(const MatrixBase<OtherDerived */ template<typename Derived, unsigned int Mode> template<int Side, typename RhsDerived> -typename ei_plain_matrix_type_column_major<RhsDerived>::type +typename internal::plain_matrix_type_column_major<RhsDerived>::type TriangularView<Derived,Mode>::solve(const MatrixBase<RhsDerived>& rhs) const { - typename ei_plain_matrix_type_column_major<RhsDerived>::type res(rhs); + typename internal::plain_matrix_type_column_major<RhsDerived>::type res(rhs); solveInPlace<Side>(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<typename ExpressionType, typename Scalar> -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<typename Derived> -inline typename NumTraits<typename ei_traits<Derived>::Scalar>::Real +inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::stableNorm() const { const Index blockSize = 4096; @@ -62,12 +64,12 @@ MatrixBase<Derived>::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 (; bi<n; bi+=blockSize) - ei_stable_norm_kernel(this->segment(bi,std::min(blockSize, n - bi)).template forceAlignedAccessIf<Alignment>(), ssq, scale, invScale); - return scale * ei_sqrt(ssq); + internal::stable_norm_kernel(this->segment(bi,std::min(blockSize, n - bi)).template forceAlignedAccessIf<Alignment>(), 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<Derived>::stableNorm() const * \sa norm(), stableNorm(), hypotNorm() */ template<typename Derived> -inline typename NumTraits<typename ei_traits<Derived>::Scalar>::Real +inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::blueNorm() const { static Index nmax = -1; @@ -116,7 +118,7 @@ MatrixBase<Derived>::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<Derived>::blueNorm() const RealScalar abig = RealScalar(0); for(Index j=0; j<n; ++j) { - RealScalar ax = ei_abs(coeff(j)); - if(ax > 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<Derived>::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<Derived>::blueNorm() const * \sa norm(), stableNorm() */ template<typename Derived> -inline typename NumTraits<typename ei_traits<Derived>::Scalar>::Real +inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real MatrixBase<Derived>::hypotNorm() const { - return this->cwiseAbs().redux(ei_scalar_hypot_op<RealScalar>()); + return this->cwiseAbs().redux(internal::scalar_hypot_op<RealScalar>()); } #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<Index, OuterStrideAtCompileTime> m_outer; - ei_variable_if_dynamic<Index, InnerStrideAtCompileTime> m_inner; + internal::variable_if_dynamic<Index, OuterStrideAtCompileTime> m_outer; + internal::variable_if_dynamic<Index, InnerStrideAtCompileTime> 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<typename ExpressionType> -struct ei_traits<SwapWrapper<ExpressionType> > : ei_traits<ExpressionType> {}; +struct traits<SwapWrapper<ExpressionType> > : traits<ExpressionType> {}; +} template<typename ExpressionType> class SwapWrapper - : public ei_dense_xpr_base<SwapWrapper<ExpressionType> >::type + : public internal::dense_xpr_base<SwapWrapper<ExpressionType> >::type { public: - typedef typename ei_dense_xpr_base<SwapWrapper>::type Base; + typedef typename internal::dense_xpr_base<SwapWrapper>::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(SwapWrapper) - typedef typename ei_packet_traits<Scalar>::type Packet; + typedef typename internal::packet_traits<Scalar>::type Packet; inline SwapWrapper(ExpressionType& xpr) : m_expression(xpr) {} @@ -65,7 +67,7 @@ template<typename ExpressionType> class SwapWrapper void copyCoeff(Index row, Index col, const DenseBase<OtherDerived>& 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<typename ExpressionType> class SwapWrapper void copyCoeff(Index index, const DenseBase<OtherDerived>& 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<typename ExpressionType> class SwapWrapper void copyPacket(Index row, Index col, const DenseBase<OtherDerived>& 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<StoreMode>(row, col); m_expression.template writePacket<StoreMode>(row, col, @@ -99,7 +101,7 @@ template<typename ExpressionType> class SwapWrapper void copyPacket(Index index, const DenseBase<OtherDerived>& 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<StoreMode>(index); m_expression.template writePacket<StoreMode>(index, _other.template packet<LoadMode>(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<typename MatrixType> -struct ei_traits<Transpose<MatrixType> > : ei_traits<MatrixType> +struct traits<Transpose<MatrixType> > : traits<MatrixType> { typedef typename MatrixType::Scalar Scalar; - typedef typename ei_nested<MatrixType>::type MatrixTypeNested; - typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested; - typedef typename ei_traits<MatrixType>::StorageKind StorageKind; - typedef typename ei_traits<MatrixType>::XprKind XprKind; + typedef typename nested<MatrixType>::type MatrixTypeNested; + typedef typename unref<MatrixTypeNested>::type _MatrixTypeNested; + typedef typename traits<MatrixType>::StorageKind StorageKind; + typedef typename traits<MatrixType>::XprKind XprKind; enum { RowsAtCompileTime = MatrixType::ColsAtCompileTime, ColsAtCompileTime = MatrixType::RowsAtCompileTime, @@ -54,19 +56,20 @@ struct ei_traits<Transpose<MatrixType> > : ei_traits<MatrixType> MaxColsAtCompileTime = MatrixType::MaxRowsAtCompileTime, Flags = int(_MatrixTypeNested::Flags & ~NestByRefBit) ^ RowMajorBit, CoeffReadCost = _MatrixTypeNested::CoeffReadCost, - InnerStrideAtCompileTime = ei_inner_stride_at_compile_time<MatrixType>::ret, - OuterStrideAtCompileTime = ei_outer_stride_at_compile_time<MatrixType>::ret + InnerStrideAtCompileTime = inner_stride_at_compile_time<MatrixType>::ret, + OuterStrideAtCompileTime = outer_stride_at_compile_time<MatrixType>::ret }; }; +} template<typename MatrixType, typename StorageKind> class TransposeImpl; template<typename MatrixType> class Transpose - : public TransposeImpl<MatrixType,typename ei_traits<MatrixType>::StorageKind> + : public TransposeImpl<MatrixType,typename internal::traits<MatrixType>::StorageKind> { public: - typedef typename TransposeImpl<MatrixType,typename ei_traits<MatrixType>::StorageKind>::Base Base; + typedef typename TransposeImpl<MatrixType,typename internal::traits<MatrixType>::StorageKind>::Base Base; EIGEN_GENERIC_PUBLIC_INTERFACE(Transpose) inline Transpose(const MatrixType& matrix) : m_matrix(matrix) {} @@ -77,35 +80,39 @@ template<typename MatrixType> class Transpose inline Index cols() const { return m_matrix.rows(); } /** \returns the nested expression */ - const typename ei_cleantype<typename MatrixType::Nested>::type& + const typename internal::cleantype<typename MatrixType::Nested>::type& nestedExpression() const { return m_matrix; } /** \returns the nested expression */ - typename ei_cleantype<typename MatrixType::Nested>::type& + typename internal::cleantype<typename MatrixType::Nested>::type& nestedExpression() { return m_matrix.const_cast_derived(); } protected: const typename MatrixType::Nested m_matrix; }; -template<typename MatrixType, bool HasDirectAccess = ei_has_direct_access<MatrixType>::ret> -struct ei_TransposeImpl_base +namespace internal { + +template<typename MatrixType, bool HasDirectAccess = has_direct_access<MatrixType>::ret> +struct TransposeImpl_base { - typedef typename ei_dense_xpr_base<Transpose<MatrixType> >::type type; + typedef typename dense_xpr_base<Transpose<MatrixType> >::type type; }; template<typename MatrixType> -struct ei_TransposeImpl_base<MatrixType, false> +struct TransposeImpl_base<MatrixType, false> { - typedef typename ei_dense_xpr_base<Transpose<MatrixType> >::type type; + typedef typename dense_xpr_base<Transpose<MatrixType> >::type type; }; +} // end namespace internal + template<typename MatrixType> class TransposeImpl<MatrixType,Dense> - : public ei_TransposeImpl_base<MatrixType>::type + : public internal::TransposeImpl_base<MatrixType>::type { public: - typedef typename ei_TransposeImpl_base<MatrixType>::type Base; + typedef typename internal::TransposeImpl_base<MatrixType>::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(Transpose<MatrixType>) inline Index innerStride() const { return derived().nestedExpression().innerStride(); } @@ -214,7 +221,7 @@ DenseBase<Derived>::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<typename Derived> inline const typename MatrixBase<Derived>::AdjointReturnType MatrixBase<Derived>::adjoint() const @@ -226,19 +233,21 @@ MatrixBase<Derived>::adjoint() const * "in place" transpose implementation ***************************************************************************/ +namespace internal { + template<typename MatrixType, bool IsSquare = (MatrixType::RowsAtCompileTime == MatrixType::ColsAtCompileTime) && MatrixType::RowsAtCompileTime!=Dynamic> -struct ei_inplace_transpose_selector; +struct inplace_transpose_selector; template<typename MatrixType> -struct ei_inplace_transpose_selector<MatrixType,true> { // square matrix +struct inplace_transpose_selector<MatrixType,true> { // square matrix static void run(MatrixType& m) { m.template triangularView<StrictlyUpper>().swap(m.transpose()); } }; template<typename MatrixType> -struct ei_inplace_transpose_selector<MatrixType,false> { // non square matrix +struct inplace_transpose_selector<MatrixType,false> { // non square matrix static void run(MatrixType& m) { if (m.rows()==m.cols()) m.template triangularView<StrictlyUpper>().swap(m.transpose()); @@ -247,6 +256,8 @@ struct ei_inplace_transpose_selector<MatrixType,false> { // 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<MatrixType,false> { // non square matrix template<typename Derived> inline void DenseBase<Derived>::transposeInPlace() { - ei_inplace_transpose_selector<Derived>::run(derived()); + internal::inplace_transpose_selector<Derived>::run(derived()); } /*************************************************************************** @@ -303,45 +314,47 @@ inline void MatrixBase<Derived>::adjointInPlace() // The following is to detect aliasing problems in most common cases. +namespace internal { + template<typename BinOp,typename NestedXpr,typename Rhs> -struct ei_blas_traits<SelfCwiseBinaryOp<BinOp,NestedXpr,Rhs> > - : ei_blas_traits<NestedXpr> +struct blas_traits<SelfCwiseBinaryOp<BinOp,NestedXpr,Rhs> > + : blas_traits<NestedXpr> { typedef SelfCwiseBinaryOp<BinOp,NestedXpr,Rhs> XprType; static inline const XprType extract(const XprType& x) { return x; } }; template<bool DestIsTransposed, typename OtherDerived> -struct ei_check_transpose_aliasing_compile_time_selector +struct check_transpose_aliasing_compile_time_selector { - enum { ret = ei_blas_traits<OtherDerived>::IsTransposed != DestIsTransposed + enum { ret = blas_traits<OtherDerived>::IsTransposed != DestIsTransposed }; }; template<bool DestIsTransposed, typename BinOp, typename DerivedA, typename DerivedB> -struct ei_check_transpose_aliasing_compile_time_selector<DestIsTransposed,CwiseBinaryOp<BinOp,DerivedA,DerivedB> > +struct check_transpose_aliasing_compile_time_selector<DestIsTransposed,CwiseBinaryOp<BinOp,DerivedA,DerivedB> > { - enum { ret = ei_blas_traits<DerivedA>::IsTransposed != DestIsTransposed - || ei_blas_traits<DerivedB>::IsTransposed != DestIsTransposed + enum { ret = blas_traits<DerivedA>::IsTransposed != DestIsTransposed + || blas_traits<DerivedB>::IsTransposed != DestIsTransposed }; }; template<typename Scalar, bool DestIsTransposed, typename OtherDerived> -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<OtherDerived>::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(Scalar*)ei_extract_data(src)); + return (blas_traits<OtherDerived>::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(Scalar*)extract_data(src)); } }; template<typename Scalar, bool DestIsTransposed, typename BinOp, typename DerivedA, typename DerivedB> -struct ei_check_transpose_aliasing_run_time_selector<Scalar,DestIsTransposed,CwiseBinaryOp<BinOp,DerivedA,DerivedB> > +struct check_transpose_aliasing_run_time_selector<Scalar,DestIsTransposed,CwiseBinaryOp<BinOp,DerivedA,DerivedB> > { static bool run(const Scalar* dest, const CwiseBinaryOp<BinOp,DerivedA,DerivedB>& src) { - return ((ei_blas_traits<DerivedA>::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(Scalar*)ei_extract_data(src.lhs()))) - || ((ei_blas_traits<DerivedB>::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(Scalar*)ei_extract_data(src.rhs()))); + return ((blas_traits<DerivedA>::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(Scalar*)extract_data(src.lhs()))) + || ((blas_traits<DerivedB>::IsTransposed != DestIsTransposed) && (dest!=0 && dest==(Scalar*)extract_data(src.rhs()))); } }; @@ -353,16 +366,16 @@ struct ei_check_transpose_aliasing_run_time_selector<Scalar,DestIsTransposed,Cwi template<typename Derived, typename OtherDerived, bool MightHaveTransposeAliasing - = ei_check_transpose_aliasing_compile_time_selector - <ei_blas_traits<Derived>::IsTransposed,OtherDerived>::ret + = check_transpose_aliasing_compile_time_selector + <blas_traits<Derived>::IsTransposed,OtherDerived>::ret > struct checkTransposeAliasing_impl { static void run(const Derived& dst, const OtherDerived& other) { - ei_assert((!ei_check_transpose_aliasing_run_time_selector - <typename Derived::Scalar,ei_blas_traits<Derived>::IsTransposed,OtherDerived> - ::run(ei_extract_data(dst), other)) + eigen_assert((!check_transpose_aliasing_run_time_selector + <typename Derived::Scalar,blas_traits<Derived>::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<Derived, OtherDerived, false> } }; +} // end namespace internal template<typename Derived> template<typename OtherDerived> void DenseBase<Derived>::checkTransposeAliasing(const OtherDerived& other) const { - checkTransposeAliasing_impl<Derived, OtherDerived>::run(derived(), other); + internal::checkTransposeAliasing_impl<Derived, OtherDerived>::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<typename TranspositionType, typename MatrixType, int Side, bool Transposed=false> struct ei_transposition_matrix_product_retval; + +namespace internal { +template<typename TranspositionType, typename MatrixType, int Side, bool Transposed=false> struct transposition_matrix_product_retval; +} template<int SizeAtCompileTime, int MaxSizeAtCompileTime> class Transpositions @@ -188,11 +191,11 @@ class Transpositions /** \returns the \a matrix with the \a transpositions applied to the columns. */ template<typename Derived, int SizeAtCompileTime, int MaxSizeAtCompileTime> -inline const ei_transposition_matrix_product_retval<Transpositions<SizeAtCompileTime, MaxSizeAtCompileTime>, Derived, OnTheRight> +inline const internal::transposition_matrix_product_retval<Transpositions<SizeAtCompileTime, MaxSizeAtCompileTime>, Derived, OnTheRight> operator*(const MatrixBase<Derived>& matrix, const Transpositions<SizeAtCompileTime, MaxSizeAtCompileTime> &transpositions) { - return ei_transposition_matrix_product_retval + return internal::transposition_matrix_product_retval <Transpositions<SizeAtCompileTime, MaxSizeAtCompileTime>, Derived, OnTheRight> (transpositions, matrix.derived()); } @@ -200,30 +203,32 @@ operator*(const MatrixBase<Derived>& matrix, /** \returns the \a matrix with the \a transpositions applied to the rows. */ template<typename Derived, int SizeAtCompileTime, int MaxSizeAtCompileTime> -inline const ei_transposition_matrix_product_retval +inline const internal::transposition_matrix_product_retval <Transpositions<SizeAtCompileTime, MaxSizeAtCompileTime>, Derived, OnTheLeft> operator*(const Transpositions<SizeAtCompileTime, MaxSizeAtCompileTime> &transpositions, const MatrixBase<Derived>& matrix) { - return ei_transposition_matrix_product_retval + return internal::transposition_matrix_product_retval <Transpositions<SizeAtCompileTime, MaxSizeAtCompileTime>, Derived, OnTheLeft> (transpositions, matrix.derived()); } +namespace internal { + template<typename TranspositionType, typename MatrixType, int Side, bool Transposed> -struct ei_traits<ei_transposition_matrix_product_retval<TranspositionType, MatrixType, Side, Transposed> > +struct traits<transposition_matrix_product_retval<TranspositionType, MatrixType, Side, Transposed> > { typedef typename MatrixType::PlainObject ReturnType; }; template<typename TranspositionType, typename MatrixType, int Side, bool Transposed> -struct ei_transposition_matrix_product_retval - : public ReturnByValue<ei_transposition_matrix_product_retval<TranspositionType, MatrixType, Side, Transposed> > +struct transposition_matrix_product_retval + : public ReturnByValue<transposition_matrix_product_retval<TranspositionType, MatrixType, Side, Transposed> > { - typedef typename ei_cleantype<typename MatrixType::Nested>::type MatrixTypeNestedCleaned; + typedef typename cleantype<typename MatrixType::Nested>::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<MatrixTypeNestedCleaned,Dest>::ret && ei_extract_data(dst) == ei_extract_data(m_matrix))) + if(!(is_same_type<MatrixTypeNestedCleaned,Dest>::ret && extract_data(dst) == extract_data(m_matrix))) dst = m_matrix; for(int k=(Transposed?size-1:0) ; Transposed?k>=0:k<size ; Transposed?--k:++k) @@ -253,6 +258,8 @@ struct ei_transposition_matrix_product_retval const typename MatrixType::Nested m_matrix; }; +} // end namespace internal + /* Template partial specialization for transposed/inverse transpositions */ template<int SizeAtCompileTime, int MaxSizeAtCompileTime> @@ -269,19 +276,19 @@ class Transpose<Transpositions<SizeAtCompileTime, MaxSizeAtCompileTime> > /** \returns the \a matrix with the inverse transpositions applied to the columns. */ template<typename Derived> friend - inline const ei_transposition_matrix_product_retval<TranspositionType, Derived, OnTheRight, true> + inline const internal::transposition_matrix_product_retval<TranspositionType, Derived, OnTheRight, true> operator*(const MatrixBase<Derived>& matrix, const Transpose& trt) { - return ei_transposition_matrix_product_retval<TranspositionType, Derived, OnTheRight, true>(trt.m_transpositions, matrix.derived()); + return internal::transposition_matrix_product_retval<TranspositionType, Derived, OnTheRight, true>(trt.m_transpositions, matrix.derived()); } /** \returns the \a matrix with the inverse transpositions applied to the rows. */ template<typename Derived> - inline const ei_transposition_matrix_product_retval<TranspositionType, Derived, OnTheLeft, true> + inline const internal::transposition_matrix_product_retval<TranspositionType, Derived, OnTheLeft, true> operator*(const MatrixBase<Derived>& matrix) const { - return ei_transposition_matrix_product_retval<TranspositionType, Derived, OnTheLeft, true>(m_transpositions, matrix.derived()); + return internal::transposition_matrix_product_retval<TranspositionType, Derived, OnTheLeft, true>(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<typename Derived> class TriangularBase : public EigenBase<Derived> public: enum { - Mode = ei_traits<Derived>::Mode, - CoeffReadCost = ei_traits<Derived>::CoeffReadCost, - RowsAtCompileTime = ei_traits<Derived>::RowsAtCompileTime, - ColsAtCompileTime = ei_traits<Derived>::ColsAtCompileTime, - MaxRowsAtCompileTime = ei_traits<Derived>::MaxRowsAtCompileTime, - MaxColsAtCompileTime = ei_traits<Derived>::MaxColsAtCompileTime + Mode = internal::traits<Derived>::Mode, + CoeffReadCost = internal::traits<Derived>::CoeffReadCost, + RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime, + ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime, + MaxRowsAtCompileTime = internal::traits<Derived>::MaxRowsAtCompileTime, + MaxColsAtCompileTime = internal::traits<Derived>::MaxColsAtCompileTime }; - typedef typename ei_traits<Derived>::Scalar Scalar; - typedef typename ei_traits<Derived>::StorageKind StorageKind; - typedef typename ei_traits<Derived>::Index Index; + typedef typename internal::traits<Derived>::Scalar Scalar; + typedef typename internal::traits<Derived>::StorageKind StorageKind; + typedef typename internal::traits<Derived>::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<typename Derived> class TriangularBase : public EigenBase<Derived> { EIGEN_ONLY_USED_FOR_DEBUG(row); EIGEN_ONLY_USED_FOR_DEBUG(col); - ei_assert(col>=0 && col<cols() && row>=0 && row<rows()); - ei_assert( (Mode==Upper && col>=row) + eigen_assert(col>=0 && col<cols() && row>=0 && row<rows()); + eigen_assert( (Mode==Upper && col>=row) || (Mode==Lower && col<=row) || ((Mode==StrictlyUpper || Mode==UnitUpper) && col>row) || ((Mode==StrictlyLower || Mode==UnitLower) && col<row)); @@ -129,11 +129,12 @@ template<typename Derived> class TriangularBase : public EigenBase<Derived> * * \sa MatrixBase::triangularView() */ +namespace internal { template<typename MatrixType, unsigned int _Mode> -struct ei_traits<TriangularView<MatrixType, _Mode> > : ei_traits<MatrixType> +struct traits<TriangularView<MatrixType, _Mode> > : traits<MatrixType> { - typedef typename ei_nested<MatrixType>::type MatrixTypeNested; - typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested; + typedef typename nested<MatrixType>::type MatrixTypeNested; + typedef typename unref<MatrixTypeNested>::type _MatrixTypeNested; typedef MatrixType ExpressionType; enum { Mode = _Mode, @@ -141,6 +142,7 @@ struct ei_traits<TriangularView<MatrixType, _Mode> > : ei_traits<MatrixType> CoeffReadCost = _MatrixTypeNested::CoeffReadCost }; }; +} template<int Mode, bool LhsIsTriangular, typename Lhs, bool LhsIsVector, @@ -153,22 +155,22 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularView public: typedef TriangularBase<TriangularView> Base; - typedef typename ei_traits<TriangularView>::Scalar Scalar; + typedef typename internal::traits<TriangularView>::Scalar Scalar; typedef _MatrixType MatrixType; typedef typename MatrixType::PlainObject DenseMatrixType; protected: typedef typename MatrixType::Nested MatrixTypeNested; - typedef typename ei_cleantype<MatrixTypeNested>::type _MatrixTypeNested; - typedef typename ei_cleantype<typename MatrixType::ConjugateReturnType>::type MatrixConjugateReturnType; + typedef typename internal::cleantype<MatrixTypeNested>::type _MatrixTypeNested; + typedef typename internal::cleantype<typename MatrixType::ConjugateReturnType>::type MatrixConjugateReturnType; public: using Base::evalToLazy; - typedef typename ei_traits<TriangularView>::StorageKind StorageKind; - typedef typename ei_traits<TriangularView>::Index Index; + typedef typename internal::traits<TriangularView>::StorageKind StorageKind; + typedef typename internal::traits<TriangularView>::Index Index; enum { Mode = _Mode, @@ -179,7 +181,7 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularView }; inline TriangularView(const MatrixType& matrix) : m_matrix(matrix) - { ei_assert(ei_are_flags_consistent<Mode>::ret); } + { eigen_assert(internal::are_flags_consistent<Mode>::ret); } inline Index rows() const { return m_matrix.rows(); } inline Index cols() const { return m_matrix.cols(); } @@ -191,9 +193,9 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularView /** \sa MatrixBase::operator-=() */ template<typename Other> TriangularView& operator-=(const Other& other) { return *this = m_matrix - other; } /** \sa MatrixBase::operator*=() */ - TriangularView& operator*=(const typename ei_traits<MatrixType>::Scalar& other) { return *this = m_matrix * other; } + TriangularView& operator*=(const typename internal::traits<MatrixType>::Scalar& other) { return *this = m_matrix * other; } /** \sa MatrixBase::operator/=() */ - TriangularView& operator/=(const typename ei_traits<MatrixType>::Scalar& other) { return *this = m_matrix / other; } + TriangularView& operator/=(const typename internal::traits<MatrixType>::Scalar& other) { return *this = m_matrix / other; } /** \sa MatrixBase::fill() */ void fill(const Scalar& value) { setConstant(value); } @@ -292,14 +294,14 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularView template<int Side, typename OtherDerived> - typename ei_plain_matrix_type_column_major<OtherDerived>::type + typename internal::plain_matrix_type_column_major<OtherDerived>::type solve(const MatrixBase<OtherDerived>& other) const; template<int Side, typename OtherDerived> void solveInPlace(const MatrixBase<OtherDerived>& other) const; template<typename OtherDerived> - typename ei_plain_matrix_type_column_major<OtherDerived>::type + typename internal::plain_matrix_type_column_major<OtherDerived>::type solve(const MatrixBase<OtherDerived>& other) const { return solve<OnTheLeft>(other); } @@ -349,8 +351,10 @@ template<typename _MatrixType, unsigned int _Mode> class TriangularView * Implementation of triangular evaluation/assignment ***************************************************************************/ +namespace internal { + template<typename Derived1, typename Derived2, unsigned int Mode, int UnrollCount, bool ClearOpposite> -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<Derived1, Derived2, Mode, UnrollCount-1, ClearOpposite>::run(dst, src); + triangular_assignment_selector<Derived1, Derived2, Mode, UnrollCount-1, ClearOpposite>::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<typename Derived1, typename Derived2, unsigned int Mode, bool ClearOpposite> -struct ei_triangular_assignment_selector<Derived1, Derived2, Mode, 0, ClearOpposite> +struct triangular_assignment_selector<Derived1, Derived2, Mode, 0, ClearOpposite> { inline static void run(Derived1 &, const Derived2 &) {} }; template<typename Derived1, typename Derived2, bool ClearOpposite> -struct ei_triangular_assignment_selector<Derived1, Derived2, Upper, Dynamic, ClearOpposite> +struct triangular_assignment_selector<Derived1, Derived2, Upper, Dynamic, ClearOpposite> { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -407,7 +411,7 @@ struct ei_triangular_assignment_selector<Derived1, Derived2, Upper, Dynamic, Cle }; template<typename Derived1, typename Derived2, bool ClearOpposite> -struct ei_triangular_assignment_selector<Derived1, Derived2, Lower, Dynamic, ClearOpposite> +struct triangular_assignment_selector<Derived1, Derived2, Lower, Dynamic, ClearOpposite> { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -425,7 +429,7 @@ struct ei_triangular_assignment_selector<Derived1, Derived2, Lower, Dynamic, Cle }; template<typename Derived1, typename Derived2, bool ClearOpposite> -struct ei_triangular_assignment_selector<Derived1, Derived2, StrictlyUpper, Dynamic, ClearOpposite> +struct triangular_assignment_selector<Derived1, Derived2, StrictlyUpper, Dynamic, ClearOpposite> { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -443,7 +447,7 @@ struct ei_triangular_assignment_selector<Derived1, Derived2, StrictlyUpper, Dyna }; template<typename Derived1, typename Derived2, bool ClearOpposite> -struct ei_triangular_assignment_selector<Derived1, Derived2, StrictlyLower, Dynamic, ClearOpposite> +struct triangular_assignment_selector<Derived1, Derived2, StrictlyLower, Dynamic, ClearOpposite> { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -461,7 +465,7 @@ struct ei_triangular_assignment_selector<Derived1, Derived2, StrictlyLower, Dyna }; template<typename Derived1, typename Derived2, bool ClearOpposite> -struct ei_triangular_assignment_selector<Derived1, Derived2, UnitUpper, Dynamic, ClearOpposite> +struct triangular_assignment_selector<Derived1, Derived2, UnitUpper, Dynamic, ClearOpposite> { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -481,7 +485,7 @@ struct ei_triangular_assignment_selector<Derived1, Derived2, UnitUpper, Dynamic, } }; template<typename Derived1, typename Derived2, bool ClearOpposite> -struct ei_triangular_assignment_selector<Derived1, Derived2, UnitLower, Dynamic, ClearOpposite> +struct triangular_assignment_selector<Derived1, Derived2, UnitLower, Dynamic, ClearOpposite> { typedef typename Derived1::Index Index; inline static void run(Derived1 &dst, const Derived2 &src) @@ -501,6 +505,8 @@ struct ei_triangular_assignment_selector<Derived1, Derived2, UnitLower, Dynamic, } }; +} // end namespace internal + // FIXME should we keep that possibility template<typename MatrixType, unsigned int Mode> template<typename OtherDerived> @@ -509,7 +515,7 @@ TriangularView<MatrixType, Mode>::operator=(const MatrixBase<OtherDerived>& othe { if(OtherDerived::Flags & EvalBeforeAssigningBit) { - typename ei_plain_matrix_type<OtherDerived>::type other_evaluated(other.rows(), other.cols()); + typename internal::plain_matrix_type<OtherDerived>::type other_evaluated(other.rows(), other.cols()); other_evaluated.template triangularView<Mode>().lazyAssign(other.derived()); lazyAssign(other_evaluated); } @@ -525,12 +531,12 @@ void TriangularView<MatrixType, Mode>::lazyAssign(const MatrixBase<OtherDerived> { enum { unroll = MatrixType::SizeAtCompileTime != Dynamic - && ei_traits<OtherDerived>::CoeffReadCost != Dynamic - && MatrixType::SizeAtCompileTime*ei_traits<OtherDerived>::CoeffReadCost/2 <= EIGEN_UNROLLING_LIMIT + && internal::traits<OtherDerived>::CoeffReadCost != Dynamic + && MatrixType::SizeAtCompileTime*internal::traits<OtherDerived>::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 <MatrixType, OtherDerived, int(Mode), unroll ? int(MatrixType::SizeAtCompileTime) : Dynamic, false // do not change the opposite triangular part @@ -544,8 +550,8 @@ template<typename OtherDerived> inline TriangularView<MatrixType, Mode>& TriangularView<MatrixType, Mode>::operator=(const TriangularBase<OtherDerived>& other) { - ei_assert(Mode == int(OtherDerived::Mode)); - if(ei_traits<OtherDerived>::Flags & EvalBeforeAssigningBit) + eigen_assert(Mode == int(OtherDerived::Mode)); + if(internal::traits<OtherDerived>::Flags & EvalBeforeAssigningBit) { typename OtherDerived::DenseMatrixType other_evaluated(other.rows(), other.cols()); other_evaluated.template triangularView<Mode>().lazyAssign(other.derived().nestedExpression()); @@ -562,13 +568,13 @@ void TriangularView<MatrixType, Mode>::lazyAssign(const TriangularBase<OtherDeri { enum { unroll = MatrixType::SizeAtCompileTime != Dynamic - && ei_traits<OtherDerived>::CoeffReadCost != Dynamic - && MatrixType::SizeAtCompileTime * ei_traits<OtherDerived>::CoeffReadCost / 2 + && internal::traits<OtherDerived>::CoeffReadCost != Dynamic + && MatrixType::SizeAtCompileTime * internal::traits<OtherDerived>::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 <MatrixType, OtherDerived, int(Mode), unroll ? int(MatrixType::SizeAtCompileTime) : Dynamic, false // preserve the opposite triangular part @@ -585,9 +591,9 @@ template<typename Derived> template<typename DenseDerived> void TriangularBase<Derived>::evalTo(MatrixBase<DenseDerived> &other) const { - if(ei_traits<Derived>::Flags & EvalBeforeAssigningBit) + if(internal::traits<Derived>::Flags & EvalBeforeAssigningBit) { - typename ei_plain_matrix_type<Derived>::type other_evaluated(rows(), cols()); + typename internal::plain_matrix_type<Derived>::type other_evaluated(rows(), cols()); evalToLazy(other_evaluated); other.derived().swap(other_evaluated); } @@ -603,14 +609,14 @@ void TriangularBase<Derived>::evalToLazy(MatrixBase<DenseDerived> &other) const { enum { unroll = DenseDerived::SizeAtCompileTime != Dynamic - && ei_traits<Derived>::CoeffReadCost != Dynamic - && DenseDerived::SizeAtCompileTime * ei_traits<Derived>::CoeffReadCost / 2 + && internal::traits<Derived>::CoeffReadCost != Dynamic + && DenseDerived::SizeAtCompileTime * internal::traits<Derived>::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 - <DenseDerived, typename ei_traits<Derived>::ExpressionType, Derived::Mode, + internal::triangular_assignment_selector + <DenseDerived, typename internal::traits<Derived>::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<Derived>::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<Derived>::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<Derived>::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<typename VectorType, int Size> -struct ei_traits<VectorBlock<VectorType, Size> > - : public ei_traits<Block<VectorType, - ei_traits<VectorType>::Flags & RowMajorBit ? 1 : Size, - ei_traits<VectorType>::Flags & RowMajorBit ? Size : 1> > +struct traits<VectorBlock<VectorType, Size> > + : public traits<Block<VectorType, + traits<VectorType>::Flags & RowMajorBit ? 1 : Size, + traits<VectorType>::Flags & RowMajorBit ? Size : 1> > { }; +} template<typename VectorType, int Size> class VectorBlock : public Block<VectorType, - ei_traits<VectorType>::Flags & RowMajorBit ? 1 : Size, - ei_traits<VectorType>::Flags & RowMajorBit ? Size : 1> + internal::traits<VectorType>::Flags & RowMajorBit ? 1 : Size, + internal::traits<VectorType>::Flags & RowMajorBit ? Size : 1> { typedef Block<VectorType, - ei_traits<VectorType>::Flags & RowMajorBit ? 1 : Size, - ei_traits<VectorType>::Flags & RowMajorBit ? Size : 1> Base; + internal::traits<VectorType>::Flags & RowMajorBit ? 1 : Size, + internal::traits<VectorType>::Flags & RowMajorBit ? Size : 1> Base; enum { - IsColVector = !(ei_traits<VectorType>::Flags & RowMajorBit) + IsColVector = !(internal::traits<VectorType>::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<typename MatrixType, typename MemberOp, int Direction> -struct ei_traits<PartialReduxExpr<MatrixType, MemberOp, Direction> > - : ei_traits<MatrixType> +struct traits<PartialReduxExpr<MatrixType, MemberOp, Direction> > + : traits<MatrixType> { typedef typename MemberOp::result_type Scalar; - typedef typename ei_traits<MatrixType>::StorageKind StorageKind; - typedef typename ei_traits<MatrixType>::XprKind XprKind; + typedef typename traits<MatrixType>::StorageKind StorageKind; + typedef typename traits<MatrixType>::XprKind XprKind; typedef typename MatrixType::Scalar InputScalar; - typedef typename ei_nested<MatrixType>::type MatrixTypeNested; - typedef typename ei_cleantype<MatrixTypeNested>::type _MatrixTypeNested; + typedef typename nested<MatrixType>::type MatrixTypeNested; + typedef typename cleantype<MatrixTypeNested>::type _MatrixTypeNested; enum { RowsAtCompileTime = Direction==Vertical ? 1 : MatrixType::RowsAtCompileTime, ColsAtCompileTime = Direction==Horizontal ? 1 : MatrixType::ColsAtCompileTime, @@ -70,20 +71,21 @@ struct ei_traits<PartialReduxExpr<MatrixType, MemberOp, Direction> > typedef typename MemberOp::template Cost<InputScalar,TraversalSize> 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<MatrixType, MemberOp, Direction> >::type +class PartialReduxExpr : internal::no_assignment_operator, + public internal::dense_xpr_base< PartialReduxExpr<MatrixType, MemberOp, Direction> >::type { public: - typedef typename ei_dense_xpr_base<PartialReduxExpr>::type Base; + typedef typename internal::dense_xpr_base<PartialReduxExpr>::type Base; EIGEN_DENSE_PUBLIC_INTERFACE(PartialReduxExpr) - typedef typename ei_traits<PartialReduxExpr>::MatrixTypeNested MatrixTypeNested; - typedef typename ei_traits<PartialReduxExpr>::_MatrixTypeNested _MatrixTypeNested; + typedef typename internal::traits<PartialReduxExpr>::MatrixTypeNested MatrixTypeNested; + typedef typename internal::traits<PartialReduxExpr>::_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 <typename ResultType> \ - 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<typename Scalar, int Size> 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<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost); EIGEN_MEMBER_FUNCTOR(norm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost); EIGEN_MEMBER_FUNCTOR(stableNorm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost); EIGEN_MEMBER_FUNCTOR(blueNorm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost); -EIGEN_MEMBER_FUNCTOR(hypotNorm, (Size-1) * ei_functor_traits<ei_scalar_hypot_op<Scalar> >::Cost ); +EIGEN_MEMBER_FUNCTOR(hypotNorm, (Size-1) * functor_traits<scalar_hypot_op<Scalar> >::Cost ); EIGEN_MEMBER_FUNCTOR(sum, (Size-1)*NumTraits<Scalar>::AddCost); EIGEN_MEMBER_FUNCTOR(mean, (Size-1)*NumTraits<Scalar>::AddCost + NumTraits<Scalar>::MulCost); EIGEN_MEMBER_FUNCTOR(minCoeff, (Size-1)*NumTraits<Scalar>::AddCost); @@ -139,20 +143,20 @@ EIGEN_MEMBER_FUNCTOR(count, (Size-1)*NumTraits<Scalar>::AddCost); EIGEN_MEMBER_FUNCTOR(prod, (Size-1)*NumTraits<Scalar>::MulCost); -/** \internal */ template <typename BinaryOp, typename Scalar> -struct ei_member_redux { - typedef typename ei_result_of< +struct member_redux { + typedef typename result_of< BinaryOp(Scalar) >::type result_type; template<typename _Scalar, int Size> struct Cost - { enum { value = (Size-1) * ei_functor_traits<BinaryOp>::Cost }; }; - ei_member_redux(const BinaryOp func) : m_functor(func) {} + { enum { value = (Size-1) * functor_traits<BinaryOp>::Cost }; }; + member_redux(const BinaryOp func) : m_functor(func) {} template<typename Derived> inline result_type operator()(const DenseBase<Derived>& mat) const { return mat.redux(m_functor); } const BinaryOp m_functor; }; +} /** \class VectorwiseOp * \ingroup Core_Module @@ -178,11 +182,11 @@ template<typename ExpressionType, int Direction> class VectorwiseOp typedef typename ExpressionType::Scalar Scalar; typedef typename ExpressionType::RealScalar RealScalar; typedef typename ExpressionType::Index Index; - typedef typename ei_meta_if<ei_must_nest_by_value<ExpressionType>::ret, + typedef typename internal::meta_if<internal::must_nest_by_value<ExpressionType>::ret, ExpressionType, const ExpressionType&>::ret ExpressionTypeNested; template<template<typename _Scalar> class Functor, - typename Scalar=typename ei_traits<ExpressionType>::Scalar> struct ReturnType + typename Scalar=typename internal::traits<ExpressionType>::Scalar> struct ReturnType { typedef PartialReduxExpr<ExpressionType, Functor<Scalar>, @@ -193,7 +197,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp template<typename BinaryOp> struct ReduxReturnType { typedef PartialReduxExpr<ExpressionType, - ei_member_redux<BinaryOp,typename ei_traits<ExpressionType>::Scalar>, + internal::member_redux<BinaryOp,typename internal::traits<ExpressionType>::Scalar>, Direction > Type; }; @@ -207,7 +211,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp /** \internal * \returns the i-th subvector according to the \c Direction */ - typedef typename ei_meta_if<Direction==Vertical, + typedef typename internal::meta_if<Direction==Vertical, typename ExpressionType::ColXpr, typename ExpressionType::RowXpr>::ret SubVector; SubVector subVector(Index i) @@ -265,7 +269,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp * Output: \verbinclude PartialRedux_minCoeff.out * * \sa DenseBase::minCoeff() */ - const typename ReturnType<ei_member_minCoeff>::Type minCoeff() const + const typename ReturnType<internal::member_minCoeff>::Type minCoeff() const { return _expression(); } /** \returns a row (or column) vector expression of the largest coefficient @@ -275,7 +279,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp * Output: \verbinclude PartialRedux_maxCoeff.out * * \sa DenseBase::maxCoeff() */ - const typename ReturnType<ei_member_maxCoeff>::Type maxCoeff() const + const typename ReturnType<internal::member_maxCoeff>::Type maxCoeff() const { return _expression(); } /** \returns a row (or column) vector expression of the squared norm @@ -285,7 +289,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp * Output: \verbinclude PartialRedux_squaredNorm.out * * \sa DenseBase::squaredNorm() */ - const typename ReturnType<ei_member_squaredNorm,RealScalar>::Type squaredNorm() const + const typename ReturnType<internal::member_squaredNorm,RealScalar>::Type squaredNorm() const { return _expression(); } /** \returns a row (or column) vector expression of the norm @@ -295,7 +299,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp * Output: \verbinclude PartialRedux_norm.out * * \sa DenseBase::norm() */ - const typename ReturnType<ei_member_norm,RealScalar>::Type norm() const + const typename ReturnType<internal::member_norm,RealScalar>::Type norm() const { return _expression(); } @@ -304,7 +308,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp * blue's algorithm. * * \sa DenseBase::blueNorm() */ - const typename ReturnType<ei_member_blueNorm,RealScalar>::Type blueNorm() const + const typename ReturnType<internal::member_blueNorm,RealScalar>::Type blueNorm() const { return _expression(); } @@ -313,7 +317,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp * underflow and overflow. * * \sa DenseBase::stableNorm() */ - const typename ReturnType<ei_member_stableNorm,RealScalar>::Type stableNorm() const + const typename ReturnType<internal::member_stableNorm,RealScalar>::Type stableNorm() const { return _expression(); } @@ -322,7 +326,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp * underflow and overflow using a concatenation of hypot() calls. * * \sa DenseBase::hypotNorm() */ - const typename ReturnType<ei_member_hypotNorm,RealScalar>::Type hypotNorm() const + const typename ReturnType<internal::member_hypotNorm,RealScalar>::Type hypotNorm() const { return _expression(); } /** \returns a row (or column) vector expression of the sum @@ -332,28 +336,28 @@ template<typename ExpressionType, int Direction> class VectorwiseOp * Output: \verbinclude PartialRedux_sum.out * * \sa DenseBase::sum() */ - const typename ReturnType<ei_member_sum>::Type sum() const + const typename ReturnType<internal::member_sum>::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<ei_member_mean>::Type mean() const + const typename ReturnType<internal::member_mean>::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<ei_member_all>::Type all() const + const typename ReturnType<internal::member_all>::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<ei_member_any>::Type any() const + const typename ReturnType<internal::member_any>::Type any() const { return _expression(); } /** \returns a row (or column) vector expression representing @@ -363,7 +367,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp * Output: \verbinclude PartialRedux_count.out * * \sa DenseBase::count() */ - const PartialReduxExpr<ExpressionType, ei_member_count<Index>, Direction> count() const + const PartialReduxExpr<ExpressionType, internal::member_count<Index>, Direction> count() const { return _expression(); } /** \returns a row (or column) vector expression of the product @@ -373,7 +377,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp * Output: \verbinclude PartialRedux_prod.out * * \sa DenseBase::prod() */ - const typename ReturnType<ei_member_prod>::Type prod() const + const typename ReturnType<internal::member_prod>::Type prod() const { return _expression(); } @@ -413,7 +417,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp ExpressionType& operator=(const DenseBase<OtherDerived>& 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<subVectors(); ++j) subVector(j) = other; return const_cast<ExpressionType&>(m_matrix); @@ -441,7 +445,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp /** Returns the expression of the sum of the vector \a other to each subvector of \c *this */ template<typename OtherDerived> EIGEN_STRONG_INLINE - CwiseBinaryOp<ei_scalar_sum_op<Scalar>, + CwiseBinaryOp<internal::scalar_sum_op<Scalar>, ExpressionType, typename ExtendedType<OtherDerived>::Type> operator+(const DenseBase<OtherDerived>& other) const @@ -452,7 +456,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp /** Returns the expression of the difference between each subvector of \c *this and the vector \a other */ template<typename OtherDerived> - CwiseBinaryOp<ei_scalar_difference_op<Scalar>, + CwiseBinaryOp<internal::scalar_difference_op<Scalar>, ExpressionType, typename ExtendedType<OtherDerived>::Type> operator-(const DenseBase<OtherDerived>& other) const @@ -470,21 +474,21 @@ template<typename ExpressionType, int Direction> class VectorwiseOp const CrossReturnType cross(const MatrixBase<OtherDerived>& other) const; enum { - HNormalized_Size = Direction==Vertical ? ei_traits<ExpressionType>::RowsAtCompileTime - : ei_traits<ExpressionType>::ColsAtCompileTime, + HNormalized_Size = Direction==Vertical ? internal::traits<ExpressionType>::RowsAtCompileTime + : internal::traits<ExpressionType>::ColsAtCompileTime, HNormalized_SizeMinusOne = HNormalized_Size==Dynamic ? Dynamic : HNormalized_Size-1 }; typedef Block<ExpressionType, Direction==Vertical ? int(HNormalized_SizeMinusOne) - : int(ei_traits<ExpressionType>::RowsAtCompileTime), + : int(internal::traits<ExpressionType>::RowsAtCompileTime), Direction==Horizontal ? int(HNormalized_SizeMinusOne) - : int(ei_traits<ExpressionType>::ColsAtCompileTime)> + : int(internal::traits<ExpressionType>::ColsAtCompileTime)> HNormalized_Block; typedef Block<ExpressionType, - Direction==Vertical ? 1 : int(ei_traits<ExpressionType>::RowsAtCompileTime), - Direction==Horizontal ? 1 : int(ei_traits<ExpressionType>::ColsAtCompileTime)> + Direction==Vertical ? 1 : int(internal::traits<ExpressionType>::RowsAtCompileTime), + Direction==Horizontal ? 1 : int(internal::traits<ExpressionType>::ColsAtCompileTime)> HNormalized_Factors; - typedef CwiseBinaryOp<ei_scalar_quotient_op<typename ei_traits<ExpressionType>::Scalar>, + typedef CwiseBinaryOp<internal::scalar_quotient_op<typename internal::traits<ExpressionType>::Scalar>, HNormalized_Block, Replicate<HNormalized_Factors, Direction==Vertical ? HNormalized_SizeMinusOne : 1, diff --git a/Eigen/src/Core/Visitor.h b/Eigen/src/Core/Visitor.h index db6fac4b1..6b3b3bfb4 100644 --- a/Eigen/src/Core/Visitor.h +++ b/Eigen/src/Core/Visitor.h @@ -25,8 +25,10 @@ #ifndef EIGEN_VISITOR_H #define EIGEN_VISITOR_H +namespace internal { + template<typename Visitor, typename Derived, int UnrollCount> -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<Visitor, Derived, UnrollCount-1>::run(mat, visitor); + visitor_impl<Visitor, Derived, UnrollCount-1>::run(mat, visitor); visitor(mat.coeff(row, col), row, col); } }; template<typename Visitor, typename Derived> -struct ei_visitor_impl<Visitor, Derived, 1> +struct visitor_impl<Visitor, Derived, 1> { inline static void run(const Derived &mat, Visitor& visitor) { @@ -50,7 +52,7 @@ struct ei_visitor_impl<Visitor, Derived, 1> }; template<typename Visitor, typename Derived> -struct ei_visitor_impl<Visitor, Derived, Dynamic> +struct visitor_impl<Visitor, Derived, Dynamic> { typedef typename Derived::Index Index; inline static void run(const Derived& mat, Visitor& visitor) @@ -64,6 +66,7 @@ struct ei_visitor_impl<Visitor, Derived, Dynamic> } }; +} // end namespace internal /** Applies the visitor \a visitor to the whole coefficients of the matrix or vector. * @@ -88,19 +91,21 @@ void DenseBase<Derived>::visit(Visitor& visitor) const { enum { unroll = SizeAtCompileTime != Dynamic && CoeffReadCost != Dynamic - && (SizeAtCompileTime == 1 || ei_functor_traits<Visitor>::Cost != Dynamic) - && SizeAtCompileTime * CoeffReadCost + (SizeAtCompileTime-1) * ei_functor_traits<Visitor>::Cost + && (SizeAtCompileTime == 1 || internal::functor_traits<Visitor>::Cost != Dynamic) + && SizeAtCompileTime * CoeffReadCost + (SizeAtCompileTime-1) * internal::functor_traits<Visitor>::Cost <= EIGEN_UNROLLING_LIMIT }; - return ei_visitor_impl<Visitor, Derived, + return internal::visitor_impl<Visitor, Derived, unroll ? int(SizeAtCompileTime) : Dynamic >::run(derived(), visitor); } +namespace internal { + /** \internal * \brief Base class to implement min and max visitors */ template <typename Derived> -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 <typename Derived> -struct ei_min_coeff_visitor : ei_coeff_visitor<Derived> +struct min_coeff_visitor : coeff_visitor<Derived> { typedef typename Derived::Index Index; typedef typename Derived::Scalar Scalar; @@ -136,7 +141,7 @@ struct ei_min_coeff_visitor : ei_coeff_visitor<Derived> }; template<typename Scalar> -struct ei_functor_traits<ei_min_coeff_visitor<Scalar> > { +struct functor_traits<min_coeff_visitor<Scalar> > { enum { Cost = NumTraits<Scalar>::AddCost }; @@ -148,7 +153,7 @@ struct ei_functor_traits<ei_min_coeff_visitor<Scalar> > { * \sa DenseBase::maxCoeff(Index*, Index*) */ template <typename Derived> -struct ei_max_coeff_visitor : ei_coeff_visitor<Derived> +struct max_coeff_visitor : coeff_visitor<Derived> { typedef typename Derived::Index Index; typedef typename Derived::Scalar Scalar; @@ -164,22 +169,24 @@ struct ei_max_coeff_visitor : ei_coeff_visitor<Derived> }; template<typename Scalar> -struct ei_functor_traits<ei_max_coeff_visitor<Scalar> > { +struct functor_traits<max_coeff_visitor<Scalar> > { enum { Cost = NumTraits<Scalar>::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 Derived> -typename ei_traits<Derived>::Scalar +typename internal::traits<Derived>::Scalar DenseBase<Derived>::minCoeff(Index* row, Index* col) const { - ei_min_coeff_visitor<Derived> minVisitor; + internal::min_coeff_visitor<Derived> minVisitor; this->visit(minVisitor); *row = minVisitor.row; if (col) *col = minVisitor.col; @@ -192,11 +199,11 @@ DenseBase<Derived>::minCoeff(Index* row, Index* col) const * \sa DenseBase::minCoeff(Index*,Index*), DenseBase::maxCoeff(Index*,Index*), DenseBase::visitor(), DenseBase::minCoeff() */ template<typename Derived> -typename ei_traits<Derived>::Scalar +typename internal::traits<Derived>::Scalar DenseBase<Derived>::minCoeff(Index* index) const { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) - ei_min_coeff_visitor<Derived> minVisitor; + internal::min_coeff_visitor<Derived> minVisitor; this->visit(minVisitor); *index = (RowsAtCompileTime==1) ? minVisitor.col : minVisitor.row; return minVisitor.res; @@ -208,10 +215,10 @@ DenseBase<Derived>::minCoeff(Index* index) const * \sa DenseBase::minCoeff(Index*,Index*), DenseBase::visitor(), DenseBase::maxCoeff() */ template<typename Derived> -typename ei_traits<Derived>::Scalar +typename internal::traits<Derived>::Scalar DenseBase<Derived>::maxCoeff(Index* row, Index* col) const { - ei_max_coeff_visitor<Derived> maxVisitor; + internal::max_coeff_visitor<Derived> maxVisitor; this->visit(maxVisitor); *row = maxVisitor.row; if (col) *col = maxVisitor.col; @@ -224,11 +231,11 @@ DenseBase<Derived>::maxCoeff(Index* row, Index* col) const * \sa DenseBase::maxCoeff(Index*,Index*), DenseBase::minCoeff(Index*,Index*), DenseBase::visitor(), DenseBase::maxCoeff() */ template<typename Derived> -typename ei_traits<Derived>::Scalar +typename internal::traits<Derived>::Scalar DenseBase<Derived>::maxCoeff(Index* index) const { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) - ei_max_coeff_visitor<Derived> maxVisitor; + internal::max_coeff_visitor<Derived> 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<std::complex<float> > : ei_default_packet_traits +template<> struct packet_traits<std::complex<float> > : default_packet_traits { typedef Packet2cf type; enum { @@ -61,106 +63,106 @@ template<> struct ei_packet_traits<std::complex<float> > : ei_default_packet_tr }; }; -template<> struct ei_unpacket_traits<Packet2cf> { typedef std::complex<float> type; enum {size=2}; }; +template<> struct unpacket_traits<Packet2cf> { typedef std::complex<float> type; enum {size=2}; }; -template<> EIGEN_STRONG_INLINE Packet2cf ei_pset1<Packet2cf>(const std::complex<float>& from) +template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>& 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<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_add(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_psub<Packet2cf>(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<Packet4f>(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<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_add(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(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<Packet4f>(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<Packet2cf>(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(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 <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_and(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_por <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_or(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pxor <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_xor(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_and(a.v, vec_nor(b.v,b.v))); } +template<> EIGEN_STRONG_INLINE Packet2cf pand <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_and(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf por <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_or(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pxor <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(vec_xor(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(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 <std::complex<float> >(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(ei_pload((const float*)from)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_ploadu<std::complex<float> >(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ei_ploadu((const float*)from)); } +template<> EIGEN_STRONG_INLINE Packet2cf pload <std::complex<float> >(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload((const float*)from)); } +template<> EIGEN_STRONG_INLINE Packet2cf ploadu<std::complex<float> >(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu((const float*)from)); } -template<> EIGEN_STRONG_INLINE void ei_pstore <std::complex<float> >(std::complex<float> * to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE ei_pstore((float*)to, from.v); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu<std::complex<float> >(std::complex<float> * to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE ei_pstoreu((float*)to, from.v); } +template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> * to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((float*)to, from.v); } +template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> * to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((float*)to, from.v); } -template<> EIGEN_STRONG_INLINE void ei_prefetch<std::complex<float> >(const std::complex<float> * addr) { vec_dstt((float *)addr, DST_CTRL(2,2,32), DST_CHAN); } +template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> * addr) { vec_dstt((float *)addr, DST_CTRL(2,2,32), DST_CHAN); } -template<> EIGEN_STRONG_INLINE std::complex<float> ei_pfirst<Packet2cf>(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet2cf>(const Packet2cf& a) { std::complex<float> 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<float> ei_predux<Packet2cf>(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(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<Packet2cf>(const Packet2cf* vecs) +template<> EIGEN_STRONG_INLINE Packet2cf preduxp<Packet2cf>(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<float> ei_predux_mul<Packet2cf>(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(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<int Offset> -struct ei_palign_impl<Offset,Packet2cf> +struct palign_impl<Offset,Packet2cf> { EIGEN_STRONG_INLINE static void run(Packet2cf& first, const Packet2cf& second) { @@ -171,45 +173,47 @@ struct ei_palign_impl<Offset,Packet2cf> } }; -template<> struct ei_conj_helper<Packet2cf, Packet2cf, false,true> +template<> struct conj_helper<Packet2cf, Packet2cf, false,true> { 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<Packet2cf, Packet2cf, true,false> +template<> struct conj_helper<Packet2cf, Packet2cf, true,false> { 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<Packet2cf, Packet2cf, true,true> +template<> struct conj_helper<Packet2cf, Packet2cf, true,true> { 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<Packet2cf>(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { // TODO optimize it for AltiVec - Packet2cf res = ei_conj_helper<Packet2cf,Packet2cf,false,true>().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<Packet2cf,Packet2cf,false,true>().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<Packet4f>(X) + Packet4f p4f_##NAME = pset1<Packet4f>(X) #define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \ - Packet4f ei_p4f_##NAME = vreinterpretq_f32_u32(ei_pset1<int>(X)) + Packet4f p4f_##NAME = vreinterpretq_f32_u32(pset1<int>(X)) #define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \ - Packet4i ei_p4i_##NAME = ei_pset1<Packet4i>(X) + Packet4i p4i_##NAME = pset1<Packet4i>(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<float> : ei_default_packet_traits +template<> struct packet_traits<float> : default_packet_traits { typedef Packet4f type; enum { @@ -100,7 +102,7 @@ template<> struct ei_packet_traits<float> : ei_default_packet_traits HasSqrt = 0 }; }; -template<> struct ei_packet_traits<int> : ei_default_packet_traits +template<> struct packet_traits<int> : default_packet_traits { typedef Packet4i type; enum { @@ -111,8 +113,8 @@ template<> struct ei_packet_traits<int> : ei_default_packet_traits }; }; -template<> struct ei_unpacket_traits<Packet4f> { typedef float type; enum {size=4}; }; -template<> struct ei_unpacket_traits<Packet4i> { typedef int type; enum {size=4}; }; +template<> struct unpacket_traits<Packet4f> { typedef float type; enum {size=4}; }; +template<> struct unpacket_traits<Packet4i> { 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<Packet4f>(const float& from) { +template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(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<Packet4f>(const float& from) { return vc; } -template<> EIGEN_STRONG_INLINE Packet4i ei_pset1<Packet4i>(const int& from) { +template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(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<Packet4i>(const int& from) return vc; } -template<> EIGEN_STRONG_INLINE Packet4f ei_plset<float>(const float& a) { return vec_add(ei_pset1<Packet4f>(a), ei_p4f_COUNTDOWN); } -template<> EIGEN_STRONG_INLINE Packet4i ei_plset<int>(const int& a) { return vec_add(ei_pset1<Packet4i>(a), ei_p4i_COUNTDOWN); } +template<> EIGEN_STRONG_INLINE Packet4f plset<float>(const float& a) { return vec_add(pset1<Packet4f>(a), p4f_COUNTDOWN); } +template<> EIGEN_STRONG_INLINE Packet4i plset<int>(const int& a) { return vec_add(pset1<Packet4i>(a), p4i_COUNTDOWN); } -template<> EIGEN_STRONG_INLINE Packet4f ei_padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_add(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_add(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_add(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_add(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_sub(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_sub(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_sub(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_sub(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pnegate(const Packet4f& a) { return ei_psub<Packet4f>(ei_p4f_ZERO, a); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pnegate(const Packet4i& a) { return ei_psub<Packet4i>(ei_p4i_ZERO, a); } +template<> EIGEN_STRONG_INLINE Packet4f pnegate(const Packet4f& a) { return psub<Packet4f>(p4f_ZERO, a); } +template<> EIGEN_STRONG_INLINE Packet4i pnegate(const Packet4i& a) { return psub<Packet4i>(p4i_ZERO, a); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_madd(a,b,ei_p4f_ZERO); } +template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(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<Packet4i>(const Packet4i& a, const Packet4i& b) +template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(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<Packet4i>(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<Packet4i>(const Packet4i& a, con return prod; } */ -template<> EIGEN_STRONG_INLINE Packet4f ei_pdiv<Packet4f>(const Packet4f& a, const Packet4f& b) +template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b) { Packet4f t, y_0, y_1, res; @@ -232,45 +234,45 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_pdiv<Packet4f>(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<Packet4i>(const Packet4i& /*a*/, const Packet4i& /*b*/) -{ ei_assert(false && "packet integer division are not supported by AltiVec"); - return ei_pset1<Packet4i>(0); +template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& /*a*/, const Packet4i& /*b*/) +{ eigen_assert(false && "packet integer division are not supported by AltiVec"); + return pset1<Packet4i>(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<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_min(a, b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_min(a, b); } +template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_min(a, b); } +template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_min(a, b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pmax<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_max(a, b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmax<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_max(a, b); } +template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_max(a, b); } +template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(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<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_and(a, b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_and(a, b); } +template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_and(a, b); } +template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_and(a, b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_por<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_or(a, b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_por<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_or(a, b); } +template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_or(a, b); } +template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_or(a, b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pxor<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_xor(a, b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_xor(a, b); } +template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_xor(a, b); } +template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_xor(a, b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_and(a, vec_nor(b, b)); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_and(a, vec_nor(b, b)); } +template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) { return vec_and(a, vec_nor(b, b)); } +template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return vec_and(a, vec_nor(b, b)); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pload<Packet4f>(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return vec_ld(0, from); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pload<Packet4i>(const int* from) { EIGEN_DEBUG_ALIGNED_LOAD return vec_ld(0, from); } +template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return vec_ld(0, from); } +template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int* from) { EIGEN_DEBUG_ALIGNED_LOAD return vec_ld(0, from); } -template<> EIGEN_STRONG_INLINE Packet4f ei_ploadu<Packet4f>(const float* from) +template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(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<Packet4f>(const float* from) return (Packet4f) vec_perm(MSQ, LSQ, mask); // align the data } -template<> EIGEN_STRONG_INLINE Packet4i ei_ploadu<Packet4i>(const int* from) +template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(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<Packet4i>(const int* from) return (Packet4i) vec_perm(MSQ, LSQ, mask); // align the data } -template<> EIGEN_STRONG_INLINE void ei_pstore<float>(float* to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE vec_st(from, 0, to); } -template<> EIGEN_STRONG_INLINE void ei_pstore<int>(int* to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE vec_st(from, 0, to); } +template<> EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE vec_st(from, 0, to); } +template<> EIGEN_STRONG_INLINE void pstore<int>(int* to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE vec_st(from, 0, to); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu<float>(float* to, const Packet4f& from) +template<> EIGEN_STRONG_INLINE void pstoreu<float>(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>(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>(int* to, const Packet4i& from) +template<> EIGEN_STRONG_INLINE void pstoreu<int>(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>(int* to, const Packet4i vec_st( MSQ, 0, (unsigned char *)to ); // Store the MSQ part } -template<> EIGEN_STRONG_INLINE void ei_prefetch<float>(const float* addr) { vec_dstt(addr, DST_CTRL(2,2,32), DST_CHAN); } -template<> EIGEN_STRONG_INLINE void ei_prefetch<int>(const int* addr) { vec_dstt(addr, DST_CTRL(2,2,32), DST_CHAN); } +template<> EIGEN_STRONG_INLINE void prefetch<float>(const float* addr) { vec_dstt(addr, DST_CTRL(2,2,32), DST_CHAN); } +template<> EIGEN_STRONG_INLINE void prefetch<int>(const int* addr) { vec_dstt(addr, DST_CTRL(2,2,32), DST_CHAN); } -template<> EIGEN_STRONG_INLINE float ei_pfirst<Packet4f>(const Packet4f& a) { float EIGEN_ALIGN16 x[4]; vec_st(a, 0, x); return x[0]; } -template<> EIGEN_STRONG_INLINE int ei_pfirst<Packet4i>(const Packet4i& a) { int EIGEN_ALIGN16 x[4]; vec_st(a, 0, x); return x[0]; } +template<> EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) { float EIGEN_ALIGN16 x[4]; vec_st(a, 0, x); return x[0]; } +template<> EIGEN_STRONG_INLINE int pfirst<Packet4i>(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<Packet4f>(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux<Packet4f>(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<Packet4f>(const Packet4f* vecs) +template<> EIGEN_STRONG_INLINE Packet4f preduxp<Packet4f>(const Packet4f* vecs) { Packet4f v[4], sum[4]; @@ -384,15 +386,15 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_preduxp<Packet4f>(const Packet4f* vec return sum[0]; } -template<> EIGEN_STRONG_INLINE int ei_predux<Packet4i>(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux<Packet4i>(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<Packet4i>(const Packet4i* vecs) +template<> EIGEN_STRONG_INLINE Packet4i preduxp<Packet4i>(const Packet4i* vecs) { Packet4i v[4], sum[4]; @@ -422,56 +424,56 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_preduxp<Packet4i>(const Packet4i* vec // Other reduction functions: // mul -template<> EIGEN_STRONG_INLINE float ei_predux_mul<Packet4f>(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(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<Packet4i>(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_mul<Packet4i>(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<Packet4f>(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(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<Packet4i>(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_min<Packet4i>(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<Packet4f>(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(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<Packet4i>(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_max<Packet4i>(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<int Offset> -struct ei_palign_impl<Offset,Packet4f> +struct palign_impl<Offset,Packet4f> { EIGEN_STRONG_INLINE static void run(Packet4f& first, const Packet4f& second) { @@ -481,7 +483,7 @@ struct ei_palign_impl<Offset,Packet4f> }; template<int Offset> -struct ei_palign_impl<Offset,Packet4i> +struct palign_impl<Offset,Packet4i> { EIGEN_STRONG_INLINE static void run(Packet4i& first, const Packet4i& second) { @@ -489,4 +491,7 @@ struct ei_palign_impl<Offset,Packet4i> 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 <http://www.gnu.org/licenses/>. -#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<std::complex<float> > : ei_default_packet_traits +template<> struct packet_traits<std::complex<float> > : default_packet_traits { typedef Packet2cf type; enum { @@ -56,9 +58,9 @@ template<> struct ei_packet_traits<std::complex<float> > : ei_default_packet_tr }; }; -template<> struct ei_unpacket_traits<Packet2cf> { typedef std::complex<float> type; enum {size=2}; }; +template<> struct unpacket_traits<Packet2cf> { typedef std::complex<float> type; enum {size=2}; }; -template<> EIGEN_STRONG_INLINE Packet2cf ei_pset1<Packet2cf>(const std::complex<float>& from) +template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>& from) { float32x2_t r64; r64 = vld1_f32((float *)&from); @@ -66,15 +68,15 @@ template<> EIGEN_STRONG_INLINE Packet2cf ei_pset1<Packet2cf>(const std::complex< return Packet2cf(vcombine_f32(r64, r64)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(ei_padd<Packet4f>(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(ei_psub<Packet4f>(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pnegate(const Packet2cf& a) { return Packet2cf(ei_pnegate<Packet4f>(a.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pconj(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE Packet2cf padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(padd<Packet4f>(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(psub<Packet4f>(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate<Packet4f>(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<Packet2cf>(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(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<Packet2cf>(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<Packet2cf>(const Packet2cf& a, return Packet2cf(vaddq_f32(v1, v2)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pand <Packet2cf>(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pand <Packet2cf>(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 <Packet2cf>(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf por <Packet2cf>(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 <Packet2cf>(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pxor <Packet2cf>(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<Packet2cf>(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(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 <std::complex<float> >(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(ei_pload((const float*)from)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_ploadu<std::complex<float> >(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ei_ploadu((const float*)from)); } +template<> EIGEN_STRONG_INLINE Packet2cf pload <std::complex<float> >(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload((const float*)from)); } +template<> EIGEN_STRONG_INLINE Packet2cf ploadu<std::complex<float> >(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu((const float*)from)); } -template<> EIGEN_STRONG_INLINE void ei_pstore <std::complex<float> >(std::complex<float> * to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE ei_pstore((float*)to, from.v); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu<std::complex<float> >(std::complex<float> * to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE ei_pstoreu((float*)to, from.v); } +template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> * to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((float*)to, from.v); } +template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> * to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((float*)to, from.v); } -template<> EIGEN_STRONG_INLINE void ei_prefetch<std::complex<float> >(const std::complex<float> * addr) { __pld((float *)addr); } +template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> * addr) { __pld((float *)addr); } -template<> EIGEN_STRONG_INLINE std::complex<float> ei_pfirst<Packet2cf>(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet2cf>(const Packet2cf& a) { std::complex<float> 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/*<Packet2cf>*/(const Packet2cf& x) +EIGEN_STRONG_INLINE Packet2cf pcplxflip/*<Packet2cf>*/(const Packet2cf& x) { return Packet2cf(vrev64q_f32(a.v)); } -template<> EIGEN_STRONG_INLINE std::complex<float> ei_predux<Packet2cf>(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(const Packet2cf& a) { float32x2_t a1, a2; std::complex<float> s; @@ -159,7 +161,7 @@ template<> EIGEN_STRONG_INLINE std::complex<float> ei_predux<Packet2cf>(const Pa return s; } -template<> EIGEN_STRONG_INLINE Packet2cf ei_preduxp<Packet2cf>(const Packet2cf* vecs) +template<> EIGEN_STRONG_INLINE Packet2cf preduxp<Packet2cf>(const Packet2cf* vecs) { Packet4f sum1, sum2, sum; @@ -171,7 +173,7 @@ template<> EIGEN_STRONG_INLINE Packet2cf ei_preduxp<Packet2cf>(const Packet2cf* return Packet2cf(sum); } -template<> EIGEN_STRONG_INLINE std::complex<float> ei_predux_mul<Packet2cf>(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(const Packet2cf& a) { float32x2_t a1, a2, v1, v2, prod; std::complex<float> s; @@ -187,7 +189,7 @@ template<> EIGEN_STRONG_INLINE std::complex<float> ei_predux_mul<Packet2cf>(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<float> ei_predux_mul<Packet2cf>(cons } template<int Offset> -struct ei_palign_impl<Offset,Packet2cf> +struct palign_impl<Offset,Packet2cf> { EIGEN_STRONG_INLINE static void run(Packet2cf& first, const Packet2cf& second) { @@ -210,43 +212,43 @@ struct ei_palign_impl<Offset,Packet2cf> } }; -template<> struct ei_conj_helper<Packet2cf, Packet2cf, false,true> +template<> struct conj_helper<Packet2cf, Packet2cf, false,true> { 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<Packet2cf, Packet2cf, true,false> +template<> struct conj_helper<Packet2cf, Packet2cf, true,false> { 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<Packet2cf, Packet2cf, true,true> +template<> struct conj_helper<Packet2cf, Packet2cf, true,true> { 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<Packet2cf>(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { // TODO optimize it for AltiVec - Packet2cf res = ei_conj_helper<Packet2cf,Packet2cf,false,true>().pmul(a,b); + Packet2cf res = conj_helper<Packet2cf,Packet2cf,false,true>().pmul(a,b); Packet4f s, rev_s; float32x2_t a_lo, a_hi; @@ -256,7 +258,9 @@ template<> EIGEN_STRONG_INLINE Packet2cf ei_pdiv<Packet2cf>(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<Packet4f>(X) + const Packet4f p4f_##NAME = pset1<Packet4f>(X) #define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \ - const Packet4f ei_p4f_##NAME = vreinterpretq_f32_u32(ei_pset1<int>(X)) + const Packet4f p4f_##NAME = vreinterpretq_f32_u32(pset1<int>(X)) #define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \ - const Packet4i ei_p4i_##NAME = ei_pset1<Packet4i>(X) + const Packet4i p4i_##NAME = pset1<Packet4i>(X) #ifndef __pld #define __pld(x) asm volatile ( " pld [%[addr]]\n" :: [addr] "r" (x) : "cc" ); #endif -template<> struct ei_packet_traits<float> : ei_default_packet_traits +template<> struct packet_traits<float> : default_packet_traits { typedef Packet4f type; enum { @@ -74,7 +76,7 @@ template<> struct ei_packet_traits<float> : ei_default_packet_traits HasSqrt = 0 }; }; -template<> struct ei_packet_traits<int> : ei_default_packet_traits +template<> struct packet_traits<int> : default_packet_traits { typedef Packet4i type; enum { @@ -85,36 +87,36 @@ template<> struct ei_packet_traits<int> : ei_default_packet_traits }; }; -template<> struct ei_unpacket_traits<Packet4f> { typedef float type; enum {size=4}; }; -template<> struct ei_unpacket_traits<Packet4i> { typedef int type; enum {size=4}; }; +template<> struct unpacket_traits<Packet4f> { typedef float type; enum {size=4}; }; +template<> struct unpacket_traits<Packet4i> { typedef int type; enum {size=4}; }; -template<> EIGEN_STRONG_INLINE Packet4f ei_pset1<Packet4f>(const float& from) { return vdupq_n_f32(from); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pset1<Packet4i>(const int& from) { return vdupq_n_s32(from); } +template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float& from) { return vdupq_n_f32(from); } +template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int& from) { return vdupq_n_s32(from); } -template<> EIGEN_STRONG_INLINE Packet4f ei_plset<float>(const float& a) +template<> EIGEN_STRONG_INLINE Packet4f plset<float>(const float& a) { Packet4f countdown = { 3, 2, 1, 0 }; - return vaddq_f32(ei_pset1<Packet4f>(a), countdown); + return vaddq_f32(pset1<Packet4f>(a), countdown); } -template<> EIGEN_STRONG_INLINE Packet4i ei_plset<int>(const int& a) +template<> EIGEN_STRONG_INLINE Packet4i plset<int>(const int& a) { Packet4i countdown = { 3, 2, 1, 0 }; - return vaddq_s32(ei_pset1<Packet4i>(a), countdown); + return vaddq_s32(pset1<Packet4i>(a), countdown); } -template<> EIGEN_STRONG_INLINE Packet4f ei_padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return vaddq_f32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return vaddq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return vaddq_f32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return vaddq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return vsubq_f32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return vsubq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return vsubq_f32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(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<Packet4f>(const Packet4f& a, const Packet4f& b) { return vmulq_f32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmul<Packet4i>(const Packet4i& a, const Packet4i& b) { return vmulq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return vmulq_f32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(const Packet4i& a, const Packet4i& b) { return vmulq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pdiv<Packet4f>(const Packet4f& a, const Packet4f& b) +template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b) { Packet4f inv, restep, div; @@ -135,59 +137,59 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_pdiv<Packet4f>(const Packet4f& a, con return div; } -template<> EIGEN_STRONG_INLINE Packet4i ei_pdiv<Packet4i>(const Packet4i& /*a*/, const Packet4i& /*b*/) -{ ei_assert(false && "packet integer division are not supported by NEON"); - return ei_pset1<Packet4i>(0); +template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& /*a*/, const Packet4i& /*b*/) +{ eigen_assert(false && "packet integer division are not supported by NEON"); + return pset1<Packet4i>(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<Packet4f>(const Packet4f& a, const Packet4f& b) { return vminq_f32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vminq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) { return vminq_f32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(const Packet4i& a, const Packet4i& b) { return vminq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pmax<Packet4f>(const Packet4f& a, const Packet4f& b) { return vmaxq_f32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmax<Packet4i>(const Packet4i& a, const Packet4i& b) { return vmaxq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) { return vmaxq_f32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(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<Packet4f>(const Packet4f& a, const Packet4f& b) +template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(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<Packet4i>(const Packet4i& a, const Packet4i& b) { return vandq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return vandq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_por<Packet4f>(const Packet4f& a, const Packet4f& b) +template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(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<Packet4i>(const Packet4i& a, const Packet4i& b) { return vorrq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return vorrq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pxor<Packet4f>(const Packet4f& a, const Packet4f& b) +template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(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<Packet4i>(const Packet4i& a, const Packet4i& b) { return veorq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return veorq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) +template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(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<Packet4i>(const Packet4i& a, const Packet4i& b) { return vbicq_s32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return vbicq_s32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pload<float>(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f32(from); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pload<int>(const int* from) { EIGEN_DEBUG_ALIGNED_LOAD return vld1q_s32(from); } +template<> EIGEN_STRONG_INLINE Packet4f pload<float>(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return vld1q_f32(from); } +template<> EIGEN_STRONG_INLINE Packet4i pload<int>(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<Packet4f>(const float* from) +template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(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<Packet4i>(const float* from) +template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const float* from) { int32x2_t lo, ho; lo = vdup_n_s32(*from); @@ -195,20 +197,20 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_ploaddup<Packet4i>(const float* from) return vcombine_s32(lo, hi); } -template<> EIGEN_STRONG_INLINE void ei_pstore<float>(float* to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_f32(to, from); } -template<> EIGEN_STRONG_INLINE void ei_pstore<int>(int* to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_s32(to, from); } +template<> EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_f32(to, from); } +template<> EIGEN_STRONG_INLINE void pstore<int>(int* to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE vst1q_s32(to, from); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu<float>(float* to, const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_f32(to, from); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu<int>(int* to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_s32(to, from); } +template<> EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_f32(to, from); } +template<> EIGEN_STRONG_INLINE void pstoreu<int>(int* to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE vst1q_s32(to, from); } -template<> EIGEN_STRONG_INLINE void ei_prefetch<float>(const float* addr) { __pld(addr); } -template<> EIGEN_STRONG_INLINE void ei_prefetch<int>(const int* addr) { __pld(addr); } +template<> EIGEN_STRONG_INLINE void prefetch<float>(const float* addr) { __pld(addr); } +template<> EIGEN_STRONG_INLINE void prefetch<int>(const int* addr) { __pld(addr); } // FIXME only store the 2 first elements ? -template<> EIGEN_STRONG_INLINE float ei_pfirst<Packet4f>(const Packet4f& a) { float EIGEN_ALIGN16 x[4]; vst1q_f32(x, a); return x[0]; } -template<> EIGEN_STRONG_INLINE int ei_pfirst<Packet4i>(const Packet4i& a) { int EIGEN_ALIGN16 x[4]; vst1q_s32(x, a); return x[0]; } +template<> EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) { float EIGEN_ALIGN16 x[4]; vst1q_f32(x, a); return x[0]; } +template<> EIGEN_STRONG_INLINE int pfirst<Packet4i>(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<Packet4f>(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux<Packet4f>(const Packet4f& a) { float32x2_t a_lo, a_hi, sum; float s[2]; @@ -243,7 +245,7 @@ template<> EIGEN_STRONG_INLINE float ei_predux<Packet4f>(const Packet4f& a) return s[0]; } -template<> EIGEN_STRONG_INLINE Packet4f ei_preduxp<Packet4f>(const Packet4f* vecs) +template<> EIGEN_STRONG_INLINE Packet4f preduxp<Packet4f>(const Packet4f* vecs) { float32x4x2_t vtrn1, vtrn2, res1, res2; Packet4f sum1, sum2, sum; @@ -263,7 +265,7 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_preduxp<Packet4f>(const Packet4f* vec return sum; } -template<> EIGEN_STRONG_INLINE int ei_predux<Packet4i>(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux<Packet4i>(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<Packet4i>(const Packet4i& a) return s[0]; } -template<> EIGEN_STRONG_INLINE Packet4i ei_preduxp<Packet4i>(const Packet4i* vecs) +template<> EIGEN_STRONG_INLINE Packet4i preduxp<Packet4i>(const Packet4i* vecs) { int32x4x2_t vtrn1, vtrn2, res1, res2; Packet4i sum1, sum2, sum; @@ -299,7 +301,7 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_preduxp<Packet4i>(const Packet4i* vec // Other reduction functions: // mul -template<> EIGEN_STRONG_INLINE float ei_predux_mul<Packet4f>(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(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<Packet4f>(const Packet4f& a) return s[0]; } -template<> EIGEN_STRONG_INLINE int ei_predux_mul<Packet4i>(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_mul<Packet4i>(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<Packet4i>(const Packet4i& a) } // min -template<> EIGEN_STRONG_INLINE float ei_predux_min<Packet4f>(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(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<Packet4f>(const Packet4f& a) return s[0]; } -template<> EIGEN_STRONG_INLINE int ei_predux_min<Packet4i>(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_min<Packet4i>(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<Packet4i>(const Packet4i& a) } // max -template<> EIGEN_STRONG_INLINE float ei_predux_max<Packet4f>(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(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<Packet4f>(const Packet4f& a) return s[0]; } -template<> EIGEN_STRONG_INLINE int ei_predux_max<Packet4i>(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_max<Packet4i>(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<Packet4i>(const Packet4i& a) } template<int Offset> -struct ei_palign_impl<Offset,Packet4f> +struct palign_impl<Offset,Packet4f> { EIGEN_STRONG_INLINE static void run(Packet4f& first, const Packet4f& second) { @@ -399,7 +401,7 @@ struct ei_palign_impl<Offset,Packet4f> }; template<int Offset> -struct ei_palign_impl<Offset,Packet4i> +struct palign_impl<Offset,Packet4i> { EIGEN_STRONG_INLINE static void run(Packet4i& first, const Packet4i& second) { @@ -407,4 +409,7 @@ struct ei_palign_impl<Offset,Packet4i> 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<std::complex<float> > : ei_default_packet_traits +template<> struct packet_traits<std::complex<float> > : default_packet_traits { typedef Packet2cf type; enum { @@ -54,85 +56,85 @@ template<> struct ei_packet_traits<std::complex<float> > : ei_default_packet_tr }; }; -template<> struct ei_unpacket_traits<Packet2cf> { typedef std::complex<float> type; enum {size=2}; }; +template<> struct unpacket_traits<Packet2cf> { typedef std::complex<float> type; enum {size=2}; }; -template<> EIGEN_STRONG_INLINE Packet2cf ei_padd<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_add_ps(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_psub<Packet2cf>(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<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_add_ps(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf psub<Packet2cf>(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<Packet2cf>(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pmul<Packet2cf>(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 <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_and_ps(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_por <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_or_ps(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pxor <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_xor_ps(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_andnot_ps(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pand <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_and_ps(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf por <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_or_ps(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pxor <Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_xor_ps(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet2cf pandnot<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { return Packet2cf(_mm_andnot_ps(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pload <Packet2cf>(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(ei_pload<Packet4f>(&ei_real_ref(*from))); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_ploadu<Packet2cf>(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ei_ploadu<Packet4f>(&ei_real_ref(*from))); } +template<> EIGEN_STRONG_INLINE Packet2cf pload <Packet2cf>(const std::complex<float>* from) { EIGEN_DEBUG_ALIGNED_LOAD return Packet2cf(pload<Packet4f>(&real_ref(*from))); } +template<> EIGEN_STRONG_INLINE Packet2cf ploadu<Packet2cf>(const std::complex<float>* from) { EIGEN_DEBUG_UNALIGNED_LOAD return Packet2cf(ploadu<Packet4f>(&real_ref(*from))); } -template<> EIGEN_STRONG_INLINE void ei_pstore <std::complex<float> >(std::complex<float> * 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<float> >(std::complex<float> * to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE ei_pstoreu(&ei_real_ref(*to), from.v); } +template<> EIGEN_STRONG_INLINE void pstore <std::complex<float> >(std::complex<float> * to, const Packet2cf& from) { EIGEN_DEBUG_ALIGNED_STORE pstore(&real_ref(*to), from.v); } +template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<float> >(std::complex<float> * to, const Packet2cf& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu(&real_ref(*to), from.v); } -template<> EIGEN_STRONG_INLINE void ei_prefetch<std::complex<float> >(const std::complex<float> * addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } +template<> EIGEN_STRONG_INLINE void prefetch<std::complex<float> >(const std::complex<float> * addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } -template<> EIGEN_STRONG_INLINE Packet2cf ei_pset1<Packet2cf>(const std::complex<float>& from) +template<> EIGEN_STRONG_INLINE Packet2cf pset1<Packet2cf>(const std::complex<float>& 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<float> ei_pfirst<Packet2cf>(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet2cf>(const Packet2cf& a) { std::complex<float> 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<float> ei_predux<Packet2cf>(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex<float> predux<Packet2cf>(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<Packet2cf>(const Packet2cf* vecs) +template<> EIGEN_STRONG_INLINE Packet2cf preduxp<Packet2cf>(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<float> ei_predux_mul<Packet2cf>(const Packet2cf& a) +template<> EIGEN_STRONG_INLINE std::complex<float> predux_mul<Packet2cf>(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<int Offset> -struct ei_palign_impl<Offset,Packet2cf> +struct palign_impl<Offset,Packet2cf> { EIGEN_STRONG_INLINE static void run(Packet2cf& first, const Packet2cf& second) { @@ -144,89 +146,89 @@ struct ei_palign_impl<Offset,Packet2cf> } }; -template<> struct ei_conj_helper<Packet2cf, Packet2cf, false,true> +template<> struct conj_helper<Packet2cf, Packet2cf, false,true> { 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<Packet2cf, Packet2cf, true,false> +template<> struct conj_helper<Packet2cf, Packet2cf, true,false> { 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<Packet2cf, Packet2cf, true,true> +template<> struct conj_helper<Packet2cf, Packet2cf, true,true> { 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<Packet4f, Packet2cf, false,false> +template<> struct conj_helper<Packet4f, Packet2cf, false,false> { 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<Packet2cf, Packet4f, false,false> +template<> struct conj_helper<Packet2cf, Packet4f, false,false> { 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<Packet2cf>(const Packet2cf& a, const Packet2cf& b) +template<> EIGEN_STRONG_INLINE Packet2cf pdiv<Packet2cf>(const Packet2cf& a, const Packet2cf& b) { // TODO optimize it for SSE3 and 4 - Packet2cf res = ei_conj_helper<Packet2cf,Packet2cf,false,true>().pmul(a,b); + Packet2cf res = conj_helper<Packet2cf,Packet2cf,false,true>().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/*<Packet2cf>*/(const Packet2cf& x) +EIGEN_STRONG_INLINE Packet2cf pcplxflip/*<Packet2cf>*/(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<std::complex<double> > : ei_default_packet_traits +template<> struct packet_traits<std::complex<double> > : default_packet_traits { typedef Packet1cd type; enum { @@ -259,77 +261,77 @@ template<> struct ei_packet_traits<std::complex<double> > : ei_default_packet_t }; }; -template<> struct ei_unpacket_traits<Packet1cd> { typedef std::complex<double> type; enum {size=1}; }; +template<> struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; enum {size=1}; }; -template<> EIGEN_STRONG_INLINE Packet1cd ei_padd<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_add_pd(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_psub<Packet1cd>(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<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_add_pd(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet1cd psub<Packet1cd>(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<Packet1cd>(const Packet1cd& a, const Packet1cd& b) +template<> EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(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 <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_and_pd(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_por <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_or_pd(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_pxor <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_xor_pd(a.v,b.v)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_pandnot<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_andnot_pd(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet1cd pand <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_and_pd(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet1cd por <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_or_pd(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet1cd pxor <Packet1cd>(const Packet1cd& a, const Packet1cd& b) { return Packet1cd(_mm_xor_pd(a.v,b.v)); } +template<> EIGEN_STRONG_INLINE Packet1cd pandnot<Packet1cd>(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 <Packet1cd>(const std::complex<double>* from) -{ EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(ei_pload<Packet2d>((const double*)from)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_ploadu<Packet1cd>(const std::complex<double>* from) -{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ei_ploadu<Packet2d>((const double*)from)); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_pset1<Packet1cd>(const std::complex<double>& from) -{ /* here we really have to use unaligned loads :( */ return ei_ploadu<Packet1cd>(&from); } +template<> EIGEN_STRONG_INLINE Packet1cd pload <Packet1cd>(const std::complex<double>* from) +{ EIGEN_DEBUG_ALIGNED_LOAD return Packet1cd(pload<Packet2d>((const double*)from)); } +template<> EIGEN_STRONG_INLINE Packet1cd ploadu<Packet1cd>(const std::complex<double>* from) +{ EIGEN_DEBUG_UNALIGNED_LOAD return Packet1cd(ploadu<Packet2d>((const double*)from)); } +template<> EIGEN_STRONG_INLINE Packet1cd pset1<Packet1cd>(const std::complex<double>& from) +{ /* here we really have to use unaligned loads :( */ return ploadu<Packet1cd>(&from); } // FIXME force unaligned store, this is a temporary fix -template<> EIGEN_STRONG_INLINE void ei_pstore <std::complex<double> >(std::complex<double> * to, const Packet1cd& from) { EIGEN_DEBUG_ALIGNED_STORE ei_pstore((double*)to, from.v); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu<std::complex<double> >(std::complex<double> * to, const Packet1cd& from) { EIGEN_DEBUG_UNALIGNED_STORE ei_pstoreu((double*)to, from.v); } +template<> EIGEN_STRONG_INLINE void pstore <std::complex<double> >(std::complex<double> * to, const Packet1cd& from) { EIGEN_DEBUG_ALIGNED_STORE pstore((double*)to, from.v); } +template<> EIGEN_STRONG_INLINE void pstoreu<std::complex<double> >(std::complex<double> * to, const Packet1cd& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, from.v); } -template<> EIGEN_STRONG_INLINE void ei_prefetch<std::complex<double> >(const std::complex<double> * addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } +template<> EIGEN_STRONG_INLINE void prefetch<std::complex<double> >(const std::complex<double> * addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } -template<> EIGEN_STRONG_INLINE std::complex<double> ei_pfirst<Packet1cd>(const Packet1cd& a) +template<> EIGEN_STRONG_INLINE std::complex<double> pfirst<Packet1cd>(const Packet1cd& a) { EIGEN_ALIGN16 double res[2]; _mm_store_pd(res, a.v); return std::complex<double>(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<double> ei_predux<Packet1cd>(const Packet1cd& a) +template<> EIGEN_STRONG_INLINE std::complex<double> predux<Packet1cd>(const Packet1cd& a) { - return ei_pfirst(a); + return pfirst(a); } -template<> EIGEN_STRONG_INLINE Packet1cd ei_preduxp<Packet1cd>(const Packet1cd* vecs) +template<> EIGEN_STRONG_INLINE Packet1cd preduxp<Packet1cd>(const Packet1cd* vecs) { return vecs[0]; } -template<> EIGEN_STRONG_INLINE std::complex<double> ei_predux_mul<Packet1cd>(const Packet1cd& a) +template<> EIGEN_STRONG_INLINE std::complex<double> predux_mul<Packet1cd>(const Packet1cd& a) { - return ei_pfirst(a); + return pfirst(a); } template<int Offset> -struct ei_palign_impl<Offset,Packet1cd> +struct palign_impl<Offset,Packet1cd> { EIGEN_STRONG_INLINE static void run(Packet1cd& /*first*/, const Packet1cd& /*second*/) { @@ -338,89 +340,91 @@ struct ei_palign_impl<Offset,Packet1cd> } }; -template<> struct ei_conj_helper<Packet1cd, Packet1cd, false,true> +template<> struct conj_helper<Packet1cd, Packet1cd, false,true> { 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<Packet1cd, Packet1cd, true,false> +template<> struct conj_helper<Packet1cd, Packet1cd, true,false> { 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<Packet1cd, Packet1cd, true,true> +template<> struct conj_helper<Packet1cd, Packet1cd, true,true> { 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<Packet2d, Packet1cd, false,false> +template<> struct conj_helper<Packet2d, Packet1cd, false,false> { 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<Packet1cd, Packet2d, false,false> +template<> struct conj_helper<Packet1cd, Packet2d, false,false> { 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<Packet1cd>(const Packet1cd& a, const Packet1cd& b) +template<> EIGEN_STRONG_INLINE Packet1cd pdiv<Packet1cd>(const Packet1cd& a, const Packet1cd& b) { // TODO optimize it for SSE3 and 4 - Packet1cd res = ei_conj_helper<Packet1cd,Packet1cd,false,true>().pmul(a,b); + Packet1cd res = conj_helper<Packet1cd,Packet1cd,false,true>().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/*<Packet1cd>*/(const Packet1cd& x) +EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(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<Packet4f>(const Packet4f& _x) +Packet4f plog<Packet4f>(const Packet4f& _x) { Packet4f x = _x; _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f); @@ -64,15 +66,15 @@ Packet4f ei_plog<Packet4f>(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<Packet4f>(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<Packet4f>(const Packet4f& _x) +Packet4f pexp<Packet4f>(const Packet4f& _x) { Packet4f x = _x; _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f); @@ -137,40 +139,40 @@ Packet4f ei_pexp<Packet4f>(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<Packet4f>(const Packet4f& _x) */ template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED -Packet4f ei_psin<Packet4f>(const Packet4f& _x) +Packet4f psin<Packet4f>(const Packet4f& _x) { Packet4f x = _x; _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f); @@ -215,24 +217,24 @@ Packet4f ei_psin<Packet4f>(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<Packet4f>(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<Packet4f>(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<Packet4f>(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<Packet4f>(const Packet4f& _x) +Packet4f pcos<Packet4f>(const Packet4f& _x) { Packet4f x = _x; _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f); @@ -312,25 +314,25 @@ Packet4f ei_pcos<Packet4f>(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<Packet4f>(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<Packet4f>(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<Packet4f>(const Packet4f& _x) +Packet4f psqrt<Packet4f>(const Packet4f& _x) { - Packet4f half = ei_pmul(_x, ei_pset1<Packet4f>(.5f)); + Packet4f half = pmul(_x, pset1<Packet4f>(.5f)); /* select only the inverse sqrt of non-zero inputs */ - Packet4f non_zero_mask = _mm_cmpgt_ps(_x, ei_pset1<Packet4f>(std::numeric_limits<float>::epsilon())); + Packet4f non_zero_mask = _mm_cmpgt_ps(_x, pset1<Packet4f>(std::numeric_limits<float>::epsilon())); Packet4f x = _mm_and_ps(non_zero_mask, _mm_rsqrt_ps(_x)); - x = ei_pmul(x, ei_psub(ei_pset1<Packet4f>(1.5f), ei_pmul(half, ei_pmul(x,x)))); - return ei_pmul(_x,x); + x = pmul(x, psub(pset1<Packet4f>(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<Packet4f>(X) + const Packet4f p4f_##NAME = pset1<Packet4f>(X) #define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME,X) \ - const Packet4f ei_p4f_##NAME = _mm_castsi128_ps(ei_pset1<Packet4i>(X)) + const Packet4f p4f_##NAME = _mm_castsi128_ps(pset1<Packet4i>(X)) #define _EIGEN_DECLARE_CONST_Packet4i(NAME,X) \ - const Packet4i ei_p4i_##NAME = ei_pset1<Packet4i>(X) + const Packet4i p4i_##NAME = pset1<Packet4i>(X) -template<> struct ei_packet_traits<float> : ei_default_packet_traits +template<> struct packet_traits<float> : default_packet_traits { typedef Packet4f type; enum { @@ -82,7 +84,7 @@ template<> struct ei_packet_traits<float> : ei_default_packet_traits HasSqrt = 1 }; }; -template<> struct ei_packet_traits<double> : ei_default_packet_traits +template<> struct packet_traits<double> : default_packet_traits { typedef Packet2d type; enum { @@ -93,7 +95,7 @@ template<> struct ei_packet_traits<double> : ei_default_packet_traits HasDiv = 1 }; }; -template<> struct ei_packet_traits<int> : ei_default_packet_traits +template<> struct packet_traits<int> : default_packet_traits { typedef Packet4i type; enum { @@ -104,125 +106,125 @@ template<> struct ei_packet_traits<int> : ei_default_packet_traits }; }; -template<> struct ei_unpacket_traits<Packet4f> { typedef float type; enum {size=4}; }; -template<> struct ei_unpacket_traits<Packet2d> { typedef double type; enum {size=2}; }; -template<> struct ei_unpacket_traits<Packet4i> { typedef int type; enum {size=4}; }; +template<> struct unpacket_traits<Packet4f> { typedef float type; enum {size=4}; }; +template<> struct unpacket_traits<Packet2d> { typedef double type; enum {size=2}; }; +template<> struct unpacket_traits<Packet4i> { 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<Packet4f>(const float& from) { +// that is inefficient :( (e.g., see gemm_pack_rhs) +template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(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<Packet2d>(const double& from) { +template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(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<Packet4f>(const float& from) { return _mm_set1_ps(from); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pset1<Packet2d>(const double& from) { return _mm_set1_pd(from); } +template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float& from) { return _mm_set1_ps(from); } +template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) { return _mm_set1_pd(from); } #endif -template<> EIGEN_STRONG_INLINE Packet4i ei_pset1<Packet4i>(const int& from) { return _mm_set1_epi32(from); } +template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int& from) { return _mm_set1_epi32(from); } -template<> EIGEN_STRONG_INLINE Packet4f ei_plset<float>(const float& a) { return _mm_add_ps(ei_pset1<Packet4f>(a), _mm_set_ps(3,2,1,0)); } -template<> EIGEN_STRONG_INLINE Packet2d ei_plset<double>(const double& a) { return _mm_add_pd(ei_pset1<Packet2d>(a),_mm_set_pd(1,0)); } -template<> EIGEN_STRONG_INLINE Packet4i ei_plset<int>(const int& a) { return _mm_add_epi32(ei_pset1<Packet4i>(a),_mm_set_epi32(3,2,1,0)); } +template<> EIGEN_STRONG_INLINE Packet4f plset<float>(const float& a) { return _mm_add_ps(pset1<Packet4f>(a), _mm_set_ps(3,2,1,0)); } +template<> EIGEN_STRONG_INLINE Packet2d plset<double>(const double& a) { return _mm_add_pd(pset1<Packet2d>(a),_mm_set_pd(1,0)); } +template<> EIGEN_STRONG_INLINE Packet4i plset<int>(const int& a) { return _mm_add_epi32(pset1<Packet4i>(a),_mm_set_epi32(3,2,1,0)); } -template<> EIGEN_STRONG_INLINE Packet4f ei_padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_add_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_add_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_add_epi32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_add_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_add_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_add_epi32(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_sub_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_sub_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_psub<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_sub_epi32(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_sub_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_sub_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(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<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_mul_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_mul_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmul<Packet4i>(const Packet4i& a, const Packet4i& b) +template<> EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_mul_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_mul_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(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<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_div_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_div_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pdiv<Packet4i>(const Packet4i& /*a*/, const Packet4i& /*b*/) -{ ei_assert(false && "packet integer division are not supported by SSE"); - return ei_pset1<Packet4i>(0); +template<> EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_div_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_div_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(const Packet4i& /*a*/, const Packet4i& /*b*/) +{ eigen_assert(false && "packet integer division are not supported by SSE"); + return pset1<Packet4i>(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<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_min_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pmin<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_min_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmin<Packet4i>(const Packet4i& a, const Packet4i& b) +template<> EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_min_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_min_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(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<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_max_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pmax<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_max_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pmax<Packet4i>(const Packet4i& a, const Packet4i& b) +template<> EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_max_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_max_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(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<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_and_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pand<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_and_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_and_si128(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_and_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_and_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_and_si128(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_por<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_or_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_por<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_or_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_por<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_or_si128(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f por<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_or_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d por<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_or_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i por<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_or_si128(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pxor<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_xor_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pxor<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_xor_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_xor_si128(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_xor_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_xor_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_xor_si128(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_andnot_ps(a,b); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pandnot<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_andnot_pd(a,b); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_andnot_si128(a,b); } +template<> EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(const Packet4f& a, const Packet4f& b) { return _mm_andnot_ps(a,b); } +template<> EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(const Packet2d& a, const Packet2d& b) { return _mm_andnot_pd(a,b); } +template<> EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(const Packet4i& a, const Packet4i& b) { return _mm_andnot_si128(a,b); } -template<> EIGEN_STRONG_INLINE Packet4f ei_pload<Packet4f>(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_ps(from); } -template<> EIGEN_STRONG_INLINE Packet2d ei_pload<Packet2d>(const double* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_pd(from); } -template<> EIGEN_STRONG_INLINE Packet4i ei_pload<Packet4i>(const int* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_si128(reinterpret_cast<const Packet4i*>(from)); } +template<> EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(const float* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_ps(from); } +template<> EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(const double* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_pd(from); } +template<> EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(const int* from) { EIGEN_DEBUG_ALIGNED_LOAD return _mm_load_si128(reinterpret_cast<const Packet4i*>(from)); } #if defined(_MSC_VER) - template<> EIGEN_STRONG_INLINE Packet4f ei_ploadu<Packet4f>(const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm_loadu_ps(from); } - template<> EIGEN_STRONG_INLINE Packet2d ei_ploadu<Packet2d>(const double* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm_loadu_pd(from); } - template<> EIGEN_STRONG_INLINE Packet4i ei_ploadu<Packet4i>(const int* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm_loadu_si128(reinterpret_cast<const Packet4i*>(from)); } + template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm_loadu_ps(from); } + template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm_loadu_pd(from); } + template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int* from) { EIGEN_DEBUG_UNALIGNED_LOAD return _mm_loadu_si128(reinterpret_cast<const Packet4i*>(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<Packet4i>(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<Packet4f>(const float* from) +template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD __m128d res; @@ -238,7 +240,7 @@ template<> EIGEN_STRONG_INLINE Packet4f ei_ploadu<Packet4f>(const float* from) res = _mm_loadh_pd(res, (const double*)(from+2)) ; return _mm_castpd_ps(res); } -template<> EIGEN_STRONG_INLINE Packet2d ei_ploadu<Packet2d>(const double* from) +template<> EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from) { EIGEN_DEBUG_UNALIGNED_LOAD __m128d res; @@ -246,7 +248,7 @@ template<> EIGEN_STRONG_INLINE Packet2d ei_ploadu<Packet2d>(const double* from) res = _mm_loadh_pd(res,from+1); return res; } -template<> EIGEN_STRONG_INLINE Packet4i ei_ploadu<Packet4i>(const int* from) +template<> EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(const int* from) { EIGEN_DEBUG_UNALIGNED_LOAD __m128d res; @@ -256,71 +258,71 @@ template<> EIGEN_STRONG_INLINE Packet4i ei_ploadu<Packet4i>(const int* from) } #endif -template<> EIGEN_STRONG_INLINE Packet4f ei_ploaddup<Packet4f>(const float* from) +template<> EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(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<Packet2d>(const double* from) -{ return ei_pset1<Packet2d>(from[0]); } -template<> EIGEN_STRONG_INLINE Packet4i ei_ploaddup<Packet4i>(const int* from) +template<> EIGEN_STRONG_INLINE Packet2d ploaddup<Packet2d>(const double* from) +{ return pset1<Packet2d>(from[0]); } +template<> EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(const int* from) { Packet4i tmp; tmp = _mm_loadl_epi64(reinterpret_cast<const Packet4i*>(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>(float* to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_ps(to, from); } -template<> EIGEN_STRONG_INLINE void ei_pstore<double>(double* to, const Packet2d& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_pd(to, from); } -template<> EIGEN_STRONG_INLINE void ei_pstore<int>(int* to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(reinterpret_cast<Packet4i*>(to), from); } +template<> EIGEN_STRONG_INLINE void pstore<float>(float* to, const Packet4f& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_ps(to, from); } +template<> EIGEN_STRONG_INLINE void pstore<double>(double* to, const Packet2d& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_pd(to, from); } +template<> EIGEN_STRONG_INLINE void pstore<int>(int* to, const Packet4i& from) { EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(reinterpret_cast<Packet4i*>(to), from); } -template<> EIGEN_STRONG_INLINE void ei_pstoreu<double>(double* to, const Packet2d& from) { +template<> EIGEN_STRONG_INLINE void pstoreu<double>(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>(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>(int* to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE ei_pstoreu((double*)to, _mm_castsi128_pd(from)); } +template<> EIGEN_STRONG_INLINE void pstoreu<float>(float* to, const Packet4f& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, _mm_castps_pd(from)); } +template<> EIGEN_STRONG_INLINE void pstoreu<int>(int* to, const Packet4i& from) { EIGEN_DEBUG_UNALIGNED_STORE pstoreu((double*)to, _mm_castsi128_pd(from)); } -template<> EIGEN_STRONG_INLINE void ei_prefetch<float>(const float* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } -template<> EIGEN_STRONG_INLINE void ei_prefetch<double>(const double* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } -template<> EIGEN_STRONG_INLINE void ei_prefetch<int>(const int* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } +template<> EIGEN_STRONG_INLINE void prefetch<float>(const float* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } +template<> EIGEN_STRONG_INLINE void prefetch<double>(const double* addr) { _mm_prefetch((const char*)(addr), _MM_HINT_T0); } +template<> EIGEN_STRONG_INLINE void prefetch<int>(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<Packet4f>(const Packet4f& a) { return a.m128_f32[0]; } -template<> EIGEN_STRONG_INLINE double ei_pfirst<Packet2d>(const Packet2d& a) { return a.m128d_f64[0]; } -template<> EIGEN_STRONG_INLINE int ei_pfirst<Packet4i>(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; } +template<> EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) { return a.m128_f32[0]; } +template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { return a.m128d_f64[0]; } +template<> EIGEN_STRONG_INLINE int pfirst<Packet4i>(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<Packet4f>(const Packet4f& a) { float x = _mm_cvtss_f32(a); return x; } -template<> EIGEN_STRONG_INLINE double ei_pfirst<Packet2d>(const Packet2d& a) { double x = _mm_cvtsd_f64(a); return x; } -template<> EIGEN_STRONG_INLINE int ei_pfirst<Packet4i>(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; } +template<> EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) { float x = _mm_cvtss_f32(a); return x; } +template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { double x = _mm_cvtsd_f64(a); return x; } +template<> EIGEN_STRONG_INLINE int pfirst<Packet4i>(const Packet4i& a) { int x = _mm_cvtsi128_si32(a); return x; } #else -template<> EIGEN_STRONG_INLINE float ei_pfirst<Packet4f>(const Packet4f& a) { return _mm_cvtss_f32(a); } -template<> EIGEN_STRONG_INLINE double ei_pfirst<Packet2d>(const Packet2d& a) { return _mm_cvtsd_f64(a); } -template<> EIGEN_STRONG_INLINE int ei_pfirst<Packet4i>(const Packet4i& a) { return _mm_cvtsi128_si32(a); } +template<> EIGEN_STRONG_INLINE float pfirst<Packet4f>(const Packet4f& a) { return _mm_cvtss_f32(a); } +template<> EIGEN_STRONG_INLINE double pfirst<Packet2d>(const Packet2d& a) { return _mm_cvtsd_f64(a); } +template<> EIGEN_STRONG_INLINE int pfirst<Packet4i>(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<Packet4f>(const Packet4f* vecs) +template<> EIGEN_STRONG_INLINE Packet4f preduxp<Packet4f>(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<Packet2d>(const Packet2d* vecs) +template<> EIGEN_STRONG_INLINE Packet2d preduxp<Packet2d>(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<Packet4f>(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux<Packet4f>(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<Packet2d>(const Packet2d& a) { return ei_pfirst(_mm_hadd_pd(a, a)); } +template<> EIGEN_STRONG_INLINE double predux<Packet2d>(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<Packet4f>(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux<Packet4f>(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<Packet2d>(const Packet2d& a) +template<> EIGEN_STRONG_INLINE double predux<Packet2d>(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<Packet4f>(const Packet4f* vecs) +template<> EIGEN_STRONG_INLINE Packet4f preduxp<Packet4f>(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<Packet4f>(const Packet4f* vec return _mm_add_ps(tmp0, tmp2); } -template<> EIGEN_STRONG_INLINE Packet2d ei_preduxp<Packet2d>(const Packet2d* vecs) +template<> EIGEN_STRONG_INLINE Packet2d preduxp<Packet2d>(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<Packet4i>(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux<Packet4i>(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<Packet4i>(const Packet4i* vecs) +template<> EIGEN_STRONG_INLINE Packet4i preduxp<Packet4i>(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<Packet4i>(const Packet4i* vec // Other reduction functions: // mul -template<> EIGEN_STRONG_INLINE float ei_predux_mul<Packet4f>(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_mul<Packet4f>(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<Packet2d>(const Packet2d& a) +template<> EIGEN_STRONG_INLINE double predux_mul<Packet2d>(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<Packet4i>(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_mul<Packet4i>(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<Packet4f>(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_min<Packet4f>(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<Packet2d>(const Packet2d& a) +template<> EIGEN_STRONG_INLINE double predux_min<Packet2d>(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<Packet4i>(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_min<Packet4i>(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; } // max -template<> EIGEN_STRONG_INLINE float ei_predux_max<Packet4f>(const Packet4f& a) +template<> EIGEN_STRONG_INLINE float predux_max<Packet4f>(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<Packet2d>(const Packet2d& a) +template<> EIGEN_STRONG_INLINE double predux_max<Packet2d>(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<Packet4i>(const Packet4i& a) +template<> EIGEN_STRONG_INLINE int predux_max<Packet4i>(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<Packet4i>(const Packet4i& a) #ifdef EIGEN_VECTORIZE_SSSE3 // SSSE3 versions template<int Offset> -struct ei_palign_impl<Offset,Packet4f> +struct palign_impl<Offset,Packet4f> { EIGEN_STRONG_INLINE static void run(Packet4f& first, const Packet4f& second) { @@ -512,7 +514,7 @@ struct ei_palign_impl<Offset,Packet4f> }; template<int Offset> -struct ei_palign_impl<Offset,Packet4i> +struct palign_impl<Offset,Packet4i> { EIGEN_STRONG_INLINE static void run(Packet4i& first, const Packet4i& second) { @@ -522,7 +524,7 @@ struct ei_palign_impl<Offset,Packet4i> }; template<int Offset> -struct ei_palign_impl<Offset,Packet2d> +struct palign_impl<Offset,Packet2d> { EIGEN_STRONG_INLINE static void run(Packet2d& first, const Packet2d& second) { @@ -533,7 +535,7 @@ struct ei_palign_impl<Offset,Packet2d> #else // SSE2 versions template<int Offset> -struct ei_palign_impl<Offset,Packet4f> +struct palign_impl<Offset,Packet4f> { EIGEN_STRONG_INLINE static void run(Packet4f& first, const Packet4f& second) { @@ -556,7 +558,7 @@ struct ei_palign_impl<Offset,Packet4f> }; template<int Offset> -struct ei_palign_impl<Offset,Packet4i> +struct palign_impl<Offset,Packet4i> { EIGEN_STRONG_INLINE static void run(Packet4i& first, const Packet4i& second) { @@ -579,7 +581,7 @@ struct ei_palign_impl<Offset,Packet4i> }; template<int Offset> -struct ei_palign_impl<Offset,Packet2d> +struct palign_impl<Offset,Packet2d> { EIGEN_STRONG_INLINE static void run(Packet2d& first, const Packet2d& second) { @@ -592,4 +594,6 @@ struct ei_palign_impl<Offset,Packet2d> }; #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<int Traversal, int UnrollingIndex, typename Lhs, typename Rhs, typename RetScalar> -struct ei_product_coeff_impl; +struct product_coeff_impl; template<int StorageOrder, int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode> -struct ei_product_packet_impl; +struct product_packet_impl; template<typename LhsNested, typename RhsNested, int NestingFlags> -struct ei_traits<CoeffBasedProduct<LhsNested,RhsNested,NestingFlags> > +struct traits<CoeffBasedProduct<LhsNested,RhsNested,NestingFlags> > { typedef MatrixXpr XprKind; - typedef typename ei_cleantype<LhsNested>::type _LhsNested; - typedef typename ei_cleantype<RhsNested>::type _RhsNested; - typedef typename ei_scalar_product_traits<typename _LhsNested::Scalar, typename _RhsNested::Scalar>::ReturnType Scalar; - typedef typename ei_promote_storage_type<typename ei_traits<_LhsNested>::StorageKind, - typename ei_traits<_RhsNested>::StorageKind>::ret StorageKind; - typedef typename ei_promote_index_type<typename ei_traits<_LhsNested>::Index, - typename ei_traits<_RhsNested>::Index>::type Index; + typedef typename cleantype<LhsNested>::type _LhsNested; + typedef typename cleantype<RhsNested>::type _RhsNested; + typedef typename scalar_product_traits<typename _LhsNested::Scalar, typename _RhsNested::Scalar>::ReturnType Scalar; + typedef typename promote_storage_type<typename traits<_LhsNested>::StorageKind, + typename traits<_RhsNested>::StorageKind>::ret StorageKind; + typedef typename promote_index_type<typename traits<_LhsNested>::Index, + typename traits<_RhsNested>::Index>::type Index; enum { LhsCoeffReadCost = _LhsNested::CoeffReadCost, @@ -73,18 +75,18 @@ struct ei_traits<CoeffBasedProduct<LhsNested,RhsNested,NestingFlags> > LhsRowMajor = LhsFlags & RowMajorBit, RhsRowMajor = RhsFlags & RowMajorBit, - SameType = ei_is_same_type<typename _LhsNested::Scalar,typename _RhsNested::Scalar>::ret, + SameType = is_same_type<typename _LhsNested::Scalar,typename _RhsNested::Scalar>::ret, CanVectorizeRhs = RhsRowMajor && (RhsFlags & PacketAccessBit) && (ColsAtCompileTime == Dynamic - || ( (ColsAtCompileTime % ei_packet_traits<Scalar>::size) == 0 + || ( (ColsAtCompileTime % packet_traits<Scalar>::size) == 0 && (RhsFlags&AlignedBit) ) ), CanVectorizeLhs = (!LhsRowMajor) && (LhsFlags & PacketAccessBit) && (RowsAtCompileTime == Dynamic - || ( (RowsAtCompileTime % ei_packet_traits<Scalar>::size) == 0 + || ( (RowsAtCompileTime % packet_traits<Scalar>::size) == 0 && (LhsFlags&AlignedBit) ) ), @@ -113,13 +115,15 @@ struct ei_traits<CoeffBasedProduct<LhsNested,RhsNested,NestingFlags> > && (!RhsRowMajor) && (LhsFlags & RhsFlags & ActualPacketAccessBit) && (LhsFlags & RhsFlags & AlignedBit) - && (InnerSize % ei_packet_traits<Scalar>::size == 0) + && (InnerSize % packet_traits<Scalar>::size == 0) }; }; +} // end namespace internal + template<typename LhsNested, typename RhsNested, int NestingFlags> class CoeffBasedProduct - : ei_no_assignment_operator, + : internal::no_assignment_operator, public MatrixBase<CoeffBasedProduct<LhsNested, RhsNested, NestingFlags> > { public: @@ -130,19 +134,19 @@ class CoeffBasedProduct private: - typedef typename ei_traits<CoeffBasedProduct>::_LhsNested _LhsNested; - typedef typename ei_traits<CoeffBasedProduct>::_RhsNested _RhsNested; + typedef typename internal::traits<CoeffBasedProduct>::_LhsNested _LhsNested; + typedef typename internal::traits<CoeffBasedProduct>::_RhsNested _RhsNested; enum { - PacketSize = ei_packet_traits<Scalar>::size, - InnerSize = ei_traits<CoeffBasedProduct>::InnerSize, + PacketSize = internal::packet_traits<Scalar>::size, + InnerSize = internal::traits<CoeffBasedProduct>::InnerSize, Unroll = CoeffReadCost != Dynamic && CoeffReadCost <= EIGEN_UNROLLING_LIMIT, - CanVectorizeInner = ei_traits<CoeffBasedProduct>::CanVectorizeInner + CanVectorizeInner = internal::traits<CoeffBasedProduct>::CanVectorizeInner }; - typedef ei_product_coeff_impl<CanVectorizeInner ? InnerVectorizedTraversal : DefaultTraversal, - Unroll ? InnerSize-1 : Dynamic, - _LhsNested, _RhsNested, Scalar> ScalarCoeffImpl; + typedef internal::product_coeff_impl<CanVectorizeInner ? InnerVectorizedTraversal : DefaultTraversal, + Unroll ? InnerSize-1 : Dynamic, + _LhsNested, _RhsNested, Scalar> ScalarCoeffImpl; typedef CoeffBasedProduct<LhsNested,RhsNested,NestByRefBit> 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<T>. - EIGEN_STATIC_ASSERT((ei_is_same_type<typename Lhs::RealScalar, typename Rhs::RealScalar>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type<typename Lhs::RealScalar, typename Rhs::RealScalar>::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<Flags&RowMajorBit ? RowMajor : ColMajor, - Unroll ? InnerSize-1 : Dynamic, - _LhsNested, _RhsNested, PacketScalar, LoadMode> + internal::product_packet_impl<Flags&RowMajorBit ? RowMajor : ColMajor, + Unroll ? InnerSize-1 : Dynamic, + _LhsNested, _RhsNested, PacketScalar, LoadMode> ::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<typename Lhs, typename Rhs, int N, typename PlainObject> -struct ei_nested<CoeffBasedProduct<Lhs,Rhs,EvalBeforeNestingBit|EvalBeforeAssigningBit>, N, PlainObject> +struct nested<CoeffBasedProduct<Lhs,Rhs,EvalBeforeNestingBit|EvalBeforeAssigningBit>, N, PlainObject> { typedef PlainObject const& type; }; @@ -242,18 +248,18 @@ struct ei_nested<CoeffBasedProduct<Lhs,Rhs,EvalBeforeNestingBit|EvalBeforeAssign **************************************/ template<int UnrollingIndex, typename Lhs, typename Rhs, typename RetScalar> -struct ei_product_coeff_impl<DefaultTraversal, UnrollingIndex, Lhs, Rhs, RetScalar> +struct product_coeff_impl<DefaultTraversal, UnrollingIndex, Lhs, Rhs, RetScalar> { 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<DefaultTraversal, UnrollingIndex-1, Lhs, Rhs, RetScalar>::run(row, col, lhs, rhs, res); + product_coeff_impl<DefaultTraversal, UnrollingIndex-1, Lhs, Rhs, RetScalar>::run(row, col, lhs, rhs, res); res += lhs.coeff(row, UnrollingIndex) * rhs.coeff(UnrollingIndex, col); } }; template<typename Lhs, typename Rhs, typename RetScalar> -struct ei_product_coeff_impl<DefaultTraversal, 0, Lhs, Rhs, RetScalar> +struct product_coeff_impl<DefaultTraversal, 0, Lhs, Rhs, RetScalar> { 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<DefaultTraversal, 0, Lhs, Rhs, RetScalar> }; template<typename Lhs, typename Rhs, typename RetScalar> -struct ei_product_coeff_impl<DefaultTraversal, Dynamic, Lhs, Rhs, RetScalar> +struct product_coeff_impl<DefaultTraversal, Dynamic, Lhs, Rhs, RetScalar> { 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<DefaultTraversal, Dynamic, Lhs, Rhs, RetScalar> *******************************************/ template<int UnrollingIndex, typename Lhs, typename Rhs, typename Packet> -struct ei_product_coeff_vectorized_unroller +struct product_coeff_vectorized_unroller { typedef typename Lhs::Index Index; - enum { PacketSize = ei_packet_traits<typename Lhs::Scalar>::size }; + enum { PacketSize = packet_traits<typename Lhs::Scalar>::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<UnrollingIndex-PacketSize, Lhs, Rhs, Packet>::run(row, col, lhs, rhs, pres); - pres = ei_padd(pres, ei_pmul( lhs.template packet<Aligned>(row, UnrollingIndex) , rhs.template packet<Aligned>(UnrollingIndex, col) )); + product_coeff_vectorized_unroller<UnrollingIndex-PacketSize, Lhs, Rhs, Packet>::run(row, col, lhs, rhs, pres); + pres = padd(pres, pmul( lhs.template packet<Aligned>(row, UnrollingIndex) , rhs.template packet<Aligned>(UnrollingIndex, col) )); } }; template<typename Lhs, typename Rhs, typename Packet> -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<Aligned>(row, 0) , rhs.template packet<Aligned>(0, col)); + pres = pmul(lhs.template packet<Aligned>(row, 0) , rhs.template packet<Aligned>(0, col)); } }; template<int UnrollingIndex, typename Lhs, typename Rhs, typename RetScalar> -struct ei_product_coeff_impl<InnerVectorizedTraversal, UnrollingIndex, Lhs, Rhs, RetScalar> +struct product_coeff_impl<InnerVectorizedTraversal, UnrollingIndex, Lhs, Rhs, RetScalar> { typedef typename Lhs::PacketScalar Packet; typedef typename Lhs::Index Index; - enum { PacketSize = ei_packet_traits<typename Lhs::Scalar>::size }; + enum { PacketSize = packet_traits<typename Lhs::Scalar>::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<UnrollingIndex+1-PacketSize, Lhs, Rhs, Packet>::run(row, col, lhs, rhs, pres); - ei_product_coeff_impl<DefaultTraversal,UnrollingIndex,Lhs,Rhs,RetScalar>::run(row, col, lhs, rhs, res); - res = ei_predux(pres); + product_coeff_vectorized_unroller<UnrollingIndex+1-PacketSize, Lhs, Rhs, Packet>::run(row, col, lhs, rhs, pres); + product_coeff_impl<DefaultTraversal,UnrollingIndex,Lhs,Rhs,RetScalar>::run(row, col, lhs, rhs, res); + res = predux(pres); } }; template<typename Lhs, typename Rhs, int LhsRows = Lhs::RowsAtCompileTime, int RhsCols = Rhs::ColsAtCompileTime> -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<Matrix> template<typename Lhs, typename Rhs, int RhsCols> -struct ei_product_coeff_vectorized_dyn_selector<Lhs,Rhs,1,RhsCols> +struct product_coeff_vectorized_dyn_selector<Lhs,Rhs,1,RhsCols> { 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<Lhs,Rhs,1,RhsCols> }; template<typename Lhs, typename Rhs, int LhsRows> -struct ei_product_coeff_vectorized_dyn_selector<Lhs,Rhs,LhsRows,1> +struct product_coeff_vectorized_dyn_selector<Lhs,Rhs,LhsRows,1> { 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<Lhs,Rhs,LhsRows,1> }; template<typename Lhs, typename Rhs> -struct ei_product_coeff_vectorized_dyn_selector<Lhs,Rhs,1,1> +struct product_coeff_vectorized_dyn_selector<Lhs,Rhs,1,1> { 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<Lhs,Rhs,1,1> }; template<typename Lhs, typename Rhs, typename RetScalar> -struct ei_product_coeff_impl<InnerVectorizedTraversal, Dynamic, Lhs, Rhs, RetScalar> +struct product_coeff_impl<InnerVectorizedTraversal, Dynamic, Lhs, Rhs, RetScalar> { 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<Lhs,Rhs>::run(row, col, lhs, rhs, res); + product_coeff_vectorized_dyn_selector<Lhs,Rhs>::run(row, col, lhs, rhs, res); } }; @@ -373,71 +379,73 @@ struct ei_product_coeff_impl<InnerVectorizedTraversal, Dynamic, Lhs, Rhs, RetSca *******************/ template<int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode> -struct ei_product_packet_impl<RowMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode> +struct product_packet_impl<RowMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode> { 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<RowMajor, UnrollingIndex-1, Lhs, Rhs, Packet, LoadMode>::run(row, col, lhs, rhs, res); - res = ei_pmadd(ei_pset1<Packet>(lhs.coeff(row, UnrollingIndex)), rhs.template packet<LoadMode>(UnrollingIndex, col), res); + product_packet_impl<RowMajor, UnrollingIndex-1, Lhs, Rhs, Packet, LoadMode>::run(row, col, lhs, rhs, res); + res = pmadd(pset1<Packet>(lhs.coeff(row, UnrollingIndex)), rhs.template packet<LoadMode>(UnrollingIndex, col), res); } }; template<int UnrollingIndex, typename Lhs, typename Rhs, typename Packet, int LoadMode> -struct ei_product_packet_impl<ColMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode> +struct product_packet_impl<ColMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode> { 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<ColMajor, UnrollingIndex-1, Lhs, Rhs, Packet, LoadMode>::run(row, col, lhs, rhs, res); - res = ei_pmadd(lhs.template packet<LoadMode>(row, UnrollingIndex), ei_pset1<Packet>(rhs.coeff(UnrollingIndex, col)), res); + product_packet_impl<ColMajor, UnrollingIndex-1, Lhs, Rhs, Packet, LoadMode>::run(row, col, lhs, rhs, res); + res = pmadd(lhs.template packet<LoadMode>(row, UnrollingIndex), pset1<Packet>(rhs.coeff(UnrollingIndex, col)), res); } }; template<typename Lhs, typename Rhs, typename Packet, int LoadMode> -struct ei_product_packet_impl<RowMajor, 0, Lhs, Rhs, Packet, LoadMode> +struct product_packet_impl<RowMajor, 0, Lhs, Rhs, Packet, LoadMode> { 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<Packet>(lhs.coeff(row, 0)),rhs.template packet<LoadMode>(0, col)); + res = pmul(pset1<Packet>(lhs.coeff(row, 0)),rhs.template packet<LoadMode>(0, col)); } }; template<typename Lhs, typename Rhs, typename Packet, int LoadMode> -struct ei_product_packet_impl<ColMajor, 0, Lhs, Rhs, Packet, LoadMode> +struct product_packet_impl<ColMajor, 0, Lhs, Rhs, Packet, LoadMode> { 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<LoadMode>(row, 0), ei_pset1<Packet>(rhs.coeff(0, col))); + res = pmul(lhs.template packet<LoadMode>(row, 0), pset1<Packet>(rhs.coeff(0, col))); } }; template<typename Lhs, typename Rhs, typename Packet, int LoadMode> -struct ei_product_packet_impl<RowMajor, Dynamic, Lhs, Rhs, Packet, LoadMode> +struct product_packet_impl<RowMajor, Dynamic, Lhs, Rhs, Packet, LoadMode> { 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<Packet>(lhs.coeff(row, 0)),rhs.template packet<LoadMode>(0, col)); + eigen_assert(lhs.cols()>0 && "you are using a non initialized matrix"); + res = pmul(pset1<Packet>(lhs.coeff(row, 0)),rhs.template packet<LoadMode>(0, col)); for(Index i = 1; i < lhs.cols(); ++i) - res = ei_pmadd(ei_pset1<Packet>(lhs.coeff(row, i)), rhs.template packet<LoadMode>(i, col), res); + res = pmadd(pset1<Packet>(lhs.coeff(row, i)), rhs.template packet<LoadMode>(i, col), res); } }; template<typename Lhs, typename Rhs, typename Packet, int LoadMode> -struct ei_product_packet_impl<ColMajor, Dynamic, Lhs, Rhs, Packet, LoadMode> +struct product_packet_impl<ColMajor, Dynamic, Lhs, Rhs, Packet, LoadMode> { 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<LoadMode>(row, 0), ei_pset1<Packet>(rhs.coeff(0, col))); + eigen_assert(lhs.cols()>0 && "you are using a non initialized matrix"); + res = pmul(lhs.template packet<LoadMode>(row, 0), pset1<Packet>(rhs.coeff(0, col))); for(Index i = 1; i < lhs.cols(); ++i) - res = ei_pmadd(lhs.template packet<LoadMode>(row, i), ei_pset1<Packet>(rhs.coeff(i, col)), res); + res = pmadd(lhs.template packet<LoadMode>(row, i), pset1<Packet>(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<typename _LhsScalar, typename _RhsScalar, bool _ConjLhs=false, bool _ConjRhs=false> -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<LhsScalar,RhsScalar> Traits; + typedef gebp_traits<LhsScalar,RhsScalar> Traits; enum { kdiv = KcFactor * 2 * Traits::nr * Traits::RhsProgress * sizeof(RhsScalar), - mr = ei_gebp_traits<LhsScalar,RhsScalar>::mr, + mr = gebp_traits<LhsScalar,RhsScalar>::mr, mr_mask = (0xffffffff/mr)*mr }; - ei_manage_caching_sizes(GetAction, &l1, &l2); + manage_caching_sizes(GetAction, &l1, &l2); k = std::min<std::ptrdiff_t>(k, l1/kdiv); std::ptrdiff_t _m = k>0 ? l2/(4 * sizeof(LhsScalar) * k) : 0; if(_m<m) m = _m & mr_mask; @@ -143,28 +117,28 @@ inline void computeProductBlockingSizes(std::ptrdiff_t& k, std::ptrdiff_t& m, st // FIXME (a bit overkill maybe ?) - template<typename CJ, typename A, typename B, typename C, typename T> struct ei_gebp_madd_selector { + template<typename CJ, typename A, typename B, typename C, typename T> 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<typename CJ, typename T> struct ei_gebp_madd_selector<CJ,T,T,T,T> { + template<typename CJ, typename T> struct gebp_madd_selector<CJ,T,T,T,T> { 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<typename CJ, typename A, typename B, typename C, typename T> - 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<CJ,A,B,C,T>::run(cj,a,b,c,t); + gebp_madd_selector<CJ,A,B,C,T>::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<typename _LhsScalar, typename _RhsScalar, bool _ConjLhs, bool _ConjRhs> -class ei_gebp_traits +class gebp_traits { public: typedef _LhsScalar LhsScalar; typedef _RhsScalar RhsScalar; - typedef typename ei_scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar; + typedef typename scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar; enum { ConjLhs = _ConjLhs, ConjRhs = _ConjRhs, - Vectorizable = ei_packet_traits<LhsScalar>::Vectorizable && ei_packet_traits<RhsScalar>::Vectorizable, - LhsPacketSize = Vectorizable ? ei_packet_traits<LhsScalar>::size : 1, - RhsPacketSize = Vectorizable ? ei_packet_traits<RhsScalar>::size : 1, - ResPacketSize = Vectorizable ? ei_packet_traits<ResScalar>::size : 1, + Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable, + LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1, + RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1, + ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1, NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS, @@ -207,67 +181,67 @@ public: RhsProgress = RhsPacketSize }; - typedef typename ei_packet_traits<LhsScalar>::type _LhsPacket; - typedef typename ei_packet_traits<RhsScalar>::type _RhsPacket; - typedef typename ei_packet_traits<ResScalar>::type _ResPacket; + typedef typename packet_traits<LhsScalar>::type _LhsPacket; + typedef typename packet_traits<RhsScalar>::type _RhsPacket; + typedef typename packet_traits<ResScalar>::type _ResPacket; - typedef typename ei_meta_if<Vectorizable,_LhsPacket,LhsScalar>::ret LhsPacket; - typedef typename ei_meta_if<Vectorizable,_RhsPacket,RhsScalar>::ret RhsPacket; - typedef typename ei_meta_if<Vectorizable,_ResPacket,ResScalar>::ret ResPacket; + typedef typename meta_if<Vectorizable,_LhsPacket,LhsScalar>::ret LhsPacket; + typedef typename meta_if<Vectorizable,_RhsPacket,RhsScalar>::ret RhsPacket; + typedef typename meta_if<Vectorizable,_ResPacket,ResScalar>::ret ResPacket; typedef ResPacket AccPacket; EIGEN_STRONG_INLINE void initAcc(AccPacket& p) { - p = ei_pset1<ResPacket>(ResScalar(0)); + p = pset1<ResPacket>(ResScalar(0)); } EIGEN_STRONG_INLINE void unpackRhs(DenseIndex n, const RhsScalar* rhs, RhsScalar* b) { for(DenseIndex k=0; k<n; k++) - ei_pstore(&b[k*RhsPacketSize], ei_pset1<RhsPacket>(rhs[k])); + pstore(&b[k*RhsPacketSize], pset1<RhsPacket>(rhs[k])); } EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const { - dest = ei_pload<RhsPacket>(b); + dest = pload<RhsPacket>(b); } EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const { - dest = ei_pload<LhsPacket>(a); + dest = pload<LhsPacket>(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<LhsScalar,RhsScalar,ConjLhs,ConjRhs> cj; -// ei_conj_helper<LhsPacket,RhsPacket,ConjLhs,ConjRhs> pcj; +// conj_helper<LhsScalar,RhsScalar,ConjLhs,ConjRhs> cj; +// conj_helper<LhsPacket,RhsPacket,ConjLhs,ConjRhs> pcj; }; template<typename RealScalar, bool _ConjLhs> -class ei_gebp_traits<std::complex<RealScalar>, RealScalar, _ConjLhs, false> +class gebp_traits<std::complex<RealScalar>, RealScalar, _ConjLhs, false> { public: typedef std::complex<RealScalar> LhsScalar; typedef RealScalar RhsScalar; - typedef typename ei_scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar; + typedef typename scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar; enum { ConjLhs = _ConjLhs, ConjRhs = false, - Vectorizable = ei_packet_traits<LhsScalar>::Vectorizable && ei_packet_traits<RhsScalar>::Vectorizable, - LhsPacketSize = Vectorizable ? ei_packet_traits<LhsScalar>::size : 1, - RhsPacketSize = Vectorizable ? ei_packet_traits<RhsScalar>::size : 1, - ResPacketSize = Vectorizable ? ei_packet_traits<ResScalar>::size : 1, + Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable, + LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1, + RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1, + ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1, NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS, nr = NumberOfRegisters/4, @@ -278,48 +252,48 @@ public: RhsProgress = RhsPacketSize }; - typedef typename ei_packet_traits<LhsScalar>::type _LhsPacket; - typedef typename ei_packet_traits<RhsScalar>::type _RhsPacket; - typedef typename ei_packet_traits<ResScalar>::type _ResPacket; + typedef typename packet_traits<LhsScalar>::type _LhsPacket; + typedef typename packet_traits<RhsScalar>::type _RhsPacket; + typedef typename packet_traits<ResScalar>::type _ResPacket; - typedef typename ei_meta_if<Vectorizable,_LhsPacket,LhsScalar>::ret LhsPacket; - typedef typename ei_meta_if<Vectorizable,_RhsPacket,RhsScalar>::ret RhsPacket; - typedef typename ei_meta_if<Vectorizable,_ResPacket,ResScalar>::ret ResPacket; + typedef typename meta_if<Vectorizable,_LhsPacket,LhsScalar>::ret LhsPacket; + typedef typename meta_if<Vectorizable,_RhsPacket,RhsScalar>::ret RhsPacket; + typedef typename meta_if<Vectorizable,_ResPacket,ResScalar>::ret ResPacket; typedef ResPacket AccPacket; EIGEN_STRONG_INLINE void initAcc(AccPacket& p) { - p = ei_pset1<ResPacket>(ResScalar(0)); + p = pset1<ResPacket>(ResScalar(0)); } EIGEN_STRONG_INLINE void unpackRhs(DenseIndex n, const RhsScalar* rhs, RhsScalar* b) { for(DenseIndex k=0; k<n; k++) - ei_pstore(&b[k*RhsPacketSize], ei_pset1<RhsPacket>(rhs[k])); + pstore(&b[k*RhsPacketSize], pset1<RhsPacket>(rhs[k])); } EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const { - dest = ei_pload<RhsPacket>(b); + dest = pload<RhsPacket>(b); } EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const { - dest = ei_pload<LhsPacket>(a); + dest = pload<LhsPacket>(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<Vectorizable,ei_meta_true,ei_meta_false>::ret()); + madd_impl(a, b, c, tmp, typename meta_if<Vectorizable,meta_true,meta_false>::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<ResPacket,ResPacket,ConjLhs,false> cj; + conj_helper<ResPacket,ResPacket,ConjLhs,false> cj; }; template<typename RealScalar, bool _ConjLhs, bool _ConjRhs> -class ei_gebp_traits<std::complex<RealScalar>, std::complex<RealScalar>, _ConjLhs, _ConjRhs > +class gebp_traits<std::complex<RealScalar>, std::complex<RealScalar>, _ConjLhs, _ConjRhs > { public: typedef std::complex<RealScalar> Scalar; @@ -345,10 +319,10 @@ public: enum { ConjLhs = _ConjLhs, ConjRhs = _ConjRhs, - Vectorizable = ei_packet_traits<RealScalar>::Vectorizable - && ei_packet_traits<Scalar>::Vectorizable, - RealPacketSize = Vectorizable ? ei_packet_traits<RealScalar>::size : 1, - ResPacketSize = Vectorizable ? ei_packet_traits<ResScalar>::size : 1, + Vectorizable = packet_traits<RealScalar>::Vectorizable + && packet_traits<Scalar>::Vectorizable, + RealPacketSize = Vectorizable ? packet_traits<RealScalar>::size : 1, + ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1, nr = 2, mr = 2 * ResPacketSize, @@ -358,25 +332,25 @@ public: RhsProgress = Vectorizable ? 2*ResPacketSize : 1 }; - typedef typename ei_packet_traits<RealScalar>::type RealPacket; - typedef typename ei_packet_traits<Scalar>::type ScalarPacket; + typedef typename packet_traits<RealScalar>::type RealPacket; + typedef typename packet_traits<Scalar>::type ScalarPacket; struct DoublePacket { RealPacket first; RealPacket second; }; - typedef typename ei_meta_if<Vectorizable,RealPacket, Scalar>::ret LhsPacket; - typedef typename ei_meta_if<Vectorizable,DoublePacket,Scalar>::ret RhsPacket; - typedef typename ei_meta_if<Vectorizable,ScalarPacket,Scalar>::ret ResPacket; - typedef typename ei_meta_if<Vectorizable,DoublePacket,Scalar>::ret AccPacket; + typedef typename meta_if<Vectorizable,RealPacket, Scalar>::ret LhsPacket; + typedef typename meta_if<Vectorizable,DoublePacket,Scalar>::ret RhsPacket; + typedef typename meta_if<Vectorizable,ScalarPacket,Scalar>::ret ResPacket; + typedef typename meta_if<Vectorizable,DoublePacket,Scalar>::ret AccPacket; EIGEN_STRONG_INLINE void initAcc(Scalar& p) { p = Scalar(0); } EIGEN_STRONG_INLINE void initAcc(DoublePacket& p) { - p.first = ei_pset1<RealPacket>(RealScalar(0)); - p.second = ei_pset1<RealPacket>(RealScalar(0)); + p.first = pset1<RealPacket>(RealScalar(0)); + p.second = pset1<RealPacket>(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<RealPacket>(ei_real(rhs[k]))); - ei_pstore((RealScalar*)&b[k*ResPacketSize*2+ResPacketSize], ei_pset1<RealPacket>(ei_imag(rhs[k]))); + pstore((RealScalar*)&b[k*ResPacketSize*2+0], pset1<RealPacket>(real(rhs[k]))); + pstore((RealScalar*)&b[k*ResPacketSize*2+ResPacketSize], pset1<RealPacket>(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<RealPacket>((const RealScalar*)b); - dest.second = ei_pload<RealPacket>((const RealScalar*)(b+ResPacketSize)); + dest.first = pload<RealPacket>((const RealScalar*)b); + dest.second = pload<RealPacket>((const RealScalar*)(b+ResPacketSize)); } // nothing special here EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const { - dest = ei_pload<LhsPacket>((const typename ei_unpacket_traits<LhsPacket>::type*)(a)); + dest = pload<LhsPacket>((const typename unpacket_traits<LhsPacket>::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<LhsScalar,RhsScalar,ConjLhs,ConjRhs> cj; + conj_helper<LhsScalar,RhsScalar,ConjLhs,ConjRhs> cj; }; template<typename RealScalar, bool _ConjRhs> -class ei_gebp_traits<RealScalar, std::complex<RealScalar>, false, _ConjRhs > +class gebp_traits<RealScalar, std::complex<RealScalar>, false, _ConjRhs > { public: typedef std::complex<RealScalar> Scalar; @@ -468,11 +442,11 @@ public: enum { ConjLhs = false, ConjRhs = _ConjRhs, - Vectorizable = ei_packet_traits<RealScalar>::Vectorizable - && ei_packet_traits<Scalar>::Vectorizable, - LhsPacketSize = Vectorizable ? ei_packet_traits<LhsScalar>::size : 1, - RhsPacketSize = Vectorizable ? ei_packet_traits<RhsScalar>::size : 1, - ResPacketSize = Vectorizable ? ei_packet_traits<ResScalar>::size : 1, + Vectorizable = packet_traits<RealScalar>::Vectorizable + && packet_traits<Scalar>::Vectorizable, + LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1, + RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1, + ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1, NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS, nr = 4, @@ -483,48 +457,48 @@ public: RhsProgress = ResPacketSize }; - typedef typename ei_packet_traits<LhsScalar>::type _LhsPacket; - typedef typename ei_packet_traits<RhsScalar>::type _RhsPacket; - typedef typename ei_packet_traits<ResScalar>::type _ResPacket; + typedef typename packet_traits<LhsScalar>::type _LhsPacket; + typedef typename packet_traits<RhsScalar>::type _RhsPacket; + typedef typename packet_traits<ResScalar>::type _ResPacket; - typedef typename ei_meta_if<Vectorizable,_LhsPacket,LhsScalar>::ret LhsPacket; - typedef typename ei_meta_if<Vectorizable,_RhsPacket,RhsScalar>::ret RhsPacket; - typedef typename ei_meta_if<Vectorizable,_ResPacket,ResScalar>::ret ResPacket; + typedef typename meta_if<Vectorizable,_LhsPacket,LhsScalar>::ret LhsPacket; + typedef typename meta_if<Vectorizable,_RhsPacket,RhsScalar>::ret RhsPacket; + typedef typename meta_if<Vectorizable,_ResPacket,ResScalar>::ret ResPacket; typedef ResPacket AccPacket; EIGEN_STRONG_INLINE void initAcc(AccPacket& p) { - p = ei_pset1<ResPacket>(ResScalar(0)); + p = pset1<ResPacket>(ResScalar(0)); } EIGEN_STRONG_INLINE void unpackRhs(DenseIndex n, const RhsScalar* rhs, RhsScalar* b) { for(DenseIndex k=0; k<n; k++) - ei_pstore(&b[k*RhsPacketSize], ei_pset1<RhsPacket>(rhs[k])); + pstore(&b[k*RhsPacketSize], pset1<RhsPacket>(rhs[k])); } EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const { - dest = ei_pload<RhsPacket>(b); + dest = pload<RhsPacket>(b); } EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const { - dest = ei_ploaddup<LhsPacket>(a); + dest = ploaddup<LhsPacket>(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<Vectorizable,ei_meta_true,ei_meta_false>::ret()); + madd_impl(a, b, c, tmp, typename meta_if<Vectorizable,meta_true,meta_false>::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<ResPacket,ResPacket,false,ConjRhs> cj; + conj_helper<ResPacket,ResPacket,false,ConjRhs> cj; }; /* optimized GEneral packed Block * packed Panel product kernel @@ -546,9 +520,9 @@ protected: * |cplx |real | easy vectorization */ template<typename LhsScalar, typename RhsScalar, typename Index, int mr, int nr, bool ConjugateLhs, bool ConjugateRhs> -struct ei_gebp_kernel +struct gebp_kernel { - typedef ei_gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> Traits; + typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> 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<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj; -// ei_conj_helper<LhsPacket,RhsPacket,ConjugateLhs,ConjugateRhs> pcj; + conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj; +// conj_helper<LhsPacket,RhsPacket,ConjugateLhs,ConjugateRhs> 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<peeled_mc; i+=mr) { const LhsScalar* blA = &blockA[i*strideA+offsetA*mr]; - ei_prefetch(&blA[0]); + prefetch(&blA[0]); // gets res block as register AccPacket C0, C1, C2, C3, C4, C5, C6, C7; @@ -610,10 +584,10 @@ struct ei_gebp_kernel ResScalar* r2 = r1 + resStride; ResScalar* r3 = r2 + resStride; - ei_prefetch(r0+16); - ei_prefetch(r1+16); - ei_prefetch(r2+16); - ei_prefetch(r3+16); + prefetch(r0+16); + prefetch(r1+16); + prefetch(r2+16); + prefetch(r3+16); // performs "inner" product // TODO let's check wether the folowing peeled loop could not be @@ -781,16 +755,16 @@ EIGEN_ASM_COMMENT("mybegin4"); } ResPacket R0, R1, R2, R3, R4, R5, R6, R7; - ResPacket alphav = ei_pset1<ResPacket>(alpha); + ResPacket alphav = pset1<ResPacket>(alpha); - R0 = ei_ploadu<ResPacket>(r0); - R1 = ei_ploadu<ResPacket>(r1); - if(nr==4) R2 = ei_ploadu<ResPacket>(r2); - if(nr==4) R3 = ei_ploadu<ResPacket>(r3); - R4 = ei_ploadu<ResPacket>(r0 + ResPacketSize); - R5 = ei_ploadu<ResPacket>(r1 + ResPacketSize); - if(nr==4) R6 = ei_ploadu<ResPacket>(r2 + ResPacketSize); - if(nr==4) R7 = ei_ploadu<ResPacket>(r3 + ResPacketSize); + R0 = ploadu<ResPacket>(r0); + R1 = ploadu<ResPacket>(r1); + if(nr==4) R2 = ploadu<ResPacket>(r2); + if(nr==4) R3 = ploadu<ResPacket>(r3); + R4 = ploadu<ResPacket>(r0 + ResPacketSize); + R5 = ploadu<ResPacket>(r1 + ResPacketSize); + if(nr==4) R6 = ploadu<ResPacket>(r2 + ResPacketSize); + if(nr==4) R7 = ploadu<ResPacket>(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<ResPacket>(alpha); + ResPacket alphav = pset1<ResPacket>(alpha); ResScalar* r0 = &res[(j2+0)*resStride + i]; ResScalar* r1 = r0 + resStride; ResScalar* r2 = r1 + resStride; ResScalar* r3 = r2 + resStride; - R0 = ei_ploadu<ResPacket>(r0); - R1 = ei_ploadu<ResPacket>(r1); - if(nr==4) R2 = ei_ploadu<ResPacket>(r2); - if(nr==4) R3 = ei_ploadu<ResPacket>(r3); + R0 = ploadu<ResPacket>(r0); + R1 = ploadu<ResPacket>(r1); + if(nr==4) R2 = ploadu<ResPacket>(r2); + if(nr==4) R3 = ploadu<ResPacket>(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<rows; i++) { const LhsScalar* blA = &blockA[i*strideA+offsetA]; - ei_prefetch(&blA[0]); + prefetch(&blA[0]); // gets a 1 x nr res block as registers ResScalar C0(0), C1(0), C2(0), C3(0); @@ -1017,13 +991,13 @@ EIGEN_ASM_COMMENT("mybegin4"); traits.unpackRhs(depth, &blockB[j2*strideB+offsetB], unpackedB); // const RhsScalar* blB = &blockB[j2*strideB+offsetB]; // for(Index k=0; k<depth; k++) -// ei_pstore(&unpackedB[k*RhsPacketSize], ei_pset1<RhsPacket>(blB[k])); +// pstore(&unpackedB[k*RhsPacketSize], pset1<RhsPacket>(blB[k])); } for(Index i=0; i<peeled_mc; i+=mr) { const LhsScalar* blA = &blockA[i*strideA+offsetA*mr]; - ei_prefetch(&blA[0]); + prefetch(&blA[0]); // TODO move the res loads to the stores @@ -1049,24 +1023,24 @@ EIGEN_ASM_COMMENT("mybegin4"); blA += 2*LhsProgress; } ResPacket R0, R4; - ResPacket alphav = ei_pset1<ResPacket>(alpha); + ResPacket alphav = pset1<ResPacket>(alpha); ResScalar* r0 = &res[(j2+0)*resStride + i]; - R0 = ei_ploadu<ResPacket>(r0); - R4 = ei_ploadu<ResPacket>(r0+ResPacketSize); + R0 = ploadu<ResPacket>(r0); + R4 = ploadu<ResPacket>(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<ResPacket>(alpha); - ResPacket R0 = ei_ploadu<ResPacket>(&res[(j2+0)*resStride + i]); + ResPacket alphav = pset1<ResPacket>(alpha); + ResPacket R0 = ploadu<ResPacket>(&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<rows; i++) { const LhsScalar* blA = &blockA[i*strideA+offsetA]; - ei_prefetch(&blA[0]); + prefetch(&blA[0]); // gets a 1 x 1 res block as registers ResScalar C0(0); @@ -1126,15 +1100,15 @@ EIGEN_ASM_COMMENT("mybegin4"); // 32 33 34 35 ... // 36 36 38 39 ... template<typename Scalar, typename Index, int Pack1, int Pack2, int StorageOrder, bool Conjugate, bool PanelMode> -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<Scalar>::size }; - ei_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride)); - ei_conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj; - ei_const_blas_data_mapper<Scalar, Index, StorageOrder> lhs(_lhs,lhsStride); +// enum { PacketSize = packet_traits<Scalar>::size }; + eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride)); + conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj; + const_blas_data_mapper<Scalar, Index, StorageOrder> lhs(_lhs,lhsStride); Index count = 0; Index peeled_mc = (rows/Pack1)*Pack1; for(Index i=0; i<peeled_mc; i+=Pack1) @@ -1172,15 +1146,15 @@ struct ei_gemm_pack_lhs // 8 9 10 11 20 21 22 23 26 29 // . . . . . . . . . . template<typename Scalar, typename Index, int nr, bool Conjugate, bool PanelMode> -struct ei_gemm_pack_rhs<Scalar, Index, nr, ColMajor, Conjugate, PanelMode> +struct gemm_pack_rhs<Scalar, Index, nr, ColMajor, Conjugate, PanelMode> { - typedef typename ei_packet_traits<Scalar>::type Packet; - enum { PacketSize = ei_packet_traits<Scalar>::size }; + typedef typename packet_traits<Scalar>::type Packet; + enum { PacketSize = packet_traits<Scalar>::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<NumTraits<Scalar>::IsComplex && Conjugate> cj; + eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride)); + conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj; Index packet_cols = (cols/nr) * nr; Index count = 0; for(Index j2=0; j2<packet_cols; j2+=nr) @@ -1220,14 +1194,14 @@ struct ei_gemm_pack_rhs<Scalar, Index, nr, ColMajor, Conjugate, PanelMode> // this version is optimized for row major matrices template<typename Scalar, typename Index, int nr, bool Conjugate, bool PanelMode> -struct ei_gemm_pack_rhs<Scalar, Index, nr, RowMajor, Conjugate, PanelMode> +struct gemm_pack_rhs<Scalar, Index, nr, RowMajor, Conjugate, PanelMode> { - enum { PacketSize = ei_packet_traits<Scalar>::size }; + enum { PacketSize = packet_traits<Scalar>::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<NumTraits<Scalar>::IsComplex && Conjugate> cj; + eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride)); + conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj; Index packet_cols = (cols/nr) * nr; Index count = 0; for(Index j2=0; j2<packet_cols; j2+=nr) @@ -1261,4 +1235,34 @@ struct ei_gemm_pack_rhs<Scalar, Index, nr, RowMajor, Conjugate, PanelMode> } }; +} // 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<typename _LhsScalar, typename _RhsScalar> class ei_level3_blocking; +namespace internal { + +template<typename _LhsScalar, typename _RhsScalar> 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<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,RowMajor> +struct general_matrix_matrix_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,RowMajor> { - typedef typename ei_scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar; + typedef typename scalar_product_traits<LhsScalar, RhsScalar>::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<RhsScalar,LhsScalar>& blocking, + level3_blocking<RhsScalar,LhsScalar>& blocking, GemmParallelInfo<Index>* info = 0) { // transpose the product such that the result is column major - ei_general_matrix_matrix_product<Index, + general_matrix_matrix_product<Index, RhsScalar, RhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateRhs, LhsScalar, LhsStorageOrder==RowMajor ? ColMajor : RowMajor, ConjugateLhs, ColMajor> @@ -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<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,ColMajor> +struct general_matrix_matrix_product<Index,LhsScalar,LhsStorageOrder,ConjugateLhs,RhsScalar,RhsStorageOrder,ConjugateRhs,ColMajor> { -typedef typename ei_scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar; +typedef typename scalar_product_traits<LhsScalar, RhsScalar>::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<LhsScalar,RhsScalar>& blocking, + level3_blocking<LhsScalar,RhsScalar>& blocking, GemmParallelInfo<Index>* info = 0) { - ei_const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> lhs(_lhs,lhsStride); - ei_const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> rhs(_rhs,rhsStride); + const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> lhs(_lhs,lhsStride); + const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> rhs(_rhs,rhsStride); - typedef ei_gebp_traits<LhsScalar,RhsScalar> Traits; + typedef gebp_traits<LhsScalar,RhsScalar> 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<LhsScalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs; - ei_gemm_pack_rhs<RhsScalar, Index, Traits::nr, RhsStorageOrder> pack_rhs; - ei_gebp_kernel<LhsScalar, RhsScalar, Index, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp; + gemm_pack_lhs<LhsScalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs; + gemm_pack_rhs<RhsScalar, Index, Traits::nr, RhsStorageOrder> pack_rhs; + gebp_kernel<LhsScalar, RhsScalar, Index, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> 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<depth; k+=kc) @@ -208,18 +210,18 @@ static void run(Index rows, Index cols, Index depth, /********************************************************************************* * Specialization of GeneralProduct<> 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<typename Lhs, typename Rhs> -struct ei_traits<GeneralProduct<Lhs,Rhs,GemmProduct> > - : ei_traits<ProductBase<GeneralProduct<Lhs,Rhs,GemmProduct>, Lhs, Rhs> > +struct traits<GeneralProduct<Lhs,Rhs,GemmProduct> > + : traits<ProductBase<GeneralProduct<Lhs,Rhs,GemmProduct>, Lhs, Rhs> > {}; template<typename Scalar, typename Index, typename Gemm, typename Lhs, typename Rhs, typename Dest, typename BlockingType> -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<int StorageOrder, typename LhsScalar, typename RhsScalar, int MaxRows, int MaxCols, int MaxDepth, -bool FiniteAtCompileTime = MaxRows!=Dynamic && MaxCols!=Dynamic && MaxDepth != Dynamic> class ei_gemm_blocking_space; +bool FiniteAtCompileTime = MaxRows!=Dynamic && MaxCols!=Dynamic && MaxDepth != Dynamic> class gemm_blocking_space; template<typename _LhsScalar, typename _RhsScalar> -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<int StorageOrder, typename _LhsScalar, typename _RhsScalar, int MaxRows, int MaxCols, int MaxDepth> -class ei_gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols, MaxDepth, true> - : public ei_level3_blocking< - typename ei_meta_if<StorageOrder==RowMajor,_RhsScalar,_LhsScalar>::ret, - typename ei_meta_if<StorageOrder==RowMajor,_LhsScalar,_RhsScalar>::ret> +class gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols, MaxDepth, true> + : public level3_blocking< + typename meta_if<StorageOrder==RowMajor,_RhsScalar,_LhsScalar>::ret, + typename meta_if<StorageOrder==RowMajor,_LhsScalar,_RhsScalar>::ret> { enum { Transpose = StorageOrder==RowMajor, ActualRows = Transpose ? MaxCols : MaxRows, ActualCols = Transpose ? MaxRows : MaxCols }; - typedef typename ei_meta_if<Transpose,_RhsScalar,_LhsScalar>::ret LhsScalar; - typedef typename ei_meta_if<Transpose,_LhsScalar,_RhsScalar>::ret RhsScalar; - typedef ei_gebp_traits<LhsScalar,RhsScalar> Traits; + typedef typename meta_if<Transpose,_RhsScalar,_LhsScalar>::ret LhsScalar; + typedef typename meta_if<Transpose,_LhsScalar,_RhsScalar>::ret RhsScalar; + typedef gebp_traits<LhsScalar,RhsScalar> Traits; enum { SizeA = ActualRows * MaxDepth, SizeB = ActualCols * MaxDepth, @@ -308,7 +310,7 @@ class ei_gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols public: - ei_gemm_blocking_space(DenseIndex /*rows*/, DenseIndex /*cols*/, DenseIndex /*depth*/) + gemm_blocking_space(DenseIndex /*rows*/, DenseIndex /*cols*/, DenseIndex /*depth*/) { this->m_mc = ActualRows; this->m_nc = ActualCols; @@ -325,17 +327,17 @@ class ei_gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols }; template<int StorageOrder, typename _LhsScalar, typename _RhsScalar, int MaxRows, int MaxCols, int MaxDepth> -class ei_gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols, MaxDepth, false> - : public ei_level3_blocking< - typename ei_meta_if<StorageOrder==RowMajor,_RhsScalar,_LhsScalar>::ret, - typename ei_meta_if<StorageOrder==RowMajor,_LhsScalar,_RhsScalar>::ret> +class gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols, MaxDepth, false> + : public level3_blocking< + typename meta_if<StorageOrder==RowMajor,_RhsScalar,_LhsScalar>::ret, + typename meta_if<StorageOrder==RowMajor,_LhsScalar,_RhsScalar>::ret> { enum { Transpose = StorageOrder==RowMajor }; - typedef typename ei_meta_if<Transpose,_RhsScalar,_LhsScalar>::ret LhsScalar; - typedef typename ei_meta_if<Transpose,_LhsScalar,_RhsScalar>::ret RhsScalar; - typedef ei_gebp_traits<LhsScalar,RhsScalar> Traits; + typedef typename meta_if<Transpose,_RhsScalar,_LhsScalar>::ret LhsScalar; + typedef typename meta_if<Transpose,_LhsScalar,_RhsScalar>::ret RhsScalar; + typedef gebp_traits<LhsScalar,RhsScalar> Traits; DenseIndex m_sizeA; DenseIndex m_sizeB; @@ -343,7 +345,7 @@ class ei_gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols public: - ei_gemm_blocking_space(DenseIndex rows, DenseIndex cols, DenseIndex depth) + gemm_blocking_space(DenseIndex rows, DenseIndex cols, DenseIndex depth) { this->m_mc = Transpose ? cols : rows; this->m_nc = Transpose ? rows : cols; @@ -358,19 +360,19 @@ class ei_gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols void allocateA() { if(this->m_blockA==0) - this->m_blockA = ei_aligned_new<LhsScalar>(m_sizeA); + this->m_blockA = aligned_new<LhsScalar>(m_sizeA); } void allocateB() { if(this->m_blockB==0) - this->m_blockB = ei_aligned_new<RhsScalar>(m_sizeB); + this->m_blockB = aligned_new<RhsScalar>(m_sizeB); } void allocateW() { if(this->m_blockW==0) - this->m_blockW = ei_aligned_new<RhsScalar>(m_sizeW); + this->m_blockW = aligned_new<RhsScalar>(m_sizeW); } void allocateAll() @@ -380,14 +382,16 @@ class ei_gemm_blocking_space<StorageOrder,_LhsScalar,_RhsScalar,MaxRows, MaxCols allocateW(); } - ~ei_gemm_blocking_space() + ~gemm_blocking_space() { - ei_aligned_delete(this->m_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<typename Lhs, typename Rhs> class GeneralProduct<Lhs, Rhs, GemmProduct> : public ProductBase<GeneralProduct<Lhs,Rhs,GemmProduct>, Lhs, Rhs> @@ -404,13 +408,13 @@ class GeneralProduct<Lhs, Rhs, GemmProduct> GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs) { - typedef ei_scalar_product_op<LhsScalar,RhsScalar> BinOp; + typedef internal::scalar_product_op<LhsScalar,RhsScalar> BinOp; EIGEN_CHECK_BINARY_COMPATIBILIY(BinOp,LhsScalar,RhsScalar); } template<typename Dest> 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<Lhs, Rhs, GemmProduct> 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<Lhs, Rhs, GemmProduct> 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<typename Index, typename LhsScalar, bool ConjugateLhs, typename RhsScalar, bool ConjugateRhs> -struct ei_general_matrix_vector_product<Index,LhsScalar,ColMajor,ConjugateLhs,RhsScalar,ConjugateRhs> +struct general_matrix_vector_product<Index,LhsScalar,ColMajor,ConjugateLhs,RhsScalar,ConjugateRhs> { -typedef typename ei_scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar; +typedef typename scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar; enum { - Vectorizable = ei_packet_traits<LhsScalar>::Vectorizable && ei_packet_traits<RhsScalar>::Vectorizable - && int(ei_packet_traits<LhsScalar>::size)==int(ei_packet_traits<RhsScalar>::size), - LhsPacketSize = Vectorizable ? ei_packet_traits<LhsScalar>::size : 1, - RhsPacketSize = Vectorizable ? ei_packet_traits<RhsScalar>::size : 1, - ResPacketSize = Vectorizable ? ei_packet_traits<ResScalar>::size : 1 + Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable + && int(packet_traits<LhsScalar>::size)==int(packet_traits<RhsScalar>::size), + LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1, + RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1, + ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1 }; -typedef typename ei_packet_traits<LhsScalar>::type _LhsPacket; -typedef typename ei_packet_traits<RhsScalar>::type _RhsPacket; -typedef typename ei_packet_traits<ResScalar>::type _ResPacket; +typedef typename packet_traits<LhsScalar>::type _LhsPacket; +typedef typename packet_traits<RhsScalar>::type _RhsPacket; +typedef typename packet_traits<ResScalar>::type _ResPacket; -typedef typename ei_meta_if<Vectorizable,_LhsPacket,LhsScalar>::ret LhsPacket; -typedef typename ei_meta_if<Vectorizable,_RhsPacket,RhsScalar>::ret RhsPacket; -typedef typename ei_meta_if<Vectorizable,_ResPacket,ResScalar>::ret ResPacket; +typedef typename meta_if<Vectorizable,_LhsPacket,LhsScalar>::ret LhsPacket; +typedef typename meta_if<Vectorizable,_RhsPacket,RhsScalar>::ret RhsPacket; +typedef typename meta_if<Vectorizable,_ResPacket,ResScalar>::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<ResPacket>(&res[j]), \ - ei_padd( \ - ei_padd(pcj.pmul(EIGEN_CAT(ei_ploa , A0)<LhsPacket>(&lhs0[j]), ptmp0), \ - pcj.pmul(EIGEN_CAT(ei_ploa , A13)<LhsPacket>(&lhs1[j]), ptmp1)), \ - ei_padd(pcj.pmul(EIGEN_CAT(ei_ploa , A2)<LhsPacket>(&lhs2[j]), ptmp2), \ - pcj.pmul(EIGEN_CAT(ei_ploa , A13)<LhsPacket>(&lhs3[j]), ptmp3)) ))) - - ei_conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj; - ei_conj_helper<LhsPacket,RhsPacket,ConjugateLhs,ConjugateRhs> pcj; + pstore(&res[j], \ + padd(pload<ResPacket>(&res[j]), \ + padd( \ + padd(pcj.pmul(EIGEN_CAT(ploa , A0)<LhsPacket>(&lhs0[j]), ptmp0), \ + pcj.pmul(EIGEN_CAT(ploa , A13)<LhsPacket>(&lhs1[j]), ptmp1)), \ + padd(pcj.pmul(EIGEN_CAT(ploa , A2)<LhsPacket>(&lhs2[j]), ptmp2), \ + pcj.pmul(EIGEN_CAT(ploa , A13)<LhsPacket>(&lhs3[j]), ptmp3)) ))) + + conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj; + conj_helper<LhsPacket,RhsPacket,ConjugateLhs,ConjugateRhs> 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<LhsPacketSize); + eigen_internal_assert(size_t(lhs+lhsAlignmentOffset)%sizeof(LhsPacket)==0 || size<LhsPacketSize); while (skipColumns<LhsPacketSize && alignedStart != ((lhsAlignmentOffset + alignmentStep*skipColumns)%LhsPacketSize)) @@ -136,7 +138,7 @@ EIGEN_DONT_INLINE static void run( // note that the skiped columns are processed later. } - ei_internal_assert( (alignmentPattern==NoneAligned) + eigen_internal_assert( (alignmentPattern==NoneAligned) || (skipColumns + columnsAtOnce >= 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<columnBound; i+=columnsAtOnce) { - RhsPacket ptmp0 = ei_pset1<RhsPacket>(alpha*rhs[i*rhsIncr]), - ptmp1 = ei_pset1<RhsPacket>(alpha*rhs[(i+offset1)*rhsIncr]), - ptmp2 = ei_pset1<RhsPacket>(alpha*rhs[(i+2)*rhsIncr]), - ptmp3 = ei_pset1<RhsPacket>(alpha*rhs[(i+offset3)*rhsIncr]); + RhsPacket ptmp0 = pset1<RhsPacket>(alpha*rhs[i*rhsIncr]), + ptmp1 = pset1<RhsPacket>(alpha*rhs[(i+offset1)*rhsIncr]), + ptmp2 = pset1<RhsPacket>(alpha*rhs[(i+2)*rhsIncr]), + ptmp3 = pset1<RhsPacket>(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; j<alignedStart; ++j) { - res[j] = cj.pmadd(lhs0[j], ei_pfirst(ptmp0), res[j]); - res[j] = cj.pmadd(lhs1[j], ei_pfirst(ptmp1), res[j]); - res[j] = cj.pmadd(lhs2[j], ei_pfirst(ptmp2), res[j]); - res[j] = cj.pmadd(lhs3[j], ei_pfirst(ptmp3), res[j]); + res[j] = cj.pmadd(lhs0[j], pfirst(ptmp0), res[j]); + res[j] = cj.pmadd(lhs1[j], pfirst(ptmp1), res[j]); + res[j] = cj.pmadd(lhs2[j], pfirst(ptmp2), res[j]); + res[j] = cj.pmadd(lhs3[j], pfirst(ptmp3), res[j]); } if (alignedSize>alignedStart) @@ -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<LhsPacket>(&lhs1[alignedStart-1]); - A02 = ei_pload<LhsPacket>(&lhs2[alignedStart-2]); - A03 = ei_pload<LhsPacket>(&lhs3[alignedStart-3]); + A01 = pload<LhsPacket>(&lhs1[alignedStart-1]); + A02 = pload<LhsPacket>(&lhs2[alignedStart-2]); + A03 = pload<LhsPacket>(&lhs3[alignedStart-3]); for (Index j = alignedStart; j<peeledSize; j+=peels*ResPacketSize) { - A11 = ei_pload<LhsPacket>(&lhs1[j-1+LhsPacketSize]); ei_palign<1>(A01,A11); - A12 = ei_pload<LhsPacket>(&lhs2[j-2+LhsPacketSize]); ei_palign<2>(A02,A12); - A13 = ei_pload<LhsPacket>(&lhs3[j-3+LhsPacketSize]); ei_palign<3>(A03,A13); + A11 = pload<LhsPacket>(&lhs1[j-1+LhsPacketSize]); palign<1>(A01,A11); + A12 = pload<LhsPacket>(&lhs2[j-2+LhsPacketSize]); palign<2>(A02,A12); + A13 = pload<LhsPacket>(&lhs3[j-3+LhsPacketSize]); palign<3>(A03,A13); - A00 = ei_pload<LhsPacket>(&lhs0[j]); - A10 = ei_pload<LhsPacket>(&lhs0[j+LhsPacketSize]); - T0 = pcj.pmadd(A00, ptmp0, ei_pload<ResPacket>(&res[j])); - T1 = pcj.pmadd(A10, ptmp0, ei_pload<ResPacket>(&res[j+ResPacketSize])); + A00 = pload<LhsPacket>(&lhs0[j]); + A10 = pload<LhsPacket>(&lhs0[j+LhsPacketSize]); + T0 = pcj.pmadd(A00, ptmp0, pload<ResPacket>(&res[j])); + T1 = pcj.pmadd(A10, ptmp0, pload<ResPacket>(&res[j+ResPacketSize])); T0 = pcj.pmadd(A01, ptmp1, T0); - A01 = ei_pload<LhsPacket>(&lhs1[j-1+2*LhsPacketSize]); ei_palign<1>(A11,A01); + A01 = pload<LhsPacket>(&lhs1[j-1+2*LhsPacketSize]); palign<1>(A11,A01); T0 = pcj.pmadd(A02, ptmp2, T0); - A02 = ei_pload<LhsPacket>(&lhs2[j-2+2*LhsPacketSize]); ei_palign<2>(A12,A02); + A02 = pload<LhsPacket>(&lhs2[j-2+2*LhsPacketSize]); palign<2>(A12,A02); T0 = pcj.pmadd(A03, ptmp3, T0); - ei_pstore(&res[j],T0); - A03 = ei_pload<LhsPacket>(&lhs3[j-3+2*LhsPacketSize]); ei_palign<3>(A13,A03); + pstore(&res[j],T0); + A03 = pload<LhsPacket>(&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<alignedSize; j+=ResPacketSize) @@ -235,10 +237,10 @@ EIGEN_DONT_INLINE static void run( /* process remaining coeffs (or all if there is no explicit vectorization) */ for (Index j=alignedSize; j<size; ++j) { - res[j] = cj.pmadd(lhs0[j], ei_pfirst(ptmp0), res[j]); - res[j] = cj.pmadd(lhs1[j], ei_pfirst(ptmp1), res[j]); - res[j] = cj.pmadd(lhs2[j], ei_pfirst(ptmp2), res[j]); - res[j] = cj.pmadd(lhs3[j], ei_pfirst(ptmp3), res[j]); + res[j] = cj.pmadd(lhs0[j], pfirst(ptmp0), res[j]); + res[j] = cj.pmadd(lhs1[j], pfirst(ptmp1), res[j]); + res[j] = cj.pmadd(lhs2[j], pfirst(ptmp2), res[j]); + res[j] = cj.pmadd(lhs3[j], pfirst(ptmp3), res[j]); } } @@ -249,7 +251,7 @@ EIGEN_DONT_INLINE static void run( { for (Index k=start; k<end; ++k) { - RhsPacket ptmp0 = ei_pset1<RhsPacket>(alpha*rhs[k*rhsIncr]); + RhsPacket ptmp0 = pset1<RhsPacket>(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<alignedStart; ++j) - res[j] += cj.pmul(lhs0[j], ei_pfirst(ptmp0)); + res[j] += cj.pmul(lhs0[j], pfirst(ptmp0)); // process aligned result's coeffs if ((size_t(lhs0+alignedStart)%sizeof(LhsPacket))==0) for (Index i = alignedStart;i<alignedSize;i+=ResPacketSize) - ei_pstore(&res[i], pcj.pmadd(ei_ploadu<LhsPacket>(&lhs0[i]), ptmp0, ei_pload<ResPacket>(&res[i]))); + pstore(&res[i], pcj.pmadd(ploadu<LhsPacket>(&lhs0[i]), ptmp0, pload<ResPacket>(&res[i]))); else for (Index i = alignedStart;i<alignedSize;i+=ResPacketSize) - ei_pstore(&res[i], pcj.pmadd(ei_ploadu<LhsPacket>(&lhs0[i]), ptmp0, ei_pload<ResPacket>(&res[i]))); + pstore(&res[i], pcj.pmadd(ploadu<LhsPacket>(&lhs0[i]), ptmp0, pload<ResPacket>(&res[i]))); } // process remaining scalars (or all if no explicit vectorization) for (Index i=alignedSize; i<size; ++i) - res[i] += cj.pmul(lhs0[i], ei_pfirst(ptmp0)); + res[i] += cj.pmul(lhs0[i], pfirst(ptmp0)); } if (skipColumns) { @@ -295,25 +297,25 @@ EIGEN_DONT_INLINE static void run( * - no vectorization */ template<typename Index, typename LhsScalar, bool ConjugateLhs, typename RhsScalar, bool ConjugateRhs> -struct ei_general_matrix_vector_product<Index,LhsScalar,RowMajor,ConjugateLhs,RhsScalar,ConjugateRhs> +struct general_matrix_vector_product<Index,LhsScalar,RowMajor,ConjugateLhs,RhsScalar,ConjugateRhs> { -typedef typename ei_scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar; +typedef typename scalar_product_traits<LhsScalar, RhsScalar>::ReturnType ResScalar; enum { - Vectorizable = ei_packet_traits<LhsScalar>::Vectorizable && ei_packet_traits<RhsScalar>::Vectorizable - && int(ei_packet_traits<LhsScalar>::size)==int(ei_packet_traits<RhsScalar>::size), - LhsPacketSize = Vectorizable ? ei_packet_traits<LhsScalar>::size : 1, - RhsPacketSize = Vectorizable ? ei_packet_traits<RhsScalar>::size : 1, - ResPacketSize = Vectorizable ? ei_packet_traits<ResScalar>::size : 1 + Vectorizable = packet_traits<LhsScalar>::Vectorizable && packet_traits<RhsScalar>::Vectorizable + && int(packet_traits<LhsScalar>::size)==int(packet_traits<RhsScalar>::size), + LhsPacketSize = Vectorizable ? packet_traits<LhsScalar>::size : 1, + RhsPacketSize = Vectorizable ? packet_traits<RhsScalar>::size : 1, + ResPacketSize = Vectorizable ? packet_traits<ResScalar>::size : 1 }; -typedef typename ei_packet_traits<LhsScalar>::type _LhsPacket; -typedef typename ei_packet_traits<RhsScalar>::type _RhsPacket; -typedef typename ei_packet_traits<ResScalar>::type _ResPacket; +typedef typename packet_traits<LhsScalar>::type _LhsPacket; +typedef typename packet_traits<RhsScalar>::type _RhsPacket; +typedef typename packet_traits<ResScalar>::type _ResPacket; -typedef typename ei_meta_if<Vectorizable,_LhsPacket,LhsScalar>::ret LhsPacket; -typedef typename ei_meta_if<Vectorizable,_RhsPacket,RhsScalar>::ret RhsPacket; -typedef typename ei_meta_if<Vectorizable,_ResPacket,ResScalar>::ret ResPacket; +typedef typename meta_if<Vectorizable,_LhsPacket,LhsScalar>::ret LhsPacket; +typedef typename meta_if<Vectorizable,_RhsPacket,RhsScalar>::ret RhsPacket; +typedef typename meta_if<Vectorizable,_ResPacket,ResScalar>::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<RhsPacket>(&rhs[j]); \ - ptmp0 = pcj.pmadd(EIGEN_CAT(ei_ploa,A0) <LhsPacket>(&lhs0[j]), b, ptmp0); \ - ptmp1 = pcj.pmadd(EIGEN_CAT(ei_ploa,A13)<LhsPacket>(&lhs1[j]), b, ptmp1); \ - ptmp2 = pcj.pmadd(EIGEN_CAT(ei_ploa,A2) <LhsPacket>(&lhs2[j]), b, ptmp2); \ - ptmp3 = pcj.pmadd(EIGEN_CAT(ei_ploa,A13)<LhsPacket>(&lhs3[j]), b, ptmp3); } + RhsPacket b = pload<RhsPacket>(&rhs[j]); \ + ptmp0 = pcj.pmadd(EIGEN_CAT(ploa,A0) <LhsPacket>(&lhs0[j]), b, ptmp0); \ + ptmp1 = pcj.pmadd(EIGEN_CAT(ploa,A13)<LhsPacket>(&lhs1[j]), b, ptmp1); \ + ptmp2 = pcj.pmadd(EIGEN_CAT(ploa,A2) <LhsPacket>(&lhs2[j]), b, ptmp2); \ + ptmp3 = pcj.pmadd(EIGEN_CAT(ploa,A13)<LhsPacket>(&lhs3[j]), b, ptmp3); } - ei_conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj; - ei_conj_helper<LhsPacket,RhsPacket,ConjugateLhs,ConjugateRhs> pcj; + conj_helper<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> cj; + conj_helper<LhsPacket,RhsPacket,ConjugateLhs,ConjugateRhs> 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<LhsPacketSize); + eigen_internal_assert(size_t(lhs+lhsAlignmentOffset)%sizeof(LhsPacket)==0 || depth<LhsPacketSize); while (skipRows<LhsPacketSize && alignedStart != ((lhsAlignmentOffset + alignmentStep*skipRows)%LhsPacketSize)) @@ -387,7 +389,7 @@ EIGEN_DONT_INLINE static void run( skipRows = std::min(skipRows,Index(rows)); // note that the skiped columns are processed later. } - ei_internal_assert( alignmentPattern==NoneAligned + eigen_internal_assert( alignmentPattern==NoneAligned || LhsPacketSize==1 || (skipRows + rowsAtOnce >= rows) || LhsPacketSize > depth @@ -416,8 +418,8 @@ EIGEN_DONT_INLINE static void run( if (Vectorizable) { /* explicit vectorization */ - ResPacket ptmp0 = ei_pset1<ResPacket>(ResScalar(0)), ptmp1 = ei_pset1<ResPacket>(ResScalar(0)), - ptmp2 = ei_pset1<ResPacket>(ResScalar(0)), ptmp3 = ei_pset1<ResPacket>(ResScalar(0)); + ResPacket ptmp0 = pset1<ResPacket>(ResScalar(0)), ptmp1 = pset1<ResPacket>(ResScalar(0)), + ptmp2 = pset1<ResPacket>(ResScalar(0)), ptmp3 = pset1<ResPacket>(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<LhsPacket>(&lhs1[alignedStart-1]); - A02 = ei_pload<LhsPacket>(&lhs2[alignedStart-2]); - A03 = ei_pload<LhsPacket>(&lhs3[alignedStart-3]); + A01 = pload<LhsPacket>(&lhs1[alignedStart-1]); + A02 = pload<LhsPacket>(&lhs2[alignedStart-2]); + A03 = pload<LhsPacket>(&lhs3[alignedStart-3]); for (Index j = alignedStart; j<peeledSize; j+=peels*RhsPacketSize) { - RhsPacket b = ei_pload<RhsPacket>(&rhs[j]); - A11 = ei_pload<LhsPacket>(&lhs1[j-1+LhsPacketSize]); ei_palign<1>(A01,A11); - A12 = ei_pload<LhsPacket>(&lhs2[j-2+LhsPacketSize]); ei_palign<2>(A02,A12); - A13 = ei_pload<LhsPacket>(&lhs3[j-3+LhsPacketSize]); ei_palign<3>(A03,A13); + RhsPacket b = pload<RhsPacket>(&rhs[j]); + A11 = pload<LhsPacket>(&lhs1[j-1+LhsPacketSize]); palign<1>(A01,A11); + A12 = pload<LhsPacket>(&lhs2[j-2+LhsPacketSize]); palign<2>(A02,A12); + A13 = pload<LhsPacket>(&lhs3[j-3+LhsPacketSize]); palign<3>(A03,A13); - ptmp0 = pcj.pmadd(ei_pload<LhsPacket>(&lhs0[j]), b, ptmp0); + ptmp0 = pcj.pmadd(pload<LhsPacket>(&lhs0[j]), b, ptmp0); ptmp1 = pcj.pmadd(A01, b, ptmp1); - A01 = ei_pload<LhsPacket>(&lhs1[j-1+2*LhsPacketSize]); ei_palign<1>(A11,A01); + A01 = pload<LhsPacket>(&lhs1[j-1+2*LhsPacketSize]); palign<1>(A11,A01); ptmp2 = pcj.pmadd(A02, b, ptmp2); - A02 = ei_pload<LhsPacket>(&lhs2[j-2+2*LhsPacketSize]); ei_palign<2>(A12,A02); + A02 = pload<LhsPacket>(&lhs2[j-2+2*LhsPacketSize]); palign<2>(A12,A02); ptmp3 = pcj.pmadd(A03, b, ptmp3); - A03 = ei_pload<LhsPacket>(&lhs3[j-3+2*LhsPacketSize]); ei_palign<3>(A13,A03); + A03 = pload<LhsPacket>(&lhs3[j-3+2*LhsPacketSize]); palign<3>(A13,A03); - b = ei_pload<RhsPacket>(&rhs[j+RhsPacketSize]); - ptmp0 = pcj.pmadd(ei_pload<LhsPacket>(&lhs0[j+LhsPacketSize]), b, ptmp0); + b = pload<RhsPacket>(&rhs[j+RhsPacketSize]); + ptmp0 = pcj.pmadd(pload<LhsPacket>(&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<end; ++i) { EIGEN_ALIGN16 ResScalar tmp0 = ResScalar(0); - ResPacket ptmp0 = ei_pset1<ResPacket>(tmp0); + ResPacket ptmp0 = pset1<ResPacket>(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<alignedSize;j+=RhsPacketSize) - ptmp0 = pcj.pmadd(ei_pload<LhsPacket>(&lhs0[j]), ei_pload<RhsPacket>(&rhs[j]), ptmp0); + ptmp0 = pcj.pmadd(pload<LhsPacket>(&lhs0[j]), pload<RhsPacket>(&rhs[j]), ptmp0); else for (Index j = alignedStart;j<alignedSize;j+=RhsPacketSize) - ptmp0 = pcj.pmadd(ei_ploadu<LhsPacket>(&lhs0[j]), ei_pload<RhsPacket>(&rhs[j]), ptmp0); - tmp0 += ei_predux(ptmp0); + ptmp0 = pcj.pmadd(ploadu<LhsPacket>(&lhs0[j]), pload<RhsPacket>(&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<typename Index> struct GemmParallelInfo @@ -81,7 +83,7 @@ template<typename Index> struct GemmParallelInfo }; template<bool Condition, typename Functor, typename Index> -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<typename Scalar, typename Index, int Pack1, int Pack2, int StorageOrder> -struct ei_symm_pack_lhs +struct symm_pack_lhs { template<int BlockRows> inline - void pack(Scalar* blockA, const ei_const_blas_data_mapper<Scalar,Index,StorageOrder>& lhs, Index cols, Index i, Index& count) + void pack(Scalar* blockA, const const_blas_data_mapper<Scalar,Index,StorageOrder>& lhs, Index cols, Index i, Index& count) { // normal copy for(Index k=0; k<i; k++) @@ -41,9 +43,9 @@ struct ei_symm_pack_lhs for(Index k=i; k<i+BlockRows; k++) { for(Index w=0; w<h; w++) - blockA[count++] = ei_conj(lhs(k, i+w)); // transposed + blockA[count++] = conj(lhs(k, i+w)); // transposed - blockA[count++] = ei_real(lhs(k,k)); // real (diagonal) + blockA[count++] = real(lhs(k,k)); // real (diagonal) for(Index w=h+1; w<BlockRows; w++) blockA[count++] = lhs(i+w, k); // normal @@ -52,11 +54,11 @@ struct ei_symm_pack_lhs // transposed copy for(Index k=i+BlockRows; k<cols; k++) for(Index w=0; w<BlockRows; w++) - blockA[count++] = ei_conj(lhs(k, i+w)); // transposed + blockA[count++] = conj(lhs(k, i+w)); // transposed } void operator()(Scalar* blockA, const Scalar* _lhs, Index lhsStride, Index cols, Index rows) { - ei_const_blas_data_mapper<Scalar,Index,StorageOrder> lhs(_lhs,lhsStride); + const_blas_data_mapper<Scalar,Index,StorageOrder> lhs(_lhs,lhsStride); Index count = 0; Index peeled_mc = (rows/Pack1)*Pack1; for(Index i=0; i<peeled_mc; i+=Pack1) @@ -76,23 +78,23 @@ struct ei_symm_pack_lhs for(Index k=0; k<i; k++) blockA[count++] = lhs(i, k); // normal - blockA[count++] = ei_real(lhs(i, i)); // real (diagonal) + blockA[count++] = real(lhs(i, i)); // real (diagonal) for(Index k=i+1; k<cols; k++) - blockA[count++] = ei_conj(lhs(k, i)); // transposed + blockA[count++] = conj(lhs(k, i)); // transposed } } }; template<typename Scalar, typename Index, int nr, int StorageOrder> -struct ei_symm_pack_rhs +struct symm_pack_rhs { - enum { PacketSize = ei_packet_traits<Scalar>::size }; + enum { PacketSize = packet_traits<Scalar>::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<Scalar,Index,StorageOrder> rhs(_rhs,rhsStride); + const_blas_data_mapper<Scalar,Index,StorageOrder> 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<j2; k++) { - blockB[count+0] = ei_conj(rhs(j2+0,k)); - blockB[count+1] = ei_conj(rhs(j2+1,k)); + blockB[count+0] = conj(rhs(j2+0,k)); + blockB[count+1] = conj(rhs(j2+1,k)); if (nr==4) { - blockB[count+2] = ei_conj(rhs(j2+2,k)); - blockB[count+3] = ei_conj(rhs(j2+3,k)); + blockB[count+2] = conj(rhs(j2+2,k)); + blockB[count+3] = conj(rhs(j2+3,k)); } count += nr; } @@ -135,11 +137,11 @@ struct ei_symm_pack_rhs for (Index w=0 ; w<h; ++w) blockB[count+w] = rhs(k,j2+w); - blockB[count+h] = ei_real(rhs(k,k)); + blockB[count+h] = real(rhs(k,k)); // transpose for (Index w=h+1 ; w<nr; ++w) - blockB[count+w] = ei_conj(rhs(j2+w,k)); + blockB[count+w] = conj(rhs(j2+w,k)); count += nr; ++h; } @@ -162,12 +164,12 @@ struct ei_symm_pack_rhs { for(Index k=k2; k<end_k; k++) { - blockB[count+0] = ei_conj(rhs(j2+0,k)); - blockB[count+1] = ei_conj(rhs(j2+1,k)); + blockB[count+0] = conj(rhs(j2+0,k)); + blockB[count+1] = conj(rhs(j2+1,k)); if (nr==4) { - blockB[count+2] = ei_conj(rhs(j2+2,k)); - blockB[count+3] = ei_conj(rhs(j2+3,k)); + blockB[count+2] = conj(rhs(j2+2,k)); + blockB[count+3] = conj(rhs(j2+3,k)); } count += nr; } @@ -180,13 +182,13 @@ struct ei_symm_pack_rhs Index half = std::min(end_k,j2); for(Index k=k2; k<half; k++) { - blockB[count] = ei_conj(rhs(j2,k)); + blockB[count] = conj(rhs(j2,k)); count += 1; } if(half==j2 && half<k2+rows) { - blockB[count] = ei_real(rhs(j2,j2)); + blockB[count] = real(rhs(j2,j2)); count += 1; } else @@ -209,12 +211,12 @@ template <typename Scalar, typename Index, int LhsStorageOrder, bool LhsSelfAdjoint, bool ConjugateLhs, int RhsStorageOrder, bool RhsSelfAdjoint, bool ConjugateRhs, int ResStorageOrder> -struct ei_product_selfadjoint_matrix; +struct product_selfadjoint_matrix; template <typename Scalar, typename Index, int LhsStorageOrder, bool LhsSelfAdjoint, bool ConjugateLhs, int RhsStorageOrder, bool RhsSelfAdjoint, bool ConjugateRhs> -struct ei_product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,LhsSelfAdjoint,ConjugateLhs, RhsStorageOrder,RhsSelfAdjoint,ConjugateRhs,RowMajor> +struct product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,LhsSelfAdjoint,ConjugateLhs, RhsStorageOrder,RhsSelfAdjoint,ConjugateRhs,RowMajor> { static EIGEN_STRONG_INLINE void run( @@ -224,7 +226,7 @@ struct ei_product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,LhsSelfAdjoint Scalar* res, Index resStride, Scalar alpha) { - ei_product_selfadjoint_matrix<Scalar, Index, + product_selfadjoint_matrix<Scalar, Index, EIGEN_LOGICAL_XOR(RhsSelfAdjoint,RhsStorageOrder==RowMajor) ? ColMajor : RowMajor, RhsSelfAdjoint, NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(RhsSelfAdjoint,ConjugateRhs), EIGEN_LOGICAL_XOR(LhsSelfAdjoint,LhsStorageOrder==RowMajor) ? ColMajor : RowMajor, @@ -237,7 +239,7 @@ struct ei_product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,LhsSelfAdjoint template <typename Scalar, typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs> -struct ei_product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,true,ConjugateLhs, RhsStorageOrder,false,ConjugateRhs,ColMajor> +struct product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,true,ConjugateLhs, RhsStorageOrder,false,ConjugateRhs,ColMajor> { static EIGEN_DONT_INLINE void run( @@ -249,10 +251,10 @@ struct ei_product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,true,Conjugate { Index size = rows; - ei_const_blas_data_mapper<Scalar, Index, LhsStorageOrder> lhs(_lhs,lhsStride); - ei_const_blas_data_mapper<Scalar, Index, RhsStorageOrder> rhs(_rhs,rhsStride); + const_blas_data_mapper<Scalar, Index, LhsStorageOrder> lhs(_lhs,lhsStride); + const_blas_data_mapper<Scalar, Index, RhsStorageOrder> rhs(_rhs,rhsStride); - typedef ei_gebp_traits<Scalar,Scalar> Traits; + typedef gebp_traits<Scalar,Scalar> 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<Scalar,Index,LhsStorageOrder,true,Conjugate Scalar* allocatedBlockB = ei_aligned_stack_new(Scalar, sizeB); Scalar* blockB = allocatedBlockB + sizeW; - ei_gebp_kernel<Scalar, Scalar, Index, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel; - ei_symm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs; - ei_gemm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder> pack_rhs; - ei_gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder==RowMajor?ColMajor:RowMajor, true> pack_lhs_transposed; + gebp_kernel<Scalar, Scalar, Index, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel; + symm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs; + gemm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder> pack_rhs; + gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder==RowMajor?ColMajor:RowMajor, true> pack_lhs_transposed; for(Index k2=0; k2<size; k2+=kc) { @@ -305,7 +307,7 @@ struct ei_product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,true,Conjugate for(Index i2=k2+kc; i2<size; i2+=mc) { const Index actual_mc = std::min(i2+mc,size)-i2; - ei_gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder,false>() + gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder,false>() (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<Scalar,Index,LhsStorageOrder,true,Conjugate template <typename Scalar, typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs> -struct ei_product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,false,ConjugateLhs, RhsStorageOrder,true,ConjugateRhs,ColMajor> +struct product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,false,ConjugateLhs, RhsStorageOrder,true,ConjugateRhs,ColMajor> { static EIGEN_DONT_INLINE void run( @@ -333,9 +335,9 @@ struct ei_product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,false,Conjugat { Index size = cols; - ei_const_blas_data_mapper<Scalar, Index, LhsStorageOrder> lhs(_lhs,lhsStride); + const_blas_data_mapper<Scalar, Index, LhsStorageOrder> lhs(_lhs,lhsStride); - typedef ei_gebp_traits<Scalar,Scalar> Traits; + typedef gebp_traits<Scalar,Scalar> 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<Scalar,Index,LhsStorageOrder,false,Conjugat Scalar* allocatedBlockB = ei_aligned_stack_new(Scalar, sizeB); Scalar* blockB = allocatedBlockB + sizeW; - ei_gebp_kernel<Scalar, Scalar, Index, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel; - ei_gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs; - ei_symm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder> pack_rhs; + gebp_kernel<Scalar, Scalar, Index, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel; + gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs; + symm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder> pack_rhs; for(Index k2=0; k2<size; k2+=kc) { @@ -373,14 +375,18 @@ struct ei_product_selfadjoint_matrix<Scalar,Index,LhsStorageOrder,false,Conjugat } }; +} // end namespace internal + /*************************************************************************** -* Wrapper to ei_product_selfadjoint_matrix +* Wrapper to product_selfadjoint_matrix ***************************************************************************/ +namespace internal { template<typename Lhs, int LhsMode, typename Rhs, int RhsMode> -struct ei_traits<SelfadjointProductMatrix<Lhs,LhsMode,false,Rhs,RhsMode,false> > - : ei_traits<ProductBase<SelfadjointProductMatrix<Lhs,LhsMode,false,Rhs,RhsMode,false>, Lhs, Rhs> > +struct traits<SelfadjointProductMatrix<Lhs,LhsMode,false,Rhs,RhsMode,false> > + : traits<ProductBase<SelfadjointProductMatrix<Lhs,LhsMode,false,Rhs,RhsMode,false>, Lhs, Rhs> > {}; +} template<typename Lhs, int LhsMode, typename Rhs, int RhsMode> struct SelfadjointProductMatrix<Lhs,LhsMode,false,Rhs,RhsMode,false> @@ -399,7 +405,7 @@ struct SelfadjointProductMatrix<Lhs,LhsMode,false,Rhs,RhsMode,false> template<typename Dest> 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<Lhs,LhsMode,false,Rhs,RhsMode,false> Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(m_lhs) * RhsBlasTraits::extractScalarFactor(m_rhs); - ei_product_selfadjoint_matrix<Scalar, Index, + internal::product_selfadjoint_matrix<Scalar, Index, EIGEN_LOGICAL_XOR(LhsIsUpper, - ei_traits<Lhs>::Flags &RowMajorBit) ? RowMajor : ColMajor, LhsIsSelfAdjoint, + internal::traits<Lhs>::Flags &RowMajorBit) ? RowMajor : ColMajor, LhsIsSelfAdjoint, NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(LhsIsUpper,bool(LhsBlasTraits::NeedToConjugate)), EIGEN_LOGICAL_XOR(RhsIsUpper, - ei_traits<Rhs>::Flags &RowMajorBit) ? RowMajor : ColMajor, RhsIsSelfAdjoint, + internal::traits<Rhs>::Flags &RowMajorBit) ? RowMajor : ColMajor, RhsIsSelfAdjoint, NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(RhsIsUpper,bool(RhsBlasTraits::NeedToConjugate)), - ei_traits<Dest>::Flags&RowMajorBit ? RowMajor : ColMajor> + internal::traits<Dest>::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<typename Scalar, typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs> -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<Scalar>::type Packet; + typedef typename packet_traits<Scalar>::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<Scalar,Scalar,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, IsRowMajor), ConjugateRhs> cj0; - ei_conj_helper<Scalar,Scalar,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> cj1; + conj_helper<Scalar,Scalar,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, IsRowMajor), ConjugateRhs> cj0; + conj_helper<Scalar,Scalar,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> cj1; - ei_conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, IsRowMajor), ConjugateRhs> pcj0; - ei_conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> pcj1; + conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, IsRowMajor), ConjugateRhs> pcj0; + conj_helper<Packet,Packet,NumTraits<Scalar>::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<Packet>(t0); + Packet ptmp0 = pset1<Packet>(t0); Scalar t1 = cjAlpha * rhs[j+1]; - Packet ptmp1 = ei_pset1<Packet>(t1); + Packet ptmp1 = pset1<Packet>(t1); Scalar t2 = 0; - Packet ptmp2 = ei_pset1<Packet>(t2); + Packet ptmp2 = pset1<Packet>(t2); Scalar t3 = 0; - Packet ptmp3 = ei_pset1<Packet>(t3); + Packet ptmp3 = pset1<Packet>(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<alignedStart; ++i) { res[i] += t0 * A0[i] + t1 * A1[i]; - t2 += ei_conj(A0[i]) * rhs[i]; - t3 += ei_conj(A1[i]) * rhs[i]; + t2 += conj(A0[i]) * rhs[i]; + t3 += conj(A1[i]) * rhs[i]; } // Yes this an optimization for gcc 4.3 and 4.4 (=> 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<alignedEnd; i+=PacketSize) { - Packet A0i = ei_ploadu<Packet>(a0It); a0It += PacketSize; - Packet A1i = ei_ploadu<Packet>(a1It); a1It += PacketSize; - Packet Bi = ei_ploadu<Packet>(rhsIt); rhsIt += PacketSize; // FIXME should be aligned in most cases - Packet Xi = ei_pload <Packet>(resIt); + Packet A0i = ploadu<Packet>(a0It); a0It += PacketSize; + Packet A1i = ploadu<Packet>(a1It); a1It += PacketSize; + Packet Bi = ploadu<Packet>(rhsIt); rhsIt += PacketSize; // FIXME should be aligned in most cases + Packet Xi = pload <Packet>(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<endi; i++) { @@ -136,8 +138,8 @@ static EIGEN_DONT_INLINE void ei_product_selfadjoint_vector( t3 += cj1.pmul(A1[i], rhs[i]); } - res[j] += alpha * (t2 + ei_predux(ptmp2)); - res[j+1] += alpha * (t3 + ei_predux(ptmp3)); + res[j] += alpha * (t2 + predux(ptmp2)); + res[j+1] += alpha * (t3 + predux(ptmp3)); } for (Index j=FirstTriangular ? 0 : bound;j<(FirstTriangular ? bound : size);j++) { @@ -157,14 +159,18 @@ static EIGEN_DONT_INLINE void ei_product_selfadjoint_vector( ei_aligned_stack_delete(Scalar, const_cast<Scalar*>(rhs), size); } +} // end namespace internal + /*************************************************************************** -* Wrapper to ei_product_selfadjoint_vector +* Wrapper to product_selfadjoint_vector ***************************************************************************/ +namespace internal { template<typename Lhs, int LhsMode, typename Rhs> -struct ei_traits<SelfadjointProductMatrix<Lhs,LhsMode,false,Rhs,0,true> > - : ei_traits<ProductBase<SelfadjointProductMatrix<Lhs,LhsMode,false,Rhs,0,true>, Lhs, Rhs> > +struct traits<SelfadjointProductMatrix<Lhs,LhsMode,false,Rhs,0,true> > + : traits<ProductBase<SelfadjointProductMatrix<Lhs,LhsMode,false,Rhs,0,true>, Lhs, Rhs> > {}; +} template<typename Lhs, int LhsMode, typename Rhs> struct SelfadjointProductMatrix<Lhs,LhsMode,false,Rhs,0,true> @@ -180,7 +186,7 @@ struct SelfadjointProductMatrix<Lhs,LhsMode,false,Rhs,0,true> template<typename Dest> 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<Lhs,LhsMode,false,Rhs,0,true> 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<Scalar, Index, (ei_traits<_ActualLhsType>::Flags&RowMajorBit) ? RowMajor : ColMajor, int(LhsUpLo), bool(LhsBlasTraits::NeedToConjugate), bool(RhsBlasTraits::NeedToConjugate)> + internal::product_selfadjoint_vector<Scalar, Index, (internal::traits<_ActualLhsType>::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<Lhs,LhsMode,false,Rhs,0,true> } }; +namespace internal { template<typename Lhs, typename Rhs, int RhsMode> -struct ei_traits<SelfadjointProductMatrix<Lhs,0,true,Rhs,RhsMode,false> > - : ei_traits<ProductBase<SelfadjointProductMatrix<Lhs,0,true,Rhs,RhsMode,false>, Lhs, Rhs> > +struct traits<SelfadjointProductMatrix<Lhs,0,true,Rhs,RhsMode,false> > + : traits<ProductBase<SelfadjointProductMatrix<Lhs,0,true,Rhs,RhsMode,false>, Lhs, Rhs> > {}; +} template<typename Lhs, typename Rhs, int RhsMode> struct SelfadjointProductMatrix<Lhs,0,true,Rhs,RhsMode,false> @@ -220,7 +228,7 @@ struct SelfadjointProductMatrix<Lhs,0,true,Rhs,RhsMode,false> template<typename Dest> 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<Lhs,0,true,Rhs,RhsMode,false> 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<Scalar, Index, (ei_traits<_ActualRhsType>::Flags&RowMajorBit) ? ColMajor : RowMajor, int(RhsUpLo)==Upper ? Lower : Upper, + internal::product_selfadjoint_vector<Scalar, Index, (internal::traits<_ActualRhsType>::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<typename Scalar, typename Index, int mr, int nr, bool ConjLhs, bool ConjRhs, int UpLo> -struct ei_sybb_kernel; +struct sybb_kernel; /* Optimized selfadjoint product (_SYRK) */ template <typename Scalar, typename Index, int RhsStorageOrder, int ResStorageOrder, bool AAT, int UpLo> -struct ei_selfadjoint_product; +struct selfadjoint_product; // as usual if the result is row major => we transpose the product template <typename Scalar, typename Index, int MatStorageOrder, bool AAT, int UpLo> -struct ei_selfadjoint_product<Scalar, Index, MatStorageOrder, RowMajor, AAT, UpLo> +struct selfadjoint_product<Scalar, Index, MatStorageOrder, RowMajor, AAT, UpLo> { static EIGEN_STRONG_INLINE void run(Index size, Index depth, const Scalar* mat, Index matStride, Scalar* res, Index resStride, Scalar alpha) { - ei_selfadjoint_product<Scalar, Index, MatStorageOrder, ColMajor, !AAT, UpLo==Lower?Upper:Lower> + selfadjoint_product<Scalar, Index, MatStorageOrder, ColMajor, !AAT, UpLo==Lower?Upper:Lower> ::run(size, depth, mat, matStride, res, resStride, alpha); } }; template <typename Scalar, typename Index, int MatStorageOrder, bool AAT, int UpLo> -struct ei_selfadjoint_product<Scalar, Index, MatStorageOrder, ColMajor, AAT, UpLo> +struct selfadjoint_product<Scalar, Index, MatStorageOrder, ColMajor, AAT, UpLo> { static EIGEN_DONT_INLINE void run( @@ -63,12 +65,12 @@ struct ei_selfadjoint_product<Scalar, Index, MatStorageOrder, ColMajor, AAT, UpL Scalar* res, Index resStride, Scalar alpha) { - ei_const_blas_data_mapper<Scalar, Index, MatStorageOrder> mat(_mat,matStride); + const_blas_data_mapper<Scalar, Index, MatStorageOrder> mat(_mat,matStride); // if(AAT) -// alpha = ei_conj(alpha); +// alpha = conj(alpha); - typedef ei_gebp_traits<Scalar,Scalar> Traits; + typedef gebp_traits<Scalar,Scalar> 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<Scalar, Index, MatStorageOrder, ColMajor, AAT, UpL ConjRhs = NumTraits<Scalar>::IsComplex && AAT }; - ei_gebp_kernel<Scalar, Scalar, Index, Traits::mr, Traits::nr, ConjLhs, ConjRhs> gebp_kernel; - ei_gemm_pack_rhs<Scalar, Index, Traits::nr,MatStorageOrder==RowMajor ? ColMajor : RowMajor> pack_rhs; - ei_gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, MatStorageOrder, false> pack_lhs; - ei_sybb_kernel<Scalar, Index, Traits::mr, Traits::nr, ConjLhs, ConjRhs, UpLo> sybb; + gebp_kernel<Scalar, Scalar, Index, Traits::mr, Traits::nr, ConjLhs, ConjRhs> gebp_kernel; + gemm_pack_rhs<Scalar, Index, Traits::nr,MatStorageOrder==RowMajor ? ColMajor : RowMajor> pack_rhs; + gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, MatStorageOrder, false> pack_lhs; + sybb_kernel<Scalar, Index, Traits::mr, Traits::nr, ConjLhs, ConjRhs, UpLo> sybb; for(Index k2=0; k2<depth; k2+=kc) { @@ -131,33 +133,6 @@ struct ei_selfadjoint_product<Scalar, Index, MatStorageOrder, ColMajor, AAT, UpL } }; -// high level API - -template<typename MatrixType, unsigned int UpLo> -template<typename DerivedU> -SelfAdjointView<MatrixType,UpLo>& SelfAdjointView<MatrixType,UpLo> -::rankUpdate(const MatrixBase<DerivedU>& u, Scalar alpha) -{ - typedef ei_blas_traits<DerivedU> UBlasTraits; - typedef typename UBlasTraits::DirectLinearAccessType ActualUType; - typedef typename ei_cleantype<ActualUType>::type _ActualUType; - const ActualUType actualU = UBlasTraits::extract(u.derived()); - - Scalar actualAlpha = alpha * UBlasTraits::extractScalarFactor(u.derived()); - - enum { IsRowMajor = (ei_traits<MatrixType>::Flags&RowMajorBit) ? 1 : 0 }; - - ei_selfadjoint_product<Scalar, Index, - _ActualUType::Flags&RowMajorBit ? RowMajor : ColMajor, - MatrixType::Flags&RowMajorBit ? RowMajor : ColMajor, - !UBlasTraits::NeedToConjugate, UpLo> - ::run(_expression().cols(), actualU.cols(), &actualU.coeff(0,0), actualU.outerStride(), - const_cast<Scalar*>(_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<MatrixType,UpLo>& SelfAdjointView<MatrixType,UpLo> // small temporary buffer which is then accumulated into the result using a // triangular traversal. template<typename Scalar, typename Index, int mr, int nr, bool ConjLhs, bool ConjRhs, int UpLo> -struct ei_sybb_kernel +struct sybb_kernel { enum { - PacketSize = ei_packet_traits<Scalar>::size, + PacketSize = packet_traits<Scalar>::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<Scalar, Scalar, Index, mr, nr, ConjLhs, ConjRhs> gebp_kernel; + gebp_kernel<Scalar, Scalar, Index, mr, nr, ConjLhs, ConjRhs> gebp_kernel; Matrix<Scalar,BlockSize,BlockSize,ColMajor> 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<typename MatrixType, unsigned int UpLo> +template<typename DerivedU> +SelfAdjointView<MatrixType,UpLo>& SelfAdjointView<MatrixType,UpLo> +::rankUpdate(const MatrixBase<DerivedU>& u, Scalar alpha) +{ + typedef internal::blas_traits<DerivedU> UBlasTraits; + typedef typename UBlasTraits::DirectLinearAccessType ActualUType; + typedef typename internal::cleantype<ActualUType>::type _ActualUType; + const ActualUType actualU = UBlasTraits::extract(u.derived()); + + Scalar actualAlpha = alpha * UBlasTraits::extractScalarFactor(u.derived()); + + enum { IsRowMajor = (internal::traits<MatrixType>::Flags&RowMajorBit) ? 1 : 0 }; + + internal::selfadjoint_product<Scalar, Index, + _ActualUType::Flags&RowMajorBit ? RowMajor : ColMajor, + MatrixType::Flags&RowMajorBit ? RowMajor : ColMajor, + !UBlasTraits::NeedToConjugate, UpLo> + ::run(_expression().cols(), actualU.cols(), &actualU.coeff(0,0), actualU.outerStride(), + const_cast<Scalar*>(_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<typename Scalar, typename Index, typename UType, typename VType, int UpLo> -struct ei_selfadjoint_rank2_update_selector; +struct selfadjoint_rank2_update_selector; template<typename Scalar, typename Index, typename UType, typename VType> -struct ei_selfadjoint_rank2_update_selector<Scalar,Index,UType,VType,Lower> +struct selfadjoint_rank2_update_selector<Scalar,Index,UType,VType,Lower> { 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<Scalar,Index,UType,VType,Lower> for (Index i=0; i<size; ++i) { Map<Matrix<Scalar,Dynamic,1> >(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<typename Scalar, typename Index, typename UType, typename VType> -struct ei_selfadjoint_rank2_update_selector<Scalar,Index,UType,VType,Upper> +struct selfadjoint_rank2_update_selector<Scalar,Index,UType,VType,Upper> { 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<size; ++i) Map<Matrix<Scalar,Dynamic,1> >(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<bool Cond, typename T> struct ei_conj_expr_if - : ei_meta_if<!Cond, const T&, - CwiseUnaryOp<ei_scalar_conjugate_op<typename ei_traits<T>::Scalar>,T> > {}; +template<bool Cond, typename T> struct conj_expr_if + : meta_if<!Cond, const T&, + CwiseUnaryOp<scalar_conjugate_op<typename traits<T>::Scalar>,T> > {}; +} // end namespace internal template<typename MatrixType, unsigned int UpLo> template<typename DerivedU, typename DerivedV> SelfAdjointView<MatrixType,UpLo>& SelfAdjointView<MatrixType,UpLo> ::rankUpdate(const MatrixBase<DerivedU>& u, const MatrixBase<DerivedV>& v, Scalar alpha) { - typedef ei_blas_traits<DerivedU> UBlasTraits; + typedef internal::blas_traits<DerivedU> UBlasTraits; typedef typename UBlasTraits::DirectLinearAccessType ActualUType; - typedef typename ei_cleantype<ActualUType>::type _ActualUType; + typedef typename internal::cleantype<ActualUType>::type _ActualUType; const ActualUType actualU = UBlasTraits::extract(u.derived()); - typedef ei_blas_traits<DerivedV> VBlasTraits; + typedef internal::blas_traits<DerivedV> VBlasTraits; typedef typename VBlasTraits::DirectLinearAccessType ActualVType; - typedef typename ei_cleantype<ActualVType>::type _ActualVType; + typedef typename internal::cleantype<ActualVType>::type _ActualVType; const ActualVType actualV = VBlasTraits::extract(v.derived()); Scalar actualAlpha = alpha * UBlasTraits::extractScalarFactor(u.derived()) * VBlasTraits::extractScalarFactor(v.derived()); - enum { IsRowMajor = (ei_traits<MatrixType>::Flags&RowMajorBit) ? 1 : 0 }; - ei_selfadjoint_rank2_update_selector<Scalar, Index, - typename ei_cleantype<typename ei_conj_expr_if<IsRowMajor ^ UBlasTraits::NeedToConjugate,_ActualUType>::ret>::type, - typename ei_cleantype<typename ei_conj_expr_if<IsRowMajor ^ VBlasTraits::NeedToConjugate,_ActualVType>::ret>::type, + enum { IsRowMajor = (internal::traits<MatrixType>::Flags&RowMajorBit) ? 1 : 0 }; + internal::selfadjoint_rank2_update_selector<Scalar, Index, + typename internal::cleantype<typename internal::conj_expr_if<IsRowMajor ^ UBlasTraits::NeedToConjugate,_ActualUType>::ret>::type, + typename internal::cleantype<typename internal::conj_expr_if<IsRowMajor ^ VBlasTraits::NeedToConjugate,_ActualVType>::ret>::type, (IsRowMajor ? int(UpLo==Upper ? Lower : Upper) : UpLo)> ::run(const_cast<Scalar*>(_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<typename Scalar, int mr, int StorageOrder, bool Conjugate, int Mode> -// struct ei_gemm_pack_lhs_triangular +// struct gemm_pack_lhs_triangular // { // Matrix<Scalar,mr,mr, // void operator()(Scalar* blockA, const EIGEN_RESTRICT Scalar* _lhs, int lhsStride, int depth, int rows) // { -// ei_conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj; -// ei_const_blas_data_mapper<Scalar, StorageOrder> lhs(_lhs,lhsStride); +// conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj; +// const_blas_data_mapper<Scalar, StorageOrder> lhs(_lhs,lhsStride); // int count = 0; // const int peeled_mc = (rows/mr)*mr; // for(int i=0; i<peeled_mc; i+=mr) @@ -57,13 +59,13 @@ template <typename Scalar, typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs, int ResStorageOrder> -struct ei_product_triangular_matrix_matrix; +struct product_triangular_matrix_matrix; template <typename Scalar, typename Index, int Mode, bool LhsIsTriangular, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs> -struct ei_product_triangular_matrix_matrix<Scalar,Index,Mode,LhsIsTriangular, +struct product_triangular_matrix_matrix<Scalar,Index,Mode,LhsIsTriangular, LhsStorageOrder,ConjugateLhs, RhsStorageOrder,ConjugateRhs,RowMajor> { @@ -74,7 +76,7 @@ struct ei_product_triangular_matrix_matrix<Scalar,Index,Mode,LhsIsTriangular, Scalar* res, Index resStride, Scalar alpha) { - ei_product_triangular_matrix_matrix<Scalar, Index, + product_triangular_matrix_matrix<Scalar, Index, (Mode&(UnitDiag|ZeroDiag)) | ((Mode&Upper) ? Lower : Upper), (!LhsIsTriangular), RhsStorageOrder==RowMajor ? ColMajor : RowMajor, @@ -90,7 +92,7 @@ struct ei_product_triangular_matrix_matrix<Scalar,Index,Mode,LhsIsTriangular, template <typename Scalar, typename Index, int Mode, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs> -struct ei_product_triangular_matrix_matrix<Scalar,Index,Mode,true, +struct product_triangular_matrix_matrix<Scalar,Index,Mode,true, LhsStorageOrder,ConjugateLhs, RhsStorageOrder,ConjugateRhs,ColMajor> { @@ -102,10 +104,10 @@ struct ei_product_triangular_matrix_matrix<Scalar,Index,Mode,true, Scalar* res, Index resStride, Scalar alpha) { - ei_const_blas_data_mapper<Scalar, Index, LhsStorageOrder> lhs(_lhs,lhsStride); - ei_const_blas_data_mapper<Scalar, Index, RhsStorageOrder> rhs(_rhs,rhsStride); + const_blas_data_mapper<Scalar, Index, LhsStorageOrder> lhs(_lhs,lhsStride); + const_blas_data_mapper<Scalar, Index, RhsStorageOrder> rhs(_rhs,rhsStride); - typedef ei_gebp_traits<Scalar,Scalar> Traits; + typedef gebp_traits<Scalar,Scalar> 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<Scalar,Index,Mode,true, else triangularBuffer.diagonal().setOnes(); - ei_gebp_kernel<Scalar, Scalar, Index, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel; - ei_gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs; - ei_gemm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder> pack_rhs; + gebp_kernel<Scalar, Scalar, Index, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel; + gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs; + gemm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder> pack_rhs; for(Index k2=IsLower ? depth : 0; IsLower ? k2>0 : k2<depth; @@ -199,7 +201,7 @@ struct ei_product_triangular_matrix_matrix<Scalar,Index,Mode,true, for(Index i2=start; i2<end; i2+=mc) { const Index actual_mc = std::min(i2+mc,end)-i2; - ei_gemm_pack_lhs<Scalar, Index, Traits::mr,Traits::LhsProgress, LhsStorageOrder,false>() + gemm_pack_lhs<Scalar, Index, Traits::mr,Traits::LhsProgress, LhsStorageOrder,false>() (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<Scalar,Index,Mode,true, template <typename Scalar, typename Index, int Mode, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs> -struct ei_product_triangular_matrix_matrix<Scalar,Index,Mode,false, +struct product_triangular_matrix_matrix<Scalar,Index,Mode,false, LhsStorageOrder,ConjugateLhs, RhsStorageOrder,ConjugateRhs,ColMajor> { @@ -229,10 +231,10 @@ struct ei_product_triangular_matrix_matrix<Scalar,Index,Mode,false, Scalar* res, Index resStride, Scalar alpha) { - ei_const_blas_data_mapper<Scalar, Index, LhsStorageOrder> lhs(_lhs,lhsStride); - ei_const_blas_data_mapper<Scalar, Index, RhsStorageOrder> rhs(_rhs,rhsStride); + const_blas_data_mapper<Scalar, Index, LhsStorageOrder> lhs(_lhs,lhsStride); + const_blas_data_mapper<Scalar, Index, RhsStorageOrder> rhs(_rhs,rhsStride); - typedef ei_gebp_traits<Scalar,Scalar> Traits; + typedef gebp_traits<Scalar,Scalar> 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<Scalar,Index,Mode,false, else triangularBuffer.diagonal().setOnes(); - ei_gebp_kernel<Scalar, Scalar, Index, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel; - ei_gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs; - ei_gemm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder> pack_rhs; - ei_gemm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder,false,true> pack_rhs_panel; + gebp_kernel<Scalar, Scalar, Index, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel; + gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs; + gemm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder> pack_rhs; + gemm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder,false,true> pack_rhs_panel; for(Index k2=IsLower ? 0 : depth; IsLower ? k2<depth : k2>0; @@ -352,14 +354,16 @@ struct ei_product_triangular_matrix_matrix<Scalar,Index,Mode,false, }; /*************************************************************************** -* Wrapper to ei_product_triangular_matrix_matrix +* Wrapper to product_triangular_matrix_matrix ***************************************************************************/ template<int Mode, bool LhsIsTriangular, typename Lhs, typename Rhs> -struct ei_traits<TriangularProduct<Mode,LhsIsTriangular,Lhs,false,Rhs,false> > - : ei_traits<ProductBase<TriangularProduct<Mode,LhsIsTriangular,Lhs,false,Rhs,false>, Lhs, Rhs> > +struct traits<TriangularProduct<Mode,LhsIsTriangular,Lhs,false,Rhs,false> > + : traits<ProductBase<TriangularProduct<Mode,LhsIsTriangular,Lhs,false,Rhs,false>, Lhs, Rhs> > {}; +} // end namespace internal + template<int Mode, bool LhsIsTriangular, typename Lhs, typename Rhs> struct TriangularProduct<Mode,LhsIsTriangular,Lhs,false,Rhs,false> : public ProductBase<TriangularProduct<Mode,LhsIsTriangular,Lhs,false,Rhs,false>, Lhs, Rhs > @@ -376,11 +380,11 @@ struct TriangularProduct<Mode,LhsIsTriangular,Lhs,false,Rhs,false> Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(m_lhs) * RhsBlasTraits::extractScalarFactor(m_rhs); - ei_product_triangular_matrix_matrix<Scalar, Index, + internal::product_triangular_matrix_matrix<Scalar, Index, Mode, LhsIsTriangular, - (ei_traits<_ActualLhsType>::Flags&RowMajorBit) ? RowMajor : ColMajor, LhsBlasTraits::NeedToConjugate, - (ei_traits<_ActualRhsType>::Flags&RowMajorBit) ? RowMajor : ColMajor, RhsBlasTraits::NeedToConjugate, - (ei_traits<Dest >::Flags&RowMajorBit) ? RowMajor : ColMajor> + (internal::traits<_ActualLhsType>::Flags&RowMajorBit) ? RowMajor : ColMajor, LhsBlasTraits::NeedToConjugate, + (internal::traits<_ActualRhsType>::Flags&RowMajorBit) ? RowMajor : ColMajor, RhsBlasTraits::NeedToConjugate, + (internal::traits<Dest >::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<Mode,LhsIsTriangular,Lhs,false,Rhs,false> } }; + #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<bool LhsIsTriangular, typename Lhs, typename Rhs, typename Result, int Mode, bool ConjLhs, bool ConjRhs, int StorageOrder> -struct ei_product_triangular_vector_selector; +struct product_triangular_vector_selector; template<typename Lhs, typename Rhs, typename Result, int Mode, bool ConjLhs, bool ConjRhs, int StorageOrder> -struct ei_product_triangular_vector_selector<false,Lhs,Rhs,Result,Mode,ConjLhs,ConjRhs,StorageOrder> +struct product_triangular_vector_selector<false,Lhs,Rhs,Result,Mode,ConjLhs,ConjRhs,StorageOrder> { - static EIGEN_DONT_INLINE void run(const Lhs& lhs, const Rhs& rhs, Result& res, typename ei_traits<Lhs>::Scalar alpha) + static EIGEN_DONT_INLINE void run(const Lhs& lhs, const Rhs& rhs, Result& res, typename traits<Lhs>::Scalar alpha) { typedef Transpose<Rhs> TrRhs; TrRhs trRhs(rhs); typedef Transpose<Lhs> TrLhs; TrLhs trLhs(lhs); typedef Transpose<Result> TrRes; TrRes trRes(res); - ei_product_triangular_vector_selector<true,TrRhs,TrLhs,TrRes, + product_triangular_vector_selector<true,TrRhs,TrLhs,TrRes, (Mode & UnitDiag) | (Mode & Lower) ? Upper : Lower, ConjRhs, ConjLhs, StorageOrder==RowMajor ? ColMajor : RowMajor> ::run(trRhs,trLhs,trRes,alpha); } }; template<typename Lhs, typename Rhs, typename Result, int Mode, bool ConjLhs, bool ConjRhs> -struct ei_product_triangular_vector_selector<true,Lhs,Rhs,Result,Mode,ConjLhs,ConjRhs,ColMajor> +struct product_triangular_vector_selector<true,Lhs,Rhs,Result,Mode,ConjLhs,ConjRhs,ColMajor> { typedef typename Rhs::Scalar Scalar; typedef typename Rhs::Index Index; @@ -52,11 +54,11 @@ struct ei_product_triangular_vector_selector<true,Lhs,Rhs,Result,Mode,ConjLhs,Co IsLower = ((Mode&Lower)==Lower), HasUnitDiag = (Mode & UnitDiag)==UnitDiag }; - static EIGEN_DONT_INLINE void run(const Lhs& lhs, const Rhs& rhs, Result& res, typename ei_traits<Lhs>::Scalar alpha) + static EIGEN_DONT_INLINE void run(const Lhs& lhs, const Rhs& rhs, Result& res, typename traits<Lhs>::Scalar alpha) { static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH; - typename ei_conj_expr_if<ConjLhs,Lhs>::ret cjLhs(lhs); - typename ei_conj_expr_if<ConjRhs,Rhs>::ret cjRhs(rhs); + typename conj_expr_if<ConjLhs,Lhs>::ret cjLhs(lhs); + typename conj_expr_if<ConjRhs,Rhs>::ret cjRhs(rhs); Index size = lhs.cols(); for (Index pi=0; pi<size; pi+=PanelWidth) @@ -76,7 +78,7 @@ struct ei_product_triangular_vector_selector<true,Lhs,Rhs,Result,Mode,ConjLhs,Co if (r>0) { Index s = IsLower ? pi+actualPanelWidth : 0; - ei_general_matrix_vector_product<Index,Scalar,ColMajor,ConjLhs,Scalar,ConjRhs>::run( + general_matrix_vector_product<Index,Scalar,ColMajor,ConjLhs,Scalar,ConjRhs>::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<true,Lhs,Rhs,Result,Mode,ConjLhs,Co }; template<typename Lhs, typename Rhs, typename Result, int Mode, bool ConjLhs, bool ConjRhs> -struct ei_product_triangular_vector_selector<true,Lhs,Rhs,Result,Mode,ConjLhs,ConjRhs,RowMajor> +struct product_triangular_vector_selector<true,Lhs,Rhs,Result,Mode,ConjLhs,ConjRhs,RowMajor> { typedef typename Rhs::Scalar Scalar; typedef typename Rhs::Index Index; @@ -95,11 +97,11 @@ struct ei_product_triangular_vector_selector<true,Lhs,Rhs,Result,Mode,ConjLhs,Co IsLower = ((Mode&Lower)==Lower), HasUnitDiag = (Mode & UnitDiag)==UnitDiag }; - static void run(const Lhs& lhs, const Rhs& rhs, Result& res, typename ei_traits<Lhs>::Scalar alpha) + static void run(const Lhs& lhs, const Rhs& rhs, Result& res, typename traits<Lhs>::Scalar alpha) { static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH; - typename ei_conj_expr_if<ConjLhs,Lhs>::ret cjLhs(lhs); - typename ei_conj_expr_if<ConjRhs,Rhs>::ret cjRhs(rhs); + typename conj_expr_if<ConjLhs,Lhs>::ret cjLhs(lhs); + typename conj_expr_if<ConjRhs,Rhs>::ret cjRhs(rhs); Index size = lhs.cols(); for (Index pi=0; pi<size; pi+=PanelWidth) { @@ -118,7 +120,7 @@ struct ei_product_triangular_vector_selector<true,Lhs,Rhs,Result,Mode,ConjLhs,Co if (r>0) { Index s = IsLower ? 0 : pi + actualPanelWidth; - ei_general_matrix_vector_product<Index,Scalar,RowMajor,ConjLhs,Scalar,ConjRhs>::run( + general_matrix_vector_product<Index,Scalar,RowMajor,ConjLhs,Scalar,ConjRhs>::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<true,Lhs,Rhs,Result,Mode,ConjLhs,Co }; /*************************************************************************** -* Wrapper to ei_product_triangular_vector +* Wrapper to product_triangular_vector ***************************************************************************/ template<int Mode, bool LhsIsTriangular, typename Lhs, typename Rhs> -struct ei_traits<TriangularProduct<Mode,LhsIsTriangular,Lhs,false,Rhs,true> > - : ei_traits<ProductBase<TriangularProduct<Mode,LhsIsTriangular,Lhs,false,Rhs,true>, Lhs, Rhs> > +struct traits<TriangularProduct<Mode,LhsIsTriangular,Lhs,false,Rhs,true> > + : traits<ProductBase<TriangularProduct<Mode,LhsIsTriangular,Lhs,false,Rhs,true>, Lhs, Rhs> > {}; template<int Mode, bool LhsIsTriangular, typename Lhs, typename Rhs> -struct ei_traits<TriangularProduct<Mode,LhsIsTriangular,Lhs,true,Rhs,false> > - : ei_traits<ProductBase<TriangularProduct<Mode,LhsIsTriangular,Lhs,true,Rhs,false>, Lhs, Rhs> > +struct traits<TriangularProduct<Mode,LhsIsTriangular,Lhs,true,Rhs,false> > + : traits<ProductBase<TriangularProduct<Mode,LhsIsTriangular,Lhs,true,Rhs,false>, Lhs, Rhs> > {}; +} // end namespace internal + template<int Mode, typename Lhs, typename Rhs> struct TriangularProduct<Mode,true,Lhs,false,Rhs,true> : public ProductBase<TriangularProduct<Mode,true,Lhs,false,Rhs,true>, Lhs, Rhs > @@ -152,7 +156,7 @@ struct TriangularProduct<Mode,true,Lhs,false,Rhs,true> template<typename Dest> 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<Mode,true,Lhs,false,Rhs,true> Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(m_lhs) * RhsBlasTraits::extractScalarFactor(m_rhs); - ei_product_triangular_vector_selector + internal::product_triangular_vector_selector <true,_ActualLhsType,_ActualRhsType,Dest, Mode, LhsBlasTraits::NeedToConjugate, RhsBlasTraits::NeedToConjugate, - (int(ei_traits<Lhs>::Flags)&RowMajorBit) ? RowMajor : ColMajor> + (int(internal::traits<Lhs>::Flags)&RowMajorBit) ? RowMajor : ColMajor> ::run(lhs,rhs,dst,actualAlpha); } }; @@ -181,7 +185,7 @@ struct TriangularProduct<Mode,false,Lhs,true,Rhs,false> template<typename Dest> 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<Mode,false,Lhs,true,Rhs,false> Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(m_lhs) * RhsBlasTraits::extractScalarFactor(m_rhs); - ei_product_triangular_vector_selector + internal::product_triangular_vector_selector <false,_ActualLhsType,_ActualRhsType,Dest, Mode, LhsBlasTraits::NeedToConjugate, RhsBlasTraits::NeedToConjugate, - (int(ei_traits<Rhs>::Flags)&RowMajorBit) ? RowMajor : ColMajor> + (int(internal::traits<Rhs>::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 <typename Scalar, typename Index, int Side, int Mode, bool Conjugate, int TriStorageOrder> -struct ei_triangular_solve_matrix<Scalar,Index,Side,Mode,Conjugate,TriStorageOrder,RowMajor> +struct triangular_solve_matrix<Scalar,Index,Side,Mode,Conjugate,TriStorageOrder,RowMajor> { 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<Scalar>::IsComplex && Conjugate, @@ -46,7 +48,7 @@ struct ei_triangular_solve_matrix<Scalar,Index,Side,Mode,Conjugate,TriStorageOrd /* Optimized triangular solver with multiple right hand side and the triangular matrix on the left */ template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder> -struct ei_triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor> +struct triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor> { static EIGEN_DONT_INLINE void run( Index size, Index otherSize, @@ -54,10 +56,10 @@ struct ei_triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStora Scalar* _other, Index otherStride) { Index cols = otherSize; - ei_const_blas_data_mapper<Scalar, Index, TriStorageOrder> tri(_tri,triStride); - ei_blas_data_mapper<Scalar, Index, ColMajor> other(_other,otherStride); + const_blas_data_mapper<Scalar, Index, TriStorageOrder> tri(_tri,triStride); + blas_data_mapper<Scalar, Index, ColMajor> other(_other,otherStride); - typedef ei_gebp_traits<Scalar,Scalar> Traits; + typedef gebp_traits<Scalar,Scalar> Traits; enum { SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr), IsLower = (Mode&Lower) == Lower @@ -74,10 +76,10 @@ struct ei_triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStora Scalar* allocatedBlockB = ei_aligned_stack_new(Scalar, sizeB); Scalar* blockB = allocatedBlockB + sizeW; - ei_conj_if<Conjugate> conj; - ei_gebp_kernel<Scalar, Scalar, Index, Traits::mr, Traits::nr, Conjugate, false> gebp_kernel; - ei_gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, TriStorageOrder> pack_lhs; - ei_gemm_pack_rhs<Scalar, Index, Traits::nr, ColMajor, false, true> pack_rhs; + conj_if<Conjugate> conj; + gebp_kernel<Scalar, Scalar, Index, Traits::mr, Traits::nr, Conjugate, false> gebp_kernel; + gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, TriStorageOrder> pack_lhs; + gemm_pack_rhs<Scalar, Index, Traits::nr, ColMajor, false, true> pack_rhs; for(Index k2=IsLower ? 0 : size; IsLower ? k2<size : k2>0; @@ -181,7 +183,7 @@ struct ei_triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStora /* Optimized triangular solver with multiple left hand sides and the trinagular matrix on the right */ template <typename Scalar, typename Index, int Mode, bool Conjugate, int TriStorageOrder> -struct ei_triangular_solve_matrix<Scalar,Index,OnTheRight,Mode,Conjugate,TriStorageOrder,ColMajor> +struct triangular_solve_matrix<Scalar,Index,OnTheRight,Mode,Conjugate,TriStorageOrder,ColMajor> { static EIGEN_DONT_INLINE void run( Index size, Index otherSize, @@ -189,10 +191,10 @@ struct ei_triangular_solve_matrix<Scalar,Index,OnTheRight,Mode,Conjugate,TriStor Scalar* _other, Index otherStride) { Index rows = otherSize; - ei_const_blas_data_mapper<Scalar, Index, TriStorageOrder> rhs(_tri,triStride); - ei_blas_data_mapper<Scalar, Index, ColMajor> lhs(_other,otherStride); + const_blas_data_mapper<Scalar, Index, TriStorageOrder> rhs(_tri,triStride); + blas_data_mapper<Scalar, Index, ColMajor> lhs(_other,otherStride); - typedef ei_gebp_traits<Scalar,Scalar> Traits; + typedef gebp_traits<Scalar,Scalar> Traits; enum { RhsStorageOrder = TriStorageOrder, SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr), @@ -213,11 +215,11 @@ struct ei_triangular_solve_matrix<Scalar,Index,OnTheRight,Mode,Conjugate,TriStor Scalar* allocatedBlockB = ei_aligned_stack_new(Scalar, sizeB); Scalar* blockB = allocatedBlockB + sizeW; - ei_conj_if<Conjugate> conj; - ei_gebp_kernel<Scalar,Scalar, Index, Traits::mr, Traits::nr, false, Conjugate> gebp_kernel; - ei_gemm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder> pack_rhs; - ei_gemm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder,false,true> pack_rhs_panel; - ei_gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, ColMajor, false, true> pack_lhs_panel; + conj_if<Conjugate> conj; + gebp_kernel<Scalar,Scalar, Index, Traits::mr, Traits::nr, false, Conjugate> gebp_kernel; + gemm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder> pack_rhs; + gemm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder,false,true> pack_rhs_panel; + gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, ColMajor, false, true> pack_lhs_panel; for(Index k2=IsLower ? size : 0; IsLower ? k2>0 : k2<size; @@ -318,4 +320,6 @@ struct ei_triangular_solve_matrix<Scalar,Index,OnTheRight,Mode,Conjugate,TriStor } }; +} // end namespace internal + #endif // EIGEN_TRIANGULAR_SOLVER_MATRIX_H diff --git a/Eigen/src/Core/util/BlasUtil.h b/Eigen/src/Core/util/BlasUtil.h index 972814dc9..7c976a5bc 100644 --- a/Eigen/src/Core/util/BlasUtil.h +++ b/Eigen/src/Core/util/BlasUtil.h @@ -28,109 +28,111 @@ // This file contains many lightweight helper classes used to // implement and control fast level 2 and level 3 BLAS-like routines. +namespace internal { + // forward declarations template<typename LhsScalar, typename RhsScalar, typename Index, int mr, int nr, bool ConjugateLhs=false, bool ConjugateRhs=false> -struct ei_gebp_kernel; +struct gebp_kernel; template<typename Scalar, typename Index, int nr, int StorageOrder, bool Conjugate = false, bool PanelMode=false> -struct ei_gemm_pack_rhs; +struct gemm_pack_rhs; template<typename Scalar, typename Index, int Pack1, int Pack2, int StorageOrder, bool Conjugate = false, bool PanelMode = false> -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<typename Index, typename LhsScalar, int LhsStorageOrder, bool ConjugateLhs, typename RhsScalar, bool ConjugateRhs> -struct ei_general_matrix_vector_product; +struct general_matrix_vector_product; -template<bool Conjugate> struct ei_conj_if; +template<bool Conjugate> struct conj_if; -template<> struct ei_conj_if<true> { +template<> struct conj_if<true> { template<typename T> - inline T operator()(const T& x) { return ei_conj(x); } + inline T operator()(const T& x) { return conj(x); } }; -template<> struct ei_conj_if<false> { +template<> struct conj_if<false> { template<typename T> inline const T& operator()(const T& x) { return x; } }; -template<typename Scalar> struct ei_conj_helper<Scalar,Scalar,false,false> +template<typename Scalar> struct conj_helper<Scalar,Scalar,false,false> { - 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<typename RealScalar> struct ei_conj_helper<std::complex<RealScalar>, std::complex<RealScalar>, false,true> +template<typename RealScalar> struct conj_helper<std::complex<RealScalar>, std::complex<RealScalar>, false,true> { typedef std::complex<RealScalar> 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<typename RealScalar> struct ei_conj_helper<std::complex<RealScalar>, std::complex<RealScalar>, true,false> +template<typename RealScalar> struct conj_helper<std::complex<RealScalar>, std::complex<RealScalar>, true,false> { typedef std::complex<RealScalar> 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<typename RealScalar> struct ei_conj_helper<std::complex<RealScalar>, std::complex<RealScalar>, true,true> +template<typename RealScalar> struct conj_helper<std::complex<RealScalar>, std::complex<RealScalar>, true,true> { typedef std::complex<RealScalar> 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<typename RealScalar,bool Conj> struct ei_conj_helper<std::complex<RealScalar>, RealScalar, Conj,false> +template<typename RealScalar,bool Conj> struct conj_helper<std::complex<RealScalar>, RealScalar, Conj,false> { typedef std::complex<RealScalar> 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<Conj>()(x)*y; } + { return conj_if<Conj>()(x)*y; } }; -template<typename RealScalar,bool Conj> struct ei_conj_helper<RealScalar, std::complex<RealScalar>, false,Conj> +template<typename RealScalar,bool Conj> struct conj_helper<RealScalar, std::complex<RealScalar>, false,Conj> { typedef std::complex<RealScalar> 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<Conj>()(y); } + { return x*conj_if<Conj>()(y); } }; -template<typename From,typename To> struct ei_get_factor { +template<typename From,typename To> struct get_factor { EIGEN_STRONG_INLINE static To run(const From& x) { return x; } }; -template<typename Scalar> struct ei_get_factor<Scalar,typename NumTraits<Scalar>::Real> { - EIGEN_STRONG_INLINE static typename NumTraits<Scalar>::Real run(const Scalar& x) { return ei_real(x); } +template<typename Scalar> struct get_factor<Scalar,typename NumTraits<Scalar>::Real> { + EIGEN_STRONG_INLINE static typename NumTraits<Scalar>::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<typename Scalar, typename Index, int StorageOrder> -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<typename Scalar, typename Index, int StorageOrder> -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<typename XprType> struct ei_blas_traits +template<typename XprType> struct blas_traits { - typedef typename ei_traits<XprType>::Scalar Scalar; + typedef typename traits<XprType>::Scalar Scalar; typedef const XprType& ExtractType; typedef XprType _ExtractType; enum { @@ -168,10 +170,10 @@ template<typename XprType> 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<XprType>::ret) == 1) + int(inner_stride_at_compile_time<XprType>::ret) == 1) ) ? 1 : 0 }; - typedef typename ei_meta_if<bool(HasUsableDirectAccess), + typedef typename meta_if<bool(HasUsableDirectAccess), ExtractType, typename _ExtractType::PlainObject >::ret DirectLinearAccessType; @@ -181,11 +183,11 @@ template<typename XprType> struct ei_blas_traits // pop conjugate template<typename Scalar, typename NestedXpr> -struct ei_blas_traits<CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestedXpr> > - : ei_blas_traits<NestedXpr> +struct blas_traits<CwiseUnaryOp<scalar_conjugate_op<Scalar>, NestedXpr> > + : blas_traits<NestedXpr> { - typedef ei_blas_traits<NestedXpr> Base; - typedef CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestedXpr> XprType; + typedef blas_traits<NestedXpr> Base; + typedef CwiseUnaryOp<scalar_conjugate_op<Scalar>, NestedXpr> XprType; typedef typename Base::ExtractType ExtractType; enum { @@ -193,16 +195,16 @@ struct ei_blas_traits<CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, 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<typename Scalar, typename NestedXpr> -struct ei_blas_traits<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, NestedXpr> > - : ei_blas_traits<NestedXpr> +struct blas_traits<CwiseUnaryOp<scalar_multiple_op<Scalar>, NestedXpr> > + : blas_traits<NestedXpr> { - typedef ei_blas_traits<NestedXpr> Base; - typedef CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, NestedXpr> XprType; + typedef blas_traits<NestedXpr> Base; + typedef CwiseUnaryOp<scalar_multiple_op<Scalar>, 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<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, NestedXpr> > // pop opposite template<typename Scalar, typename NestedXpr> -struct ei_blas_traits<CwiseUnaryOp<ei_scalar_opposite_op<Scalar>, NestedXpr> > - : ei_blas_traits<NestedXpr> +struct blas_traits<CwiseUnaryOp<scalar_opposite_op<Scalar>, NestedXpr> > + : blas_traits<NestedXpr> { - typedef ei_blas_traits<NestedXpr> Base; - typedef CwiseUnaryOp<ei_scalar_opposite_op<Scalar>, NestedXpr> XprType; + typedef blas_traits<NestedXpr> Base; + typedef CwiseUnaryOp<scalar_opposite_op<Scalar>, 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<CwiseUnaryOp<ei_scalar_opposite_op<Scalar>, NestedXpr> > // pop/push transpose template<typename NestedXpr> -struct ei_blas_traits<Transpose<NestedXpr> > - : ei_blas_traits<NestedXpr> +struct blas_traits<Transpose<NestedXpr> > + : blas_traits<NestedXpr> { typedef typename NestedXpr::Scalar Scalar; - typedef ei_blas_traits<NestedXpr> Base; + typedef blas_traits<NestedXpr> Base; typedef Transpose<NestedXpr> XprType; typedef Transpose<typename Base::_ExtractType> ExtractType; typedef Transpose<typename Base::_ExtractType> _ExtractType; - typedef typename ei_meta_if<bool(Base::HasUsableDirectAccess), + typedef typename meta_if<bool(Base::HasUsableDirectAccess), ExtractType, typename ExtractType::PlainObject >::ret DirectLinearAccessType; @@ -243,22 +245,24 @@ struct ei_blas_traits<Transpose<NestedXpr> > static inline Scalar extractScalarFactor(const XprType& x) { return Base::extractScalarFactor(x.nestedExpression()); } }; -template<typename T, bool HasUsableDirectAccess=ei_blas_traits<T>::HasUsableDirectAccess> -struct ei_extract_data_selector { +template<typename T, bool HasUsableDirectAccess=blas_traits<T>::HasUsableDirectAccess> +struct extract_data_selector { static const typename T::Scalar* run(const T& m) { - return &ei_blas_traits<T>::extract(m).const_cast_derived().coeffRef(0,0); // FIXME this should be .data() + return &blas_traits<T>::extract(m).const_cast_derived().coeffRef(0,0); // FIXME this should be .data() } }; template<typename T> -struct ei_extract_data_selector<T,false> { +struct extract_data_selector<T,false> { static typename T::Scalar* run(const T&) { return 0; } }; -template<typename T> const typename T::Scalar* ei_extract_data(const T& m) +template<typename T> const typename T::Scalar* extract_data(const T& m) { - return ei_extract_data_selector<T>::run(m); + return extract_data_selector<T>::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<typename T> struct ei_traits; -template<typename T> struct NumTraits; +namespace internal { +template<typename T> struct traits; -template<typename Derived> struct ei_has_direct_access +template<typename Derived> struct has_direct_access { - enum { ret = (ei_traits<Derived>::Flags & DirectAccessBit) ? 1 : 0 }; + enum { ret = (traits<Derived>::Flags & DirectAccessBit) ? 1 : 0 }; }; +} // end namespace internal + +template<typename T> struct NumTraits; template<typename Derived> struct EigenBase; template<typename Derived> class DenseBase; template<typename Derived, - AccessorLevels Level = (ei_traits<Derived>::Flags & DirectAccessBit) ? DirectAccessors - : (ei_traits<Derived>::Flags & LvalueBit) ? WriteAccessors + AccessorLevels Level = (internal::traits<Derived>::Flags & DirectAccessBit) ? DirectAccessors + : (internal::traits<Derived>::Flags & LvalueBit) ? WriteAccessors : ReadOnlyAccessors> class DenseCoeffsBase; @@ -61,7 +64,7 @@ template<typename ExpressionType> class ForceAlignedAccess; template<typename ExpressionType> class SwapWrapper; template<typename XprType, int BlockRows=Dynamic, int BlockCols=Dynamic, bool InnerPanel = false, - bool HasDirectAccess = ei_has_direct_access<XprType>::ret> class Block; + bool HasDirectAccess = internal::has_direct_access<XprType>::ret> class Block; template<typename MatrixType, int Size=Dynamic> class VectorBlock; template<typename MatrixType> class Transpose; @@ -95,58 +98,67 @@ template<typename MatrixType> struct CommaInitializer; template<typename Derived> class ReturnByValue; template<typename ExpressionType> class ArrayWrapper; -template<typename DecompositionType, typename Rhs> struct ei_solve_retval_base; -template<typename DecompositionType, typename Rhs> struct ei_solve_retval; -template<typename DecompositionType> struct ei_kernel_retval_base; -template<typename DecompositionType> struct ei_kernel_retval; -template<typename DecompositionType> struct ei_image_retval_base; -template<typename DecompositionType> struct ei_image_retval; +namespace internal { +template<typename DecompositionType, typename Rhs> struct solve_retval_base; +template<typename DecompositionType, typename Rhs> struct solve_retval; +template<typename DecompositionType> struct kernel_retval_base; +template<typename DecompositionType> struct kernel_retval; +template<typename DecompositionType> struct image_retval_base; +template<typename DecompositionType> struct image_retval; +} // end namespace internal template<typename _Scalar, int Rows=Dynamic, int Cols=Dynamic, int Supers=Dynamic, int Subs=Dynamic, int Options=0> class BandMatrix; -template<typename Lhs, typename Rhs> struct ei_product_type; +namespace internal { +template<typename Lhs, typename Rhs> struct product_type; +} + template<typename Lhs, typename Rhs, - int ProductType = ei_product_type<Lhs,Rhs>::value> + int ProductType = internal::product_type<Lhs,Rhs>::value> struct ProductReturnType; // this is a workaround for sun CC template<typename Lhs, typename Rhs> struct LazyProductReturnType; +namespace internal { + // Provides scalar/packet-wise product and product with accumulation // with optional conjugation of the arguments. -template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct ei_conj_helper; - -template<typename Scalar> struct ei_scalar_sum_op; -template<typename Scalar> struct ei_scalar_difference_op; -template<typename Scalar> struct ei_scalar_conj_product_op; -template<typename Scalar> struct ei_scalar_quotient_op; -template<typename Scalar> struct ei_scalar_opposite_op; -template<typename Scalar> struct ei_scalar_conjugate_op; -template<typename Scalar> struct ei_scalar_real_op; -template<typename Scalar> struct ei_scalar_imag_op; -template<typename Scalar> struct ei_scalar_abs_op; -template<typename Scalar> struct ei_scalar_abs2_op; -template<typename Scalar> struct ei_scalar_sqrt_op; -template<typename Scalar> struct ei_scalar_exp_op; -template<typename Scalar> struct ei_scalar_log_op; -template<typename Scalar> struct ei_scalar_cos_op; -template<typename Scalar> struct ei_scalar_sin_op; -template<typename Scalar> struct ei_scalar_pow_op; -template<typename Scalar> struct ei_scalar_inverse_op; -template<typename Scalar> struct ei_scalar_square_op; -template<typename Scalar> struct ei_scalar_cube_op; -template<typename Scalar, typename NewType> struct ei_scalar_cast_op; -template<typename Scalar> struct ei_scalar_multiple_op; -template<typename Scalar> struct ei_scalar_quotient1_op; -template<typename Scalar> struct ei_scalar_min_op; -template<typename Scalar> struct ei_scalar_max_op; -template<typename Scalar> struct ei_scalar_random_op; -template<typename Scalar> struct ei_scalar_add_op; -template<typename Scalar> struct ei_scalar_constant_op; -template<typename Scalar> struct ei_scalar_identity_op; - -template<typename LhsScalar,typename RhsScalar=LhsScalar> struct ei_scalar_product_op; -template<typename LhsScalar,typename RhsScalar> struct ei_scalar_multiple2_op; +template<typename LhsScalar, typename RhsScalar, bool ConjLhs=false, bool ConjRhs=false> struct conj_helper; + +template<typename Scalar> struct scalar_sum_op; +template<typename Scalar> struct scalar_difference_op; +template<typename Scalar> struct scalar_conj_product_op; +template<typename Scalar> struct scalar_quotient_op; +template<typename Scalar> struct scalar_opposite_op; +template<typename Scalar> struct scalar_conjugate_op; +template<typename Scalar> struct scalar_real_op; +template<typename Scalar> struct scalar_imag_op; +template<typename Scalar> struct scalar_abs_op; +template<typename Scalar> struct scalar_abs2_op; +template<typename Scalar> struct scalar_sqrt_op; +template<typename Scalar> struct scalar_exp_op; +template<typename Scalar> struct scalar_log_op; +template<typename Scalar> struct scalar_cos_op; +template<typename Scalar> struct scalar_sin_op; +template<typename Scalar> struct scalar_pow_op; +template<typename Scalar> struct scalar_inverse_op; +template<typename Scalar> struct scalar_square_op; +template<typename Scalar> struct scalar_cube_op; +template<typename Scalar, typename NewType> struct scalar_cast_op; +template<typename Scalar> struct scalar_multiple_op; +template<typename Scalar> struct scalar_quotient1_op; +template<typename Scalar> struct scalar_min_op; +template<typename Scalar> struct scalar_max_op; +template<typename Scalar> struct scalar_random_op; +template<typename Scalar> struct scalar_add_op; +template<typename Scalar> struct scalar_constant_op; +template<typename Scalar> struct scalar_identity_op; + +template<typename LhsScalar,typename RhsScalar=LhsScalar> struct scalar_product_op; +template<typename LhsScalar,typename RhsScalar> struct scalar_multiple2_op; + +} // end namespace internal struct IOFormat; @@ -165,7 +177,9 @@ template<typename MatrixType, int Direction = BothDirections> class Reverse; template<typename MatrixType> class FullPivLU; template<typename MatrixType> class PartialPivLU; -template<typename MatrixType> struct ei_inverse_impl; +namespace internal { +template<typename MatrixType> struct inverse_impl; +} template<typename MatrixType> class HouseholderQR; template<typename MatrixType> class ColPivHouseholderQR; template<typename MatrixType> class FullPivHouseholderQR; @@ -192,12 +206,15 @@ template<typename MatrixType,int Direction> class Homogeneous; // MatrixFunctions module template<typename Derived> struct MatrixExponentialReturnValue; template<typename Derived> class MatrixFunctionReturnValue; + +namespace internal { template <typename Scalar> -struct ei_stem_function +struct stem_function { typedef std::complex<typename NumTraits<Scalar>::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<Derived>::Scalar Scalar; /*!< \brief Numeric type, e.g. float, double, int or std::complex<float>. */ \ + typedef typename Eigen::internal::traits<Derived>::Scalar Scalar; /*!< \brief Numeric type, e.g. float, double, int or std::complex<float>. */ \ typedef typename Eigen::NumTraits<Scalar>::Real RealScalar; /*!< \brief The underlying numeric type for composed scalar types. \details In cases where Scalar is e.g. std::complex<T>, 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<Derived>::type Nested; \ - typedef typename Eigen::ei_traits<Derived>::StorageKind StorageKind; \ - typedef typename Eigen::ei_traits<Derived>::Index Index; \ - enum { RowsAtCompileTime = Eigen::ei_traits<Derived>::RowsAtCompileTime, \ - ColsAtCompileTime = Eigen::ei_traits<Derived>::ColsAtCompileTime, \ - Flags = Eigen::ei_traits<Derived>::Flags, \ - CoeffReadCost = Eigen::ei_traits<Derived>::CoeffReadCost, \ + typedef typename Eigen::internal::nested<Derived>::type Nested; \ + typedef typename Eigen::internal::traits<Derived>::StorageKind StorageKind; \ + typedef typename Eigen::internal::traits<Derived>::Index Index; \ + enum { RowsAtCompileTime = Eigen::internal::traits<Derived>::RowsAtCompileTime, \ + ColsAtCompileTime = Eigen::internal::traits<Derived>::ColsAtCompileTime, \ + Flags = Eigen::internal::traits<Derived>::Flags, \ + CoeffReadCost = Eigen::internal::traits<Derived>::CoeffReadCost, \ SizeAtCompileTime = Base::SizeAtCompileTime, \ MaxSizeAtCompileTime = Base::MaxSizeAtCompileTime, \ IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; #define EIGEN_DENSE_PUBLIC_INTERFACE(Derived) \ - typedef typename Eigen::ei_traits<Derived>::Scalar Scalar; /*!< \brief Numeric type, e.g. float, double, int or std::complex<float>. */ \ + typedef typename Eigen::internal::traits<Derived>::Scalar Scalar; /*!< \brief Numeric type, e.g. float, double, int or std::complex<float>. */ \ typedef typename Eigen::NumTraits<Scalar>::Real RealScalar; /*!< \brief The underlying numeric type for composed scalar types. \details In cases where Scalar is e.g. std::complex<T>, 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<Derived>::type Nested; \ - typedef typename Eigen::ei_traits<Derived>::StorageKind StorageKind; \ - typedef typename Eigen::ei_traits<Derived>::Index Index; \ - enum { RowsAtCompileTime = Eigen::ei_traits<Derived>::RowsAtCompileTime, \ - ColsAtCompileTime = Eigen::ei_traits<Derived>::ColsAtCompileTime, \ - MaxRowsAtCompileTime = Eigen::ei_traits<Derived>::MaxRowsAtCompileTime, \ - MaxColsAtCompileTime = Eigen::ei_traits<Derived>::MaxColsAtCompileTime, \ - Flags = Eigen::ei_traits<Derived>::Flags, \ - CoeffReadCost = Eigen::ei_traits<Derived>::CoeffReadCost, \ + typedef typename Eigen::internal::nested<Derived>::type Nested; \ + typedef typename Eigen::internal::traits<Derived>::StorageKind StorageKind; \ + typedef typename Eigen::internal::traits<Derived>::Index Index; \ + enum { RowsAtCompileTime = Eigen::internal::traits<Derived>::RowsAtCompileTime, \ + ColsAtCompileTime = Eigen::internal::traits<Derived>::ColsAtCompileTime, \ + MaxRowsAtCompileTime = Eigen::internal::traits<Derived>::MaxRowsAtCompileTime, \ + MaxColsAtCompileTime = Eigen::internal::traits<Derived>::MaxColsAtCompileTime, \ + Flags = Eigen::internal::traits<Derived>::Flags, \ + CoeffReadCost = Eigen::internal::traits<Derived>::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<LHS>::Scalar, \ - typename ei_traits<RHS>::Scalar \ + internal::scalar_product_op< \ + typename internal::traits<LHS>::Scalar, \ + typename internal::traits<RHS>::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<void**>(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<void**>(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<bool Align> inline void* ei_conditional_aligned_malloc(size_t size) +template<bool Align> inline void* conditional_aligned_malloc(size_t size) { - return ei_aligned_malloc(size); + return aligned_malloc(size); } -template<> inline void* ei_conditional_aligned_malloc<false>(size_t size) +template<> inline void* conditional_aligned_malloc<false>(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<false>(size_t size) return result; } -/** \internal Frees memory allocated with ei_conditional_aligned_malloc */ -template<bool Align> inline void ei_conditional_aligned_free(void *ptr) +/** \internal Frees memory allocated with conditional_aligned_malloc */ +template<bool Align> inline void conditional_aligned_free(void *ptr) { - ei_aligned_free(ptr); + aligned_free(ptr); } -template<> inline void ei_conditional_aligned_free<false>(void *ptr) +template<> inline void conditional_aligned_free<false>(void *ptr) { std::free(ptr); } -template<bool Align> inline void* ei_conditional_aligned_realloc(void* ptr, size_t new_size, size_t old_size) +template<bool Align> 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<false>(void* ptr, size_t new_size, size_t) +template<> inline void* conditional_aligned_realloc<false>(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<false>(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<typename T> inline T* ei_construct_elements_of_array(T *ptr, size_t size) +template<typename T> 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<typename T> 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<typename T> inline void ei_destruct_elements_of_array(T *ptr, size_t size) +template<typename T> 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<typename T> 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<typename T> inline T* ei_aligned_new(size_t size) +template<typename T> inline T* aligned_new(size_t size) { - T *result = reinterpret_cast<T*>(ei_aligned_malloc(sizeof(T)*size)); - return ei_construct_elements_of_array(result, size); + T *result = reinterpret_cast<T*>(aligned_malloc(sizeof(T)*size)); + return construct_elements_of_array(result, size); } -template<typename T, bool Align> inline T* ei_conditional_aligned_new(size_t size) +template<typename T, bool Align> inline T* conditional_aligned_new(size_t size) { - T *result = reinterpret_cast<T*>(ei_conditional_aligned_malloc<Align>(sizeof(T)*size)); - return ei_construct_elements_of_array(result, size); + T *result = reinterpret_cast<T*>(conditional_aligned_malloc<Align>(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<typename T> inline void ei_aligned_delete(T *ptr, size_t size) +template<typename T> inline void aligned_delete(T *ptr, size_t size) { - ei_destruct_elements_of_array<T>(ptr, size); - ei_aligned_free(ptr); + destruct_elements_of_array<T>(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<typename T, bool Align> inline void ei_conditional_aligned_delete(T *ptr, size_t size) +template<typename T, bool Align> inline void conditional_aligned_delete(T *ptr, size_t size) { - ei_destruct_elements_of_array<T>(ptr, size); - ei_conditional_aligned_free<Align>(ptr); + destruct_elements_of_array<T>(ptr, size); + conditional_aligned_free<Align>(ptr); } -template<typename T, bool Align> inline T* ei_conditional_aligned_realloc_new(T* pts, size_t new_size, size_t old_size) +template<typename T, bool Align> inline T* conditional_aligned_realloc_new(T* pts, size_t new_size, size_t old_size) { - T *result = reinterpret_cast<T*>(ei_conditional_aligned_realloc<Align>(reinterpret_cast<void*>(pts), sizeof(T)*new_size, sizeof(T)*old_size)); + T *result = reinterpret_cast<T*>(conditional_aligned_realloc<Align>(reinterpret_cast<void*>(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<typename T, bool Align> 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<typename Scalar, typename Index> -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<Scalar>::type Packet; - enum { PacketSize = ei_packet_traits<Scalar>::size, + typedef typename packet_traits<Scalar>::type Packet; + enum { PacketSize = packet_traits<Scalar>::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<TYPE*>(ei_aligned_stack_alloc(sizeof(TYPE)*SIZE)), SIZE) -#define ei_aligned_stack_delete(TYPE,PTR,SIZE) do {ei_destruct_elements_of_array<TYPE>(PTR, SIZE); \ +#define ei_aligned_stack_new(TYPE,SIZE) Eigen::internal::construct_elements_of_array(reinterpret_cast<TYPE*>(ei_aligned_stack_alloc(sizeof(TYPE)*SIZE)), SIZE) +#define ei_aligned_stack_delete(TYPE,PTR,SIZE) do {Eigen::internal::destruct_elements_of_array<TYPE>(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<NeedsToAlign>(size); } \ + try { return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(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<NeedsToAlign>(size); \ + return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); \ } #endif #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign) \ void *operator new(size_t size) { \ - return Eigen::ei_conditional_aligned_malloc<NeedsToAlign>(size); \ + return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); \ } \ void *operator new[](size_t size) { \ - return Eigen::ei_conditional_aligned_malloc<NeedsToAlign>(size); \ + return Eigen::internal::conditional_aligned_malloc<NeedsToAlign>(size); \ } \ - void operator delete(void * ptr) throw() { Eigen::ei_conditional_aligned_free<NeedsToAlign>(ptr); } \ - void operator delete[](void * ptr) throw() { Eigen::ei_conditional_aligned_free<NeedsToAlign>(ptr); } \ + void operator delete(void * ptr) throw() { Eigen::internal::conditional_aligned_free<NeedsToAlign>(ptr); } \ + void operator delete[](void * ptr) throw() { Eigen::internal::conditional_aligned_free<NeedsToAlign>(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<NeedsToAlign>(ptr); \ + Eigen::internal::conditional_aligned_free<NeedsToAlign>(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<void>( hint ); // suppress unused variable warning - return static_cast<pointer>( ei_aligned_malloc( num * sizeof(T) ) ); + return static_cast<pointer>( 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<T>& ) 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<bool Condition, typename Then, typename Else> -struct ei_meta_if { typedef Then ret; }; +struct meta_if { typedef Then ret; }; template<typename Then, typename Else> -struct ei_meta_if <false, Then, Else> { typedef Else ret; }; - -template<typename T, typename U> struct ei_is_same_type { enum { ret = 0 }; }; -template<typename T> struct ei_is_same_type<T,T> { enum { ret = 1 }; }; - -template<typename T> struct ei_unref { typedef T type; }; -template<typename T> struct ei_unref<T&> { typedef T type; }; - -template<typename T> struct ei_unpointer { typedef T type; }; -template<typename T> struct ei_unpointer<T*> { typedef T type; }; -template<typename T> struct ei_unpointer<T*const> { typedef T type; }; - -template<typename T> struct ei_unconst { typedef T type; }; -template<typename T> struct ei_unconst<const T> { typedef T type; }; -template<typename T> struct ei_unconst<T const &> { typedef T & type; }; -template<typename T> struct ei_unconst<T const *> { typedef T * type; }; - -template<typename T> struct ei_cleantype { typedef T type; }; -template<typename T> struct ei_cleantype<const T> { typedef typename ei_cleantype<T>::type type; }; -template<typename T> struct ei_cleantype<const T&> { typedef typename ei_cleantype<T>::type type; }; -template<typename T> struct ei_cleantype<T&> { typedef typename ei_cleantype<T>::type type; }; -template<typename T> struct ei_cleantype<const T*> { typedef typename ei_cleantype<T>::type type; }; -template<typename T> struct ei_cleantype<T*> { typedef typename ei_cleantype<T>::type type; }; - -template<typename T> struct ei_is_arithmetic { enum { ret = false }; }; -template<> struct ei_is_arithmetic<float> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<double> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<long double> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<bool> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<char> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<signed char> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<unsigned char> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<signed short> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<unsigned short>{ enum { ret = true }; }; -template<> struct ei_is_arithmetic<signed int> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<unsigned int> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<signed long> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<unsigned long> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<signed long long> { enum { ret = true }; }; -template<> struct ei_is_arithmetic<unsigned long long> { enum { ret = true }; }; - -template<typename T> struct ei_makeconst { typedef const T type; }; -template<typename T> struct ei_makeconst<const T> { typedef const T type; }; -template<typename T> struct ei_makeconst<T&> { typedef const T& type; }; -template<typename T> struct ei_makeconst<const T&> { typedef const T& type; }; -template<typename T> struct ei_makeconst<T*> { typedef const T* type; }; -template<typename T> struct ei_makeconst<const T*> { typedef const T* type; }; - -template<typename T> struct ei_makeconst_return_type +struct meta_if <false, Then, Else> { typedef Else ret; }; + +template<typename T, typename U> struct is_same_type { enum { ret = 0 }; }; +template<typename T> struct is_same_type<T,T> { enum { ret = 1 }; }; + +template<typename T> struct unref { typedef T type; }; +template<typename T> struct unref<T&> { typedef T type; }; + +template<typename T> struct unpointer { typedef T type; }; +template<typename T> struct unpointer<T*> { typedef T type; }; +template<typename T> struct unpointer<T*const> { typedef T type; }; + +template<typename T> struct unconst { typedef T type; }; +template<typename T> struct unconst<const T> { typedef T type; }; +template<typename T> struct unconst<T const &> { typedef T & type; }; +template<typename T> struct unconst<T const *> { typedef T * type; }; + +template<typename T> struct cleantype { typedef T type; }; +template<typename T> struct cleantype<const T> { typedef typename cleantype<T>::type type; }; +template<typename T> struct cleantype<const T&> { typedef typename cleantype<T>::type type; }; +template<typename T> struct cleantype<T&> { typedef typename cleantype<T>::type type; }; +template<typename T> struct cleantype<const T*> { typedef typename cleantype<T>::type type; }; +template<typename T> struct cleantype<T*> { typedef typename cleantype<T>::type type; }; + +template<typename T> struct is_arithmetic { enum { ret = false }; }; +template<> struct is_arithmetic<float> { enum { ret = true }; }; +template<> struct is_arithmetic<double> { enum { ret = true }; }; +template<> struct is_arithmetic<long double> { enum { ret = true }; }; +template<> struct is_arithmetic<bool> { enum { ret = true }; }; +template<> struct is_arithmetic<char> { enum { ret = true }; }; +template<> struct is_arithmetic<signed char> { enum { ret = true }; }; +template<> struct is_arithmetic<unsigned char> { enum { ret = true }; }; +template<> struct is_arithmetic<signed short> { enum { ret = true }; }; +template<> struct is_arithmetic<unsigned short>{ enum { ret = true }; }; +template<> struct is_arithmetic<signed int> { enum { ret = true }; }; +template<> struct is_arithmetic<unsigned int> { enum { ret = true }; }; +template<> struct is_arithmetic<signed long> { enum { ret = true }; }; +template<> struct is_arithmetic<unsigned long> { enum { ret = true }; }; +template<> struct is_arithmetic<signed long long> { enum { ret = true }; }; +template<> struct is_arithmetic<unsigned long long> { enum { ret = true }; }; + +template<typename T> struct makeconst { typedef const T type; }; +template<typename T> struct makeconst<const T> { typedef const T type; }; +template<typename T> struct makeconst<T&> { typedef const T& type; }; +template<typename T> struct makeconst<const T&> { typedef const T& type; }; +template<typename T> struct makeconst<T*> { typedef const T* type; }; +template<typename T> struct makeconst<const T*> { typedef const T* type; }; + +template<typename T> struct makeconst_return_type { - typedef typename ei_meta_if<ei_is_arithmetic<T>::ret, T, typename ei_makeconst<T>::type>::ret type; + typedef typename meta_if<is_arithmetic<T>::ret, T, typename makeconst<T>::type>::ret type; }; /** \internal Allows to enable/disable an overload * according to a compile time condition. */ -template<bool Condition, typename T> struct ei_enable_if; +template<bool Condition, typename T> struct enable_if; -template<typename T> struct ei_enable_if<true,T> +template<typename T> struct enable_if<true,T> { typedef T type; }; /** \internal @@ -108,67 +110,67 @@ template<typename T> struct ei_enable_if<true,T> * 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<typename T> struct ei_result_of {}; +template<typename T> 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<typename Func, typename ArgType, int SizeOf=sizeof(ei_has_none)> -struct ei_unary_result_of_select {typedef ArgType type;}; +template<typename Func, typename ArgType, int SizeOf=sizeof(has_none)> +struct unary_result_of_select {typedef ArgType type;}; template<typename Func, typename ArgType> -struct ei_unary_result_of_select<Func, ArgType, sizeof(ei_has_std_result_type)> {typedef typename Func::result_type type;}; +struct unary_result_of_select<Func, ArgType, sizeof(has_std_result_type)> {typedef typename Func::result_type type;}; template<typename Func, typename ArgType> -struct ei_unary_result_of_select<Func, ArgType, sizeof(ei_has_tr1_result)> {typedef typename Func::template result<Func(ArgType)>::type type;}; +struct unary_result_of_select<Func, ArgType, sizeof(has_tr1_result)> {typedef typename Func::template result<Func(ArgType)>::type type;}; template<typename Func, typename ArgType> -struct ei_result_of<Func(ArgType)> { +struct result_of<Func(ArgType)> { template<typename T> - 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<typename T> - static ei_has_tr1_result testFunctor(T const *, typename T::template result<T(ArgType)>::type const * = 0); - static ei_has_none testFunctor(...); + static has_tr1_result testFunctor(T const *, typename T::template result<T(ArgType)>::type const * = 0); + static has_none testFunctor(...); // note that the following indirection is needed for gcc-3.3 enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))}; - typedef typename ei_unary_result_of_select<Func, ArgType, FunctorType>::type type; + typedef typename unary_result_of_select<Func, ArgType, FunctorType>::type type; }; -template<typename Func, typename ArgType0, typename ArgType1, int SizeOf=sizeof(ei_has_none)> -struct ei_binary_result_of_select {typedef ArgType0 type;}; +template<typename Func, typename ArgType0, typename ArgType1, int SizeOf=sizeof(has_none)> +struct binary_result_of_select {typedef ArgType0 type;}; template<typename Func, typename ArgType0, typename ArgType1> -struct ei_binary_result_of_select<Func, ArgType0, ArgType1, sizeof(ei_has_std_result_type)> +struct binary_result_of_select<Func, ArgType0, ArgType1, sizeof(has_std_result_type)> {typedef typename Func::result_type type;}; template<typename Func, typename ArgType0, typename ArgType1> -struct ei_binary_result_of_select<Func, ArgType0, ArgType1, sizeof(ei_has_tr1_result)> +struct binary_result_of_select<Func, ArgType0, ArgType1, sizeof(has_tr1_result)> {typedef typename Func::template result<Func(ArgType0,ArgType1)>::type type;}; template<typename Func, typename ArgType0, typename ArgType1> -struct ei_result_of<Func(ArgType0,ArgType1)> { +struct result_of<Func(ArgType0,ArgType1)> { template<typename T> - 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<typename T> - static ei_has_tr1_result testFunctor(T const *, typename T::template result<T(ArgType0,ArgType1)>::type const * = 0); - static ei_has_none testFunctor(...); + static has_tr1_result testFunctor(T const *, typename T::template result<T(ArgType0,ArgType1)>::type const * = 0); + static has_none testFunctor(...); // note that the following indirection is needed for gcc-3.3 enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))}; - typedef typename ei_binary_result_of_select<Func, ArgType0, ArgType1, FunctorType>::type type; + typedef typename binary_result_of_select<Func, ArgType0, ArgType1, FunctorType>::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<int Y, int InfX = 0, int SupX = ((Y==1) ? 1 : Y/2), bool Done = ((SupX-InfX)<=1 ? true : ((SupX*SupX <= Y) && ((SupX+1)*(SupX+1) > 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<Y,NewInf,NewSup>::ret }; + enum { ret = meta_sqrt<Y,NewInf,NewSup>::ret }; }; template<int Y, int InfX, int SupX> -class ei_meta_sqrt<Y, InfX, SupX, true> { public: enum { ret = (SupX*SupX <= Y) ? SupX : InfX }; }; +class meta_sqrt<Y, InfX, SupX, true> { 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<typename T, typename U> struct ei_scalar_product_traits; +template<typename T, typename U> struct scalar_product_traits; -template<typename T> struct ei_scalar_product_traits<T,T> +template<typename T> struct scalar_product_traits<T,T> { //enum { Cost = NumTraits<T>::MulCost }; typedef T ReturnType; }; -template<typename T> struct ei_scalar_product_traits<T,std::complex<T> > +template<typename T> struct scalar_product_traits<T,std::complex<T> > { //enum { Cost = 2*NumTraits<T>::MulCost }; typedef std::complex<T> ReturnType; }; -template<typename T> struct ei_scalar_product_traits<std::complex<T>, T> +template<typename T> struct scalar_product_traits<std::complex<T>, T> { //enum { Cost = 2*NumTraits<T>::MulCost }; typedef std::complex<T> ReturnType; }; -// FIXME quick workaround around current limitation of ei_result_of +// FIXME quick workaround around current limitation of result_of // template<typename Scalar, typename ArgType0, typename ArgType1> -// struct ei_result_of<ei_scalar_product_op<Scalar>(ArgType0,ArgType1)> { -// typedef typename ei_scalar_product_traits<typename ei_cleantype<ArgType0>::type, typename ei_cleantype<ArgType1>::type>::ReturnType type; +// struct result_of<scalar_product_op<Scalar>(ArgType0,ArgType1)> { +// typedef typename scalar_product_traits<typename cleantype<ArgType0>::type, typename cleantype<ArgType1>::type>::ReturnType type; // }; -template<typename T> struct ei_is_diagonal +template<typename T> struct is_diagonal { enum { ret = false }; }; -template<typename T> struct ei_is_diagonal<DiagonalBase<T> > +template<typename T> struct is_diagonal<DiagonalBase<T> > { enum { ret = true }; }; -template<typename T> struct ei_is_diagonal<DiagonalWrapper<T> > +template<typename T> struct is_diagonal<DiagonalWrapper<T> > { enum { ret = true }; }; -template<typename T, int S> struct ei_is_diagonal<DiagonalMatrix<T,S> > +template<typename T, int S> struct is_diagonal<DiagonalMatrix<T,S> > { 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<true> + * expression, and MSG an enum listed in struct internal::static_assertion<true> * * - 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<bool condition> - struct ei_static_assert {}; + struct static_assertion {}; template<> - struct ei_static_assert<true> + struct static_assertion<true> { 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 <gael.guennebaud@inria.fr> @@ -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<typename I1, typename I2> -struct ei_promote_index_type +struct promote_index_type { - typedef typename ei_meta_if<(sizeof(I1)<sizeof(I2)), I2, I1>::ret type; + typedef typename meta_if<(sizeof(I1)<sizeof(I2)), I2, 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<typename T, int Value> class ei_variable_if_dynamic +template<typename T, int Value> 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<typename T> class ei_variable_if_dynamic<T, Dynamic> +template<typename T> class variable_if_dynamic<T, 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<typename T> struct ei_functor_traits +template<typename T> struct functor_traits { enum { @@ -85,9 +87,9 @@ template<typename T> struct ei_functor_traits }; }; -template<typename T> struct ei_packet_traits; +template<typename T> struct packet_traits; -template<typename T> struct ei_unpacket_traits +template<typename T> struct unpacket_traits { typedef T type; enum {size=1}; @@ -100,7 +102,7 @@ template<typename _Scalar, int _Rows, int _Cols, : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ), int _MaxRows = _Rows, int _MaxCols = _Cols -> class ei_make_proper_matrix_type +> class make_proper_matrix_type { enum { IsColVector = _Cols==1 && _Rows!=1, @@ -114,7 +116,7 @@ template<typename _Scalar, int _Rows, int _Cols, }; template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols> -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<Scalar>::Vectorizable + && packet_traits<Scalar>::Vectorizable && ( #if EIGEN_ALIGN_STATICALLY - ((!is_dynamic_size_storage) && (((MaxCols*MaxRows) % ei_packet_traits<Scalar>::size) == 0)) + ((!is_dynamic_size_storage) && (((MaxCols*MaxRows) % packet_traits<Scalar>::size) == 0)) #else 0 #endif @@ -141,95 +143,95 @@ class ei_compute_matrix_flags ) ) ? AlignedBit : 0, - packet_access_bit = ei_packet_traits<Scalar>::Vectorizable && aligned_bit ? PacketAccessBit : 0 + packet_access_bit = packet_traits<Scalar>::Vectorizable && aligned_bit ? PacketAccessBit : 0 }; public: enum { ret = LinearAccessBit | LvalueBit | DirectAccessBit | NestByRefBit | packet_access_bit | row_major_bit | aligned_bit }; }; -template<int _Rows, int _Cols> struct ei_size_at_compile_time +template<int _Rows, int _Cols> 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<typename T, typename StorageKind = typename ei_traits<T>::StorageKind> struct ei_plain_matrix_type; -template<typename T, typename BaseClassType> struct ei_plain_matrix_type_dense; -template<typename T> struct ei_plain_matrix_type<T,Dense> +template<typename T, typename StorageKind = typename traits<T>::StorageKind> struct plain_matrix_type; +template<typename T, typename BaseClassType> struct plain_matrix_type_dense; +template<typename T> struct plain_matrix_type<T,Dense> { - typedef typename ei_plain_matrix_type_dense<T,typename ei_traits<T>::XprKind>::type type; + typedef typename plain_matrix_type_dense<T,typename traits<T>::XprKind>::type type; }; -template<typename T> struct ei_plain_matrix_type_dense<T,MatrixXpr> +template<typename T> struct plain_matrix_type_dense<T,MatrixXpr> { - typedef Matrix<typename ei_traits<T>::Scalar, - ei_traits<T>::RowsAtCompileTime, - ei_traits<T>::ColsAtCompileTime, - AutoAlign | (ei_traits<T>::Flags&RowMajorBit ? RowMajor : ColMajor), - ei_traits<T>::MaxRowsAtCompileTime, - ei_traits<T>::MaxColsAtCompileTime + typedef Matrix<typename traits<T>::Scalar, + traits<T>::RowsAtCompileTime, + traits<T>::ColsAtCompileTime, + AutoAlign | (traits<T>::Flags&RowMajorBit ? RowMajor : ColMajor), + traits<T>::MaxRowsAtCompileTime, + traits<T>::MaxColsAtCompileTime > type; }; -template<typename T> struct ei_plain_matrix_type_dense<T,ArrayXpr> +template<typename T> struct plain_matrix_type_dense<T,ArrayXpr> { - typedef Array<typename ei_traits<T>::Scalar, - ei_traits<T>::RowsAtCompileTime, - ei_traits<T>::ColsAtCompileTime, - AutoAlign | (ei_traits<T>::Flags&RowMajorBit ? RowMajor : ColMajor), - ei_traits<T>::MaxRowsAtCompileTime, - ei_traits<T>::MaxColsAtCompileTime + typedef Array<typename traits<T>::Scalar, + traits<T>::RowsAtCompileTime, + traits<T>::ColsAtCompileTime, + AutoAlign | (traits<T>::Flags&RowMajorBit ? RowMajor : ColMajor), + traits<T>::MaxRowsAtCompileTime, + traits<T>::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<typename T, typename StorageKind = typename ei_traits<T>::StorageKind> struct ei_eval; +template<typename T, typename StorageKind = typename traits<T>::StorageKind> struct eval; -template<typename T> struct ei_eval<T,Dense> +template<typename T> struct eval<T,Dense> { - typedef typename ei_plain_matrix_type<T>::type type; + typedef typename plain_matrix_type<T>::type type; // typedef typename T::PlainObject type; -// typedef T::Matrix<typename ei_traits<T>::Scalar, -// ei_traits<T>::RowsAtCompileTime, -// ei_traits<T>::ColsAtCompileTime, -// AutoAlign | (ei_traits<T>::Flags&RowMajorBit ? RowMajor : ColMajor), -// ei_traits<T>::MaxRowsAtCompileTime, -// ei_traits<T>::MaxColsAtCompileTime +// typedef T::Matrix<typename traits<T>::Scalar, +// traits<T>::RowsAtCompileTime, +// traits<T>::ColsAtCompileTime, +// AutoAlign | (traits<T>::Flags&RowMajorBit ? RowMajor : ColMajor), +// traits<T>::MaxRowsAtCompileTime, +// traits<T>::MaxColsAtCompileTime // > type; }; // for matrices, no need to evaluate, just use a const reference to avoid a useless copy template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> -struct ei_eval<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, Dense> +struct eval<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, Dense> { typedef const Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& type; }; template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> -struct ei_eval<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, Dense> +struct eval<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, 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<typename T> struct ei_plain_matrix_type_column_major +template<typename T> struct plain_matrix_type_column_major { - enum { Rows = ei_traits<T>::RowsAtCompileTime, - Cols = ei_traits<T>::ColsAtCompileTime, - MaxRows = ei_traits<T>::MaxRowsAtCompileTime, - MaxCols = ei_traits<T>::MaxColsAtCompileTime + enum { Rows = traits<T>::RowsAtCompileTime, + Cols = traits<T>::ColsAtCompileTime, + MaxRows = traits<T>::MaxRowsAtCompileTime, + MaxCols = traits<T>::MaxColsAtCompileTime }; - typedef Matrix<typename ei_traits<T>::Scalar, + typedef Matrix<typename traits<T>::Scalar, Rows, Cols, (MaxRows==1&&MaxCols!=1) ? RowMajor : ColMajor, @@ -238,16 +240,16 @@ template<typename T> 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<typename T> struct ei_plain_matrix_type_row_major +template<typename T> struct plain_matrix_type_row_major { - enum { Rows = ei_traits<T>::RowsAtCompileTime, - Cols = ei_traits<T>::ColsAtCompileTime, - MaxRows = ei_traits<T>::MaxRowsAtCompileTime, - MaxCols = ei_traits<T>::MaxColsAtCompileTime + enum { Rows = traits<T>::RowsAtCompileTime, + Cols = traits<T>::ColsAtCompileTime, + MaxRows = traits<T>::MaxRowsAtCompileTime, + MaxCols = traits<T>::MaxColsAtCompileTime }; - typedef Matrix<typename ei_traits<T>::Scalar, + typedef Matrix<typename traits<T>::Scalar, Rows, Cols, (MaxCols==1&&MaxRows!=1) ? RowMajor : ColMajor, @@ -257,16 +259,16 @@ template<typename T> struct ei_plain_matrix_type_row_major }; // we should be able to get rid of this one too -template<typename T> struct ei_must_nest_by_value { enum { ret = false }; }; +template<typename T> struct must_nest_by_value { enum { ret = false }; }; template<class T> -struct ei_is_reference +struct is_reference { enum { ret = false }; }; template<class T> -struct ei_is_reference<T&> +struct is_reference<T&> { enum { ret = true }; }; @@ -277,10 +279,10 @@ struct ei_is_reference<T&> * objects which should generate no copying overhead. **/ template <typename T> -struct ei_ref_selector +struct ref_selector { - typedef typename ei_meta_if< - bool(ei_traits<T>::Flags & NestByRefBit), + typedef typename meta_if< + bool(traits<T>::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<S, 3>::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<Matrix3d, 3>::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<S, 3>::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<Matrix3d, 3>::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<typename T, int n=1, typename PlainObject = typename ei_eval<T>::type> struct ei_nested +template<typename T, int n=1, typename PlainObject = typename eval<T>::type> struct nested { // this is a direct port of the logic used when Dynamic was 33331, to make an atomic commit. enum { - _ScalarReadCost = NumTraits<typename ei_traits<T>::Scalar>::ReadCost, + _ScalarReadCost = NumTraits<typename traits<T>::Scalar>::ReadCost, ScalarReadCost = _ScalarReadCost == Dynamic ? 33331 : int(_ScalarReadCost), - _CoeffReadCost = int(ei_traits<T>::CoeffReadCost), + _CoeffReadCost = int(traits<T>::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<T>::Flags) & EvalBeforeNestingBit ) || + typedef typename meta_if< + ( int(traits<T>::Flags) & EvalBeforeNestingBit ) || ( int(CostEval) <= int(CostNoEval) ), PlainObject, - typename ei_ref_selector<T>::type + typename ref_selector<T>::type >::ret type; /* this is what the above logic should be updated to look like: enum { - ScalarReadCost = NumTraits<typename ei_traits<T>::Scalar>::ReadCost, - CoeffReadCost = ei_traits<T>::CoeffReadCost, + ScalarReadCost = NumTraits<typename traits<T>::Scalar>::ReadCost, + CoeffReadCost = traits<T>::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<T>::Flags) & EvalBeforeNestingBit ) || + typedef typename meta_if< + ( int(traits<T>::Flags) & EvalBeforeNestingBit ) || ( int(CostNoEval) == Dynamic ? true : int(CostEval) == Dynamic ? false : int(CostEval) <= int(CostNoEval) ), PlainObject, - typename ei_ref_selector<T>::type + typename ref_selector<T>::type >::ret type; */ }; -template<unsigned int Flags> struct ei_are_flags_consistent +template<unsigned int Flags> struct are_flags_consistent { enum { ret = EIGEN_IMPLIES(bool(Flags&DirectAccessBit), bool(Flags&LvalueBit)) }; }; -template<typename Derived, typename XprKind = typename ei_traits<Derived>::XprKind> -struct ei_dense_xpr_base +template<typename Derived, typename XprKind = typename traits<Derived>::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<typename Derived> -struct ei_dense_xpr_base<Derived, MatrixXpr> +struct dense_xpr_base<Derived, MatrixXpr> { typedef MatrixBase<Derived> type; }; template<typename Derived> -struct ei_dense_xpr_base<Derived, ArrayXpr> +struct dense_xpr_base<Derived, ArrayXpr> { typedef ArrayBase<Derived> type; }; @@ -369,27 +371,27 @@ struct ei_dense_xpr_base<Derived, ArrayXpr> /** \internal Helper base class to add a scalar multiple operator * overloads for complex types */ template<typename Derived,typename Scalar,typename OtherScalar, - bool EnableIt = !ei_is_same_type<Scalar,OtherScalar>::ret > -struct ei_special_scalar_op_base : public DenseCoeffsBase<Derived> + bool EnableIt = !is_same_type<Scalar,OtherScalar>::ret > +struct special_scalar_op_base : public DenseCoeffsBase<Derived> { // dummy operator* so that the - // "using ei_special_scalar_op_base::operator*" compiles + // "using special_scalar_op_base::operator*" compiles void operator*() const; }; template<typename Derived,typename Scalar,typename OtherScalar> -struct ei_special_scalar_op_base<Derived,Scalar,OtherScalar,true> : public DenseCoeffsBase<Derived> +struct special_scalar_op_base<Derived,Scalar,OtherScalar,true> : public DenseCoeffsBase<Derived> { - const CwiseUnaryOp<ei_scalar_multiple2_op<Scalar,OtherScalar>, Derived> + const CwiseUnaryOp<scalar_multiple2_op<Scalar,OtherScalar>, Derived> operator*(const OtherScalar& scalar) const { - return CwiseUnaryOp<ei_scalar_multiple2_op<Scalar,OtherScalar>, Derived> - (*static_cast<const Derived*>(this), ei_scalar_multiple2_op<Scalar,OtherScalar>(scalar)); + return CwiseUnaryOp<scalar_multiple2_op<Scalar,OtherScalar>, Derived> + (*static_cast<const Derived*>(this), scalar_multiple2_op<Scalar,OtherScalar>(scalar)); } - inline friend const CwiseUnaryOp<ei_scalar_multiple2_op<Scalar,OtherScalar>, Derived> + inline friend const CwiseUnaryOp<scalar_multiple2_op<Scalar,OtherScalar>, Derived> operator*(const OtherScalar& scalar, const Derived& matrix) - { return static_cast<const ei_special_scalar_op_base&>(matrix).operator*(scalar); } + { return static_cast<const special_scalar_op_base&>(matrix).operator*(scalar); } }; template<typename ExpressionType> struct HNormalizedReturnType { @@ -399,24 +401,24 @@ template<typename ExpressionType> struct HNormalizedReturnType { SizeMinusOne = SizeAtCompileTime==Dynamic ? Dynamic : SizeAtCompileTime-1 }; typedef Block<ExpressionType, - ei_traits<ExpressionType>::ColsAtCompileTime==1 ? SizeMinusOne : 1, - ei_traits<ExpressionType>::ColsAtCompileTime==1 ? 1 : SizeMinusOne> StartMinusOne; - typedef CwiseUnaryOp<ei_scalar_quotient1_op<typename ei_traits<ExpressionType>::Scalar>, + traits<ExpressionType>::ColsAtCompileTime==1 ? SizeMinusOne : 1, + traits<ExpressionType>::ColsAtCompileTime==1 ? 1 : SizeMinusOne> StartMinusOne; + typedef CwiseUnaryOp<scalar_quotient1_op<typename traits<ExpressionType>::Scalar>, StartMinusOne > Type; }; -template<typename XprType, typename CastType> struct ei_cast_return_type +template<typename XprType, typename CastType> struct cast_return_type { typedef typename XprType::Scalar CurrentScalarType; - typedef typename ei_cleantype<CastType>::type _CastType; + typedef typename cleantype<CastType>::type _CastType; typedef typename _CastType::Scalar NewScalarType; - typedef typename ei_meta_if<ei_is_same_type<CurrentScalarType,NewScalarType>::ret, + typedef typename meta_if<is_same_type<CurrentScalarType,NewScalarType>::ret, const XprType&,CastType>::ret type; }; -template <typename A, typename B> struct ei_promote_storage_type; +template <typename A, typename B> struct promote_storage_type; -template <typename A> struct ei_promote_storage_type<A,A> +template <typename A> struct promote_storage_type<A,A> { typedef A ret; }; @@ -425,37 +427,37 @@ template <typename A> struct ei_promote_storage_type<A,A> * \param Scalar optional parameter allowing to pass a different scalar type than the one of the MatrixType. */ template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar> -struct ei_plain_row_type +struct plain_row_type { typedef Matrix<Scalar, 1, ExpressionType::ColsAtCompileTime, ExpressionType::PlainObject::Options | RowMajor, 1, ExpressionType::MaxColsAtCompileTime> MatrixRowType; typedef Array<Scalar, 1, ExpressionType::ColsAtCompileTime, ExpressionType::PlainObject::Options | RowMajor, 1, ExpressionType::MaxColsAtCompileTime> ArrayRowType; - typedef typename ei_meta_if< - ei_is_same_type< typename ei_traits<ExpressionType>::XprKind, MatrixXpr >::ret, + typedef typename meta_if< + is_same_type< typename traits<ExpressionType>::XprKind, MatrixXpr >::ret, MatrixRowType, ArrayRowType >::ret type; }; template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar> -struct ei_plain_col_type +struct plain_col_type { typedef Matrix<Scalar, ExpressionType::RowsAtCompileTime, 1, ExpressionType::PlainObject::Options & ~RowMajor, ExpressionType::MaxRowsAtCompileTime, 1> MatrixColType; typedef Array<Scalar, ExpressionType::RowsAtCompileTime, 1, ExpressionType::PlainObject::Options & ~RowMajor, ExpressionType::MaxRowsAtCompileTime, 1> ArrayColType; - typedef typename ei_meta_if< - ei_is_same_type< typename ei_traits<ExpressionType>::XprKind, MatrixXpr >::ret, + typedef typename meta_if< + is_same_type< typename traits<ExpressionType>::XprKind, MatrixXpr >::ret, MatrixColType, ArrayColType >::ret type; }; template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar> -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<Scalar, diag_size, 1, ExpressionType::PlainObject::Options & ~RowMajor, max_diag_size, 1> MatrixDiagType; typedef Array<Scalar, diag_size, 1, ExpressionType::PlainObject::Options & ~RowMajor, max_diag_size, 1> ArrayDiagType; - typedef typename ei_meta_if< - ei_is_same_type< typename ei_traits<ExpressionType>::XprKind, MatrixXpr >::ret, + typedef typename meta_if< + is_same_type< typename traits<ExpressionType>::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<Derived> DenseBase<Derived> switch(type) { default: - ei_assert(false && "Bad corner type."); + eigen_assert(false && "Bad corner type."); case TopLeft: return Block<Derived>(derived(), 0, 0, cRows, cCols); case TopRight: @@ -69,7 +69,7 @@ DenseBase<Derived>::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>(derived(), 0, 0, cRows, cCols); case TopRight: @@ -101,7 +101,7 @@ DenseBase<Derived>::corner(CornerType type) switch(type) { default: - ei_assert(false && "Bad corner type."); + eigen_assert(false && "Bad corner type."); case TopLeft: return Block<Derived, CRows, CCols>(derived(), 0, 0); case TopRight: @@ -122,7 +122,7 @@ DenseBase<Derived>::corner(CornerType type) const switch(type) { default: - ei_assert(false && "Bad corner type."); + eigen_assert(false && "Bad corner type."); case TopLeft: return Block<Derived, CRows, CCols>(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<OP<typename ei_traits<ExpressionType>::Scalar>, ExpressionType, OtherDerived> + CwiseBinaryOp<OP<typename internal::traits<ExpressionType>::Scalar>, ExpressionType, OtherDerived> /** \internal * convenient macro to defined the return type of a cwise unary operation */ #define EIGEN_CWISE_UNOP_RETURN_TYPE(OP) \ - CwiseUnaryOp<OP<typename ei_traits<ExpressionType>::Scalar>, ExpressionType> + CwiseUnaryOp<OP<typename internal::traits<ExpressionType>::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<OP<typename ei_traits<ExpressionType>::Scalar>, ExpressionType, \ + CwiseBinaryOp<OP<typename internal::traits<ExpressionType>::Scalar>, ExpressionType, \ typename ExpressionType::ConstantReturnType > /** \class Cwise @@ -61,10 +61,10 @@ template<typename ExpressionType> class Cwise { public: - typedef typename ei_traits<ExpressionType>::Scalar Scalar; - typedef typename ei_meta_if<ei_must_nest_by_value<ExpressionType>::ret, + typedef typename internal::traits<ExpressionType>::Scalar Scalar; + typedef typename internal::meta_if<internal::must_nest_by_value<ExpressionType>::ret, ExpressionType, const ExpressionType&>::ret ExpressionTypeNested; - typedef CwiseUnaryOp<ei_scalar_add_op<Scalar>, ExpressionType> ScalarAddReturnType; + typedef CwiseUnaryOp<internal::scalar_add_op<Scalar>, ExpressionType> ScalarAddReturnType; inline Cwise(const ExpressionType& matrix) : m_matrix(matrix) {} @@ -76,28 +76,28 @@ template<typename ExpressionType> class Cwise operator*(const MatrixBase<OtherDerived> &other) const; template<typename OtherDerived> - const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op) + const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_quotient_op) operator/(const MatrixBase<OtherDerived> &other) const; template<typename OtherDerived> - const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_min_op) + const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_min_op) min(const MatrixBase<OtherDerived> &other) const; template<typename OtherDerived> - const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_max_op) + const EIGEN_CWISE_BINOP_RETURN_TYPE(internal::scalar_max_op) max(const MatrixBase<OtherDerived> &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<typename ExpressionType> -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<ExpressionType>::abs() const { return _expression(); @@ -40,7 +40,7 @@ Cwise<ExpressionType>::abs() const /** \deprecated ArrayBase::abs2() */ template<typename ExpressionType> -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<ExpressionType>::abs2() const { return _expression(); @@ -48,7 +48,7 @@ Cwise<ExpressionType>::abs2() const /** \deprecated ArrayBase::exp() */ template<typename ExpressionType> -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_exp_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_exp_op) Cwise<ExpressionType>::exp() const { return _expression(); @@ -56,7 +56,7 @@ Cwise<ExpressionType>::exp() const /** \deprecated ArrayBase::log() */ template<typename ExpressionType> -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_log_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_log_op) Cwise<ExpressionType>::log() const { return _expression(); @@ -74,10 +74,10 @@ Cwise<ExpressionType>::operator*(const MatrixBase<OtherDerived> &other) const /** \deprecated ArrayBase::operator/() */ template<typename ExpressionType> template<typename OtherDerived> -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<ExpressionType>::operator/(const MatrixBase<OtherDerived> &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<ExpressionType>::operator/=(const MatrixBase<OtherD /** \deprecated ArrayBase::min() */ template<typename ExpressionType> template<typename OtherDerived> -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<ExpressionType>::min(const MatrixBase<OtherDerived> &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<typename ExpressionType> template<typename OtherDerived> -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<ExpressionType>::max(const MatrixBase<OtherDerived> &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<ExpressionType>::max(const MatrixBase<OtherDerived> &other) const /** \deprecated ArrayBase::sqrt() */ template<typename ExpressionType> -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sqrt_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_sqrt_op) Cwise<ExpressionType>::sqrt() const { return _expression(); @@ -130,7 +130,7 @@ Cwise<ExpressionType>::sqrt() const /** \deprecated ArrayBase::cos() */ template<typename ExpressionType> -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cos_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_cos_op) Cwise<ExpressionType>::cos() const { return _expression(); @@ -139,7 +139,7 @@ Cwise<ExpressionType>::cos() const /** \deprecated ArrayBase::sin() */ template<typename ExpressionType> -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sin_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_sin_op) Cwise<ExpressionType>::sin() const { return _expression(); @@ -148,16 +148,16 @@ Cwise<ExpressionType>::sin() const /** \deprecated ArrayBase::log() */ template<typename ExpressionType> -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_pow_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_pow_op) Cwise<ExpressionType>::pow(const Scalar& exponent) const { - return EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_pow_op)(_expression(), ei_scalar_pow_op<Scalar>(exponent)); + return EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_pow_op)(_expression(), internal::scalar_pow_op<Scalar>(exponent)); } /** \deprecated ArrayBase::inverse() */ template<typename ExpressionType> -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_inverse_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_inverse_op) Cwise<ExpressionType>::inverse() const { return _expression(); @@ -165,7 +165,7 @@ Cwise<ExpressionType>::inverse() const /** \deprecated ArrayBase::square() */ template<typename ExpressionType> -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_square_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_square_op) Cwise<ExpressionType>::square() const { return _expression(); @@ -173,7 +173,7 @@ Cwise<ExpressionType>::square() const /** \deprecated ArrayBase::cube() */ template<typename ExpressionType> -inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cube_op) +inline const EIGEN_CWISE_UNOP_RETURN_TYPE(internal::scalar_cube_op) Cwise<ExpressionType>::cube() const { return _expression(); @@ -299,7 +299,7 @@ template<typename ExpressionType> inline const typename Cwise<ExpressionType>::ScalarAddReturnType Cwise<ExpressionType>::operator+(const Scalar& scalar) const { - return typename Cwise<ExpressionType>::ScalarAddReturnType(m_matrix, ei_scalar_add_op<Scalar>(scalar)); + return typename Cwise<ExpressionType>::ScalarAddReturnType(m_matrix, internal::scalar_add_op<Scalar>(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<typename MatrixType> -struct ei_traits<Minor<MatrixType> > - : ei_traits<MatrixType> +struct traits<Minor<MatrixType> > + : traits<MatrixType> { - typedef typename ei_nested<MatrixType>::type MatrixTypeNested; - typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested; + typedef typename nested<MatrixType>::type MatrixTypeNested; + typedef typename unref<MatrixTypeNested>::type _MatrixTypeNested; typedef typename MatrixType::StorageKind StorageKind; enum { RowsAtCompileTime = (MatrixType::RowsAtCompileTime != Dynamic) ? @@ -59,6 +61,7 @@ struct ei_traits<Minor<MatrixType> > // where loops are unrolled and the 'if' evaluates at compile time }; }; +} template<typename MatrixType> class Minor : public MatrixBase<Minor<MatrixType> > @@ -72,7 +75,7 @@ template<typename MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<MatrixType>::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<RealScalar>::epsilon() * matrixnorm; + internal::real_ref(z) = NumTraits<RealScalar>::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<typename MatrixType, bool IsComplex> struct ei_complex_schur_reduce_to_hessenberg; +namespace internal { +template<typename MatrixType, bool IsComplex> struct complex_schur_reduce_to_hessenberg; +} /** \eigenvalues_module \ingroup Eigenvalues_Module * @@ -146,8 +148,8 @@ template<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> class ComplexSchur bool subdiagonalEntryIsNeglegible(Index i); ComplexScalar computeShift(Index iu, Index iter); void reduceToTriangularForm(bool computeU); - friend struct ei_complex_schur_reduce_to_hessenberg<MatrixType, NumTraits<Scalar>::IsComplex>; + friend struct internal::complex_schur_reduce_to_hessenberg<MatrixType, NumTraits<Scalar>::IsComplex>; }; +namespace internal { + /** Computes the principal value of the square root of the complex \a z. */ template<typename RealScalar> -std::complex<RealScalar> ei_sqrt(const std::complex<RealScalar> &z) +std::complex<RealScalar> sqrt(const std::complex<RealScalar> &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<RealScalar> ei_sqrt(const std::complex<RealScalar> &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<RealScalar> ei_sqrt(const std::complex<RealScalar> &z) return (std::complex<RealScalar>(tre,tim)); } +} // end namespace internal /** If m_matT(i+1,i) is neglegible in floating point arithmetic @@ -268,9 +273,9 @@ std::complex<RealScalar> ei_sqrt(const std::complex<RealScalar> &z) template<typename MatrixType> inline bool ComplexSchur<MatrixType>::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<RealScalar>::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<RealScalar>::epsilon())) { m_matT.coeffRef(i+1,i) = ComplexScalar(0); return true; @@ -286,7 +291,7 @@ typename ComplexSchur<MatrixType>::ComplexScalar ComplexSchur<MatrixType>::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<MatrixType>::ComplexScalar ComplexSchur<MatrixType>::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<typename MatrixType> ComplexSchur<MatrixType>& ComplexSchur<MatrixType>::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<MatrixType>& ComplexSchur<MatrixType>::compute(const MatrixType& ma return *this; } - ei_complex_schur_reduce_to_hessenberg<MatrixType, NumTraits<Scalar>::IsComplex>::run(*this, matrix, computeU); + internal::complex_schur_reduce_to_hessenberg<MatrixType, NumTraits<Scalar>::IsComplex>::run(*this, matrix, computeU); reduceToTriangularForm(computeU); return *this; } +namespace internal { + /* Reduce given matrix to Hessenberg form */ template<typename MatrixType, bool IsComplex> -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<MatrixType>& _this, const MatrixType& matrix, bool computeU) @@ -351,7 +358,7 @@ struct ei_complex_schur_reduce_to_hessenberg }; template<typename MatrixType> -struct ei_complex_schur_reduce_to_hessenberg<MatrixType, false> +struct complex_schur_reduce_to_hessenberg<MatrixType, false> { static void run(ComplexSchur<MatrixType>& _this, const MatrixType& matrix, bool computeU) { @@ -370,6 +377,8 @@ struct ei_complex_schur_reduce_to_hessenberg<MatrixType, false> } }; +} // end namespace internal + // Reduce the Hessenberg matrix m_matT to triangular form by QR iteration. template<typename MatrixType> void ComplexSchur<MatrixType>::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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> class EigenSolver template<typename MatrixType> MatrixType EigenSolver<MatrixType>::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<n; ++i) { - if (ei_isMuchSmallerThan(ei_imag(m_eivalues.coeff(i)), ei_real(m_eivalues.coeff(i)))) - matD.coeffRef(i,i) = ei_real(m_eivalues.coeff(i)); + if (internal::isMuchSmallerThan(internal::imag(m_eivalues.coeff(i)), internal::real(m_eivalues.coeff(i)))) + matD.coeffRef(i,i) = internal::real(m_eivalues.coeff(i)); else { - matD.template block<2,2>(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<MatrixType>::pseudoEigenvalueMatrix() const template<typename MatrixType> typename EigenSolver<MatrixType>::EigenvectorsType EigenSolver<MatrixType>::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<n; ++j) { - if (ei_isMuchSmallerThan(ei_imag(m_eivalues.coeff(j)), ei_real(m_eivalues.coeff(j)))) + if (internal::isMuchSmallerThan(internal::imag(m_eivalues.coeff(j)), internal::real(m_eivalues.coeff(j)))) { // we have a real eigen value matV.col(j) = m_eivec.col(j).template cast<ComplexScalar>(); @@ -384,7 +384,7 @@ EigenSolver<MatrixType>& EigenSolver<MatrixType>::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<typename Scalar> std::complex<Scalar> 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<MatrixType>::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<MatrixType>::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<Scalar> cc = cdiv<Scalar>(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<Scalar> cc = cdiv<Scalar>(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<MatrixType>::doComputeEigenvectors() if (m_eivalues.coeff(i).imag() == 0) { std::complex<Scalar> 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<MatrixType>::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<Scalar> 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<MatrixType>::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<typename MatrixType> GeneralizedSelfAdjointEigenSolver<MatrixType>& GeneralizedSelfAdjointEigenSolver<MatrixType>:: 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<typename MatrixType> struct HessenbergDecompositionMatrixHReturnType; +namespace internal { template<typename MatrixType> -struct ei_traits<HessenbergDecompositionMatrixHReturnType<MatrixType> > +struct traits<HessenbergDecompositionMatrixHReturnType<MatrixType> > { typedef MatrixType ReturnType; }; +} /** \eigenvalues_module \ingroup Eigenvalues_Module * @@ -184,7 +186,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> class HessenbergDecomposition */ HessenbergDecompositionMatrixHReturnType<MatrixType> matrixH() const { - ei_assert(m_isInitialized && "HessenbergDecomposition is not initialized."); + eigen_assert(m_isInitialized && "HessenbergDecomposition is not initialized."); return HessenbergDecompositionMatrixHReturnType<MatrixType>(*this); } @@ -319,7 +321,7 @@ void HessenbergDecomposition<MatrixType>::_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<typename Derived, bool IsComplex> -struct ei_eigenvalues_selector +struct eigenvalues_selector { // this is the implementation for the case IsComplex = true static inline typename MatrixBase<Derived>::EigenvaluesReturnType const @@ -42,7 +42,7 @@ struct ei_eigenvalues_selector }; template<typename Derived> -struct ei_eigenvalues_selector<Derived, false> +struct eigenvalues_selector<Derived, false> { static inline typename MatrixBase<Derived>::EigenvaluesReturnType const run(const MatrixBase<Derived>& m) @@ -53,6 +53,8 @@ struct ei_eigenvalues_selector<Derived, false> } }; +} // end namespace internal + /** \brief Computes the eigenvalues of a matrix * \returns Column vector containing the eigenvalues. * @@ -77,8 +79,8 @@ template<typename Derived> inline typename MatrixBase<Derived>::EigenvaluesReturnType MatrixBase<Derived>::eigenvalues() const { - typedef typename ei_traits<Derived>::Scalar Scalar; - return ei_eigenvalues_selector<Derived, NumTraits<Scalar>::IsComplex>::run(derived()); + typedef typename internal::traits<Derived>::Scalar Scalar; + return internal::eigenvalues_selector<Derived, NumTraits<Scalar>::IsComplex>::run(derived()); } /** \brief Computes the eigenvalues of a matrix @@ -135,7 +137,7 @@ MatrixBase<Derived>::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<Lower>() .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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<MatrixType>::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<Scalar>::epsilon() * s) + if (internal::abs(m_matT.coeff(res,res-1)) < NumTraits<Scalar>::epsilon() * s) break; res--; } @@ -325,7 +325,7 @@ inline void RealSchur<MatrixType>::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<Scalar> rot; if (p >= 0) rot.makeGivens(p + z, m_matT.coeff(iu, iu-1)); @@ -357,7 +357,7 @@ inline void RealSchur<MatrixType>::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<MatrixType>::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<MatrixType>::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<Scalar>::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<Scalar>::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<typename _MatrixType> 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<MatrixType, RealScalar>::type RealVectorType; + typedef typename internal::plain_col_type<MatrixType, RealScalar>::type RealVectorType; typedef Tridiagonalization<MatrixType> TridiagonalizationType; /** \brief Default constructor for fixed-size matrices. @@ -219,8 +219,8 @@ template<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> class SelfAdjointEigenSolver * Implemented from Golub's "Matrix Computations", algorithm 8.3.2: * "implicit symmetric QR step with Wilkinson shift" */ +namespace internal { template<typename RealScalar, typename Scalar, typename Index> -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<typename MatrixType> SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType> ::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<MatrixType>& SelfAdjointEigenSolver<MatrixType> 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<MatrixType>& SelfAdjointEigenSolver<MatrixType> 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<MatrixType>& SelfAdjointEigenSolver<MatrixType> while (end>0) { for (Index i = start; i<end; ++i) - if (ei_isMuchSmallerThan(ei_abs(m_subdiag[i]),(ei_abs(diag[i])+ei_abs(diag[i+1])))) + if (internal::isMuchSmallerThan(internal::abs(m_subdiag[i]),(internal::abs(diag[i])+internal::abs(diag[i+1])))) m_subdiag[i] = 0; // find the largest unreduced block @@ -396,7 +398,7 @@ SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType> 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<MatrixType>& SelfAdjointEigenSolver<MatrixType> return *this; } +namespace internal { template<typename RealScalar, typename Scalar, typename Index> -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<typename MatrixType, typename CoeffVectorType> +void tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs); +} + /** \eigenvalues_module \ingroup Eigenvalues_Module * * @@ -78,15 +83,15 @@ template<typename _MatrixType> class Tridiagonalization }; typedef Matrix<Scalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> CoeffVectorType; - typedef typename ei_plain_col_type<MatrixType, RealScalar>::type DiagonalType; + typedef typename internal::plain_col_type<MatrixType, RealScalar>::type DiagonalType; typedef Matrix<RealScalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> SubDiagonalType; - typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex, + typedef typename internal::meta_if<NumTraits<Scalar>::IsComplex, typename Diagonal<MatrixType,0>::RealReturnType, Diagonal<MatrixType,0> >::ret DiagonalReturnType; - typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex, + typedef typename internal::meta_if<NumTraits<Scalar>::IsComplex, typename Diagonal< Block<MatrixType,SizeMinusOne,SizeMinusOne>,0 >::RealReturnType, Diagonal< @@ -129,7 +134,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename MatrixType> const typename Tridiagonalization<MatrixType>::DiagonalReturnType Tridiagonalization<MatrixType>::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<typename MatrixType> const typename Tridiagonalization<MatrixType>::SubDiagonalReturnType Tridiagonalization<MatrixType>::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<MatrixType,SizeMinusOne,SizeMinusOne>(m_matrix, 1, 0, n-1,n-1).diagonal(); } @@ -315,7 +320,7 @@ Tridiagonalization<MatrixType>::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<Scalar>().conjugate(); @@ -327,6 +332,8 @@ Tridiagonalization<MatrixType>::matrixT() const return matT; } +namespace internal { + /** \internal * Performs a tridiagonal decomposition of the selfadjoint matrix \a matA in-place. * @@ -351,10 +358,10 @@ Tridiagonalization<MatrixType>::matrixT() const * \sa Tridiagonalization::packedMatrix() */ template<typename MatrixType, typename CoeffVectorType> -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<Lower>() - * (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<Lower>() .rankUpdate(matA.col(i).tail(remainingSize), hCoeffs.tail(remainingSize), -1); @@ -387,7 +394,7 @@ void ei_tridiagonalization_inplace(MatrixType& matA, CoeffVectorType& hCoeffs) template<typename MatrixType, int Size=MatrixType::ColsAtCompileTime, bool IsComplex=NumTraits<typename MatrixType::Scalar>::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<typename MatrixType, typename DiagonalType, typename SubDiagonalType> -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<MatrixType>::run(mat, diag, subdiag, extractQ); + eigen_assert(mat.cols()==mat.rows() && diag.size()==mat.rows() && subdiag.size()==mat.rows()-1); + tridiagonalization_inplace_selector<MatrixType>::run(mat, diag, subdiag, extractQ); } /** \internal * General full tridiagonalization */ template<typename MatrixType, int Size, bool IsComplex> -struct ei_tridiagonalization_inplace_selector +struct tridiagonalization_inplace_selector { typedef typename Tridiagonalization<MatrixType>::CoeffVectorType CoeffVectorType; typedef typename Tridiagonalization<MatrixType>::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<typename MatrixType> -struct ei_tridiagonalization_inplace_selector<MatrixType,3,false> +struct tridiagonalization_inplace_selector<MatrixType,3,false> { typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::RealScalar RealScalar; @@ -473,7 +480,7 @@ struct ei_tridiagonalization_inplace_selector<MatrixType,3,false> 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<MatrixType,3,false> } 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<MatrixType,3,false> * Trivial specialization for 1x1 matrices */ template<typename MatrixType, bool IsComplex> -struct ei_tridiagonalization_inplace_selector<MatrixType,1,IsComplex> +struct tridiagonalization_inplace_selector<MatrixType,1,IsComplex> { typedef typename MatrixType::Scalar Scalar; template<typename DiagonalType, typename SubDiagonalType> 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<typename Derived> inline explicit AlignedBox(const MatrixBase<Derived>& a_p) { - const typename ei_nested<Derived,2>::type p(a_p.derived()); + const typename internal::nested<Derived,2>::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<ei_scalar_quotient1_op<Scalar>, - CwiseBinaryOp<ei_scalar_sum_op<Scalar>, VectorType, VectorType> > + inline const CwiseUnaryOp<internal::scalar_quotient1_op<Scalar>, + CwiseBinaryOp<internal::scalar_sum_op<Scalar>, 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<Scalar>, VectorType, VectorType> sizes() const + inline const CwiseBinaryOp< internal::scalar_difference_op<Scalar>, 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<Scalar>, VectorType, VectorType> diagonal() const + inline CwiseBinaryOp< internal::scalar_difference_op<Scalar>, 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>(Scalar(0), Scalar(1)); + * internal::random<Scalar>(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<typename Derived> inline bool contains(const MatrixBase<Derived>& a_p) const { - const typename ei_nested<Derived,2>::type p(a_p.derived()); + const typename internal::nested<Derived,2>::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<typename Derived> inline AlignedBox& extend(const MatrixBase<Derived>& a_p) { - const typename ei_nested<Derived,2>::type p(a_p.derived()); + const typename internal::nested<Derived,2>::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<typename Derived> inline AlignedBox& translate(const MatrixBase<Derived>& a_t) { - const typename ei_nested<Derived,2>::type t(a_t.derived()); + const typename internal::nested<Derived,2>::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<typename Derived> inline NonInteger exteriorDistance(const MatrixBase<Derived>& 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<typename NewScalarType> - inline typename ei_cast_return_type<AlignedBox, + inline typename internal::cast_return_type<AlignedBox, AlignedBox<NewScalarType,AmbientDimAtCompileTime> >::type cast() const { - return typename ei_cast_return_type<AlignedBox, + return typename internal::cast_return_type<AlignedBox, AlignedBox<NewScalarType,AmbientDimAtCompileTime> >::type(*this); } @@ -309,7 +309,7 @@ template<typename Scalar,int AmbientDim> template<typename Derived> inline Scalar AlignedBox<Scalar,AmbientDim>::squaredExteriorDistance(const MatrixBase<Derived>& a_p) const { - const typename ei_nested<Derived,2*AmbientDim>::type p(a_p.derived()); + const typename internal::nested<Derived,2*AmbientDim>::type p(a_p.derived()); Scalar dist2 = 0.; Scalar aux; for (Index k=0; k<dim(); ++k) diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h index 8319aa6f1..f3398d0be 100644 --- a/Eigen/src/Geometry/AngleAxis.h +++ b/Eigen/src/Geometry/AngleAxis.h @@ -51,10 +51,12 @@ * \sa class Quaternion, class Transform, MatrixBase::UnitX() */ -template<typename _Scalar> struct ei_traits<AngleAxis<_Scalar> > +namespace internal { +template<typename _Scalar> struct traits<AngleAxis<_Scalar> > { typedef _Scalar Scalar; }; +} template<typename _Scalar> class AngleAxis : public RotationBase<AngleAxis<_Scalar>,3> @@ -131,8 +133,8 @@ public: * then this function smartly returns a const reference to \c *this. */ template<typename NewScalarType> - inline typename ei_cast_return_type<AngleAxis,AngleAxis<NewScalarType> >::type cast() const - { return typename ei_cast_return_type<AngleAxis,AngleAxis<NewScalarType> >::type(*this); } + inline typename internal::cast_return_type<AngleAxis,AngleAxis<NewScalarType> >::type cast() const + { return typename internal::cast_return_type<AngleAxis,AngleAxis<NewScalarType> >::type(*this); } /** Copy constructor with scalar type conversion */ template<typename OtherScalarType> @@ -149,7 +151,7 @@ public: * * \sa MatrixBase::isApprox() */ bool isApprox(const AngleAxis& other, typename NumTraits<Scalar>::Real prec = NumTraits<Scalar>::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<Scalar>& AngleAxis<Scalar>::operator=(const QuaternionBase<QuatDerived else { m_angle = 2*std::acos(q.w()); - m_axis = q.vec() / ei_sqrt(n2); + m_axis = q.vec() / internal::sqrt(n2); } return *this; } @@ -208,8 +210,8 @@ typename AngleAxis<Scalar>::Matrix3 AngleAxis<Scalar>::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<Derived>::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<typename MatrixType,int Direction> -struct ei_traits<Homogeneous<MatrixType,Direction> > - : ei_traits<MatrixType> +struct traits<Homogeneous<MatrixType,Direction> > + : traits<MatrixType> { - typedef typename ei_traits<MatrixType>::StorageKind StorageKind; - typedef typename ei_nested<MatrixType>::type MatrixTypeNested; - typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested; + typedef typename traits<MatrixType>::StorageKind StorageKind; + typedef typename nested<MatrixType>::type MatrixTypeNested; + typedef typename unref<MatrixTypeNested>::type _MatrixTypeNested; enum { RowsPlusOne = (MatrixType::RowsAtCompileTime != Dynamic) ? int(MatrixType::RowsAtCompileTime) + 1 : Dynamic, @@ -63,8 +66,10 @@ struct ei_traits<Homogeneous<MatrixType,Direction> > }; }; -template<typename MatrixType,typename Lhs> struct ei_homogeneous_left_product_impl; -template<typename MatrixType,typename Rhs> struct ei_homogeneous_right_product_impl; +template<typename MatrixType,typename Lhs> struct homogeneous_left_product_impl; +template<typename MatrixType,typename Rhs> struct homogeneous_right_product_impl; + +} // end namespace internal template<typename MatrixType,int _Direction> class Homogeneous : public MatrixBase<Homogeneous<MatrixType,_Direction> > @@ -92,38 +97,38 @@ template<typename MatrixType,int _Direction> class Homogeneous } template<typename Rhs> - inline const ei_homogeneous_right_product_impl<Homogeneous,Rhs> + inline const internal::homogeneous_right_product_impl<Homogeneous,Rhs> operator* (const MatrixBase<Rhs>& rhs) const { - ei_assert(int(Direction)==Horizontal); - return ei_homogeneous_right_product_impl<Homogeneous,Rhs>(m_matrix,rhs.derived()); + eigen_assert(int(Direction)==Horizontal); + return internal::homogeneous_right_product_impl<Homogeneous,Rhs>(m_matrix,rhs.derived()); } template<typename Lhs> friend - inline const ei_homogeneous_left_product_impl<Homogeneous,Lhs> + inline const internal::homogeneous_left_product_impl<Homogeneous,Lhs> operator* (const MatrixBase<Lhs>& lhs, const Homogeneous& rhs) { - ei_assert(int(Direction)==Vertical); - return ei_homogeneous_left_product_impl<Homogeneous,Lhs>(lhs.derived(),rhs.m_matrix); + eigen_assert(int(Direction)==Vertical); + return internal::homogeneous_left_product_impl<Homogeneous,Lhs>(lhs.derived(),rhs.m_matrix); } template<typename Scalar, int Dim, int Mode> friend - inline const ei_homogeneous_left_product_impl<Homogeneous, + inline const internal::homogeneous_left_product_impl<Homogeneous, typename Transform<Scalar,Dim,Mode>::AffinePartNested> operator* (const Transform<Scalar,Dim,Mode>& tr, const Homogeneous& rhs) { - ei_assert(int(Direction)==Vertical); - return ei_homogeneous_left_product_impl<Homogeneous,typename Transform<Scalar,Dim,Mode>::AffinePartNested > + eigen_assert(int(Direction)==Vertical); + return internal::homogeneous_left_product_impl<Homogeneous,typename Transform<Scalar,Dim,Mode>::AffinePartNested > (tr.affine(),rhs.m_matrix); } template<typename Scalar, int Dim> friend - inline const ei_homogeneous_left_product_impl<Homogeneous, + inline const internal::homogeneous_left_product_impl<Homogeneous, typename Transform<Scalar,Dim,Projective>::MatrixType> operator* (const Transform<Scalar,Dim,Projective>& tr, const Homogeneous& rhs) { - ei_assert(int(Direction)==Vertical); - return ei_homogeneous_left_product_impl<Homogeneous,typename Transform<Scalar,Dim,Projective>::MatrixType> + eigen_assert(int(Direction)==Vertical); + return internal::homogeneous_left_product_impl<Homogeneous,typename Transform<Scalar,Dim,Projective>::MatrixType> (tr.matrix(),rhs.m_matrix); } @@ -210,11 +215,13 @@ VectorwiseOp<ExpressionType,Direction>::hnormalized() const Direction==Horizontal ? _expression().cols()-1 : 1)); } +namespace internal { + template<typename MatrixType,typename Lhs> -struct ei_traits<ei_homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> > +struct traits<homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> > { - typedef typename ei_make_proper_matrix_type< - typename ei_traits<MatrixType>::Scalar, + typedef typename make_proper_matrix_type< + typename traits<MatrixType>::Scalar, Lhs::RowsAtCompileTime, MatrixType::ColsAtCompileTime, MatrixType::PlainObject::Options, @@ -223,12 +230,12 @@ struct ei_traits<ei_homogeneous_left_product_impl<Homogeneous<MatrixType,Vertica }; template<typename MatrixType,typename Lhs> -struct ei_homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> - : public ReturnByValue<ei_homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> > +struct homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> + : public ReturnByValue<homogeneous_left_product_impl<Homogeneous<MatrixType,Vertical>,Lhs> > { - typedef typename ei_cleantype<typename Lhs::Nested>::type LhsNested; + typedef typename cleantype<typename Lhs::Nested>::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<Homogeneous<MatrixType,Vertical>,Lhs> }; template<typename MatrixType,typename Rhs> -struct ei_traits<ei_homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> > +struct traits<homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> > { - typedef typename ei_make_proper_matrix_type<typename ei_traits<MatrixType>::Scalar, + typedef typename make_proper_matrix_type<typename traits<MatrixType>::Scalar, MatrixType::RowsAtCompileTime, Rhs::ColsAtCompileTime, MatrixType::PlainObject::Options, @@ -262,12 +269,12 @@ struct ei_traits<ei_homogeneous_right_product_impl<Homogeneous<MatrixType,Horizo }; template<typename MatrixType,typename Rhs> -struct ei_homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> - : public ReturnByValue<ei_homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> > +struct homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> + : public ReturnByValue<homogeneous_right_product_impl<Homogeneous<MatrixType,Horizontal>,Rhs> > { - typedef typename ei_cleantype<typename Rhs::Nested>::type RhsNested; + typedef typename cleantype<typename Rhs::Nested>::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<Homogeneous<MatrixType,Horizontal>,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<typename NewScalarType> - inline typename ei_cast_return_type<Hyperplane, + inline typename internal::cast_return_type<Hyperplane, Hyperplane<NewScalarType,AmbientDimAtCompileTime> >::type cast() const { - return typename ei_cast_return_type<Hyperplane, + return typename internal::cast_return_type<Hyperplane, Hyperplane<NewScalarType,AmbientDimAtCompileTime> >::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<Derived>::cross(const MatrixBase<OtherDerived>& 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<Derived,2>::type lhs(derived()); - const typename ei_nested<OtherDerived,2>::type rhs(other.derived()); - return typename ei_plain_matrix_type<Derived>::type( + const typename internal::nested<Derived,2>::type lhs(derived()); + const typename internal::nested<OtherDerived,2>::type rhs(other.derived()); + return typename internal::plain_matrix_type<Derived>::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<VectorLhs>::type +struct cross3_impl { + inline static typename internal::plain_matrix_type<VectorLhs>::type run(const VectorLhs& lhs, const VectorRhs& rhs) { - return typename ei_plain_matrix_type<VectorLhs>::type( + return typename internal::plain_matrix_type<VectorLhs>::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<Derived>::cross3(const MatrixBase<OtherDerived>& other) const EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Derived,4) EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,4) - typedef typename ei_nested<Derived,2>::type DerivedNested; - typedef typename ei_nested<OtherDerived,2>::type OtherDerivedNested; + typedef typename internal::nested<Derived,2>::type DerivedNested; + typedef typename internal::nested<OtherDerived,2>::type OtherDerivedNested; const DerivedNested lhs(derived()); const OtherDerivedNested rhs(other.derived()); - return ei_cross3_impl<Architecture::Target, - typename ei_cleantype<DerivedNested>::type, - typename ei_cleantype<OtherDerivedNested>::type>::run(lhs,rhs); + return internal::cross3_impl<Architecture::Target, + typename internal::cleantype<DerivedNested>::type, + typename internal::cleantype<OtherDerivedNested>::type>::run(lhs,rhs); } /** \returns a matrix expression of the cross product of each column or row @@ -110,20 +114,20 @@ const typename VectorwiseOp<ExpressionType,Direction>::CrossReturnType VectorwiseOp<ExpressionType,Direction>::cross(const MatrixBase<OtherDerived>& other) const { EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,3) - EIGEN_STATIC_ASSERT((ei_is_same_type<Scalar, typename OtherDerived::Scalar>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type<Scalar, typename OtherDerived::Scalar>::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<ExpressionType,Direction>::cross(const MatrixBase<OtherDerived>& ot return res; } +namespace internal { + template<typename Derived, int Size = Derived::SizeAtCompileTime> -struct ei_unitOrthogonal_selector +struct unitOrthogonal_selector { - typedef typename ei_plain_matrix_type<Derived>::type VectorType; - typedef typename ei_traits<Derived>::Scalar Scalar; + typedef typename plain_matrix_type<Derived>::type VectorType; + typedef typename traits<Derived>::Scalar Scalar; typedef typename NumTraits<Scalar>::Real RealScalar; typedef typename Derived::Index Index; typedef Matrix<Scalar,2,1> 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<typename Derived> -struct ei_unitOrthogonal_selector<Derived,3> +struct unitOrthogonal_selector<Derived,3> { - typedef typename ei_plain_matrix_type<Derived>::type VectorType; - typedef typename ei_traits<Derived>::Scalar Scalar; + typedef typename plain_matrix_type<Derived>::type VectorType; + typedef typename traits<Derived>::Scalar Scalar; typedef typename NumTraits<Scalar>::Real RealScalar; inline static VectorType run(const Derived& src) { @@ -171,12 +177,12 @@ struct ei_unitOrthogonal_selector<Derived,3> /* 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<Derived,3> { 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<Derived,3> }; template<typename Derived> -struct ei_unitOrthogonal_selector<Derived,2> +struct unitOrthogonal_selector<Derived,2> { - typedef typename ei_plain_matrix_type<Derived>::type VectorType; + typedef typename plain_matrix_type<Derived>::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<Derived>::PlainObject MatrixBase<Derived>::unitOrthogonal() const { EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) - return ei_unitOrthogonal_selector<Derived>::run(derived()); + return internal::unitOrthogonal_selector<Derived>::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<typename NewScalarType> - inline typename ei_cast_return_type<ParametrizedLine, + inline typename internal::cast_return_type<ParametrizedLine, ParametrizedLine<NewScalarType,AmbientDimAtCompileTime> >::type cast() const { - return typename ei_cast_return_type<ParametrizedLine, + return typename internal::cast_return_type<ParametrizedLine, ParametrizedLine<NewScalarType,AmbientDimAtCompileTime> >::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<typename Other, int OtherRows=Other::RowsAtCompileTime, int OtherCols=Other::ColsAtCompileTime> -struct ei_quaternionbase_assign_impl; +struct quaternionbase_assign_impl; +} template<class Derived> class QuaternionBase : public RotationBase<Derived, 3> @@ -44,9 +46,9 @@ public: using Base::operator*; using Base::derived; - typedef typename ei_traits<Derived>::Scalar Scalar; + typedef typename internal::traits<Derived>::Scalar Scalar; typedef typename NumTraits<Scalar>::Real RealScalar; - typedef typename ei_traits<Derived>::Coefficients Coefficients; + typedef typename internal::traits<Derived>::Coefficients Coefficients; // typedef typename Matrix<Scalar,4,1> Coefficients; /** the type of a 3D vector */ @@ -83,10 +85,10 @@ public: inline VectorBlock<Coefficients,3> vec() { return coeffs().template head<3>(); } /** \returns a read-only vector expression of the coefficients (x,y,z,w) */ - inline const typename ei_traits<Derived>::Coefficients& coeffs() const { return derived().coeffs(); } + inline const typename internal::traits<Derived>::Coefficients& coeffs() const { return derived().coeffs(); } /** \returns a vector expression of the coefficients (x,y,z,w) */ - inline typename ei_traits<Derived>::Coefficients& coeffs() { return derived().coeffs(); } + inline typename internal::traits<Derived>::Coefficients& coeffs() { return derived().coeffs(); } EIGEN_STRONG_INLINE QuaternionBase<Derived>& operator=(const QuaternionBase<Derived>& other); template<class OtherDerived> EIGEN_STRONG_INLINE Derived& operator=(const QuaternionBase<OtherDerived>& other); @@ -175,9 +177,9 @@ public: * then this function smartly returns a const reference to \c *this. */ template<typename NewScalarType> - inline typename ei_cast_return_type<Derived,Quaternion<NewScalarType> >::type cast() const + inline typename internal::cast_return_type<Derived,Quaternion<NewScalarType> >::type cast() const { - return typename ei_cast_return_type<Derived,Quaternion<NewScalarType> >::type( + return typename internal::cast_return_type<Derived,Quaternion<NewScalarType> >::type( coeffs().template cast<NewScalarType>()); } @@ -212,8 +214,9 @@ public: * \sa class AngleAxis, class Transform */ +namespace internal { template<typename _Scalar> -struct ei_traits<Quaternion<_Scalar> > +struct traits<Quaternion<_Scalar> > { typedef Quaternion<_Scalar> PlainObject; typedef _Scalar Scalar; @@ -222,6 +225,7 @@ struct ei_traits<Quaternion<_Scalar> > PacketAccess = Aligned }; }; +} template<typename _Scalar> class Quaternion : public QuaternionBase<Quaternion<_Scalar> >{ @@ -232,7 +236,7 @@ public: EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Quaternion<Scalar>) using Base::operator*=; - typedef typename ei_traits<Quaternion<Scalar> >::Coefficients Coefficients; + typedef typename internal::traits<Quaternion<Scalar> >::Coefficients Coefficients; typedef typename Base::AngleAxisType AngleAxisType; /** Default constructor leaving the quaternion uninitialized. */ @@ -281,9 +285,10 @@ typedef Quaternion<double> Quaterniond; * Specialization of Map<Quaternion<Scalar>> ***************************************************************************/ +namespace internal { template<typename _Scalar, int _PacketAccess> -struct ei_traits<Map<Quaternion<_Scalar>, _PacketAccess> >: -ei_traits<Quaternion<_Scalar> > +struct traits<Map<Quaternion<_Scalar>, _PacketAccess> >: +traits<Quaternion<_Scalar> > { typedef _Scalar Scalar; typedef Map<Matrix<_Scalar,4,1>, _PacketAccess> Coefficients; @@ -291,6 +296,7 @@ ei_traits<Quaternion<_Scalar> > PacketAccess = _PacketAccess }; }; +} /** \brief Expression of a quaternion from a memory buffer * @@ -310,7 +316,7 @@ class Map<Quaternion<_Scalar>, PacketAccess > public: typedef _Scalar Scalar; - typedef typename ei_traits<Map>::Coefficients Coefficients; + typedef typename internal::traits<Map>::Coefficients Coefficients; EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Map) using Base::operator*=; @@ -348,7 +354,8 @@ typedef Map<Quaternion<double>, Aligned> QuaternionMapAlignedd; // Generic Quaternion * Quaternion product // This product can be specialized for a given architecture via the Arch template argument. -template<int Arch, class Derived1, class Derived2, typename Scalar, int PacketAccess> struct ei_quat_product +namespace internal { +template<int Arch, class Derived1, class Derived2, typename Scalar, int PacketAccess> struct quat_product { EIGEN_STRONG_INLINE static Quaternion<Scalar> run(const QuaternionBase<Derived1>& a, const QuaternionBase<Derived2>& b){ return Quaternion<Scalar> @@ -360,18 +367,19 @@ template<int Arch, class Derived1, class Derived2, typename Scalar, int PacketAc ); } }; +} /** \returns the concatenation of two rotations as a quaternion-quaternion product */ template <class Derived> template <class OtherDerived> -EIGEN_STRONG_INLINE Quaternion<typename ei_traits<Derived>::Scalar> +EIGEN_STRONG_INLINE Quaternion<typename internal::traits<Derived>::Scalar> QuaternionBase<Derived>::operator* (const QuaternionBase<OtherDerived>& other) const { - EIGEN_STATIC_ASSERT((ei_is_same_type<typename Derived::Scalar, typename OtherDerived::Scalar>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type<typename Derived::Scalar, typename OtherDerived::Scalar>::ret), YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) - return ei_quat_product<Architecture::Target, Derived, OtherDerived, - typename ei_traits<Derived>::Scalar, - ei_traits<Derived>::PacketAccess && ei_traits<OtherDerived>::PacketAccess>::run(*this, other); + return internal::quat_product<Architecture::Target, Derived, OtherDerived, + typename internal::traits<Derived>::Scalar, + internal::traits<Derived>::PacketAccess && internal::traits<OtherDerived>::PacketAccess>::run(*this, other); } /** \sa operator*(Quaternion) */ @@ -425,8 +433,8 @@ template<class Derived> EIGEN_STRONG_INLINE Derived& QuaternionBase<Derived>::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<class Derived> template<class MatrixDerived> inline Derived& QuaternionBase<Derived>::operator=(const MatrixBase<MatrixDerived>& xpr) { - EIGEN_STATIC_ASSERT((ei_is_same_type<typename Derived::Scalar, typename MatrixDerived::Scalar>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type<typename Derived::Scalar, typename MatrixDerived::Scalar>::ret), YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) - ei_quaternionbase_assign_impl<MatrixDerived>::run(*this, xpr.derived()); + internal::quaternionbase_assign_impl<MatrixDerived>::run(*this, xpr.derived()); return derived(); } @@ -519,12 +527,12 @@ inline Derived& QuaternionBase<Derived>::setFromTwoVectors(const MatrixBase<Deri Vector3 axis = svd.matrixV().col(2); Scalar w2 = (Scalar(1)+c)*Scalar(0.5); - this->w() = 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<Derived>::setFromTwoVectors(const MatrixBase<Deri * \sa QuaternionBase::conjugate() */ template <class Derived> -inline Quaternion<typename ei_traits<Derived>::Scalar> QuaternionBase<Derived>::inverse() const +inline Quaternion<typename internal::traits<Derived>::Scalar> QuaternionBase<Derived>::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<typename ei_traits<Derived>::Scalar> QuaternionBase<Derived>:: * \sa Quaternion2::inverse() */ template <class Derived> -inline Quaternion<typename ei_traits<Derived>::Scalar> +inline Quaternion<typename internal::traits<Derived>::Scalar> QuaternionBase<Derived>::conjugate() const { return Quaternion<Scalar>(this->w(),-this->x(),-this->y(),-this->z()); @@ -570,10 +578,10 @@ QuaternionBase<Derived>::conjugate() const */ template <class Derived> template <class OtherDerived> -inline typename ei_traits<Derived>::Scalar +inline typename internal::traits<Derived>::Scalar QuaternionBase<Derived>::angularDistance(const QuaternionBase<OtherDerived>& 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<Scalar>(2 * std::acos(d)); @@ -584,12 +592,12 @@ QuaternionBase<Derived>::angularDistance(const QuaternionBase<OtherDerived>& oth */ template <class Derived> template <class OtherDerived> -Quaternion<typename ei_traits<Derived>::Scalar> +Quaternion<typename internal::traits<Derived>::Scalar> QuaternionBase<Derived>::slerp(Scalar t, const QuaternionBase<OtherDerived>& other) const { static const Scalar one = Scalar(1) - NumTraits<Scalar>::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<Derived>::slerp(Scalar t, const QuaternionBase<OtherDerived>& 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<Derived>::slerp(Scalar t, const QuaternionBase<OtherDerived>& oth return Quaternion<Scalar>(scale0 * coeffs() + scale1 * other.coeffs()); } +namespace internal { + // set from a rotation matrix template<typename Other> -struct ei_quaternionbase_assign_impl<Other,3,3> +struct quaternionbase_assign_impl<Other,3,3> { typedef typename Other::Scalar Scalar; typedef DenseIndex Index; @@ -627,7 +637,7 @@ struct ei_quaternionbase_assign_impl<Other,3,3> 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<Other,3,3> 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<Other,3,3> // set from a vector of coefficients assumed to be a quaternion template<typename Other> -struct ei_quaternionbase_assign_impl<Other,4,1> +struct quaternionbase_assign_impl<Other,4,1> { typedef typename Other::Scalar Scalar; template<class Derived> inline static void run(QuaternionBase<Derived>& q, const Other& vec) @@ -665,5 +675,6 @@ struct ei_quaternionbase_assign_impl<Other,4,1> } }; +} // 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<typename _Scalar> struct ei_traits<Rotation2D<_Scalar> > + +namespace internal { + +template<typename _Scalar> struct traits<Rotation2D<_Scalar> > { typedef _Scalar Scalar; }; +} // end namespace internal template<typename _Scalar> class Rotation2D : public RotationBase<Rotation2D<_Scalar>,2> @@ -107,8 +111,8 @@ public: * then this function smartly returns a const reference to \c *this. */ template<typename NewScalarType> - inline typename ei_cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type cast() const - { return typename ei_cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type(*this); } + inline typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type cast() const + { return typename internal::cast_return_type<Rotation2D,Rotation2D<NewScalarType> >::type(*this); } /** Copy constructor with scalar type conversion */ template<typename OtherScalarType> @@ -124,7 +128,7 @@ public: * * \sa MatrixBase::isApprox() */ bool isApprox(const Rotation2D& other, typename NumTraits<Scalar>::Real prec = NumTraits<Scalar>::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<typename Derived> Rotation2D<Scalar>& Rotation2D<Scalar>::fromRotationMatrix(const MatrixBase<Derived>& 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 Scalar> typename Rotation2D<Scalar>::Matrix2 Rotation2D<Scalar>::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<typename RotationDerived, typename MatrixType, bool IsVector=MatrixType::IsVectorAtCompileTime> -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<Derived>::Scalar Scalar; + typedef typename internal::traits<Derived>::Scalar Scalar; /** corresponding linear transformation matrix type */ typedef Matrix<Scalar,Dim,Dim> RotationMatrixType; @@ -78,9 +80,9 @@ class RotationBase * - a vector of size Dim */ template<typename OtherDerived> - EIGEN_STRONG_INLINE typename ei_rotation_base_generic_product_selector<Derived,OtherDerived,OtherDerived::IsVectorAtCompileTime>::ReturnType + EIGEN_STRONG_INLINE typename internal::rotation_base_generic_product_selector<Derived,OtherDerived,OtherDerived::IsVectorAtCompileTime>::ReturnType operator*(const EigenBase<OtherDerived>& e) const - { return ei_rotation_base_generic_product_selector<Derived,OtherDerived>::run(derived(), e.derived()); } + { return internal::rotation_base_generic_product_selector<Derived,OtherDerived>::run(derived(), e.derived()); } /** \returns the concatenation of a linear transformation \a l with the rotation \a r */ template<typename OtherDerived> friend @@ -105,9 +107,11 @@ class RotationBase { return toRotationMatrix() * v; } }; +namespace internal { + // implementation of the generic product rotation * matrix template<typename RotationDerived, typename MatrixType> -struct ei_rotation_base_generic_product_selector<RotationDerived,MatrixType,false> +struct rotation_base_generic_product_selector<RotationDerived,MatrixType,false> { enum { Dim = RotationDerived::Dim }; typedef Matrix<typename RotationDerived::Scalar,Dim,Dim> ReturnType; @@ -116,7 +120,7 @@ struct ei_rotation_base_generic_product_selector<RotationDerived,MatrixType,fals }; template<typename RotationDerived, typename Scalar, int Dim, int MaxDim> -struct ei_rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix<Scalar,Dim,MaxDim>, false > +struct rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix<Scalar,Dim,MaxDim>, false > { typedef Transform<Scalar,Dim,Affine> ReturnType; inline static ReturnType run(const RotationDerived& r, const DiagonalMatrix<Scalar,Dim,MaxDim>& m) @@ -128,7 +132,7 @@ struct ei_rotation_base_generic_product_selector< RotationDerived, DiagonalMatri }; template<typename RotationDerived,typename OtherVectorType> -struct ei_rotation_base_generic_product_selector<RotationDerived,OtherVectorType,true> +struct rotation_base_generic_product_selector<RotationDerived,OtherVectorType,true> { enum { Dim = RotationDerived::Dim }; typedef Matrix<typename RotationDerived::Scalar,Dim,1> ReturnType; @@ -138,6 +142,8 @@ struct ei_rotation_base_generic_product_selector<RotationDerived,OtherVectorType } }; +} // end namespace internal + /** \geometry_module * * \brief Constructs a Dim x Dim rotation matrix from the rotation \a r @@ -165,6 +171,8 @@ Matrix<_Scalar, _Rows, _Cols, _Storage, _MaxRows, _MaxCols> 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<typename Scalar, int Dim> -inline static Matrix<Scalar,2,2> ei_toRotationMatrix(const Scalar& s) +inline static Matrix<Scalar,2,2> toRotationMatrix(const Scalar& s) { EIGEN_STATIC_ASSERT(Dim==2,YOU_MADE_A_PROGRAMMING_MISTAKE) return Rotation2D<Scalar>(s).toRotationMatrix(); } template<typename Scalar, int Dim, typename OtherDerived> -inline static Matrix<Scalar,Dim,Dim> ei_toRotationMatrix(const RotationBase<OtherDerived,Dim>& r) +inline static Matrix<Scalar,Dim,Dim> toRotationMatrix(const RotationBase<OtherDerived,Dim>& r) { return r.toRotationMatrix(); } template<typename Scalar, int Dim, typename OtherDerived> -inline static const MatrixBase<OtherDerived>& ei_toRotationMatrix(const MatrixBase<OtherDerived>& mat) +inline static const MatrixBase<OtherDerived>& toRotationMatrix(const MatrixBase<OtherDerived>& 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<typename Derived> - inline typename ei_plain_matrix_type<Derived>::type operator* (const MatrixBase<Derived>& other) const + inline typename internal::plain_matrix_type<Derived>::type operator* (const MatrixBase<Derived>& other) const { return other * m_factor; } template<typename Derived,int Dim> @@ -108,7 +108,7 @@ public: * * \sa MatrixBase::isApprox() */ bool isApprox(const UniformScaling& other, typename NumTraits<Scalar>::Real prec = NumTraits<Scalar>::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<typename Transform> -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<TransformType>::IsProjective> -struct ei_transform_right_product_impl; + bool IsProjective = transform_traits<TransformType>::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<Lhs>::IsProjective || - ei_transform_traits<Lhs>::IsProjective> -struct ei_transform_transform_product_impl; + transform_traits<Lhs>::IsProjective || + transform_traits<Lhs>::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<typename TransformType> struct transform_take_affine_part; -template<typename TransformType> 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<MatrixType,Dim,Dim> LinearPart; /** type of read/write reference to the affine part of the transformation */ - typedef typename ei_meta_if<int(Mode)==int(AffineCompact), + typedef typename internal::meta_if<int(Mode)==int(AffineCompact), MatrixType&, Block<MatrixType,Dim,HDim> >::ret AffinePart; /** type of read/write reference to the affine part of the transformation */ - typedef typename ei_meta_if<int(Mode)==int(AffineCompact), + typedef typename internal::meta_if<int(Mode)==int(AffineCompact), MatrixType&, Block<MatrixType,Dim,HDim> >::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<Transform> take_affine_part; + typedef internal::transform_take_affine_part<Transform> take_affine_part; /** Constructs and initializes a transformation from a Dim^2 or a (Dim+1)^2 matrix. */ template<typename OtherDerived> inline explicit Transform(const EigenBase<OtherDerived>& other) { - ei_transform_construct_from_matrix<OtherDerived,Mode,Dim,HDim>::run(this, other.derived()); + internal::transform_construct_from_matrix<OtherDerived,Mode,Dim,HDim>::run(this, other.derived()); } /** Set \c *this from a Dim^2 or (Dim+1)^2 matrix. */ template<typename OtherDerived> inline Transform& operator=(const EigenBase<OtherDerived>& other) { - ei_transform_construct_from_matrix<OtherDerived,Mode,Dim,HDim>::run(this, other.derived()); + internal::transform_construct_from_matrix<OtherDerived,Mode,Dim,HDim>::run(this, other.derived()); return *this; } @@ -280,7 +284,7 @@ public: else if(OtherModeIsAffineCompact) { typedef typename Transform<Scalar,Dim,OtherMode>::MatrixType OtherMatrixType; - ei_transform_construct_from_matrix<OtherMatrixType,Mode,Dim,HDim>::run(this, other.matrix()); + internal::transform_construct_from_matrix<OtherMatrixType,Mode,Dim,HDim>::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<typename OtherDerived> - EIGEN_STRONG_INLINE const typename ei_transform_right_product_impl<Transform, OtherDerived>::ResultType + EIGEN_STRONG_INLINE const typename internal::transform_right_product_impl<Transform, OtherDerived>::ResultType operator * (const EigenBase<OtherDerived> &other) const - { return ei_transform_right_product_impl<Transform, OtherDerived>::run(*this,other.derived()); } + { return internal::transform_right_product_impl<Transform, OtherDerived>::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<typename OtherDerived> friend - inline const typename ei_transform_left_product_impl<OtherDerived,Mode,_Dim,_Dim+1>::ResultType + inline const typename internal::transform_left_product_impl<OtherDerived,Mode,_Dim,_Dim+1>::ResultType operator * (const EigenBase<OtherDerived> &a, const Transform &b) - { return ei_transform_left_product_impl<OtherDerived,Mode,Dim,HDim>::run(a.derived(),b); } + { return internal::transform_left_product_impl<OtherDerived,Mode,Dim,HDim>::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<Transform,Transform>::run(*this,other); + return internal::transform_transform_product_impl<Transform,Transform>::run(*this,other); } /** Concatenates two different transformations */ template<int OtherMode> - inline const typename ei_transform_transform_product_impl< + inline const typename internal::transform_transform_product_impl< Transform,Transform<Scalar,Dim,OtherMode> >::ResultType operator * (const Transform<Scalar,Dim,OtherMode>& other) const { - return ei_transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode> >::run(*this,other); + return internal::transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode> >::run(*this,other); } /** \sa MatrixBase::setIdentity() */ @@ -495,8 +499,8 @@ public: * then this function smartly returns a const reference to \c *this. */ template<typename NewScalarType> - inline typename ei_cast_return_type<Transform,Transform<NewScalarType,Dim,Mode> >::type cast() const - { return typename ei_cast_return_type<Transform,Transform<NewScalarType,Dim,Mode> >::type(*this); } + inline typename internal::cast_return_type<Transform,Transform<NewScalarType,Dim,Mode> >::type cast() const + { return typename internal::cast_return_type<Transform,Transform<NewScalarType,Dim,Mode> >::type(*this); } /** Copy constructor with scalar type conversion */ template<typename OtherScalarType> @@ -765,7 +769,7 @@ Transform<Scalar,Dim,Mode>::pretranslate(const MatrixBase<OtherDerived> &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<typename RotationType> Transform<Scalar,Dim,Mode>& Transform<Scalar,Dim,Mode>::rotate(const RotationType& rotation) { - linearExt() *= ei_toRotationMatrix<Scalar,Dim>(rotation); + linearExt() *= internal::toRotationMatrix<Scalar,Dim>(rotation); return *this; } @@ -799,7 +803,7 @@ template<typename RotationType> Transform<Scalar,Dim,Mode>& Transform<Scalar,Dim,Mode>::prerotate(const RotationType& rotation) { - m_matrix.template block<Dim,HDim>(0,0) = ei_toRotationMatrix<Scalar,Dim>(rotation) + m_matrix.template block<Dim,HDim>(0,0) = internal::toRotationMatrix<Scalar,Dim>(rotation) * m_matrix.template block<Dim,HDim>(0,0); return *this; } @@ -877,7 +881,7 @@ template<typename Scalar, int Dim, int Mode> template<typename Derived> inline Transform<Scalar,Dim,Mode>& Transform<Scalar,Dim,Mode>::operator=(const RotationBase<Derived,Dim>& r) { - linear() = ei_toRotationMatrix<Scalar,Dim>(r); + linear() = internal::toRotationMatrix<Scalar,Dim>(r); translation().setZero(); makeAffine(); return *this; @@ -980,23 +984,25 @@ Transform<Scalar,Dim,Mode>& Transform<Scalar,Dim,Mode>::fromPositionOrientationScale(const MatrixBase<PositionDerived> &position, const OrientationType& orientation, const MatrixBase<ScaleDerived> &scale) { - linear() = ei_toRotationMatrix<Scalar,Dim>(orientation); + linear() = internal::toRotationMatrix<Scalar,Dim>(orientation); linear() *= scale.asDiagonal(); translation() = position; makeAffine(); return *this; } +namespace internal { + // selector needed to avoid taking the inverse of a 3x4 matrix template<typename TransformType, int Mode=TransformType::Mode> -struct ei_projective_transform_inverse +struct projective_transform_inverse { static inline void run(const TransformType&, TransformType&) {} }; template<typename TransformType> -struct ei_projective_transform_inverse<TransformType, Projective> +struct projective_transform_inverse<TransformType, Projective> { static inline void run(const TransformType& m, TransformType& res) { @@ -1004,6 +1010,8 @@ struct ei_projective_transform_inverse<TransformType, Projective> } }; +} // end namespace internal + /** * @@ -1031,7 +1039,7 @@ Transform<Scalar,Dim,Mode>::inverse(TransformTraits hint) const Transform res; if (hint == Projective) { - ei_projective_transform_inverse<Transform>::run(*this, res); + internal::projective_transform_inverse<Transform>::run(*this, res); } else { @@ -1045,7 +1053,7 @@ Transform<Scalar,Dim,Mode>::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<Dim,1>() @@ -1055,11 +1063,13 @@ Transform<Scalar,Dim,Mode>::inverse(TransformTraits hint) const return res; } +namespace internal { + /***************************************************** *** Specializations of take affine part *** *****************************************************/ -template<typename TransformType> struct ei_transform_take_affine_part { +template<typename TransformType> 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<typename TransformType> struct ei_transform_take_affine_part { }; template<typename Scalar, int Dim> -struct ei_transform_take_affine_part<Transform<Scalar,Dim,AffineCompact> > { +struct transform_take_affine_part<Transform<Scalar,Dim,AffineCompact> > { typedef typename Transform<Scalar,Dim,AffineCompact>::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<Transform<Scalar,Dim,AffineCompact> > { *****************************************************/ template<typename Other, int Mode, int Dim, int HDim> -struct ei_transform_construct_from_matrix<Other, Mode,Dim,HDim, Dim,Dim> +struct transform_construct_from_matrix<Other, Mode,Dim,HDim, Dim,Dim> { static inline void run(Transform<typename Other::Scalar,Dim,Mode> *transform, const Other& other) { @@ -1091,7 +1101,7 @@ struct ei_transform_construct_from_matrix<Other, Mode,Dim,HDim, Dim,Dim> }; template<typename Other, int Mode, int Dim, int HDim> -struct ei_transform_construct_from_matrix<Other, Mode,Dim,HDim, Dim,HDim> +struct transform_construct_from_matrix<Other, Mode,Dim,HDim, Dim,HDim> { static inline void run(Transform<typename Other::Scalar,Dim,Mode> *transform, const Other& other) { @@ -1101,14 +1111,14 @@ struct ei_transform_construct_from_matrix<Other, Mode,Dim,HDim, Dim,HDim> }; template<typename Other, int Mode, int Dim, int HDim> -struct ei_transform_construct_from_matrix<Other, Mode,Dim,HDim, HDim,HDim> +struct transform_construct_from_matrix<Other, Mode,Dim,HDim, HDim,HDim> { static inline void run(Transform<typename Other::Scalar,Dim,Mode> *transform, const Other& other) { transform->matrix() = other; } }; template<typename Other, int Dim, int HDim> -struct ei_transform_construct_from_matrix<Other, AffineCompact,Dim,HDim, HDim,HDim> +struct transform_construct_from_matrix<Other, AffineCompact,Dim,HDim, HDim,HDim> { static inline void run(Transform<typename Other::Scalar,Dim,AffineCompact> *transform, const Other& other) { transform->matrix() = other.template block<Dim,HDim>(0,0); } @@ -1119,7 +1129,7 @@ struct ei_transform_construct_from_matrix<Other, AffineCompact,Dim,HDim, HDim,HD **********************************************************/ template<int LhsMode,int RhsMode> -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<typename Other,int Mode, int Dim, int HDim> -struct ei_transform_left_product_impl<Other,Mode,Dim,HDim, HDim,HDim> +struct transform_left_product_impl<Other,Mode,Dim,HDim, HDim,HDim> { typedef Transform<typename Other::Scalar,Dim,Mode> TransformType; typedef typename TransformType::MatrixType MatrixType; @@ -1192,7 +1202,7 @@ struct ei_transform_left_product_impl<Other,Mode,Dim,HDim, HDim,HDim> // generic HDim x HDim matrix * AffineCompact => Projective template<typename Other, int Dim, int HDim> -struct ei_transform_left_product_impl<Other,AffineCompact,Dim,HDim, HDim,HDim> +struct transform_left_product_impl<Other,AffineCompact,Dim,HDim, HDim,HDim> { typedef Transform<typename Other::Scalar,Dim,AffineCompact> TransformType; typedef typename TransformType::MatrixType MatrixType; @@ -1208,7 +1218,7 @@ struct ei_transform_left_product_impl<Other,AffineCompact,Dim,HDim, HDim,HDim> // affine matrix * T template<typename Other,int Mode, int Dim, int HDim> -struct ei_transform_left_product_impl<Other,Mode,Dim,HDim, Dim,HDim> +struct transform_left_product_impl<Other,Mode,Dim,HDim, Dim,HDim> { typedef Transform<typename Other::Scalar,Dim,Mode> TransformType; typedef typename TransformType::MatrixType MatrixType; @@ -1224,7 +1234,7 @@ struct ei_transform_left_product_impl<Other,Mode,Dim,HDim, Dim,HDim> // affine matrix * AffineCompact template<typename Other, int Dim, int HDim> -struct ei_transform_left_product_impl<Other,AffineCompact,Dim,HDim, Dim,HDim> +struct transform_left_product_impl<Other,AffineCompact,Dim,HDim, Dim,HDim> { typedef Transform<typename Other::Scalar,Dim,AffineCompact> TransformType; typedef typename TransformType::MatrixType MatrixType; @@ -1240,7 +1250,7 @@ struct ei_transform_left_product_impl<Other,AffineCompact,Dim,HDim, Dim,HDim> // linear matrix * T template<typename Other,int Mode, int Dim, int HDim> -struct ei_transform_left_product_impl<Other,Mode,Dim,HDim, Dim,Dim> +struct transform_left_product_impl<Other,Mode,Dim,HDim, Dim,Dim> { typedef Transform<typename Other::Scalar,Dim,Mode> TransformType; typedef typename TransformType::MatrixType MatrixType; @@ -1261,9 +1271,9 @@ struct ei_transform_left_product_impl<Other,Mode,Dim,HDim, Dim,Dim> **********************************************************/ template<typename Scalar, int Dim, int LhsMode, int RhsMode> -struct ei_transform_transform_product_impl<Transform<Scalar,Dim,LhsMode>,Transform<Scalar,Dim,RhsMode>,false > +struct transform_transform_product_impl<Transform<Scalar,Dim,LhsMode>,Transform<Scalar,Dim,RhsMode>,false > { - enum { ResultMode = ei_transform_product_result<LhsMode,RhsMode>::Mode }; + enum { ResultMode = transform_product_result<LhsMode,RhsMode>::Mode }; typedef Transform<Scalar,Dim,LhsMode> Lhs; typedef Transform<Scalar,Dim,RhsMode> Rhs; typedef Transform<Scalar,Dim,ResultMode> ResultType; @@ -1278,7 +1288,7 @@ struct ei_transform_transform_product_impl<Transform<Scalar,Dim,LhsMode>,Transfo }; template<typename Scalar, int Dim, int LhsMode, int RhsMode> -struct ei_transform_transform_product_impl<Transform<Scalar,Dim,LhsMode>,Transform<Scalar,Dim,RhsMode>,true > +struct transform_transform_product_impl<Transform<Scalar,Dim,LhsMode>,Transform<Scalar,Dim,RhsMode>,true > { typedef Transform<Scalar,Dim,LhsMode> Lhs; typedef Transform<Scalar,Dim,RhsMode> Rhs; @@ -1289,4 +1299,6 @@ struct ei_transform_transform_product_impl<Transform<Scalar,Dim,LhsMode>,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<typename NewScalarType> - inline typename ei_cast_return_type<Translation,Translation<NewScalarType,Dim> >::type cast() const - { return typename ei_cast_return_type<Translation,Translation<NewScalarType,Dim> >::type(*this); } + inline typename internal::cast_return_type<Translation,Translation<NewScalarType,Dim> >::type cast() const + { return typename internal::cast_return_type<Translation,Translation<NewScalarType,Dim> >::type(*this); } /** Copy constructor with scalar type conversion */ template<typename OtherScalarType> 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<typename MatrixType, typename OtherMatrixType> +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<typename MatrixType, typename OtherMatrixType> - 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<typename ei_traits<MatrixType>::Scalar, - HomogeneousDimension, - HomogeneousDimension, - AutoAlign | (ei_traits<MatrixType>::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<typename traits<MatrixType>::Scalar, + HomogeneousDimension, + HomogeneousDimension, + AutoAlign | (traits<MatrixType>::Flags & RowMajorBit ? RowMajor : ColMajor), + HomogeneousDimension, + HomogeneousDimension + > type; +}; + } #endif @@ -103,23 +104,23 @@ namespace * Eigen::Matrix. */ template <typename Derived, typename OtherDerived> -typename ei_umeyama_transform_matrix_type<Derived, OtherDerived>::type +typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type umeyama(const MatrixBase<Derived>& src, const MatrixBase<OtherDerived>& dst, bool with_scaling = true) { - typedef typename ei_umeyama_transform_matrix_type<Derived, OtherDerived>::type TransformationMatrixType; - typedef typename ei_traits<TransformationMatrixType>::Scalar Scalar; + typedef typename internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type TransformationMatrixType; + typedef typename internal::traits<TransformationMatrixType>::Scalar Scalar; typedef typename NumTraits<Scalar>::Real RealScalar; typedef typename Derived::Index Index; EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL) - EIGEN_STATIC_ASSERT((ei_is_same_type<Scalar, typename ei_traits<OtherDerived>::Scalar>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type<Scalar, typename internal::traits<OtherDerived>::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<Scalar, Dimension, 1> VectorType; typedef Matrix<Scalar, Dimension, Dimension> MatrixType; - typedef typename ei_plain_matrix_type_row_major<Derived>::type RowMajorMatrixType; + typedef typename internal::plain_matrix_type_row_major<Derived>::type RowMajorMatrixType; const Index m = src.rows(); // dimension const Index n = src.cols(); // number of measurements @@ -152,7 +153,7 @@ umeyama(const MatrixBase<Derived>& src, const MatrixBase<OtherDerived>& dst, boo // Eq. (40) and (43) const VectorType& d = svd.singularValues(); - Index rank = 0; for (Index i=0; i<m; ++i) if (!ei_isMuchSmallerThan(d.coeff(i),d.coeff(0))) ++rank; + Index rank = 0; for (Index i=0; i<m; ++i) if (!internal::isMuchSmallerThan(d.coeff(i),d.coeff(0))) ++rank; if (rank == m-1) { if ( svd.matrixU().determinant() * svd.matrixV().determinant() > 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<class Derived, class OtherDerived> -struct ei_quat_product<Architecture::SSE, Derived, OtherDerived, float, Aligned> +struct quat_product<Architecture::SSE, Derived, OtherDerived, float, Aligned> { inline static Quaternion<float> run(const QuaternionBase<Derived>& _a, const QuaternionBase<OtherDerived>& _b) { @@ -35,31 +37,31 @@ struct ei_quat_product<Architecture::SSE, Derived, OtherDerived, float, Aligned> Quaternion<float> res; __m128 a = _a.coeffs().template packet<Aligned>(0); __m128 b = _b.coeffs().template packet<Aligned>(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<typename VectorLhs,typename VectorRhs> -struct ei_cross3_impl<Architecture::SSE,VectorLhs,VectorRhs,float,true> +struct cross3_impl<Architecture::SSE,VectorLhs,VectorRhs,float,true> { - inline static typename ei_plain_matrix_type<VectorLhs>::type + inline static typename plain_matrix_type<VectorLhs>::type run(const VectorLhs& lhs, const VectorRhs& rhs) { __m128 a = lhs.template packet<VectorLhs::Flags&AlignedBit ? Aligned : Unaligned>(0); __m128 b = rhs.template packet<VectorRhs::Flags&AlignedBit ? Aligned : Unaligned>(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<VectorLhs>::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<VectorLhs>::type res; + pstore(&res.x(),_mm_sub_ps(mul1,mul2)); return res; } }; @@ -68,7 +70,7 @@ struct ei_cross3_impl<Architecture::SSE,VectorLhs,VectorRhs,float,true> template<class Derived, class OtherDerived> -struct ei_quat_product<Architecture::SSE, Derived, OtherDerived, double, Aligned> +struct quat_product<Architecture::SSE, Derived, OtherDerived, double, Aligned> { inline static Quaternion<double> run(const QuaternionBase<Derived>& _a, const QuaternionBase<OtherDerived>& _b) { @@ -79,10 +81,10 @@ struct ei_quat_product<Architecture::SSE, Derived, OtherDerived, double, Aligned const double* a = _a.coeffs().data(); Packet2d b_xy = _b.coeffs().template packet<Aligned>(0); Packet2d b_zw = _b.coeffs().template packet<Aligned>(2); - Packet2d a_xx = ei_pset1<Packet2d>(a[0]); - Packet2d a_yy = ei_pset1<Packet2d>(a[1]); - Packet2d a_zz = ei_pset1<Packet2d>(a[2]); - Packet2d a_ww = ei_pset1<Packet2d>(a[3]); + Packet2d a_xx = pset1<Packet2d>(a[0]); + Packet2d a_yy = pset1<Packet2d>(a[1]); + Packet2d a_zz = pset1<Packet2d>(a[2]); + Packet2d a_ww = pset1<Packet2d>(a[3]); // two temporaries: Packet2d t1, t2; @@ -92,13 +94,13 @@ struct ei_quat_product<Architecture::SSE, Derived, OtherDerived, double, Aligned * t2 = zz*xy - xx*zw * res.xy = t1 +/- swap(t2) */ - t1 = ei_padd(ei_pmul(a_ww, b_xy), ei_pmul(a_yy, b_zw)); - t2 = ei_psub(ei_pmul(a_zz, b_xy), ei_pmul(a_xx, b_zw)); + t1 = padd(pmul(a_ww, b_xy), pmul(a_yy, b_zw)); + t2 = psub(pmul(a_zz, b_xy), pmul(a_xx, b_zw)); #ifdef __SSE3__ EIGEN_UNUSED_VARIABLE(mask) - ei_pstore(&res.x(), _mm_addsub_pd(t1, ei_preverse(t2))); + pstore(&res.x(), _mm_addsub_pd(t1, preverse(t2))); #else - ei_pstore(&res.x(), ei_padd(t1, ei_pxor(mask,ei_preverse(t2)))); + pstore(&res.x(), padd(t1, pxor(mask,preverse(t2)))); #endif /* @@ -106,18 +108,19 @@ struct ei_quat_product<Architecture::SSE, Derived, OtherDerived, double, Aligned * t2 = zz*zw + xx*xy * res.zw = t1 -/+ swap(t2) = swap( swap(t1) +/- t2) */ - t1 = ei_psub(ei_pmul(a_ww, b_zw), ei_pmul(a_yy, b_xy)); - t2 = ei_padd(ei_pmul(a_zz, b_zw), ei_pmul(a_xx, b_xy)); + t1 = psub(pmul(a_ww, b_zw), pmul(a_yy, b_xy)); + t2 = padd(pmul(a_zz, b_zw), pmul(a_xx, b_xy)); #ifdef __SSE3__ EIGEN_UNUSED_VARIABLE(mask) - ei_pstore(&res.z(), ei_preverse(_mm_addsub_pd(ei_preverse(t1), t2))); + pstore(&res.z(), preverse(_mm_addsub_pd(preverse(t1), t2))); #else - ei_pstore(&res.z(), ei_psub(t1, ei_pxor(mask,ei_preverse(t2)))); + pstore(&res.z(), psub(t1, pxor(mask,preverse(t2)))); #endif return res; } }; +} // end namespace internal #endif // EIGEN_GEOMETRY_SSE_H diff --git a/Eigen/src/Householder/BlockHouseholder.h b/Eigen/src/Householder/BlockHouseholder.h index 2868ef2d6..23ce1bfbd 100644 --- a/Eigen/src/Householder/BlockHouseholder.h +++ b/Eigen/src/Householder/BlockHouseholder.h @@ -28,14 +28,16 @@ // This file contains some helper function to deal with block householder reflectors +namespace internal { + /** \internal */ template<typename TriangularFactorType,typename VectorsType,typename CoeffsType> -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<typename MatrixType,typename VectorsType,typename CoeffsType> -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<typename MatrixType::Scalar, TFactorSize, TFactorSize> T(nbVecs,nbVecs); - ei_make_block_householder_triangular_factor(T, vectors, hCoeffs); + make_block_householder_triangular_factor(T, vectors, hCoeffs); const TriangularView<VectorsType, UnitLower>& 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<int n> struct ei_decrement_size +namespace internal { +template<int n> struct decrement_size { enum { ret = n==Dynamic ? n : n-1 }; }; +} template<typename Derived> void MatrixBase<Derived>::makeHouseholderInPlace(Scalar& tau, RealScalar& beta) { - VectorBlock<Derived, ei_decrement_size<Base::SizeAtCompileTime>::ret> essentialPart(derived(), 1, size()-1); + VectorBlock<Derived, internal::decrement_size<Base::SizeAtCompileTime>::ret> essentialPart(derived(), 1, size()-1); makeHouseholder(essentialPart, tau, beta); } @@ -68,18 +70,18 @@ void MatrixBase<Derived>::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<Derived>::applyHouseholderOnTheLeft( } else { - Map<typename ei_plain_row_type<PlainObject>::type> tmp(workspace,cols()); + Map<typename internal::plain_row_type<PlainObject>::type> tmp(workspace,cols()); Block<Derived, EssentialPart::SizeAtCompileTime, Derived::ColsAtCompileTime> bottom(derived(), 1, 0, rows()-1, cols()); tmp.noalias() = essential.adjoint() * bottom; tmp += this->row(0); @@ -118,7 +120,7 @@ void MatrixBase<Derived>::applyHouseholderOnTheRight( } else { - Map<typename ei_plain_col_type<PlainObject>::type> tmp(workspace,rows()); + Map<typename internal::plain_col_type<PlainObject>::type> tmp(workspace,rows()); Block<Derived, Derived::RowsAtCompileTime, EssentialPart::SizeAtCompileTime> 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<typename VectorsType, typename CoeffsType, int Side> -struct ei_traits<HouseholderSequence<VectorsType,CoeffsType,Side> > +struct traits<HouseholderSequence<VectorsType,CoeffsType,Side> > { typedef typename VectorsType::Scalar Scalar; typedef typename VectorsType::Index Index; typedef typename VectorsType::StorageKind StorageKind; enum { - RowsAtCompileTime = Side==OnTheLeft ? ei_traits<VectorsType>::RowsAtCompileTime - : ei_traits<VectorsType>::ColsAtCompileTime, + RowsAtCompileTime = Side==OnTheLeft ? traits<VectorsType>::RowsAtCompileTime + : traits<VectorsType>::ColsAtCompileTime, ColsAtCompileTime = RowsAtCompileTime, - MaxRowsAtCompileTime = Side==OnTheLeft ? ei_traits<VectorsType>::MaxRowsAtCompileTime - : ei_traits<VectorsType>::MaxColsAtCompileTime, + MaxRowsAtCompileTime = Side==OnTheLeft ? traits<VectorsType>::MaxRowsAtCompileTime + : traits<VectorsType>::MaxColsAtCompileTime, MaxColsAtCompileTime = MaxRowsAtCompileTime, Flags = 0 }; }; template<typename VectorsType, typename CoeffsType, int Side> -struct ei_hseq_side_dependent_impl +struct hseq_side_dependent_impl { typedef Block<VectorsType, Dynamic, 1> EssentialVectorType; typedef HouseholderSequence<VectorsType, CoeffsType, OnTheLeft> HouseholderSequenceType; @@ -80,7 +82,7 @@ struct ei_hseq_side_dependent_impl }; template<typename VectorsType, typename CoeffsType> -struct ei_hseq_side_dependent_impl<VectorsType, CoeffsType, OnTheRight> +struct hseq_side_dependent_impl<VectorsType, CoeffsType, OnTheRight> { typedef Transpose<Block<VectorsType, 1, Dynamic> > EssentialVectorType; typedef HouseholderSequence<VectorsType, CoeffsType, OnTheRight> HouseholderSequenceType; @@ -92,35 +94,37 @@ struct ei_hseq_side_dependent_impl<VectorsType, CoeffsType, OnTheRight> } }; -template<typename OtherScalarType, typename MatrixType> struct ei_matrix_type_times_scalar_type +template<typename OtherScalarType, typename MatrixType> struct matrix_type_times_scalar_type { - typedef typename ei_scalar_product_traits<OtherScalarType, typename MatrixType::Scalar>::ReturnType + typedef typename scalar_product_traits<OtherScalarType, typename MatrixType::Scalar>::ReturnType ResultScalar; typedef Matrix<ResultScalar, MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime, 0, MatrixType::MaxRowsAtCompileTime, MatrixType::MaxColsAtCompileTime> Type; }; +} // end namespace internal + template<typename VectorsType, typename CoeffsType, int Side> class HouseholderSequence : public EigenBase<HouseholderSequence<VectorsType,CoeffsType,Side> > { enum { - RowsAtCompileTime = ei_traits<HouseholderSequence>::RowsAtCompileTime, - ColsAtCompileTime = ei_traits<HouseholderSequence>::ColsAtCompileTime, - MaxRowsAtCompileTime = ei_traits<HouseholderSequence>::MaxRowsAtCompileTime, - MaxColsAtCompileTime = ei_traits<HouseholderSequence>::MaxColsAtCompileTime + RowsAtCompileTime = internal::traits<HouseholderSequence>::RowsAtCompileTime, + ColsAtCompileTime = internal::traits<HouseholderSequence>::ColsAtCompileTime, + MaxRowsAtCompileTime = internal::traits<HouseholderSequence>::MaxRowsAtCompileTime, + MaxColsAtCompileTime = internal::traits<HouseholderSequence>::MaxColsAtCompileTime }; - typedef typename ei_traits<HouseholderSequence>::Scalar Scalar; + typedef typename internal::traits<HouseholderSequence>::Scalar Scalar; typedef typename VectorsType::Index Index; - typedef typename ei_hseq_side_dependent_impl<VectorsType,CoeffsType,Side>::EssentialVectorType + typedef typename internal::hseq_side_dependent_impl<VectorsType,CoeffsType,Side>::EssentialVectorType EssentialVectorType; public: typedef HouseholderSequence< VectorsType, - typename ei_meta_if<NumTraits<Scalar>::IsComplex, - typename ei_cleantype<typename CoeffsType::ConjugateReturnType>::type, + typename internal::meta_if<NumTraits<Scalar>::IsComplex, + typename internal::cleantype<typename CoeffsType::ConjugateReturnType>::type, CoeffsType>::ret, Side > ConjugateReturnType; @@ -141,8 +145,8 @@ template<typename VectorsType, typename CoeffsType, int Side> class HouseholderS const EssentialVectorType essentialVector(Index k) const { - ei_assert(k >= 0 && k < m_actualVectors); - return ei_hseq_side_dependent_impl<VectorsType,CoeffsType,Side>::essentialVector(*this, k); + eigen_assert(k >= 0 && k < m_actualVectors); + return internal::hseq_side_dependent_impl<VectorsType,CoeffsType,Side>::essentialVector(*this, k); } HouseholderSequence transpose() const @@ -163,8 +167,8 @@ template<typename VectorsType, typename CoeffsType, int Side> class HouseholderS // FIXME find a way to pass this temporary if the user want to Matrix<Scalar, DestType::RowsAtCompileTime, 1, AutoAlign|ColMajor, DestType::MaxRowsAtCompileTime, 1> temp(rows()); - if( ei_is_same_type<typename ei_cleantype<VectorsType>::type,DestType>::ret - && ei_extract_data(dst) == ei_extract_data(m_vectors)) + if( internal::is_same_type<typename internal::cleantype<VectorsType>::type,DestType>::ret + && internal::extract_data(dst) == internal::extract_data(m_vectors)) { // in-place dst.diagonal().setOnes(); @@ -227,24 +231,24 @@ template<typename VectorsType, typename CoeffsType, int Side> class HouseholderS } template<typename OtherDerived> - typename ei_matrix_type_times_scalar_type<Scalar, OtherDerived>::Type operator*(const MatrixBase<OtherDerived>& other) const + typename internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::Type operator*(const MatrixBase<OtherDerived>& other) const { - typename ei_matrix_type_times_scalar_type<Scalar, OtherDerived>::Type - res(other.template cast<typename ei_matrix_type_times_scalar_type<Scalar, OtherDerived>::ResultScalar>()); + typename internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::Type + res(other.template cast<typename internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::ResultScalar>()); applyThisOnTheLeft(res); return res; } template<typename OtherDerived> friend - typename ei_matrix_type_times_scalar_type<Scalar, OtherDerived>::Type operator*(const MatrixBase<OtherDerived>& other, const HouseholderSequence& h) + typename internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::Type operator*(const MatrixBase<OtherDerived>& other, const HouseholderSequence& h) { - typename ei_matrix_type_times_scalar_type<Scalar, OtherDerived>::Type - res(other.template cast<typename ei_matrix_type_times_scalar_type<Scalar, OtherDerived>::ResultScalar>()); + typename internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::Type + res(other.template cast<typename internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::ResultScalar>()); h.applyThisOnTheRight(res); return res; } - template<typename _VectorsType, typename _CoeffsType, int _Side> friend struct ei_hseq_side_dependent_impl; + template<typename _VectorsType, typename _CoeffsType, int _Side> 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<typename Scalar> 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<typename Derived> bool makeJacobi(const MatrixBase<Derived>&, typename Derived::Index p, typename Derived::Index q); @@ -80,8 +80,8 @@ template<typename Scalar> 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<Scalar>::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<Scalar>::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<typename Scalar> template<typename Derived> inline bool JacobiRotation<Scalar>::makeJacobi(const MatrixBase<Derived>& 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<Scalar>::makeJacobi(const MatrixBase<Derived>& m, typ template<typename Scalar> void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* z) { - makeGivens(p, q, z, typename ei_meta_if<NumTraits<Scalar>::IsComplex, ei_meta_true, ei_meta_false>::ret()); + makeGivens(p, q, z, typename internal::meta_if<NumTraits<Scalar>::IsComplex, internal::meta_true, internal::meta_false>::ret()); } // specialization for complexes template<typename Scalar> -void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, ei_meta_true) +void JacobiRotation<Scalar>::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)<RealScalar(0)) + RealScalar u = internal::sqrt(RealScalar(1) + q2/p2); + if(internal::real(p)<RealScalar(0)) u = -u; m_c = Scalar(1)/u; - m_s = -qs*ei_conj(ps)*(m_c/p2); + m_s = -qs*internal::conj(ps)*(m_c/p2); if(r) *r = p * u; } else { Scalar ps = p / q1; - RealScalar p2 = ei_abs2(ps); + RealScalar p2 = internal::abs2(ps); Scalar qs = q / q1; - RealScalar q2 = ei_abs2(qs); + RealScalar q2 = internal::abs2(qs); - RealScalar u = q1 * ei_sqrt(p2 + q2); - if(ei_real(p)<RealScalar(0)) + RealScalar u = q1 * internal::sqrt(p2 + q2); + if(internal::real(p)<RealScalar(0)) u = -u; - p1 = ei_abs(p); + p1 = internal::abs(p); ps = p/p1; m_c = p1/u; - m_s = -ei_conj(ps) * (q/u); + m_s = -internal::conj(ps) * (q/u); if(r) *r = ps * u; } } @@ -218,25 +218,25 @@ void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar // specialization for reals template<typename Scalar> -void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, ei_meta_false) +void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::meta_false) { if(q==0) { m_c = p<Scalar(0) ? Scalar(-1) : Scalar(1); m_s = 0; - if(r) *r = ei_abs(p); + if(r) *r = internal::abs(p); } else if(p==0) { m_c = 0; m_s = q<Scalar(0) ? Scalar(1) : Scalar(-1); - if(r) *r = ei_abs(q); + if(r) *r = internal::abs(q); } - else if(ei_abs(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<Scalar(0)) u = -u; m_c = Scalar(1)/u; @@ -246,7 +246,7 @@ void JacobiRotation<Scalar>::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<Scalar(0)) u = -u; m_s = -Scalar(1)/u; @@ -266,14 +266,16 @@ void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar * * \sa MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight() */ +namespace internal { template<typename VectorX, typename VectorY, typename OtherScalar> -void ei_apply_rotation_in_the_plane(VectorX& _x, VectorY& _y, const JacobiRotation<OtherScalar>& j); +void apply_rotation_in_the_plane(VectorX& _x, VectorY& _y, const JacobiRotation<OtherScalar>& 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<typename Derived> template<typename OtherScalar> @@ -281,14 +283,14 @@ inline void MatrixBase<Derived>::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<typename Derived> template<typename OtherScalar> @@ -296,18 +298,18 @@ inline void MatrixBase<Derived>::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<typename VectorX, typename VectorY, typename OtherScalar> -void /*EIGEN_DONT_INLINE*/ ei_apply_rotation_in_the_plane(VectorX& _x, VectorY& _y, const JacobiRotation<OtherScalar>& j) +void /*EIGEN_DONT_INLINE*/ apply_rotation_in_the_plane(VectorX& _x, VectorY& _y, const JacobiRotation<OtherScalar>& j) { typedef typename VectorX::Index Index; typedef typename VectorX::Scalar Scalar; - enum { PacketSize = ei_packet_traits<Scalar>::size }; - typedef typename ei_packet_traits<Scalar>::type Packet; - ei_assert(_x.size() == _y.size()); + enum { PacketSize = packet_traits<Scalar>::size }; + typedef typename packet_traits<Scalar>::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<Packet>(j.c()); - const Packet ps = ei_pset1<Packet>(j.s()); - ei_conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex,false> pcj; + const Packet pc = pset1<Packet>(j.c()); + const Packet ps = pset1<Packet>(j.s()); + conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex,false> pcj; for(Index i=0; i<alignedStart; ++i) { 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; } Scalar* EIGEN_RESTRICT px = x + alignedStart; Scalar* EIGEN_RESTRICT py = y + alignedStart; - if(ei_first_aligned(x, size)==alignedStart) + if(first_aligned(x, size)==alignedStart) { for(Index i=alignedStart; i<alignedEnd; i+=PacketSize) { - Packet xi = ei_pload<Packet>(px); - Packet yi = ei_pload<Packet>(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<Packet>(px); + Packet yi = pload<Packet>(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<peelingEnd; i+=Peeling*PacketSize) { - Packet xi = ei_ploadu<Packet>(px); - Packet xi1 = ei_ploadu<Packet>(px+PacketSize); - Packet yi = ei_pload <Packet>(py); - Packet yi1 = ei_pload <Packet>(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<Packet>(px); + Packet xi1 = ploadu<Packet>(px+PacketSize); + Packet yi = pload <Packet>(py); + Packet yi1 = pload <Packet>(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<Packet>(x+peelingEnd); - Packet yi = ei_pload <Packet>(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<Packet>(x+peelingEnd); + Packet yi = pload <Packet>(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<Packet>(j.c()); - const Packet ps = ei_pset1<Packet>(j.s()); - ei_conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex,false> pcj; + const Packet pc = pset1<Packet>(j.c()); + const Packet ps = pset1<Packet>(j.s()); + conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex,false> pcj; Scalar* EIGEN_RESTRICT px = x; Scalar* EIGEN_RESTRICT py = y; for(Index i=0; i<size; i+=PacketSize) { - Packet xi = ei_pload<Packet>(px); - Packet yi = ei_pload<Packet>(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<Packet>(px); + Packet yi = pload<Packet>(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<typename Derived> -inline const typename Derived::Scalar ei_bruteforce_det3_helper +inline const typename Derived::Scalar bruteforce_det3_helper (const MatrixBase<Derived>& 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<typename Derived> -const typename Derived::Scalar ei_bruteforce_det4_helper +const typename Derived::Scalar bruteforce_det4_helper (const MatrixBase<Derived>& 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<typename Derived, int DeterminantType = Derived::RowsAtCompileTime -> struct ei_determinant_impl +> struct determinant_impl { - static inline typename ei_traits<Derived>::Scalar run(const Derived& m) + static inline typename traits<Derived>::Scalar run(const Derived& m) { if(Derived::ColsAtCompileTime==Dynamic && m.rows()==0) - return typename ei_traits<Derived>::Scalar(1); + return typename traits<Derived>::Scalar(1); return m.partialPivLu().determinant(); } }; -template<typename Derived> struct ei_determinant_impl<Derived, 1> +template<typename Derived> struct determinant_impl<Derived, 1> { - static inline typename ei_traits<Derived>::Scalar run(const Derived& m) + static inline typename traits<Derived>::Scalar run(const Derived& m) { return m.coeff(0,0); } }; -template<typename Derived> struct ei_determinant_impl<Derived, 2> +template<typename Derived> struct determinant_impl<Derived, 2> { - static inline typename ei_traits<Derived>::Scalar run(const Derived& m) + static inline typename traits<Derived>::Scalar run(const Derived& m) { return m.coeff(0,0) * m.coeff(1,1) - m.coeff(1,0) * m.coeff(0,1); } }; -template<typename Derived> struct ei_determinant_impl<Derived, 3> +template<typename Derived> struct determinant_impl<Derived, 3> { - static inline typename ei_traits<Derived>::Scalar run(const Derived& m) + static inline typename traits<Derived>::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<typename Derived> struct ei_determinant_impl<Derived, 4> +template<typename Derived> struct determinant_impl<Derived, 4> { - static typename ei_traits<Derived>::Scalar run(const Derived& m) + static typename traits<Derived>::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<typename Derived> -inline typename ei_traits<Derived>::Scalar MatrixBase<Derived>::determinant() const +inline typename internal::traits<Derived>::Scalar MatrixBase<Derived>::determinant() const { assert(rows() == cols()); - typedef typename ei_nested<Derived,Base::RowsAtCompileTime>::type Nested; - return ei_determinant_impl<typename ei_cleantype<Nested>::type>::run(derived()); + typedef typename internal::nested<Derived,Base::RowsAtCompileTime>::type Nested; + return internal::determinant_impl<typename internal::cleantype<Nested>::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<typename _MatrixType> class FullPivLU }; typedef typename MatrixType::Scalar Scalar; typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar; - typedef typename ei_traits<MatrixType>::StorageKind StorageKind; + typedef typename internal::traits<MatrixType>::StorageKind StorageKind; typedef typename MatrixType::Index Index; - typedef typename ei_plain_row_type<MatrixType, Index>::type IntRowVectorType; - typedef typename ei_plain_col_type<MatrixType, Index>::type IntColVectorType; + typedef typename internal::plain_row_type<MatrixType, Index>::type IntRowVectorType; + typedef typename internal::plain_col_type<MatrixType, Index>::type IntColVectorType; typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime> PermutationQType; typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationPType; @@ -115,7 +115,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> class FullPivLU * * \sa image() */ - inline const ei_kernel_retval<FullPivLU> kernel() const + inline const internal::kernel_retval<FullPivLU> kernel() const { - ei_assert(m_isInitialized && "LU is not initialized."); - return ei_kernel_retval<FullPivLU>(*this); + eigen_assert(m_isInitialized && "LU is not initialized."); + return internal::kernel_retval<FullPivLU>(*this); } /** \returns the image of the matrix, also called its column-space. The columns of the returned matrix @@ -196,11 +196,11 @@ template<typename _MatrixType> class FullPivLU * * \sa kernel() */ - inline const ei_image_retval<FullPivLU> + inline const internal::image_retval<FullPivLU> image(const MatrixType& originalMatrix) const { - ei_assert(m_isInitialized && "LU is not initialized."); - return ei_image_retval<FullPivLU>(*this, originalMatrix); + eigen_assert(m_isInitialized && "LU is not initialized."); + return internal::image_retval<FullPivLU>(*this, originalMatrix); } /** \return a solution x to the equation Ax=b, where A is the matrix of which @@ -223,11 +223,11 @@ template<typename _MatrixType> class FullPivLU * \sa TriangularView::solve(), kernel(), inverse() */ template<typename Rhs> - inline const ei_solve_retval<FullPivLU, Rhs> + inline const internal::solve_retval<FullPivLU, Rhs> solve(const MatrixBase<Rhs>& b) const { - ei_assert(m_isInitialized && "LU is not initialized."); - return ei_solve_retval<FullPivLU, Rhs>(*this, b.derived()); + eigen_assert(m_isInitialized && "LU is not initialized."); + return internal::solve_retval<FullPivLU, Rhs>(*this, b.derived()); } /** \returns the determinant of the matrix of which @@ -245,7 +245,7 @@ template<typename _MatrixType> class FullPivLU * * \sa MatrixBase::determinant() */ - typename ei_traits<MatrixType>::Scalar determinant() const; + typename internal::traits<MatrixType>::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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> class FullPivLU * * \sa MatrixBase::inverse() */ - inline const ei_solve_retval<FullPivLU,typename MatrixType::IdentityReturnType> inverse() const + inline const internal::solve_retval<FullPivLU,typename MatrixType::IdentityReturnType> 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<FullPivLU,typename MatrixType::IdentityReturnType> + 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<FullPivLU,typename MatrixType::IdentityReturnType> (*this, MatrixType::Identity(m_lu.rows(), m_lu.cols())); } @@ -519,10 +519,10 @@ FullPivLU<MatrixType>& FullPivLU<MatrixType>::compute(const MatrixType& matrix) } template<typename MatrixType> -typename ei_traits<MatrixType>::Scalar FullPivLU<MatrixType>::determinant() const +typename internal::traits<MatrixType>::Scalar FullPivLU<MatrixType>::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<MatrixType>::Scalar FullPivLU<MatrixType>::determinant() cons template<typename MatrixType> MatrixType FullPivLU<MatrixType>::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<MatrixType>::reconstructedMatrix() const /********* Implementation of kernel() **************************************************/ +namespace internal { template<typename _MatrixType> -struct ei_kernel_retval<FullPivLU<_MatrixType> > - : ei_kernel_retval_base<FullPivLU<_MatrixType> > +struct kernel_retval<FullPivLU<_MatrixType> > + : kernel_retval_base<FullPivLU<_MatrixType> > { EIGEN_MAKE_KERNEL_HELPERS(FullPivLU<_MatrixType>) @@ -596,9 +597,9 @@ struct ei_kernel_retval<FullPivLU<_MatrixType> > 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<FullPivLU<_MatrixType> > /***** Implementation of image() *****************************************************/ template<typename _MatrixType> -struct ei_image_retval<FullPivLU<_MatrixType> > - : ei_image_retval_base<FullPivLU<_MatrixType> > +struct image_retval<FullPivLU<_MatrixType> > + : image_retval_base<FullPivLU<_MatrixType> > { EIGEN_MAKE_IMAGE_HELPERS(FullPivLU<_MatrixType>) @@ -664,9 +665,9 @@ struct ei_image_retval<FullPivLU<_MatrixType> > 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<FullPivLU<_MatrixType> > /***** Implementation of solve() *****************************************************/ template<typename _MatrixType, typename Rhs> -struct ei_solve_retval<FullPivLU<_MatrixType>, Rhs> - : ei_solve_retval_base<FullPivLU<_MatrixType>, Rhs> +struct solve_retval<FullPivLU<_MatrixType>, Rhs> + : solve_retval_base<FullPivLU<_MatrixType>, Rhs> { EIGEN_MAKE_SOLVE_HELPERS(FullPivLU<_MatrixType>,Rhs) @@ -693,7 +694,7 @@ struct ei_solve_retval<FullPivLU<_MatrixType>, 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<FullPivLU<_MatrixType>, 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<typename MatrixType, typename ResultType, int Size = MatrixType::RowsAtCompileTime> -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<typename MatrixType, typename ResultType, int Size = MatrixType::RowsAtCompileTime> -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<typename MatrixType, typename ResultType> -struct ei_compute_inverse<MatrixType, ResultType, 1> +struct compute_inverse<MatrixType, ResultType, 1> { static inline void run(const MatrixType& matrix, ResultType& result) { @@ -56,7 +58,7 @@ struct ei_compute_inverse<MatrixType, ResultType, 1> }; template<typename MatrixType, typename ResultType> -struct ei_compute_inverse_and_det_with_check<MatrixType, ResultType, 1> +struct compute_inverse_and_det_with_check<MatrixType, ResultType, 1> { static inline void run( const MatrixType& matrix, @@ -67,7 +69,7 @@ struct ei_compute_inverse_and_det_with_check<MatrixType, ResultType, 1> ) { 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<MatrixType, ResultType, 1> ****************************/ template<typename MatrixType, typename ResultType> -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<typename MatrixType, typename ResultType> -struct ei_compute_inverse<MatrixType, ResultType, 2> +struct compute_inverse<MatrixType, ResultType, 2> { 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<typename MatrixType, typename ResultType> -struct ei_compute_inverse_and_det_with_check<MatrixType, ResultType, 2> +struct compute_inverse_and_det_with_check<MatrixType, ResultType, 2> { static inline void run( const MatrixType& matrix, @@ -111,10 +113,10 @@ struct ei_compute_inverse_and_det_with_check<MatrixType, ResultType, 2> { 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<MatrixType, ResultType, 2> ****************************/ template<typename MatrixType, int i, int j> -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<typename MatrixType, typename ResultType> -inline void ei_compute_inverse_size3_helper( +inline void compute_inverse_size3_helper( const MatrixType& matrix, const typename ResultType::Scalar& invdet, const Matrix<typename ResultType::Scalar,3,1>& cofactors_col0, ResultType& result) { result.row(0) = cofactors_col0 * invdet; - result.coeffRef(1,0) = ei_3x3_cofactor<MatrixType,0,1>(matrix) * invdet; - result.coeffRef(1,1) = ei_3x3_cofactor<MatrixType,1,1>(matrix) * invdet; - result.coeffRef(1,2) = ei_3x3_cofactor<MatrixType,2,1>(matrix) * invdet; - result.coeffRef(2,0) = ei_3x3_cofactor<MatrixType,0,2>(matrix) * invdet; - result.coeffRef(2,1) = ei_3x3_cofactor<MatrixType,1,2>(matrix) * invdet; - result.coeffRef(2,2) = ei_3x3_cofactor<MatrixType,2,2>(matrix) * invdet; + result.coeffRef(1,0) = cofactor_3x3<MatrixType,0,1>(matrix) * invdet; + result.coeffRef(1,1) = cofactor_3x3<MatrixType,1,1>(matrix) * invdet; + result.coeffRef(1,2) = cofactor_3x3<MatrixType,2,1>(matrix) * invdet; + result.coeffRef(2,0) = cofactor_3x3<MatrixType,0,2>(matrix) * invdet; + result.coeffRef(2,1) = cofactor_3x3<MatrixType,1,2>(matrix) * invdet; + result.coeffRef(2,2) = cofactor_3x3<MatrixType,2,2>(matrix) * invdet; } template<typename MatrixType, typename ResultType> -struct ei_compute_inverse<MatrixType, ResultType, 3> +struct compute_inverse<MatrixType, ResultType, 3> { static inline void run(const MatrixType& matrix, ResultType& result) { typedef typename ResultType::Scalar Scalar; Matrix<Scalar,3,1> cofactors_col0; - cofactors_col0.coeffRef(0) = ei_3x3_cofactor<MatrixType,0,0>(matrix); - cofactors_col0.coeffRef(1) = ei_3x3_cofactor<MatrixType,1,0>(matrix); - cofactors_col0.coeffRef(2) = ei_3x3_cofactor<MatrixType,2,0>(matrix); + cofactors_col0.coeffRef(0) = cofactor_3x3<MatrixType,0,0>(matrix); + cofactors_col0.coeffRef(1) = cofactor_3x3<MatrixType,1,0>(matrix); + cofactors_col0.coeffRef(2) = cofactor_3x3<MatrixType,2,0>(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<typename MatrixType, typename ResultType> -struct ei_compute_inverse_and_det_with_check<MatrixType, ResultType, 3> +struct compute_inverse_and_det_with_check<MatrixType, ResultType, 3> { static inline void run( const MatrixType& matrix, @@ -180,14 +182,14 @@ struct ei_compute_inverse_and_det_with_check<MatrixType, ResultType, 3> { typedef typename ResultType::Scalar Scalar; Matrix<Scalar,3,1> cofactors_col0; - cofactors_col0.coeffRef(0) = ei_3x3_cofactor<MatrixType,0,0>(matrix); - cofactors_col0.coeffRef(1) = ei_3x3_cofactor<MatrixType,1,0>(matrix); - cofactors_col0.coeffRef(2) = ei_3x3_cofactor<MatrixType,2,0>(matrix); + cofactors_col0.coeffRef(0) = cofactor_3x3<MatrixType,0,0>(matrix); + cofactors_col0.coeffRef(1) = cofactor_3x3<MatrixType,1,0>(matrix); + cofactors_col0.coeffRef(2) = cofactor_3x3<MatrixType,2,0>(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<MatrixType, ResultType, 3> ****************************/ template<typename Derived> -inline const typename Derived::Scalar ei_general_det3_helper +inline const typename Derived::Scalar general_det3_helper (const MatrixBase<Derived>& 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<typename MatrixType, int i, int j> -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<int Arch, typename Scalar, typename MatrixType, typename ResultType> -struct ei_compute_inverse_size4 +struct compute_inverse_size4 { static void run(const MatrixType& matrix, ResultType& result) { - result.coeffRef(0,0) = ei_4x4_cofactor<MatrixType,0,0>(matrix); - result.coeffRef(1,0) = -ei_4x4_cofactor<MatrixType,0,1>(matrix); - result.coeffRef(2,0) = ei_4x4_cofactor<MatrixType,0,2>(matrix); - result.coeffRef(3,0) = -ei_4x4_cofactor<MatrixType,0,3>(matrix); - result.coeffRef(0,2) = ei_4x4_cofactor<MatrixType,2,0>(matrix); - result.coeffRef(1,2) = -ei_4x4_cofactor<MatrixType,2,1>(matrix); - result.coeffRef(2,2) = ei_4x4_cofactor<MatrixType,2,2>(matrix); - result.coeffRef(3,2) = -ei_4x4_cofactor<MatrixType,2,3>(matrix); - result.coeffRef(0,1) = -ei_4x4_cofactor<MatrixType,1,0>(matrix); - result.coeffRef(1,1) = ei_4x4_cofactor<MatrixType,1,1>(matrix); - result.coeffRef(2,1) = -ei_4x4_cofactor<MatrixType,1,2>(matrix); - result.coeffRef(3,1) = ei_4x4_cofactor<MatrixType,1,3>(matrix); - result.coeffRef(0,3) = -ei_4x4_cofactor<MatrixType,3,0>(matrix); - result.coeffRef(1,3) = ei_4x4_cofactor<MatrixType,3,1>(matrix); - result.coeffRef(2,3) = -ei_4x4_cofactor<MatrixType,3,2>(matrix); - result.coeffRef(3,3) = ei_4x4_cofactor<MatrixType,3,3>(matrix); + result.coeffRef(0,0) = cofactor_4x4<MatrixType,0,0>(matrix); + result.coeffRef(1,0) = -cofactor_4x4<MatrixType,0,1>(matrix); + result.coeffRef(2,0) = cofactor_4x4<MatrixType,0,2>(matrix); + result.coeffRef(3,0) = -cofactor_4x4<MatrixType,0,3>(matrix); + result.coeffRef(0,2) = cofactor_4x4<MatrixType,2,0>(matrix); + result.coeffRef(1,2) = -cofactor_4x4<MatrixType,2,1>(matrix); + result.coeffRef(2,2) = cofactor_4x4<MatrixType,2,2>(matrix); + result.coeffRef(3,2) = -cofactor_4x4<MatrixType,2,3>(matrix); + result.coeffRef(0,1) = -cofactor_4x4<MatrixType,1,0>(matrix); + result.coeffRef(1,1) = cofactor_4x4<MatrixType,1,1>(matrix); + result.coeffRef(2,1) = -cofactor_4x4<MatrixType,1,2>(matrix); + result.coeffRef(3,1) = cofactor_4x4<MatrixType,1,3>(matrix); + result.coeffRef(0,3) = -cofactor_4x4<MatrixType,3,0>(matrix); + result.coeffRef(1,3) = cofactor_4x4<MatrixType,3,1>(matrix); + result.coeffRef(2,3) = -cofactor_4x4<MatrixType,3,2>(matrix); + result.coeffRef(3,3) = cofactor_4x4<MatrixType,3,3>(matrix); result /= (matrix.col(0).cwiseProduct(result.row(0).transpose())).sum(); } }; template<typename MatrixType, typename ResultType> -struct ei_compute_inverse<MatrixType, ResultType, 4> - : ei_compute_inverse_size4<Architecture::Target, typename MatrixType::Scalar, +struct compute_inverse<MatrixType, ResultType, 4> + : compute_inverse_size4<Architecture::Target, typename MatrixType::Scalar, MatrixType, ResultType> { }; template<typename MatrixType, typename ResultType> -struct ei_compute_inverse_and_det_with_check<MatrixType, ResultType, 4> +struct compute_inverse_and_det_with_check<MatrixType, ResultType, 4> { static inline void run( const MatrixType& matrix, @@ -263,8 +265,8 @@ struct ei_compute_inverse_and_det_with_check<MatrixType, ResultType, 4> ) { determinant = matrix.determinant(); - invertible = ei_abs(determinant) > absDeterminantThreshold; - if(invertible) ei_compute_inverse<MatrixType, ResultType>::run(matrix, inverse); + invertible = abs(determinant) > absDeterminantThreshold; + if(invertible) compute_inverse<MatrixType, ResultType>::run(matrix, inverse); } }; @@ -273,20 +275,20 @@ struct ei_compute_inverse_and_det_with_check<MatrixType, ResultType, 4> *************************/ template<typename MatrixType> -struct ei_traits<ei_inverse_impl<MatrixType> > +struct traits<inverse_impl<MatrixType> > { typedef typename MatrixType::PlainObject ReturnType; }; template<typename MatrixType> -struct ei_inverse_impl : public ReturnByValue<ei_inverse_impl<MatrixType> > +struct inverse_impl : public ReturnByValue<inverse_impl<MatrixType> > { typedef typename MatrixType::Index Index; - typedef typename ei_eval<MatrixType>::type MatrixTypeNested; - typedef typename ei_cleantype<MatrixTypeNested>::type MatrixTypeNestedCleaned; + typedef typename eval<MatrixType>::type MatrixTypeNested; + typedef typename cleantype<MatrixTypeNested>::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<ei_inverse_impl<MatrixType> > { 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<MatrixTypeNestedCleaned, Dest>::run(m_matrix, dst); + compute_inverse<MatrixTypeNestedCleaned, Dest>::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<ei_inverse_impl<MatrixType> > * \sa computeInverseAndDetWithCheck() */ template<typename Derived> -inline const ei_inverse_impl<Derived> MatrixBase<Derived>::inverse() const +inline const internal::inverse_impl<Derived> MatrixBase<Derived>::inverse() const { EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsInteger,THIS_FUNCTION_IS_NOT_FOR_INTEGER_NUMERIC_TYPES) - ei_assert(rows() == cols()); - return ei_inverse_impl<Derived>(derived()); + eigen_assert(rows() == cols()); + return internal::inverse_impl<Derived>(derived()); } /** \lu_module @@ -357,15 +361,15 @@ inline void MatrixBase<Derived>::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<typename ei_nested<Derived, 2>::type>::type, + typename internal::cleantype<typename internal::nested<Derived, 2>::type>::type, PlainObject >::ret MatrixType; - ei_compute_inverse_and_det_with_check<MatrixType, ResultType>::run + internal::compute_inverse_and_det_with_check<MatrixType, ResultType>::run (derived(), absDeterminantThreshold, inverse, determinant, invertible); } @@ -396,7 +400,7 @@ inline void MatrixBase<Derived>::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<typename _MatrixType> class PartialPivLU }; typedef typename MatrixType::Scalar Scalar; typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar; - typedef typename ei_traits<MatrixType>::StorageKind StorageKind; + typedef typename internal::traits<MatrixType>::StorageKind StorageKind; typedef typename MatrixType::Index Index; typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationType; typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime> TranspositionType; @@ -112,7 +112,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> class PartialPivLU * \sa TriangularView::solve(), inverse(), computeInverse() */ template<typename Rhs> - inline const ei_solve_retval<PartialPivLU, Rhs> + inline const internal::solve_retval<PartialPivLU, Rhs> solve(const MatrixBase<Rhs>& b) const { - ei_assert(m_isInitialized && "PartialPivLU is not initialized."); - return ei_solve_retval<PartialPivLU, Rhs>(*this, b.derived()); + eigen_assert(m_isInitialized && "PartialPivLU is not initialized."); + return internal::solve_retval<PartialPivLU, Rhs>(*this, b.derived()); } /** \returns the inverse of the matrix of which *this is the LU decomposition. @@ -156,10 +156,10 @@ template<typename _MatrixType> class PartialPivLU * * \sa MatrixBase::inverse(), LU::inverse() */ - inline const ei_solve_retval<PartialPivLU,typename MatrixType::IdentityReturnType> inverse() const + inline const internal::solve_retval<PartialPivLU,typename MatrixType::IdentityReturnType> inverse() const { - ei_assert(m_isInitialized && "PartialPivLU is not initialized."); - return ei_solve_retval<PartialPivLU,typename MatrixType::IdentityReturnType> + eigen_assert(m_isInitialized && "PartialPivLU is not initialized."); + return internal::solve_retval<PartialPivLU,typename MatrixType::IdentityReturnType> (*this, MatrixType::Identity(m_lu.rows(), m_lu.cols())); } @@ -176,7 +176,7 @@ template<typename _MatrixType> class PartialPivLU * * \sa MatrixBase::determinant() */ - typename ei_traits<MatrixType>::Scalar determinant() const; + typename internal::traits<MatrixType>::Scalar determinant() const; MatrixType reconstructedMatrix() const; @@ -222,9 +222,11 @@ PartialPivLU<MatrixType>::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<typename Scalar, int StorageOrder> -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<typename MatrixType, typename TranspositionType> -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 <typename MatrixType::Scalar, MatrixType::Flags&RowMajorBit?RowMajor:ColMajor> ::blocked_lu(lu.rows(), lu.cols(), &lu.coeffRef(0,0), lu.outerStride(), &row_transpositions.coeffRef(0), nb_transpositions); } +} // end namespace internal + template<typename MatrixType> PartialPivLU<MatrixType>& PartialPivLU<MatrixType>::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<MatrixType>& PartialPivLU<MatrixType>::compute(const MatrixType& ma } template<typename MatrixType> -typename ei_traits<MatrixType>::Scalar PartialPivLU<MatrixType>::determinant() const +typename internal::traits<MatrixType>::Scalar PartialPivLU<MatrixType>::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<MatrixType>::Scalar PartialPivLU<MatrixType>::determinant() c template<typename MatrixType> MatrixType PartialPivLU<MatrixType>::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<UnitLower>().toDenseMatrix() * m_lu.template triangularView<Upper>(); @@ -446,9 +450,11 @@ MatrixType PartialPivLU<MatrixType>::reconstructedMatrix() const /***** Implementation of solve() *****************************************************/ +namespace internal { + template<typename _MatrixType, typename Rhs> -struct ei_solve_retval<PartialPivLU<_MatrixType>, Rhs> - : ei_solve_retval_base<PartialPivLU<_MatrixType>, Rhs> +struct solve_retval<PartialPivLU<_MatrixType>, Rhs> + : solve_retval_base<PartialPivLU<_MatrixType>, Rhs> { EIGEN_MAKE_SOLVE_HELPERS(PartialPivLU<_MatrixType>,Rhs) @@ -461,7 +467,7 @@ struct ei_solve_retval<PartialPivLU<_MatrixType>, 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<PartialPivLU<_MatrixType>, 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<typename MatrixType, typename ResultType> -struct ei_compute_inverse_size4<Architecture::SSE, float, MatrixType, ResultType> +struct compute_inverse_size4<Architecture::SSE, float, MatrixType, ResultType> { enum { MatrixAlignment = bool(MatrixType::Flags&AlignedBit), @@ -171,7 +173,7 @@ struct ei_compute_inverse_size4<Architecture::SSE, float, MatrixType, ResultType }; template<typename MatrixType, typename ResultType> -struct ei_compute_inverse_size4<Architecture::SSE, double, MatrixType, ResultType> +struct compute_inverse_size4<Architecture::SSE, double, MatrixType, ResultType> { enum { MatrixAlignment = bool(MatrixType::Flags&AlignedBit), @@ -333,4 +335,6 @@ struct ei_compute_inverse_size4<Architecture::SSE, double, MatrixType, ResultTyp } }; +} + #endif // EIGEN_INVERSE_SSE_H diff --git a/Eigen/src/QR/ColPivHouseholderQR.h b/Eigen/src/QR/ColPivHouseholderQR.h index f34658fa9..21ad0febe 100644 --- a/Eigen/src/QR/ColPivHouseholderQR.h +++ b/Eigen/src/QR/ColPivHouseholderQR.h @@ -63,11 +63,11 @@ template<typename _MatrixType> class ColPivHouseholderQR typedef typename MatrixType::RealScalar RealScalar; typedef typename MatrixType::Index Index; typedef Matrix<Scalar, RowsAtCompileTime, RowsAtCompileTime, Options, MaxRowsAtCompileTime, MaxRowsAtCompileTime> MatrixQType; - typedef typename ei_plain_diag_type<MatrixType>::type HCoeffsType; + typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType; typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime> PermutationType; - typedef typename ei_plain_row_type<MatrixType, Index>::type IntRowVectorType; - typedef typename ei_plain_row_type<MatrixType>::type RowVectorType; - typedef typename ei_plain_row_type<MatrixType, RealScalar>::type RealRowVectorType; + typedef typename internal::plain_row_type<MatrixType, Index>::type IntRowVectorType; + typedef typename internal::plain_row_type<MatrixType>::type RowVectorType; + typedef typename internal::plain_row_type<MatrixType, RealScalar>::type RealRowVectorType; typedef typename HouseholderSequence<MatrixType,HCoeffsType>::ConjugateReturnType HouseholderSequenceType; /** @@ -132,11 +132,11 @@ template<typename _MatrixType> class ColPivHouseholderQR * Output: \verbinclude ColPivHouseholderQR_solve.out */ template<typename Rhs> - inline const ei_solve_retval<ColPivHouseholderQR, Rhs> + inline const internal::solve_retval<ColPivHouseholderQR, Rhs> solve(const MatrixBase<Rhs>& b) const { - ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); - return ei_solve_retval<ColPivHouseholderQR, Rhs>(*this, b.derived()); + eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); + return internal::solve_retval<ColPivHouseholderQR, Rhs>(*this, b.derived()); } HouseholderSequenceType householderQ(void) const; @@ -145,7 +145,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> class ColPivHouseholderQR * Use isInvertible() to first determine whether this matrix is invertible. */ inline const - ei_solve_retval<ColPivHouseholderQR, typename MatrixType::IdentityReturnType> + internal::solve_retval<ColPivHouseholderQR, typename MatrixType::IdentityReturnType> inverse() const { - ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); - return ei_solve_retval<ColPivHouseholderQR,typename MatrixType::IdentityReturnType> + eigen_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); + return internal::solve_retval<ColPivHouseholderQR,typename MatrixType::IdentityReturnType> (*this, MatrixType::Identity(m_qr.rows(), m_qr.cols())); } @@ -314,7 +314,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> class ColPivHouseholderQR template<typename MatrixType> typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::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> typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::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<MatrixType>& ColPivHouseholderQR<MatrixType>::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<Scalar>::epsilon()) / rows; + RealScalar threshold_helper = m_colSqNorms.maxCoeff() * internal::abs2(NumTraits<Scalar>::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<MatrixType>& ColPivHouseholderQR<MatrixType>::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<MatrixType>& ColPivHouseholderQR<MatrixType>::compute(const return *this; } +namespace internal { + template<typename _MatrixType, typename Rhs> -struct ei_solve_retval<ColPivHouseholderQR<_MatrixType>, Rhs> - : ei_solve_retval_base<ColPivHouseholderQR<_MatrixType>, Rhs> +struct solve_retval<ColPivHouseholderQR<_MatrixType>, Rhs> + : solve_retval_base<ColPivHouseholderQR<_MatrixType>, Rhs> { EIGEN_MAKE_SOLVE_HELPERS(ColPivHouseholderQR<_MatrixType>,Rhs) template<typename Dest> 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<ColPivHouseholderQR<_MatrixType>, Rhs> } }; +} // end namespace internal + /** \returns the matrix Q as a sequence of householder transformations */ template<typename MatrixType> typename ColPivHouseholderQR<MatrixType>::HouseholderSequenceType ColPivHouseholderQR<MatrixType> ::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<typename _MatrixType> class FullPivHouseholderQR typedef typename MatrixType::RealScalar RealScalar; typedef typename MatrixType::Index Index; typedef Matrix<Scalar, RowsAtCompileTime, RowsAtCompileTime, Options, MaxRowsAtCompileTime, MaxRowsAtCompileTime> MatrixQType; - typedef typename ei_plain_diag_type<MatrixType>::type HCoeffsType; + typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType; typedef Matrix<Index, 1, ColsAtCompileTime, RowMajor, 1, MaxColsAtCompileTime> IntRowVectorType; typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime> PermutationType; - typedef typename ei_plain_col_type<MatrixType, Index>::type IntColVectorType; - typedef typename ei_plain_row_type<MatrixType>::type RowVectorType; - typedef typename ei_plain_col_type<MatrixType>::type ColVectorType; + typedef typename internal::plain_col_type<MatrixType, Index>::type IntColVectorType; + typedef typename internal::plain_row_type<MatrixType>::type RowVectorType; + typedef typename internal::plain_col_type<MatrixType>::type ColVectorType; /** \brief Default Constructor. * @@ -129,11 +129,11 @@ template<typename _MatrixType> class FullPivHouseholderQR * Output: \verbinclude FullPivHouseholderQR_solve.out */ template<typename Rhs> - inline const ei_solve_retval<FullPivHouseholderQR, Rhs> + inline const internal::solve_retval<FullPivHouseholderQR, Rhs> solve(const MatrixBase<Rhs>& b) const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); - return ei_solve_retval<FullPivHouseholderQR, Rhs>(*this, b.derived()); + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + return internal::solve_retval<FullPivHouseholderQR, Rhs>(*this, b.derived()); } MatrixQType matrixQ(void) const; @@ -142,7 +142,7 @@ template<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<typename _MatrixType> 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<FullPivHouseholderQR, typename MatrixType::IdentityReturnType> + internal::solve_retval<FullPivHouseholderQR, typename MatrixType::IdentityReturnType> inverse() const { - ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); - return ei_solve_retval<FullPivHouseholderQR,typename MatrixType::IdentityReturnType> + eigen_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); + return internal::solve_retval<FullPivHouseholderQR,typename MatrixType::IdentityReturnType> (*this, MatrixType::Identity(m_qr.rows(), m_qr.cols())); } @@ -279,16 +279,16 @@ template<typename _MatrixType> class FullPivHouseholderQR template<typename MatrixType> typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::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> typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::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<MatrixType>& FullPivHouseholderQR<MatrixType>::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<MatrixType>& FullPivHouseholderQR<MatrixType>::compute(cons return *this; } +namespace internal { + template<typename _MatrixType, typename Rhs> -struct ei_solve_retval<FullPivHouseholderQR<_MatrixType>, Rhs> - : ei_solve_retval_base<FullPivHouseholderQR<_MatrixType>, Rhs> +struct solve_retval<FullPivHouseholderQR<_MatrixType>, Rhs> + : solve_retval_base<FullPivHouseholderQR<_MatrixType>, Rhs> { EIGEN_MAKE_SOLVE_HELPERS(FullPivHouseholderQR<_MatrixType>,Rhs) template<typename Dest> 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<FullPivHouseholderQR<_MatrixType>, Rhs> RealScalar biggest_in_lower_part_of_c = c.bottomRows(rows-dec().rank()).cwiseAbs().maxCoeff(); // FIXME brain dead const RealScalar m_precision = NumTraits<Scalar>::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<FullPivHouseholderQR<_MatrixType>, Rhs> } }; +} // end namespace internal + /** \returns the matrix Q */ template<typename MatrixType> typename FullPivHouseholderQR<MatrixType>::MatrixQType FullPivHouseholderQR<MatrixType>::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<MatrixType>::MatrixQType FullPivHouseholderQR<Matr for (Index k = size-1; k >= 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<typename _MatrixType> class HouseholderQR typedef typename MatrixType::RealScalar RealScalar; typedef typename MatrixType::Index Index; typedef Matrix<Scalar, RowsAtCompileTime, RowsAtCompileTime, (MatrixType::Flags&RowMajorBit) ? RowMajor : ColMajor, MaxRowsAtCompileTime, MaxRowsAtCompileTime> MatrixQType; - typedef typename ei_plain_diag_type<MatrixType>::type HCoeffsType; - typedef typename ei_plain_row_type<MatrixType>::type RowVectorType; + typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType; + typedef typename internal::plain_row_type<MatrixType>::type RowVectorType; typedef typename HouseholderSequence<MatrixType,HCoeffsType>::ConjugateReturnType HouseholderSequenceType; /** @@ -119,16 +119,16 @@ template<typename _MatrixType> class HouseholderQR * Output: \verbinclude HouseholderQR_solve.out */ template<typename Rhs> - inline const ei_solve_retval<HouseholderQR, Rhs> + inline const internal::solve_retval<HouseholderQR, Rhs> solve(const MatrixBase<Rhs>& b) const { - ei_assert(m_isInitialized && "HouseholderQR is not initialized."); - return ei_solve_retval<HouseholderQR, Rhs>(*this, b.derived()); + eigen_assert(m_isInitialized && "HouseholderQR is not initialized."); + return internal::solve_retval<HouseholderQR, Rhs>(*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<typename _MatrixType> 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<typename _MatrixType> class HouseholderQR template<typename MatrixType> typename MatrixType::RealScalar HouseholderQR<MatrixType>::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> typename MatrixType::RealScalar HouseholderQR<MatrixType>::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<typename MatrixQR, typename HCoeffs> -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<Scalar,MatrixQR::ColsAtCompileTime,1> TempType; TempType tempVector; @@ -237,7 +239,7 @@ void ei_householder_qr_inplace_unblocked(MatrixQR& mat, HCoeffs& hCoeffs, typena /** \internal */ template<typename MatrixQR, typename HCoeffs> -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<HCoeffs,Dynamic,1> 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<typename MatrixType> -HouseholderQR<MatrixType>& HouseholderQR<MatrixType>::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<typename _MatrixType, typename Rhs> -struct ei_solve_retval<HouseholderQR<_MatrixType>, Rhs> - : ei_solve_retval_base<HouseholderQR<_MatrixType>, Rhs> +struct solve_retval<HouseholderQR<_MatrixType>, Rhs> + : solve_retval_base<HouseholderQR<_MatrixType>, Rhs> { EIGEN_MAKE_SOLVE_HELPERS(HouseholderQR<_MatrixType>,Rhs) @@ -316,7 +300,7 @@ struct ei_solve_retval<HouseholderQR<_MatrixType>, 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<HouseholderQR<_MatrixType>, Rhs> } }; +} // end namespace internal + +template<typename MatrixType> +HouseholderQR<MatrixType>& HouseholderQR<MatrixType>::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<typename MatrixType, int QRPreconditioner, bool IsComplex = NumTraits<typename MatrixType::Scalar>::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<typename MatrixType, int QRPreconditioner, int Case> -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<typename MatrixType, int QRPreconditioner, int Case, - bool DoAnything = ei_qr_preconditioner_should_do_anything<MatrixType, QRPreconditioner, Case>::ret -> struct ei_qr_preconditioner_impl {}; + bool DoAnything = qr_preconditioner_should_do_anything<MatrixType, QRPreconditioner, Case>::ret +> struct qr_preconditioner_impl {}; template<typename MatrixType, int QRPreconditioner, int Case> -struct ei_qr_preconditioner_impl<MatrixType, QRPreconditioner, Case, false> +struct qr_preconditioner_impl<MatrixType, QRPreconditioner, Case, false> { static bool run(JacobiSVD<MatrixType, QRPreconditioner>&, const MatrixType&) { @@ -72,7 +72,7 @@ struct ei_qr_preconditioner_impl<MatrixType, QRPreconditioner, Case, false> /*** preconditioner using FullPivHouseholderQR ***/ template<typename MatrixType> -struct ei_qr_preconditioner_impl<MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true> +struct qr_preconditioner_impl<MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true> { static bool run(JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix) { @@ -89,7 +89,7 @@ struct ei_qr_preconditioner_impl<MatrixType, FullPivHouseholderQRPreconditioner, }; template<typename MatrixType> -struct ei_qr_preconditioner_impl<MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true> +struct qr_preconditioner_impl<MatrixType, FullPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true> { static bool run(JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix) { @@ -111,7 +111,7 @@ struct ei_qr_preconditioner_impl<MatrixType, FullPivHouseholderQRPreconditioner, /*** preconditioner using ColPivHouseholderQR ***/ template<typename MatrixType> -struct ei_qr_preconditioner_impl<MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true> +struct qr_preconditioner_impl<MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true> { static bool run(JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix) { @@ -132,7 +132,7 @@ struct ei_qr_preconditioner_impl<MatrixType, ColPivHouseholderQRPreconditioner, }; template<typename MatrixType> -struct ei_qr_preconditioner_impl<MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true> +struct qr_preconditioner_impl<MatrixType, ColPivHouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true> { static bool run(JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd, const MatrixType& matrix) { @@ -158,7 +158,7 @@ struct ei_qr_preconditioner_impl<MatrixType, ColPivHouseholderQRPreconditioner, /*** preconditioner using HouseholderQR ***/ template<typename MatrixType> -struct ei_qr_preconditioner_impl<MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true> +struct qr_preconditioner_impl<MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreRowsThanCols, true> { static bool run(JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd, const MatrixType& matrix) { @@ -179,7 +179,7 @@ struct ei_qr_preconditioner_impl<MatrixType, HouseholderQRPreconditioner, Precon }; template<typename MatrixType> -struct ei_qr_preconditioner_impl<MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true> +struct qr_preconditioner_impl<MatrixType, HouseholderQRPreconditioner, PreconditionIfMoreColsThanRows, true> { static bool run(JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd, const MatrixType& matrix) { @@ -202,7 +202,90 @@ struct ei_qr_preconditioner_impl<MatrixType, HouseholderQRPreconditioner, Precon } }; +/*** 2x2 SVD implementation + *** + *** JacobiSVD consists in performing a series of 2x2 SVD subproblems + ***/ + +template<typename MatrixType, int QRPreconditioner> +struct svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner, false> +{ + typedef JacobiSVD<MatrixType, QRPreconditioner> SVD; + typedef typename SVD::Index Index; + static void run(typename SVD::WorkMatrixType&, SVD&, Index, Index) {} +}; + +template<typename MatrixType, int QRPreconditioner> +struct svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner, true> +{ + typedef JacobiSVD<MatrixType, QRPreconditioner> 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<Scalar> 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<typename MatrixType, typename RealScalar, typename Index> +void real_2x2_jacobi_svd(const MatrixType& matrix, Index p, Index q, + JacobiRotation<RealScalar> *j_left, + JacobiRotation<RealScalar> *j_right) +{ + Matrix<RealScalar,2,2> m; + m << real(matrix.coeff(p,p)), real(matrix.coeff(p,q)), + real(matrix.coeff(q,p)), real(matrix.coeff(q,q)); + JacobiRotation<RealScalar> 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<typename _MatrixType, int QRPreconditioner> class JacobiSVD typedef Matrix<Scalar, ColsAtCompileTime, ColsAtCompileTime, MatrixOptions, MaxColsAtCompileTime, MaxColsAtCompileTime> MatrixVType; - typedef typename ei_plain_diag_type<MatrixType, RealScalar>::type SingularValuesType; - typedef typename ei_plain_row_type<MatrixType>::type RowType; - typedef typename ei_plain_col_type<MatrixType>::type ColType; + typedef typename internal::plain_diag_type<MatrixType, RealScalar>::type SingularValuesType; + typedef typename internal::plain_row_type<MatrixType>::type RowType; + typedef typename internal::plain_col_type<MatrixType>::type ColType; typedef Matrix<Scalar, DiagSizeAtCompileTime, DiagSizeAtCompileTime, MatrixOptions, MaxDiagSizeAtCompileTime, MaxDiagSizeAtCompileTime> WorkMatrixType; @@ -345,8 +428,8 @@ template<typename _MatrixType, int QRPreconditioner> 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<typename _MatrixType, int QRPreconditioner> 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<typename _MatrixType, int QRPreconditioner> 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<typename _MatrixType, int QRPreconditioner> class JacobiSVD * In other words, the returned solution is guaranteed to minimize the Euclidean norm \f$ \Vert A x - b \Vert \f$. */ template<typename Rhs> - inline const ei_solve_retval<JacobiSVD, Rhs> + inline const internal::solve_retval<JacobiSVD, Rhs> solve(const MatrixBase<Rhs>& 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<JacobiSVD, Rhs>(*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<JacobiSVD, Rhs>(*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<typename _MatrixType, int QRPreconditioner> class JacobiSVD Index m_nonzeroSingularValues, m_rows, m_cols, m_diagSize; template<typename __MatrixType, int _QRPreconditioner, bool _IsComplex> - friend struct ei_svd_precondition_2x2_block_to_be_real; + friend struct internal::svd_precondition_2x2_block_to_be_real; template<typename __MatrixType, int _QRPreconditioner, int _Case, bool _DoAnything> - friend struct ei_qr_preconditioner_impl; + friend struct internal::qr_preconditioner_impl; }; template<typename MatrixType, int QRPreconditioner> @@ -439,13 +522,13 @@ void JacobiSVD<MatrixType, QRPreconditioner>::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<MatrixType, QRPreconditioner>::allocate(Index rows, Index cols, u m_workMatrix.resize(m_diagSize, m_diagSize); } - -template<typename MatrixType, int QRPreconditioner> -struct ei_svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner, false> -{ - typedef JacobiSVD<MatrixType, QRPreconditioner> SVD; - typedef typename SVD::Index Index; - static void run(typename SVD::WorkMatrixType&, SVD&, Index, Index) {} -}; - -template<typename MatrixType, int QRPreconditioner> -struct ei_svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner, true> -{ - typedef JacobiSVD<MatrixType, QRPreconditioner> 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<Scalar> 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<typename MatrixType, typename RealScalar, typename Index> -void ei_real_2x2_jacobi_svd(const MatrixType& matrix, Index p, Index q, - JacobiRotation<RealScalar> *j_left, - JacobiRotation<RealScalar> *j_right) -{ - Matrix<RealScalar,2,2> 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<RealScalar> 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<typename MatrixType, int QRPreconditioner> JacobiSVD<MatrixType, QRPreconditioner>& JacobiSVD<MatrixType, QRPreconditioner>::compute(const MatrixType& matrix, unsigned int computationOptions) @@ -551,8 +555,8 @@ JacobiSVD<MatrixType, QRPreconditioner>::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<MatrixType, QRPreconditioner, PreconditionIfMoreColsThanRows>::run(*this, matrix) - && !ei_qr_preconditioner_impl<MatrixType, QRPreconditioner, PreconditionIfMoreRowsThanCols>::run(*this, matrix)) + if(!internal::qr_preconditioner_impl<MatrixType, QRPreconditioner, internal::PreconditionIfMoreColsThanRows>::run(*this, matrix) + && !internal::qr_preconditioner_impl<MatrixType, QRPreconditioner, internal::PreconditionIfMoreRowsThanCols>::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<MatrixType, QRPreconditioner>::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<MatrixType, QRPreconditioner>::run(m_workMatrix, *this, p, q); + internal::svd_precondition_2x2_block_to_be_real<MatrixType, QRPreconditioner>::run(m_workMatrix, *this, p, q); JacobiRotation<RealScalar> 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<MatrixType, QRPreconditioner>::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<MatrixType, QRPreconditioner>::compute(const MatrixType& matrix, unsig return *this; } +namespace internal { template<typename _MatrixType, int QRPreconditioner, typename Rhs> -struct ei_solve_retval<JacobiSVD<_MatrixType, QRPreconditioner>, Rhs> - : ei_solve_retval_base<JacobiSVD<_MatrixType, QRPreconditioner>, Rhs> +struct solve_retval<JacobiSVD<_MatrixType, QRPreconditioner>, Rhs> + : solve_retval_base<JacobiSVD<_MatrixType, QRPreconditioner>, Rhs> { typedef JacobiSVD<_MatrixType, QRPreconditioner> JacobiSVDType; EIGEN_MAKE_SOLVE_HELPERS(JacobiSVDType,Rhs) template<typename Dest> 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<JacobiSVD<_MatrixType, QRPreconditioner>, Rhs> * rhs(); } }; +} // end namespace internal template<typename Derived> JacobiSVD<typename MatrixBase<Derived>::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<typename _MatrixType> class UpperBidiagonalization enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime, - ColsAtCompileTimeMinusOne = ei_decrement_size<ColsAtCompileTime>::ret + ColsAtCompileTimeMinusOne = internal::decrement_size<ColsAtCompileTime>::ret }; typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::RealScalar RealScalar; @@ -45,7 +45,7 @@ template<typename _MatrixType> class UpperBidiagonalization typedef Matrix<Scalar, ColsAtCompileTimeMinusOne, 1> SuperDiagVectorType; typedef HouseholderSequence< MatrixType, - CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Diagonal<MatrixType,0> > + CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, Diagonal<MatrixType,0> > > HouseholderUSequenceType; typedef HouseholderSequence< MatrixType, @@ -76,13 +76,13 @@ template<typename _MatrixType> 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<ListEl*>(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<ListEl*>(m_buffer); } - ei_internal_assert(m_llSize<m_allocatedElements && "internal error: overflow in sparse mode"); + eigen_internal_assert(m_llSize<m_allocatedElements && "internal error: overflow in sparse mode"); // let's insert a new coefficient ListEl& el = llElements[m_llSize]; el.value = Scalar(0); @@ -266,7 +266,7 @@ _Scalar& AmbiVector<_Scalar,_Index>::coeff(_Index i) else { ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_buffer); - ei_assert(m_mode==IsSparse); + eigen_assert(m_mode==IsSparse); if ((m_llSize==0) || (i<llElements[m_llStart].index)) { return m_zero; @@ -315,7 +315,7 @@ class AmbiVector<_Scalar,_Index>::Iterator { ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_vector.m_buffer); m_currentEl = m_vector.m_llStart; - while (m_currentEl>=0 && ei_abs(llElements[m_currentEl].value)<m_epsilon) + while (m_currentEl>=0 && internal::abs(llElements[m_currentEl].value)<m_epsilon) m_currentEl = llElements[m_currentEl].next; if (m_currentEl<0) { @@ -341,7 +341,7 @@ class AmbiVector<_Scalar,_Index>::Iterator { do { ++m_cachedIndex; - } while (m_cachedIndex<m_vector.m_end && ei_abs(m_vector.m_buffer[m_cachedIndex])<m_epsilon); + } while (m_cachedIndex<m_vector.m_end && internal::abs(m_vector.m_buffer[m_cachedIndex])<m_epsilon); if (m_cachedIndex<m_vector.m_end) m_cachedValue = m_vector.m_buffer[m_cachedIndex]; else @@ -352,7 +352,7 @@ class AmbiVector<_Scalar,_Index>::Iterator ListEl* EIGEN_RESTRICT llElements = reinterpret_cast<ListEl*>(m_vector.m_buffer); do { m_currentEl = llElements[m_currentEl].next; - } while (m_currentEl>=0 && ei_abs(llElements[m_currentEl].value)<m_epsilon); + } while (m_currentEl>=0 && internal::abs(llElements[m_currentEl].value)<m_epsilon); if (m_currentEl<0) { m_cachedIndex = -1; diff --git a/Eigen/src/Sparse/CompressedStorage.h b/Eigen/src/Sparse/CompressedStorage.h index 8164b610f..1c36a2632 100644 --- a/Eigen/src/Sparse/CompressedStorage.h +++ b/Eigen/src/Sparse/CompressedStorage.h @@ -200,7 +200,7 @@ class CompressedStorage size_t n = size(); for (size_t i=0; i<n; ++i) { - if (!ei_isMuchSmallerThan(value(i), reference, epsilon)) + if (!internal::isMuchSmallerThan(value(i), reference, epsilon)) { value(k) = value(i); index(k) = index(i); diff --git a/Eigen/src/Sparse/DynamicSparseMatrix.h b/Eigen/src/Sparse/DynamicSparseMatrix.h index 620f09289..2c85a1d96 100644 --- a/Eigen/src/Sparse/DynamicSparseMatrix.h +++ b/Eigen/src/Sparse/DynamicSparseMatrix.h @@ -42,8 +42,10 @@ * * \see SparseMatrix */ + +namespace internal { template<typename _Scalar, int _Flags, typename _Index> -struct ei_traits<DynamicSparseMatrix<_Scalar, _Flags, _Index> > +struct traits<DynamicSparseMatrix<_Scalar, _Flags, _Index> > { typedef _Scalar Scalar; typedef _Index Index; @@ -59,6 +61,7 @@ struct ei_traits<DynamicSparseMatrix<_Scalar, _Flags, _Index> > SupportedAccessPatterns = OuterRandomAccessPattern }; }; +} template<typename _Scalar, int _Flags, typename _Index> class DynamicSparseMatrix @@ -158,8 +161,8 @@ class DynamicSparseMatrix /** \sa insertBack */ inline Scalar& insertBackByOuterInner(Index outer, Index inner) { - ei_assert(outer<Index(m_data.size()) && inner<m_innerSize && "out of range"); - ei_assert(((m_data[outer].size()==0) || (m_data[outer].index(m_data[outer].size()-1)<inner)) + eigen_assert(outer<Index(m_data.size()) && inner<m_innerSize && "out of range"); + eigen_assert(((m_data[outer].size()==0) || (m_data[outer].index(m_data[outer].size()-1)<inner)) && "wrong sorted insertion"); m_data[outer].append(0, inner); return m_data[outer].value(m_data[outer].size()-1); @@ -228,7 +231,7 @@ class DynamicSparseMatrix inline DynamicSparseMatrix() : m_innerSize(0), m_data(0) { - ei_assert(innerSize()==0 && outerSize()==0); + eigen_assert(innerSize()==0 && outerSize()==0); } inline DynamicSparseMatrix(Index rows, Index cols) diff --git a/Eigen/src/Sparse/MappedSparseMatrix.h b/Eigen/src/Sparse/MappedSparseMatrix.h index 941290a35..31a431fb2 100644 --- a/Eigen/src/Sparse/MappedSparseMatrix.h +++ b/Eigen/src/Sparse/MappedSparseMatrix.h @@ -34,9 +34,11 @@ * See http://www.netlib.org/linalg/html_templates/node91.html for details on the storage scheme. * */ +namespace internal { template<typename _Scalar, int _Flags, typename _Index> -struct ei_traits<MappedSparseMatrix<_Scalar, _Flags, _Index> > : ei_traits<SparseMatrix<_Scalar, _Flags, _Index> > +struct traits<MappedSparseMatrix<_Scalar, _Flags, _Index> > : traits<SparseMatrix<_Scalar, _Flags, _Index> > {}; +} template<typename _Scalar, int _Flags, typename _Index> 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<end) && "coeffRef cannot be called on a zero coefficient"); + eigen_assert((*r==inner) && (id<end) && "coeffRef cannot be called on a zero coefficient"); return m_values[id]; } diff --git a/Eigen/src/Sparse/SparseBlock.h b/Eigen/src/Sparse/SparseBlock.h index dde442caa..d90e2334b 100644 --- a/Eigen/src/Sparse/SparseBlock.h +++ b/Eigen/src/Sparse/SparseBlock.h @@ -25,12 +25,13 @@ #ifndef EIGEN_SPARSE_BLOCK_H #define EIGEN_SPARSE_BLOCK_H +namespace internal { template<typename MatrixType, int Size> -struct ei_traits<SparseInnerVectorSet<MatrixType, Size> > +struct traits<SparseInnerVectorSet<MatrixType, Size> > { - typedef typename ei_traits<MatrixType>::Scalar Scalar; - typedef typename ei_traits<MatrixType>::Index Index; - typedef typename ei_traits<MatrixType>::StorageKind StorageKind; + typedef typename traits<MatrixType>::Scalar Scalar; + typedef typename traits<MatrixType>::Index Index; + typedef typename traits<MatrixType>::StorageKind StorageKind; typedef MatrixXpr XprKind; enum { IsRowMajor = (int(MatrixType::Flags)&RowMajorBit)==RowMajorBit, @@ -42,14 +43,15 @@ struct ei_traits<SparseInnerVectorSet<MatrixType, Size> > CoeffReadCost = MatrixType::CoeffReadCost }; }; +} // end namespace internal template<typename MatrixType, int Size> -class SparseInnerVectorSet : ei_no_assignment_operator, +class SparseInnerVectorSet : internal::no_assignment_operator, public SparseMatrixBase<SparseInnerVectorSet<MatrixType, Size> > { public: - enum { IsRowMajor = ei_traits<SparseInnerVectorSet>::IsRowMajor }; + enum { IsRowMajor = internal::traits<SparseInnerVectorSet>::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<matrix.outerSize()) ); + eigen_assert(Size!=Dynamic); + eigen_assert( (outer>=0) && (outer<matrix.outerSize()) ); } // template<typename OtherDerived> @@ -96,7 +98,7 @@ class SparseInnerVectorSet : ei_no_assignment_operator, const typename MatrixType::Nested m_matrix; Index m_outerStart; - const ei_variable_if_dynamic<Index, Size> m_outerSize; + const internal::variable_if_dynamic<Index, Size> m_outerSize; }; /*************************************************************************** @@ -110,7 +112,7 @@ class SparseInnerVectorSet<DynamicSparseMatrix<_Scalar, _Options>, Size> typedef DynamicSparseMatrix<_Scalar, _Options> MatrixType; public: - enum { IsRowMajor = ei_traits<SparseInnerVectorSet>::IsRowMajor }; + enum { IsRowMajor = internal::traits<SparseInnerVectorSet>::IsRowMajor }; EIGEN_SPARSE_PUBLIC_INTERFACE(SparseInnerVectorSet) class InnerIterator: public MatrixType::InnerIterator @@ -128,14 +130,14 @@ class SparseInnerVectorSet<DynamicSparseMatrix<_Scalar, _Options>, 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<matrix.outerSize()) ); + eigen_assert(Size!=Dynamic); + eigen_assert( (outer>=0) && (outer<matrix.outerSize()) ); } template<typename OtherDerived> @@ -175,7 +177,7 @@ class SparseInnerVectorSet<DynamicSparseMatrix<_Scalar, _Options>, 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<DynamicSparseMatrix<_Scalar, _Options>, Size> const typename MatrixType::Nested m_matrix; Index m_outerStart; - const ei_variable_if_dynamic<Index, Size> m_outerSize; + const internal::variable_if_dynamic<Index, Size> m_outerSize; }; @@ -208,7 +210,7 @@ class SparseInnerVectorSet<SparseMatrix<_Scalar, _Options, _Index>, Size> typedef SparseMatrix<_Scalar, _Options> MatrixType; public: - enum { IsRowMajor = ei_traits<SparseInnerVectorSet>::IsRowMajor }; + enum { IsRowMajor = internal::traits<SparseInnerVectorSet>::IsRowMajor }; EIGEN_SPARSE_PUBLIC_INTERFACE(SparseInnerVectorSet) class InnerIterator: public MatrixType::InnerIterator @@ -226,20 +228,20 @@ class SparseInnerVectorSet<SparseMatrix<_Scalar, _Options, _Index>, 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<matrix.outerSize()) ); + eigen_assert(Size==1); + eigen_assert( (outer>=0) && (outer<matrix.outerSize()) ); } template<typename OtherDerived> inline SparseInnerVectorSet& operator=(const SparseMatrixBase<OtherDerived>& other) { - typedef typename ei_cleantype<typename MatrixType::Nested>::type _NestedMatrixType; + typedef typename internal::cleantype<typename MatrixType::Nested>::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<SparseMatrix<_Scalar, _Options, _Index>, 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<SparseMatrix<_Scalar, _Options, _Index>, Size> const typename MatrixType::Nested m_matrix; Index m_outerStart; - const ei_variable_if_dynamic<Index, Size> m_outerSize; + const internal::variable_if_dynamic<Index, Size> 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<Dense,Sparse> +namespace internal { + +template<> struct promote_storage_type<Dense,Sparse> { typedef Sparse ret; }; -template<> struct ei_promote_storage_type<Sparse,Dense> +template<> struct promote_storage_type<Sparse,Dense> { typedef Sparse ret; }; +template<typename BinaryOp, typename Lhs, typename Rhs, typename Derived, + typename _LhsStorageMode = typename traits<Lhs>::StorageKind, + typename _RhsStorageMode = typename traits<Rhs>::StorageKind> +class sparse_cwise_binary_op_inner_iterator_selector; + +} // end namespace internal + template<typename BinaryOp, typename Lhs, typename Rhs> class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Sparse> : public SparseMatrixBase<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > @@ -58,18 +67,13 @@ class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Sparse> EIGEN_SPARSE_PUBLIC_INTERFACE(Derived) }; -template<typename BinaryOp, typename Lhs, typename Rhs, typename Derived, - typename _LhsStorageMode = typename ei_traits<Lhs>::StorageKind, - typename _RhsStorageMode = typename ei_traits<Rhs>::StorageKind> -class ei_sparse_cwise_binary_op_inner_iterator_selector; - template<typename BinaryOp, typename Lhs, typename Rhs> class CwiseBinaryOpImpl<BinaryOp,Lhs,Rhs,Sparse>::InnerIterator - : public ei_sparse_cwise_binary_op_inner_iterator_selector<BinaryOp,Lhs,Rhs,typename CwiseBinaryOpImpl<BinaryOp,Lhs,Rhs,Sparse>::InnerIterator> + : public internal::sparse_cwise_binary_op_inner_iterator_selector<BinaryOp,Lhs,Rhs,typename CwiseBinaryOpImpl<BinaryOp,Lhs,Rhs,Sparse>::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<BinaryOp,Lhs,Rhs,Sparse>::InnerIterator * Implementation of inner-iterators ***************************************************************************/ -// template<typename T> struct ei_func_is_conjunction { enum { ret = false }; }; -// template<typename T> struct ei_func_is_conjunction<ei_scalar_product_op<T> > { enum { ret = true }; }; +// template<typename T> struct internal::func_is_conjunction { enum { ret = false }; }; +// template<typename T> struct internal::func_is_conjunction<internal::scalar_product_op<T> > { 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<typename BinaryOp, typename Lhs, typename Rhs, typename Derived> -class ei_sparse_cwise_binary_op_inner_iterator_selector<BinaryOp, Lhs, Rhs, Derived, Sparse, Sparse> +class sparse_cwise_binary_op_inner_iterator_selector<BinaryOp, Lhs, Rhs, Derived, Sparse, Sparse> { typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> CwiseBinaryXpr; - typedef typename ei_traits<CwiseBinaryXpr>::Scalar Scalar; - typedef typename ei_traits<CwiseBinaryXpr>::_LhsNested _LhsNested; - typedef typename ei_traits<CwiseBinaryXpr>::_RhsNested _RhsNested; + typedef typename traits<CwiseBinaryXpr>::Scalar Scalar; + typedef typename traits<CwiseBinaryXpr>::_LhsNested _LhsNested; + typedef typename traits<CwiseBinaryXpr>::_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<BinaryOp, Lhs, Rhs, Deri // sparse - sparse (product) template<typename T, typename Lhs, typename Rhs, typename Derived> -class ei_sparse_cwise_binary_op_inner_iterator_selector<ei_scalar_product_op<T>, Lhs, Rhs, Derived, Sparse, Sparse> +class sparse_cwise_binary_op_inner_iterator_selector<scalar_product_op<T>, Lhs, Rhs, Derived, Sparse, Sparse> { - typedef ei_scalar_product_op<T> BinaryFunc; + typedef scalar_product_op<T> BinaryFunc; typedef CwiseBinaryOp<BinaryFunc, Lhs, Rhs> CwiseBinaryXpr; typedef typename CwiseBinaryXpr::Scalar Scalar; - typedef typename ei_traits<CwiseBinaryXpr>::_LhsNested _LhsNested; + typedef typename traits<CwiseBinaryXpr>::_LhsNested _LhsNested; typedef typename _LhsNested::InnerIterator LhsIterator; - typedef typename ei_traits<CwiseBinaryXpr>::_RhsNested _RhsNested; + typedef typename traits<CwiseBinaryXpr>::_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<ei_scalar_product_op<T>, // sparse - dense (product) template<typename T, typename Lhs, typename Rhs, typename Derived> -class ei_sparse_cwise_binary_op_inner_iterator_selector<ei_scalar_product_op<T>, Lhs, Rhs, Derived, Sparse, Dense> +class sparse_cwise_binary_op_inner_iterator_selector<scalar_product_op<T>, Lhs, Rhs, Derived, Sparse, Dense> { - typedef ei_scalar_product_op<T> BinaryFunc; + typedef scalar_product_op<T> BinaryFunc; typedef CwiseBinaryOp<BinaryFunc, Lhs, Rhs> CwiseBinaryXpr; typedef typename CwiseBinaryXpr::Scalar Scalar; - typedef typename ei_traits<CwiseBinaryXpr>::_LhsNested _LhsNested; - typedef typename ei_traits<CwiseBinaryXpr>::RhsNested RhsNested; + typedef typename traits<CwiseBinaryXpr>::_LhsNested _LhsNested; + typedef typename traits<CwiseBinaryXpr>::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<ei_scalar_product_op<T>, // sparse - dense (product) template<typename T, typename Lhs, typename Rhs, typename Derived> -class ei_sparse_cwise_binary_op_inner_iterator_selector<ei_scalar_product_op<T>, Lhs, Rhs, Derived, Dense, Sparse> +class sparse_cwise_binary_op_inner_iterator_selector<scalar_product_op<T>, Lhs, Rhs, Derived, Dense, Sparse> { - typedef ei_scalar_product_op<T> BinaryFunc; + typedef scalar_product_op<T> BinaryFunc; typedef CwiseBinaryOp<BinaryFunc, Lhs, Rhs> CwiseBinaryXpr; typedef typename CwiseBinaryXpr::Scalar Scalar; - typedef typename ei_traits<CwiseBinaryXpr>::_RhsNested _RhsNested; + typedef typename traits<CwiseBinaryXpr>::_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<ei_scalar_product_op<T>, 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<ei_scalar_product_op<T>, // template<typename Derived> // template<typename OtherDerived> -// EIGEN_STRONG_INLINE const CwiseBinaryOp<ei_scalar_difference_op<typename ei_traits<Derived>::Scalar>, +// EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_difference_op<typename internal::traits<Derived>::Scalar>, // Derived, OtherDerived> // SparseMatrixBase<Derived>::operator-(const SparseMatrixBase<OtherDerived> &other) const // { -// return CwiseBinaryOp<ei_scalar_difference_op<Scalar>, +// return CwiseBinaryOp<internal::scalar_difference_op<Scalar>, // Derived, OtherDerived>(derived(), other.derived()); // } @@ -311,10 +318,10 @@ SparseMatrixBase<Derived>::operator-=(const SparseMatrixBase<OtherDerived> &othe // template<typename Derived> // template<typename OtherDerived> -// EIGEN_STRONG_INLINE const CwiseBinaryOp<ei_scalar_sum_op<typename ei_traits<Derived>::Scalar>, Derived, OtherDerived> +// EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_sum_op<typename internal::traits<Derived>::Scalar>, Derived, OtherDerived> // SparseMatrixBase<Derived>::operator+(const SparseMatrixBase<OtherDerived> &other) const // { -// return CwiseBinaryOp<ei_scalar_sum_op<Scalar>, Derived, OtherDerived>(derived(), other.derived()); +// return CwiseBinaryOp<internal::scalar_sum_op<Scalar>, Derived, OtherDerived>(derived(), other.derived()); // } template<typename Derived> @@ -343,18 +350,18 @@ SparseMatrixBase<Derived>::cwiseProduct(const MatrixBase<OtherDerived> &other) c // template<typename ExpressionType> // template<typename OtherDerived> -// 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<ExpressionType>::operator/(const SparseMatrixBase<OtherDerived> &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<typename ExpressionType> // template<typename OtherDerived> -// 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<ExpressionType>::operator/(const MatrixBase<OtherDerived> &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<typename ExpressionType> 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<typename UnaryOp, typename MatrixType> -// struct ei_traits<SparseCwiseUnaryOp<UnaryOp, MatrixType> > : ei_traits<MatrixType> +// struct internal::traits<SparseCwiseUnaryOp<UnaryOp, MatrixType> > : internal::traits<MatrixType> // { -// 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<MatrixTypeNested>::type _MatrixTypeNested; +// typedef typename internal::unref<MatrixTypeNested>::type _MatrixTypeNested; // enum { -// CoeffReadCost = _MatrixTypeNested::CoeffReadCost + ei_functor_traits<UnaryOp>::Cost +// CoeffReadCost = _MatrixTypeNested::CoeffReadCost + internal::functor_traits<UnaryOp>::Cost // }; // }; @@ -45,7 +45,7 @@ class CwiseUnaryOpImpl<UnaryOp,MatrixType,Sparse> public: class InnerIterator; -// typedef typename ei_unref<LhsNested>::type _LhsNested; +// typedef typename internal::unref<LhsNested>::type _LhsNested; typedef CwiseUnaryOp<UnaryOp, MatrixType> Derived; EIGEN_SPARSE_PUBLIC_INTERFACE(Derived) @@ -55,7 +55,7 @@ template<typename UnaryOp, typename MatrixType> class CwiseUnaryOpImpl<UnaryOp,MatrixType,Sparse>::InnerIterator { typedef typename CwiseUnaryOpImpl::Scalar Scalar; - typedef typename ei_traits<Derived>::_XprTypeNested _MatrixTypeNested; + typedef typename internal::traits<Derived>::_XprTypeNested _MatrixTypeNested; typedef typename _MatrixTypeNested::InnerIterator MatrixTypeIterator; typedef typename MatrixType::Index Index; public: @@ -87,7 +87,7 @@ class CwiseUnaryViewImpl<ViewOp,MatrixType,Sparse> public: class InnerIterator; -// typedef typename ei_unref<LhsNested>::type _LhsNested; +// typedef typename internal::unref<LhsNested>::type _LhsNested; typedef CwiseUnaryView<ViewOp, MatrixType> Derived; EIGEN_SPARSE_PUBLIC_INTERFACE(Derived) @@ -97,7 +97,7 @@ template<typename ViewOp, typename MatrixType> class CwiseUnaryViewImpl<ViewOp,MatrixType,Sparse>::InnerIterator { typedef typename CwiseUnaryViewImpl::Scalar Scalar; - typedef typename ei_traits<Derived>::_MatrixTypeNested _MatrixTypeNested; + typedef typename internal::traits<Derived>::_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<typename Lhs, typename Rhs> struct DenseSparseProductReturnType<Lhs,Rhs typedef SparseDenseOuterProduct<Rhs,Lhs,true> Type; }; +namespace internal { + template<typename Lhs, typename Rhs, bool Tr> -struct ei_traits<SparseDenseOuterProduct<Lhs,Rhs,Tr> > +struct traits<SparseDenseOuterProduct<Lhs,Rhs,Tr> > { typedef Sparse StorageKind; - typedef typename ei_scalar_product_traits<typename ei_traits<Lhs>::Scalar, - typename ei_traits<Rhs>::Scalar>::ReturnType Scalar; + typedef typename scalar_product_traits<typename traits<Lhs>::Scalar, + typename traits<Rhs>::Scalar>::ReturnType Scalar; typedef typename Lhs::Index Index; typedef typename Lhs::Nested LhsNested; typedef typename Rhs::Nested RhsNested; - typedef typename ei_cleantype<LhsNested>::type _LhsNested; - typedef typename ei_cleantype<RhsNested>::type _RhsNested; + typedef typename cleantype<LhsNested>::type _LhsNested; + typedef typename cleantype<RhsNested>::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<Rhs>::RowsAtCompileTime) : int(ei_traits<Lhs>::RowsAtCompileTime), - ColsAtCompileTime = Tr ? int(ei_traits<Lhs>::ColsAtCompileTime) : int(ei_traits<Rhs>::ColsAtCompileTime), - MaxRowsAtCompileTime = Tr ? int(ei_traits<Rhs>::MaxRowsAtCompileTime) : int(ei_traits<Lhs>::MaxRowsAtCompileTime), - MaxColsAtCompileTime = Tr ? int(ei_traits<Lhs>::MaxColsAtCompileTime) : int(ei_traits<Rhs>::MaxColsAtCompileTime), + RowsAtCompileTime = Tr ? int(traits<Rhs>::RowsAtCompileTime) : int(traits<Lhs>::RowsAtCompileTime), + ColsAtCompileTime = Tr ? int(traits<Lhs>::ColsAtCompileTime) : int(traits<Rhs>::ColsAtCompileTime), + MaxRowsAtCompileTime = Tr ? int(traits<Rhs>::MaxRowsAtCompileTime) : int(traits<Lhs>::MaxRowsAtCompileTime), + MaxColsAtCompileTime = Tr ? int(traits<Lhs>::MaxColsAtCompileTime) : int(traits<Rhs>::MaxColsAtCompileTime), Flags = Tr ? RowMajorBit : 0, @@ -72,6 +74,8 @@ struct ei_traits<SparseDenseOuterProduct<Lhs,Rhs,Tr> > }; }; +} // end namespace internal + template<typename Lhs, typename Rhs, bool Tr> class SparseDenseOuterProduct : public SparseMatrixBase<SparseDenseOuterProduct<Lhs,Rhs,Tr> > @@ -80,7 +84,7 @@ class SparseDenseOuterProduct typedef SparseMatrixBase<SparseDenseOuterProduct> Base; EIGEN_DENSE_PUBLIC_INTERFACE(SparseDenseOuterProduct) - typedef ei_traits<SparseDenseOuterProduct> Traits; + typedef internal::traits<SparseDenseOuterProduct> Traits; private: @@ -137,13 +141,15 @@ class SparseDenseOuterProduct<Lhs,Rhs,Transpose>::InnerIterator : public _LhsNes Scalar m_factor; }; +namespace internal { template<typename Lhs, typename Rhs> -struct ei_traits<SparseTimeDenseProduct<Lhs,Rhs> > - : ei_traits<ProductBase<SparseTimeDenseProduct<Lhs,Rhs>, Lhs, Rhs> > +struct traits<SparseTimeDenseProduct<Lhs,Rhs> > + : traits<ProductBase<SparseTimeDenseProduct<Lhs,Rhs>, Lhs, Rhs> > { typedef Dense StorageKind; typedef MatrixXpr XprKind; }; +} // end namespace internal template<typename Lhs, typename Rhs> class SparseTimeDenseProduct @@ -157,8 +163,8 @@ class SparseTimeDenseProduct template<typename Dest> void scaleAndAddTo(Dest& dest, Scalar alpha) const { - typedef typename ei_cleantype<Lhs>::type _Lhs; - typedef typename ei_cleantype<Rhs>::type _Rhs; + typedef typename internal::cleantype<Lhs>::type _Lhs; + typedef typename internal::cleantype<Rhs>::type _Rhs; typedef typename _Lhs::InnerIterator LhsInnerIterator; enum { LhsIsRowMajor = (_Lhs::Flags&RowMajorBit)==RowMajorBit }; for(Index j=0; j<m_lhs.outerSize(); ++j) @@ -180,12 +186,14 @@ class SparseTimeDenseProduct // dense = dense * sparse +namespace internal { template<typename Lhs, typename Rhs> -struct ei_traits<DenseTimeSparseProduct<Lhs,Rhs> > - : ei_traits<ProductBase<DenseTimeSparseProduct<Lhs,Rhs>, Lhs, Rhs> > +struct traits<DenseTimeSparseProduct<Lhs,Rhs> > + : traits<ProductBase<DenseTimeSparseProduct<Lhs,Rhs>, Lhs, Rhs> > { typedef Dense StorageKind; }; +} // end namespace internal template<typename Lhs, typename Rhs> class DenseTimeSparseProduct @@ -199,7 +207,7 @@ class DenseTimeSparseProduct template<typename Dest> void scaleAndAddTo(Dest& dest, Scalar alpha) const { - typedef typename ei_cleantype<Rhs>::type _Rhs; + typedef typename internal::cleantype<Rhs>::type _Rhs; typedef typename _Rhs::InnerIterator RhsInnerIterator; enum { RhsIsRowMajor = (_Rhs::Flags&RowMajorBit)==RowMajorBit }; for(Index j=0; j<m_rhs.outerSize(); ++j) diff --git a/Eigen/src/Sparse/SparseDiagonalProduct.h b/Eigen/src/Sparse/SparseDiagonalProduct.h index 1e29143af..6078a1aa2 100644 --- a/Eigen/src/Sparse/SparseDiagonalProduct.h +++ b/Eigen/src/Sparse/SparseDiagonalProduct.h @@ -37,14 +37,16 @@ // for that particular case // The two other cases are symmetric. +namespace internal { + template<typename Lhs, typename Rhs> -struct ei_traits<SparseDiagonalProduct<Lhs, Rhs> > +struct traits<SparseDiagonalProduct<Lhs, Rhs> > { - typedef typename ei_cleantype<Lhs>::type _Lhs; - typedef typename ei_cleantype<Rhs>::type _Rhs; + typedef typename cleantype<Lhs>::type _Lhs; + typedef typename cleantype<Rhs>::type _Rhs; typedef typename _Lhs::Scalar Scalar; - typedef typename ei_promote_index_type<typename ei_traits<Lhs>::Index, - typename ei_traits<Rhs>::Index>::type Index; + typedef typename promote_index_type<typename traits<Lhs>::Index, + typename traits<Rhs>::Index>::type Index; typedef Sparse StorageKind; typedef MatrixXpr XprKind; enum { @@ -54,7 +56,7 @@ struct ei_traits<SparseDiagonalProduct<Lhs, Rhs> > 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<SparseDiagonalProduct<Lhs, Rhs> > enum {SDP_IsDiagonal, SDP_IsSparseRowMajor, SDP_IsSparseColMajor}; template<typename Lhs, typename Rhs, typename SparseDiagonalProductType, int RhsMode, int LhsMode> -class ei_sparse_diagonal_product_inner_iterator_selector; +class sparse_diagonal_product_inner_iterator_selector; + +} // end namespace internal template<typename Lhs, typename Rhs> class SparseDiagonalProduct : public SparseMatrixBase<SparseDiagonalProduct<Lhs,Rhs> >, - ei_no_assignment_operator + internal::no_assignment_operator { typedef typename Lhs::Nested LhsNested; typedef typename Rhs::Nested RhsNested; - typedef typename ei_cleantype<LhsNested>::type _LhsNested; - typedef typename ei_cleantype<RhsNested>::type _RhsNested; + typedef typename internal::cleantype<LhsNested>::type _LhsNested; + typedef typename internal::cleantype<RhsNested>::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<typename Lhs, typename Rhs, typename SparseDiagonalProductType> -class ei_sparse_diagonal_product_inner_iterator_selector +class sparse_diagonal_product_inner_iterator_selector <Lhs,Rhs,SparseDiagonalProductType,SDP_IsDiagonal,SDP_IsSparseRowMajor> - : public CwiseUnaryOp<ei_scalar_multiple_op<typename Lhs::Scalar>,Rhs>::InnerIterator + : public CwiseUnaryOp<scalar_multiple_op<typename Lhs::Scalar>,Rhs>::InnerIterator { - typedef typename CwiseUnaryOp<ei_scalar_multiple_op<typename Lhs::Scalar>,Rhs>::InnerIterator Base; + typedef typename CwiseUnaryOp<scalar_multiple_op<typename Lhs::Scalar>,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<typename Lhs, typename Rhs, typename SparseDiagonalProductType> -class ei_sparse_diagonal_product_inner_iterator_selector +class sparse_diagonal_product_inner_iterator_selector <Lhs,Rhs,SparseDiagonalProductType,SDP_IsDiagonal,SDP_IsSparseColMajor> : public CwiseBinaryOp< - ei_scalar_product_op<typename Lhs::Scalar>, + scalar_product_op<typename Lhs::Scalar>, SparseInnerVectorSet<Rhs,1>, typename Lhs::DiagonalVectorType>::InnerIterator { typedef typename CwiseBinaryOp< - ei_scalar_product_op<typename Lhs::Scalar>, + scalar_product_op<typename Lhs::Scalar>, SparseInnerVectorSet<Rhs,1>, 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<typename Lhs, typename Rhs, typename SparseDiagonalProductType> -class ei_sparse_diagonal_product_inner_iterator_selector +class sparse_diagonal_product_inner_iterator_selector <Lhs,Rhs,SparseDiagonalProductType,SDP_IsSparseColMajor,SDP_IsDiagonal> - : public CwiseUnaryOp<ei_scalar_multiple_op<typename Rhs::Scalar>,Lhs>::InnerIterator + : public CwiseUnaryOp<scalar_multiple_op<typename Rhs::Scalar>,Lhs>::InnerIterator { - typedef typename CwiseUnaryOp<ei_scalar_multiple_op<typename Rhs::Scalar>,Lhs>::InnerIterator Base; + typedef typename CwiseUnaryOp<scalar_multiple_op<typename Rhs::Scalar>,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<typename Lhs, typename Rhs, typename SparseDiagonalProductType> -class ei_sparse_diagonal_product_inner_iterator_selector +class sparse_diagonal_product_inner_iterator_selector <Lhs,Rhs,SparseDiagonalProductType,SDP_IsSparseRowMajor,SDP_IsDiagonal> : public CwiseBinaryOp< - ei_scalar_product_op<typename Rhs::Scalar>, + scalar_product_op<typename Rhs::Scalar>, SparseInnerVectorSet<Lhs,1>, Transpose<typename Rhs::DiagonalVectorType> >::InnerIterator { typedef typename CwiseBinaryOp< - ei_scalar_product_op<typename Rhs::Scalar>, + scalar_product_op<typename Rhs::Scalar>, SparseInnerVectorSet<Lhs,1>, Transpose<typename Rhs::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.lhs().innerVector(outer) .cwiseProduct(expr.rhs().diagonal().transpose()), 0) {} }; +} // end namespace internal + // SparseMatrixBase functions template<typename Derived> 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<typename Derived> template<typename OtherDerived> -typename ei_traits<Derived>::Scalar +typename internal::traits<Derived>::Scalar SparseMatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& 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<Scalar, typename OtherDerived::Scalar>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type<Scalar, typename OtherDerived::Scalar>::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<Derived>::dot(const MatrixBase<OtherDerived>& other) const template<typename Derived> template<typename OtherDerived> -typename ei_traits<Derived>::Scalar +typename internal::traits<Derived>::Scalar SparseMatrixBase<Derived>::dot(const SparseMatrixBase<OtherDerived>& 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<Scalar, typename OtherDerived::Scalar>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type<Scalar, typename OtherDerived::Scalar>::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<Derived>::dot(const SparseMatrixBase<OtherDerived>& 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()<j.index()) @@ -81,17 +81,17 @@ SparseMatrixBase<Derived>::dot(const SparseMatrixBase<OtherDerived>& other) cons } template<typename Derived> -inline typename NumTraits<typename ei_traits<Derived>::Scalar>::Real +inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real SparseMatrixBase<Derived>::squaredNorm() const { - return ei_real((*this).cwiseAbs2().sum()); + return internal::real((*this).cwiseAbs2().sum()); } template<typename Derived> -inline typename NumTraits<typename ei_traits<Derived>::Scalar>::Real +inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real SparseMatrixBase<Derived>::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<Scalar>::Real prec // ) const // { -// const typename ei_nested<Derived,2>::type nested(derived()); -// const typename ei_nested<OtherDerived,2>::type otherNested(other.derived()); +// const typename internal::nested<Derived,2>::type nested(derived()); +// const typename internal::nested<OtherDerived,2>::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<typename _Scalar, int _Options, typename _Index> -struct ei_traits<SparseMatrix<_Scalar, _Options, _Index> > +struct traits<SparseMatrix<_Scalar, _Options, _Index> > { typedef _Scalar Scalar; typedef _Index Index; @@ -59,6 +61,7 @@ struct ei_traits<SparseMatrix<_Scalar, _Options, _Index> > SupportedAccessPatterns = InnerRandomAccessPattern }; }; +} // end namespace internal template<typename _Scalar, int _Options, typename _Index> 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<end) && (m_data.index(id)==inner) && "coeffRef cannot be called on a zero coefficient"); + eigen_assert((id<end) && (m_data.index(id)==inner) && "coeffRef cannot be called on a zero coefficient"); return m_data.value(id); } @@ -166,8 +169,8 @@ class SparseMatrix /** \sa insertBack, startVec */ inline Scalar& insertBackByOuterInner(Index outer, Index inner) { - ei_assert(size_t(m_outerIndex[outer+1]) == m_data.size() && "Invalid ordered insertion (invalid outer index)"); - ei_assert( (m_outerIndex[outer+1]-m_outerIndex[outer]==0 || m_data.index(m_data.size()-1)<inner) && "Invalid ordered insertion (invalid inner index)"); + eigen_assert(size_t(m_outerIndex[outer+1]) == m_data.size() && "Invalid ordered insertion (invalid outer index)"); + eigen_assert( (m_outerIndex[outer+1]-m_outerIndex[outer]==0 || m_data.index(m_data.size()-1)<inner) && "Invalid ordered insertion (invalid inner index)"); Index id = m_outerIndex[outer+1]; ++m_outerIndex[outer+1]; m_data.append(0, inner); @@ -186,8 +189,8 @@ class SparseMatrix /** \sa insertBack, insertBackByOuterInner */ inline void startVec(Index outer) { - ei_assert(m_outerIndex[outer]==int(m_data.size()) && "You must call startVec for each inner vector sequentially"); - ei_assert(m_outerIndex[outer+1]==0 && "You must call startVec for each inner vector sequentially"); + eigen_assert(m_outerIndex[outer]==int(m_data.size()) && "You must call startVec for each inner vector sequentially"); + eigen_assert(m_outerIndex[outer+1]==0 && "You must call startVec for each inner vector sequentially"); m_outerIndex[outer+1] = m_outerIndex[outer]; } @@ -336,7 +339,7 @@ class SparseMatrix Index end = m_outerIndex[j+1]; for (Index i=previousStart; i<end; ++i) { - if (!ei_isMuchSmallerThan(m_data.value(i), reference, epsilon)) + if (!internal::isMuchSmallerThan(m_data.value(i), reference, epsilon)) { m_data.value(k) = m_data.value(i); m_data.index(k) = m_data.index(i); @@ -445,8 +448,8 @@ class SparseMatrix // 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 evaluate it if needed - typedef typename ei_nested<OtherDerived,2>::type OtherCopy; - typedef typename ei_cleantype<OtherCopy>::type _OtherCopy; + typedef typename internal::nested<OtherDerived,2>::type OtherCopy; + typedef typename internal::cleantype<OtherCopy>::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)<inner && "wrong sorted insertion"); + eigen_assert(m_data.index(m_data.size()-1)<inner && "wrong sorted insertion"); } // std::cerr << size_t(m_outerIndex[outer+1]) << " == " << m_data.size() << "\n"; assert(size_t(m_outerIndex[outer+1]) == m_data.size()); diff --git a/Eigen/src/Sparse/SparseMatrixBase.h b/Eigen/src/Sparse/SparseMatrixBase.h index 5ca3b604b..eb88c8a77 100644 --- a/Eigen/src/Sparse/SparseMatrixBase.h +++ b/Eigen/src/Sparse/SparseMatrixBase.h @@ -40,30 +40,30 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived> { public: - typedef typename ei_traits<Derived>::Scalar Scalar; - typedef typename ei_packet_traits<Scalar>::type PacketScalar; - typedef typename ei_traits<Derived>::StorageKind StorageKind; - typedef typename ei_traits<Derived>::Index Index; + typedef typename internal::traits<Derived>::Scalar Scalar; + typedef typename internal::packet_traits<Scalar>::type PacketScalar; + typedef typename internal::traits<Derived>::StorageKind StorageKind; + typedef typename internal::traits<Derived>::Index Index; typedef SparseMatrixBase StorageBaseType; enum { - RowsAtCompileTime = ei_traits<Derived>::RowsAtCompileTime, + RowsAtCompileTime = internal::traits<Derived>::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<Derived>::ColsAtCompileTime, + ColsAtCompileTime = internal::traits<Derived>::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<ei_traits<Derived>::RowsAtCompileTime, - ei_traits<Derived>::ColsAtCompileTime>::ret), + SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime, + internal::traits<Derived>::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<typename Derived> class SparseMatrixBase : public EigenBase<Derived> MaxRowsAtCompileTime = RowsAtCompileTime, MaxColsAtCompileTime = ColsAtCompileTime, - MaxSizeAtCompileTime = (ei_size_at_compile_time<MaxRowsAtCompileTime, + MaxSizeAtCompileTime = (internal::size_at_compile_time<MaxRowsAtCompileTime, MaxColsAtCompileTime>::ret), IsVectorAtCompileTime = RowsAtCompileTime == 1 || ColsAtCompileTime == 1, @@ -80,12 +80,12 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived> * 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<Derived>::Flags, + Flags = internal::traits<Derived>::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<Derived>::CoeffReadCost, + CoeffReadCost = internal::traits<Derived>::CoeffReadCost, /**< This is a rough measure of how expensive it is to read one coefficient from * this expression. */ @@ -98,17 +98,17 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived> }; /* \internal the return type of MatrixBase::conjugate() */ -// typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex, -// const SparseCwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Derived>, +// typedef typename internal::meta_if<NumTraits<Scalar>::IsComplex, +// const SparseCwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, Derived>, // const Derived& // >::ret ConjugateReturnType; /* \internal the return type of MatrixBase::real() */ -// typedef SparseCwiseUnaryOp<ei_scalar_real_op<Scalar>, Derived> RealReturnType; +// typedef SparseCwiseUnaryOp<internal::scalar_real_op<Scalar>, Derived> RealReturnType; /* \internal the return type of MatrixBase::imag() */ -// typedef SparseCwiseUnaryOp<ei_scalar_imag_op<Scalar>, Derived> ImagReturnType; +// typedef SparseCwiseUnaryOp<internal::scalar_imag_op<Scalar>, Derived> ImagReturnType; /** \internal the return type of MatrixBase::adjoint() */ - typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex, - CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Eigen::Transpose<Derived> >, + typedef typename internal::meta_if<NumTraits<Scalar>::IsComplex, + CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, Eigen::Transpose<Derived> >, Transpose<Derived> >::ret AdjointReturnType; @@ -132,10 +132,10 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived> /** \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<ei_scalar_constant_op<Scalar>,Matrix<Scalar,Dynamic,Dynamic> > ConstantReturnType; + typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,Matrix<Scalar,Dynamic,Dynamic> > ConstantReturnType; /** type of the equivalent square matrix */ typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime), @@ -190,14 +190,14 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived> { // std::cout << "Derived& operator=(const MatrixBase<OtherDerived>& other)\n"; //const bool transpose = (Flags & RowMajorBit) != (OtherDerived::Flags & RowMajorBit); - ei_assert(( ((ei_traits<Derived>::SupportedAccessPatterns&OuterRandomAccessPattern)==OuterRandomAccessPattern) || + eigen_assert(( ((internal::traits<Derived>::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<transpose, LinkedVectorMatrix<Scalar,Flags&RowMajorBit>, Derived>::ret TempType; + //typedef typename internal::meta_if<transpose, LinkedVectorMatrix<Scalar,Flags&RowMajorBit>, Derived>::ret TempType; // thanks to shallow copies, we always eval to a tempary Derived temp(other.rows(), other.cols()); @@ -299,14 +299,14 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived> return s; } -// const SparseCwiseUnaryOp<ei_scalar_opposite_op<typename ei_traits<Derived>::Scalar>,Derived> operator-() const; +// const SparseCwiseUnaryOp<internal::scalar_opposite_op<typename internal::traits<Derived>::Scalar>,Derived> operator-() const; // template<typename OtherDerived> -// const CwiseBinaryOp<ei_scalar_sum_op<typename ei_traits<Derived>::Scalar>, Derived, OtherDerived> +// const CwiseBinaryOp<internal::scalar_sum_op<typename internal::traits<Derived>::Scalar>, Derived, OtherDerived> // operator+(const SparseMatrixBase<OtherDerived> &other) const; // template<typename OtherDerived> -// const CwiseBinaryOp<ei_scalar_difference_op<typename ei_traits<Derived>::Scalar>, Derived, OtherDerived> +// const CwiseBinaryOp<internal::scalar_difference_op<typename internal::traits<Derived>::Scalar>, Derived, OtherDerived> // operator-(const SparseMatrixBase<OtherDerived> &other) const; template<typename OtherDerived> @@ -322,10 +322,10 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived> #define EIGEN_SPARSE_CWISE_PRODUCT_RETURN_TYPE \ CwiseBinaryOp< \ - ei_scalar_product_op< \ - typename ei_scalar_product_traits< \ - typename ei_traits<Derived>::Scalar, \ - typename ei_traits<OtherDerived>::Scalar \ + internal::scalar_product_op< \ + typename internal::scalar_product_traits< \ + typename internal::traits<Derived>::Scalar, \ + typename internal::traits<OtherDerived>::Scalar \ >::ReturnType \ >, \ Derived, \ @@ -336,12 +336,12 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived> EIGEN_STRONG_INLINE const EIGEN_SPARSE_CWISE_PRODUCT_RETURN_TYPE cwiseProduct(const MatrixBase<OtherDerived> &other) const; -// const SparseCwiseUnaryOp<ei_scalar_multiple_op<typename ei_traits<Derived>::Scalar>, Derived> +// const SparseCwiseUnaryOp<internal::scalar_multiple_op<typename internal::traits<Derived>::Scalar>, Derived> // operator*(const Scalar& scalar) const; -// const SparseCwiseUnaryOp<ei_scalar_quotient1_op<typename ei_traits<Derived>::Scalar>, Derived> +// const SparseCwiseUnaryOp<internal::scalar_quotient1_op<typename internal::traits<Derived>::Scalar>, Derived> // operator/(const Scalar& scalar) const; -// inline friend const SparseCwiseUnaryOp<ei_scalar_multiple_op<typename ei_traits<Derived>::Scalar>, Derived> +// inline friend const SparseCwiseUnaryOp<internal::scalar_multiple_op<typename internal::traits<Derived>::Scalar>, Derived> // operator*(const Scalar& scalar, const SparseMatrixBase& matrix) // { return matrix*scalar; } @@ -379,7 +379,7 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived> #ifdef EIGEN2_SUPPORT // deprecated template<typename OtherDerived> - typename ei_plain_matrix_type_column_major<OtherDerived>::type + typename internal::plain_matrix_type_column_major<OtherDerived>::type solveTriangular(const MatrixBase<OtherDerived>& other) const; // deprecated @@ -545,15 +545,15 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived> // template<typename NewType> -// const SparseCwiseUnaryOp<ei_scalar_cast_op<typename ei_traits<Derived>::Scalar, NewType>, Derived> cast() const; +// const SparseCwiseUnaryOp<internal::scalar_cast_op<typename internal::traits<Derived>::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<Derived>::type eval() const - { return typename ei_eval<Derived>::type(derived()); } + inline const typename internal::eval<Derived>::type eval() const + { return typename internal::eval<Derived>::type(derived()); } // template<typename OtherDerived> // void swap(MatrixBase<OtherDerived> EIGEN_REF_TO_TEMPORARY other); @@ -585,14 +585,14 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived> Scalar sum() const; // Scalar trace() const; -// typename ei_traits<Derived>::Scalar minCoeff() const; -// typename ei_traits<Derived>::Scalar maxCoeff() const; +// typename internal::traits<Derived>::Scalar minCoeff() const; +// typename internal::traits<Derived>::Scalar maxCoeff() const; -// typename ei_traits<Derived>::Scalar minCoeff(int* row, int* col = 0) const; -// typename ei_traits<Derived>::Scalar maxCoeff(int* row, int* col = 0) const; +// typename internal::traits<Derived>::Scalar minCoeff(int* row, int* col = 0) const; +// typename internal::traits<Derived>::Scalar maxCoeff(int* row, int* col = 0) const; // template<typename BinaryOp> -// typename ei_result_of<BinaryOp(typename ei_traits<Derived>::Scalar)>::type +// typename internal::result_of<BinaryOp(typename internal::traits<Derived>::Scalar)>::type // redux(const BinaryOp& func) const; // template<typename Visitor> @@ -612,9 +612,9 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived> const VectorwiseOp<Derived,Horizontal> rowwise() const; const VectorwiseOp<Derived,Vertical> colwise() const; - static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random(int rows, int cols); - static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random(int size); - static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random(); + static const CwiseNullaryOp<internal::scalar_random_op<Scalar>,Derived> Random(int rows, int cols); + static const CwiseNullaryOp<internal::scalar_random_op<Scalar>,Derived> Random(int size); + static const CwiseNullaryOp<internal::scalar_random_op<Scalar>,Derived> Random(); template<typename ThenDerived,typename ElseDerived> const Select<Derived,ThenDerived,ElseDerived> @@ -638,10 +638,10 @@ template<typename Derived> class SparseMatrixBase : public EigenBase<Derived> // { // EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) // EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived) -// EIGEN_STATIC_ASSERT((ei_is_same_type<Scalar, typename OtherDerived::Scalar>::ret), +// EIGEN_STATIC_ASSERT((internal::is_same_type<Scalar, typename OtherDerived::Scalar>::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<typename Derived> class SparseMatrixBase : public EigenBase<Derived> // 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()<j.index()) diff --git a/Eigen/src/Sparse/SparseProduct.h b/Eigen/src/Sparse/SparseProduct.h index ef6ef3c02..aa8bda23d 100644 --- a/Eigen/src/Sparse/SparseProduct.h +++ b/Eigen/src/Sparse/SparseProduct.h @@ -28,35 +28,36 @@ template<typename Lhs, typename Rhs> struct SparseSparseProductReturnType { - typedef typename ei_traits<Lhs>::Scalar Scalar; + typedef typename internal::traits<Lhs>::Scalar Scalar; enum { - LhsRowMajor = ei_traits<Lhs>::Flags & RowMajorBit, - RhsRowMajor = ei_traits<Rhs>::Flags & RowMajorBit, + LhsRowMajor = internal::traits<Lhs>::Flags & RowMajorBit, + RhsRowMajor = internal::traits<Rhs>::Flags & RowMajorBit, TransposeRhs = (!LhsRowMajor) && RhsRowMajor, TransposeLhs = LhsRowMajor && (!RhsRowMajor) }; - typedef typename ei_meta_if<TransposeLhs, + typedef typename internal::meta_if<TransposeLhs, SparseMatrix<Scalar,0>, - const typename ei_nested<Lhs,Rhs::RowsAtCompileTime>::type>::ret LhsNested; + const typename internal::nested<Lhs,Rhs::RowsAtCompileTime>::type>::ret LhsNested; - typedef typename ei_meta_if<TransposeRhs, + typedef typename internal::meta_if<TransposeRhs, SparseMatrix<Scalar,0>, - const typename ei_nested<Rhs,Lhs::RowsAtCompileTime>::type>::ret RhsNested; + const typename internal::nested<Rhs,Lhs::RowsAtCompileTime>::type>::ret RhsNested; typedef SparseSparseProduct<LhsNested, RhsNested> Type; }; +namespace internal { template<typename LhsNested, typename RhsNested> -struct ei_traits<SparseSparseProduct<LhsNested, RhsNested> > +struct traits<SparseSparseProduct<LhsNested, RhsNested> > { typedef MatrixXpr XprKind; // clean the nested types: - typedef typename ei_cleantype<LhsNested>::type _LhsNested; - typedef typename ei_cleantype<RhsNested>::type _RhsNested; + typedef typename cleantype<LhsNested>::type _LhsNested; + typedef typename cleantype<RhsNested>::type _RhsNested; typedef typename _LhsNested::Scalar Scalar; - typedef typename ei_promote_index_type<typename ei_traits<_LhsNested>::Index, - typename ei_traits<_RhsNested>::Index>::type Index; + typedef typename promote_index_type<typename traits<_LhsNested>::Index, + typename traits<_RhsNested>::Index>::type Index; enum { LhsCoeffReadCost = _LhsNested::CoeffReadCost, @@ -85,8 +86,10 @@ struct ei_traits<SparseSparseProduct<LhsNested, RhsNested> > typedef Sparse StorageKind; }; +} // end namespace internal + template<typename LhsNested, typename RhsNested> -class SparseSparseProduct : ei_no_assignment_operator, +class SparseSparseProduct : internal::no_assignment_operator, public SparseMatrixBase<SparseSparseProduct<LhsNested, RhsNested> > { public: @@ -96,8 +99,8 @@ class SparseSparseProduct : ei_no_assignment_operator, private: - typedef typename ei_traits<SparseSparseProduct>::_LhsNested _LhsNested; - typedef typename ei_traits<SparseSparseProduct>::_RhsNested _RhsNested; + typedef typename internal::traits<SparseSparseProduct>::_LhsNested _LhsNested; + typedef typename internal::traits<SparseSparseProduct>::_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 Derived> -typename ei_traits<Derived>::Scalar +typename internal::traits<Derived>::Scalar SparseMatrixBase<Derived>::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<outerSize(); ++j) for (typename Derived::InnerIterator iter(derived(),j); iter; ++iter) @@ -38,18 +38,18 @@ SparseMatrixBase<Derived>::sum() const } template<typename _Scalar, int _Options, typename _Index> -typename ei_traits<SparseMatrix<_Scalar,_Options,_Index> >::Scalar +typename internal::traits<SparseMatrix<_Scalar,_Options,_Index> >::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<Scalar,1,Dynamic>::Map(&m_data.value(0), m_data.size()).sum(); } template<typename _Scalar, int _Options, typename _Index> -typename ei_traits<SparseVector<_Scalar,_Options, _Index> >::Scalar +typename internal::traits<SparseVector<_Scalar,_Options, _Index> >::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<Scalar,1,Dynamic>::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<typename MatrixType, unsigned int UpLo> class SparseSelfAdjointView inline SparseSelfAdjointView(const MatrixType& matrix) : m_matrix(matrix) { - ei_assert(ei_are_flags_consistent<UpLo>::ret); - ei_assert(rows()==cols() && "SelfAdjointView is only for squared matrices"); + eigen_assert(internal::are_flags_consistent<UpLo>::ret); + eigen_assert(rows()==cols() && "SelfAdjointView is only for squared matrices"); } inline Index rows() const { return m_matrix.rows(); } @@ -142,12 +142,14 @@ SparseSelfAdjointView<MatrixType,UpLo>::rankUpdate(const MatrixBase<DerivedU>& u * Implementation of sparse self-adjoint time dense matrix ***************************************************************************/ +namespace internal { template<typename Lhs, typename Rhs, int UpLo> -struct ei_traits<SparseSelfAdjointTimeDenseProduct<Lhs,Rhs,UpLo> > - : ei_traits<ProductBase<SparseSelfAdjointTimeDenseProduct<Lhs,Rhs,UpLo>, Lhs, Rhs> > +struct traits<SparseSelfAdjointTimeDenseProduct<Lhs,Rhs,UpLo> > + : traits<ProductBase<SparseSelfAdjointTimeDenseProduct<Lhs,Rhs,UpLo>, Lhs, Rhs> > { typedef Dense StorageKind; }; +} template<typename Lhs, typename Rhs, int UpLo> class SparseSelfAdjointTimeDenseProduct @@ -162,9 +164,9 @@ class SparseSelfAdjointTimeDenseProduct template<typename Dest> 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<Lhs>::type _Lhs; - typedef typename ei_cleantype<Rhs>::type _Rhs; + eigen_assert(alpha==Scalar(1) && "alpha != 1 is not implemented yet, sorry"); + typedef typename internal::cleantype<Lhs>::type _Lhs; + typedef typename internal::cleantype<Rhs>::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<typename Lhs, typename Rhs, int UpLo> -struct ei_traits<DenseTimeSparseSelfAdjointProduct<Lhs,Rhs,UpLo> > - : ei_traits<ProductBase<DenseTimeSparseSelfAdjointProduct<Lhs,Rhs,UpLo>, Lhs, Rhs> > +struct traits<DenseTimeSparseSelfAdjointProduct<Lhs,Rhs,UpLo> > + : traits<ProductBase<DenseTimeSparseSelfAdjointProduct<Lhs,Rhs,UpLo>, Lhs, Rhs> > {}; +} template<typename Lhs, typename Rhs, int UpLo> 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<typename Lhs, typename Rhs, typename ResultType> -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<Lhs>::type::Scalar Scalar; - typedef typename ei_cleantype<Lhs>::type::Index Index; + typedef typename cleantype<Lhs>::type::Scalar Scalar; + typedef typename cleantype<Lhs>::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<bool> mask(rows,false); Matrix<Scalar,Dynamic,1> 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<typename Lhs, typename Rhs, typename ResultType> -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<Lhs>::type::Scalar Scalar; - typedef typename ei_cleantype<Lhs>::type::Index Index; + typedef typename cleantype<Lhs>::type::Scalar Scalar; + typedef typename cleantype<Lhs>::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<Scalar,Index> tempVector(rows); @@ -159,27 +161,27 @@ static void ei_sparse_product_impl(const Lhs& lhs, const Rhs& rhs, ResultType& r } template<typename Lhs, typename Rhs, typename ResultType, - int LhsStorageOrder = ei_traits<Lhs>::Flags&RowMajorBit, - int RhsStorageOrder = ei_traits<Rhs>::Flags&RowMajorBit, - int ResStorageOrder = ei_traits<ResultType>::Flags&RowMajorBit> -struct ei_sparse_product_selector; + int LhsStorageOrder = traits<Lhs>::Flags&RowMajorBit, + int RhsStorageOrder = traits<Rhs>::Flags&RowMajorBit, + int ResStorageOrder = traits<ResultType>::Flags&RowMajorBit> +struct sparse_product_selector; template<typename Lhs, typename Rhs, typename ResultType> -struct ei_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,ColMajor> +struct sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,ColMajor> { - typedef typename ei_traits<typename ei_cleantype<Lhs>::type>::Scalar Scalar; + typedef typename traits<typename cleantype<Lhs>::type>::Scalar Scalar; static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { // std::cerr << __LINE__ << "\n"; - typename ei_cleantype<ResultType>::type _res(res.rows(), res.cols()); - ei_sparse_product_impl<Lhs,Rhs,ResultType>(lhs, rhs, _res); + typename cleantype<ResultType>::type _res(res.rows(), res.cols()); + sparse_product_impl<Lhs,Rhs,ResultType>(lhs, rhs, _res); res.swap(_res); } }; template<typename Lhs, typename Rhs, typename ResultType> -struct ei_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,RowMajor> +struct sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,RowMajor> { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { @@ -187,26 +189,26 @@ struct ei_sparse_product_selector<Lhs,Rhs,ResultType,ColMajor,ColMajor,RowMajor> // we need a col-major matrix to hold the result typedef SparseMatrix<typename ResultType::Scalar> SparseTemporaryType; SparseTemporaryType _res(res.rows(), res.cols()); - ei_sparse_product_impl<Lhs,Rhs,SparseTemporaryType>(lhs, rhs, _res); + sparse_product_impl<Lhs,Rhs,SparseTemporaryType>(lhs, rhs, _res); res = _res; } }; template<typename Lhs, typename Rhs, typename ResultType> -struct ei_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,RowMajor> +struct sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,RowMajor> { 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<ResultType>::type _res(res.rows(), res.cols()); - ei_sparse_product_impl<Rhs,Lhs,ResultType>(rhs, lhs, _res); + typename cleantype<ResultType>::type _res(res.rows(), res.cols()); + sparse_product_impl<Rhs,Lhs,ResultType>(rhs, lhs, _res); res.swap(_res); } }; template<typename Lhs, typename Rhs, typename ResultType> -struct ei_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,ColMajor> +struct sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,ColMajor> { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { @@ -215,21 +217,22 @@ struct ei_sparse_product_selector<Lhs,Rhs,ResultType,RowMajor,RowMajor,ColMajor> ColMajorMatrix colLhs(lhs); ColMajorMatrix colRhs(rhs); // std::cerr << "more...\n"; - ei_sparse_product_impl<ColMajorMatrix,ColMajorMatrix,ResultType>(colLhs, colRhs, res); + sparse_product_impl<ColMajorMatrix,ColMajorMatrix,ResultType>(colLhs, colRhs, res); // std::cerr << "OK.\n"; // let's transpose the product to get a column x column product // typedef SparseMatrix<typename ResultType::Scalar> SparseTemporaryType; // SparseTemporaryType _res(res.cols(), res.rows()); -// ei_sparse_product_impl<Rhs,Lhs,SparseTemporaryType>(rhs, lhs, _res); +// sparse_product_impl<Rhs,Lhs,SparseTemporaryType>(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<typename Derived> @@ -237,33 +240,34 @@ template<typename Lhs, typename Rhs> inline Derived& SparseMatrixBase<Derived>::operator=(const SparseSparseProduct<Lhs,Rhs>& product) { // std::cerr << "there..." << typeid(Lhs).name() << " " << typeid(Lhs).name() << " " << (Derived::Flags&&RowMajorBit) << "\n"; - ei_sparse_product_selector< - typename ei_cleantype<Lhs>::type, - typename ei_cleantype<Rhs>::type, + internal::sparse_product_selector< + typename internal::cleantype<Lhs>::type, + typename internal::cleantype<Rhs>::type, Derived>::run(product.lhs(),product.rhs(),derived()); return derived(); } +namespace internal { template<typename Lhs, typename Rhs, typename ResultType, - int LhsStorageOrder = ei_traits<Lhs>::Flags&RowMajorBit, - int RhsStorageOrder = ei_traits<Rhs>::Flags&RowMajorBit, - int ResStorageOrder = ei_traits<ResultType>::Flags&RowMajorBit> -struct ei_sparse_product_selector2; + int LhsStorageOrder = traits<Lhs>::Flags&RowMajorBit, + int RhsStorageOrder = traits<Rhs>::Flags&RowMajorBit, + int ResStorageOrder = traits<ResultType>::Flags&RowMajorBit> +struct sparse_product_selector2; template<typename Lhs, typename Rhs, typename ResultType> -struct ei_sparse_product_selector2<Lhs,Rhs,ResultType,ColMajor,ColMajor,ColMajor> +struct sparse_product_selector2<Lhs,Rhs,ResultType,ColMajor,ColMajor,ColMajor> { - typedef typename ei_traits<typename ei_cleantype<Lhs>::type>::Scalar Scalar; + typedef typename traits<typename cleantype<Lhs>::type>::Scalar Scalar; static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { - ei_sparse_product_impl2<Lhs,Rhs,ResultType>(lhs, rhs, res); + sparse_product_impl2<Lhs,Rhs,ResultType>(lhs, rhs, res); } }; template<typename Lhs, typename Rhs, typename ResultType> -struct ei_sparse_product_selector2<Lhs,Rhs,ResultType,RowMajor,ColMajor,ColMajor> +struct sparse_product_selector2<Lhs,Rhs,ResultType,RowMajor,ColMajor,ColMajor> { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { @@ -275,79 +279,79 @@ struct ei_sparse_product_selector2<Lhs,Rhs,ResultType,RowMajor,ColMajor,ColMajor // typedef SparseMatrix<typename ResultType::Scalar,RowMajor> RowMajorMatrix; // RowMajorMatrix rhsRow = rhs; // RowMajorMatrix resRow(res.rows(), res.cols()); -// ei_sparse_product_impl2<RowMajorMatrix,Lhs,RowMajorMatrix>(rhsRow, lhs, resRow); +// sparse_product_impl2<RowMajorMatrix,Lhs,RowMajorMatrix>(rhsRow, lhs, resRow); // res = resRow; } }; template<typename Lhs, typename Rhs, typename ResultType> -struct ei_sparse_product_selector2<Lhs,Rhs,ResultType,ColMajor,RowMajor,ColMajor> +struct sparse_product_selector2<Lhs,Rhs,ResultType,ColMajor,RowMajor,ColMajor> { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { typedef SparseMatrix<typename ResultType::Scalar,RowMajor> RowMajorMatrix; RowMajorMatrix lhsRow = lhs; RowMajorMatrix resRow(res.rows(), res.cols()); - ei_sparse_product_impl2<Rhs,RowMajorMatrix,RowMajorMatrix>(rhs, lhsRow, resRow); + sparse_product_impl2<Rhs,RowMajorMatrix,RowMajorMatrix>(rhs, lhsRow, resRow); res = resRow; } }; template<typename Lhs, typename Rhs, typename ResultType> -struct ei_sparse_product_selector2<Lhs,Rhs,ResultType,RowMajor,RowMajor,ColMajor> +struct sparse_product_selector2<Lhs,Rhs,ResultType,RowMajor,RowMajor,ColMajor> { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { typedef SparseMatrix<typename ResultType::Scalar,RowMajor> RowMajorMatrix; RowMajorMatrix resRow(res.rows(), res.cols()); - ei_sparse_product_impl2<Rhs,Lhs,RowMajorMatrix>(rhs, lhs, resRow); + sparse_product_impl2<Rhs,Lhs,RowMajorMatrix>(rhs, lhs, resRow); res = resRow; } }; template<typename Lhs, typename Rhs, typename ResultType> -struct ei_sparse_product_selector2<Lhs,Rhs,ResultType,ColMajor,ColMajor,RowMajor> +struct sparse_product_selector2<Lhs,Rhs,ResultType,ColMajor,ColMajor,RowMajor> { - typedef typename ei_traits<typename ei_cleantype<Lhs>::type>::Scalar Scalar; + typedef typename traits<typename cleantype<Lhs>::type>::Scalar Scalar; static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { typedef SparseMatrix<typename ResultType::Scalar,ColMajor> ColMajorMatrix; ColMajorMatrix resCol(res.rows(), res.cols()); - ei_sparse_product_impl2<Lhs,Rhs,ColMajorMatrix>(lhs, rhs, resCol); + sparse_product_impl2<Lhs,Rhs,ColMajorMatrix>(lhs, rhs, resCol); res = resCol; } }; template<typename Lhs, typename Rhs, typename ResultType> -struct ei_sparse_product_selector2<Lhs,Rhs,ResultType,RowMajor,ColMajor,RowMajor> +struct sparse_product_selector2<Lhs,Rhs,ResultType,RowMajor,ColMajor,RowMajor> { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { typedef SparseMatrix<typename ResultType::Scalar,ColMajor> ColMajorMatrix; ColMajorMatrix lhsCol = lhs; ColMajorMatrix resCol(res.rows(), res.cols()); - ei_sparse_product_impl2<ColMajorMatrix,Rhs,ColMajorMatrix>(lhsCol, rhs, resCol); + sparse_product_impl2<ColMajorMatrix,Rhs,ColMajorMatrix>(lhsCol, rhs, resCol); res = resCol; } }; template<typename Lhs, typename Rhs, typename ResultType> -struct ei_sparse_product_selector2<Lhs,Rhs,ResultType,ColMajor,RowMajor,RowMajor> +struct sparse_product_selector2<Lhs,Rhs,ResultType,ColMajor,RowMajor,RowMajor> { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { typedef SparseMatrix<typename ResultType::Scalar,ColMajor> ColMajorMatrix; ColMajorMatrix rhsCol = rhs; ColMajorMatrix resCol(res.rows(), res.cols()); - ei_sparse_product_impl2<Lhs,ColMajorMatrix,ColMajorMatrix>(lhs, rhsCol, resCol); + sparse_product_impl2<Lhs,ColMajorMatrix,ColMajorMatrix>(lhs, rhsCol, resCol); res = resCol; } }; template<typename Lhs, typename Rhs, typename ResultType> -struct ei_sparse_product_selector2<Lhs,Rhs,ResultType,RowMajor,RowMajor,RowMajor> +struct sparse_product_selector2<Lhs,Rhs,ResultType,RowMajor,RowMajor,RowMajor> { static void run(const Lhs& lhs, const Rhs& rhs, ResultType& res) { @@ -355,26 +359,28 @@ struct ei_sparse_product_selector2<Lhs,Rhs,ResultType,RowMajor,RowMajor,RowMajor // ColMajorMatrix lhsTr(lhs); // ColMajorMatrix rhsTr(rhs); // ColMajorMatrix aux(res.rows(), res.cols()); -// ei_sparse_product_impl2<Rhs,Lhs,ColMajorMatrix>(rhs, lhs, aux); +// sparse_product_impl2<Rhs,Lhs,ColMajorMatrix>(rhs, lhs, aux); // // ColMajorMatrix aux2 = aux.transpose(); // res = aux; typedef SparseMatrix<typename ResultType::Scalar,ColMajor> ColMajorMatrix; ColMajorMatrix lhsCol(lhs); ColMajorMatrix rhsCol(rhs); ColMajorMatrix resCol(res.rows(), res.cols()); - ei_sparse_product_impl2<ColMajorMatrix,ColMajorMatrix,ColMajorMatrix>(lhsCol, rhsCol, resCol); + sparse_product_impl2<ColMajorMatrix,ColMajorMatrix,ColMajorMatrix>(lhsCol, rhsCol, resCol); res = resCol; } }; +} // end namespace internal + template<typename Derived> template<typename Lhs, typename Rhs> inline void SparseMatrixBase<Derived>::_experimentalNewProduct(const Lhs& lhs, const Rhs& rhs) { //derived().resize(lhs.rows(), rhs.cols()); - ei_sparse_product_selector2< - typename ei_cleantype<Lhs>::type, - typename ei_cleantype<Rhs>::type, + internal::sparse_product_selector2< + typename internal::cleantype<Lhs>::type, + typename internal::cleantype<Rhs>::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<typename MatrixType> class TransposeImpl<MatrixType,Sparse> : public SparseMatrixBase<Transpose<MatrixType> > { - typedef typename ei_cleantype<typename MatrixType::Nested>::type _MatrixTypeNested; + typedef typename internal::cleantype<typename MatrixType::Nested>::type _MatrixTypeNested; public: EIGEN_SPARSE_PUBLIC_INTERFACE(Transpose<MatrixType>) 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<typename MatrixType, int Mode> -struct ei_traits<SparseTriangularView<MatrixType,Mode> > -: public ei_traits<MatrixType> +struct traits<SparseTriangularView<MatrixType,Mode> > +: public traits<MatrixType> {}; +} template<typename MatrixType, int Mode> class SparseTriangularView : public SparseMatrixBase<SparseTriangularView<MatrixType,Mode> > @@ -44,7 +46,7 @@ template<typename MatrixType, int Mode> class SparseTriangularView inline Index rows() { return m_matrix.rows(); } inline Index cols() { return m_matrix.cols(); } - typedef typename ei_meta_if<ei_must_nest_by_value<MatrixType>::ret, + typedef typename internal::meta_if<internal::must_nest_by_value<MatrixType>::ret, MatrixType, const MatrixType&>::ret MatrixTypeNested; inline SparseTriangularView(const MatrixType& matrix) : m_matrix(matrix) {} @@ -53,7 +55,7 @@ template<typename MatrixType, int Mode> class SparseTriangularView inline const MatrixType& nestedExpression() const { return m_matrix; } template<typename OtherDerived> - typename ei_plain_matrix_type_column_major<OtherDerived>::type + typename internal::plain_matrix_type_column_major<OtherDerived>::type solve(const MatrixBase<OtherDerived>& other) const; template<typename OtherDerived> void solveInPlace(MatrixBase<OtherDerived>& 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<Derived>::Scalar Scalar; \ + typedef typename Eigen::internal::traits<Derived>::Scalar Scalar; \ typedef typename Eigen::NumTraits<Scalar>::Real RealScalar; \ - typedef typename Eigen::ei_nested<Derived>::type Nested; \ - typedef typename Eigen::ei_traits<Derived>::StorageKind StorageKind; \ - typedef typename Eigen::ei_traits<Derived>::Index Index; \ - enum { RowsAtCompileTime = Eigen::ei_traits<Derived>::RowsAtCompileTime, \ - ColsAtCompileTime = Eigen::ei_traits<Derived>::ColsAtCompileTime, \ - Flags = Eigen::ei_traits<Derived>::Flags, \ - CoeffReadCost = Eigen::ei_traits<Derived>::CoeffReadCost, \ + typedef typename Eigen::internal::nested<Derived>::type Nested; \ + typedef typename Eigen::internal::traits<Derived>::StorageKind StorageKind; \ + typedef typename Eigen::internal::traits<Derived>::Index Index; \ + enum { RowsAtCompileTime = Eigen::internal::traits<Derived>::RowsAtCompileTime, \ + ColsAtCompileTime = Eigen::internal::traits<Derived>::ColsAtCompileTime, \ + Flags = Eigen::internal::traits<Derived>::Flags, \ + CoeffReadCost = Eigen::internal::traits<Derived>::CoeffReadCost, \ SizeAtCompileTime = Base::SizeAtCompileTime, \ IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; \ using Base::derived; \ @@ -98,29 +98,33 @@ template<typename Lhs, typename Rhs> class DenseTimeSparseProduct; template<typename Lhs, typename Rhs, bool Transpose> class SparseDenseOuterProduct; template<typename Lhs, typename Rhs> struct SparseSparseProductReturnType; -template<typename Lhs, typename Rhs, int InnerSize = ei_traits<Lhs>::ColsAtCompileTime> struct DenseSparseProductReturnType; -template<typename Lhs, typename Rhs, int InnerSize = ei_traits<Lhs>::ColsAtCompileTime> struct SparseDenseProductReturnType; +template<typename Lhs, typename Rhs, int InnerSize = internal::traits<Lhs>::ColsAtCompileTime> struct DenseSparseProductReturnType; +template<typename Lhs, typename Rhs, int InnerSize = internal::traits<Lhs>::ColsAtCompileTime> struct SparseDenseProductReturnType; -template<typename T> struct ei_eval<T,Sparse> +namespace internal { + +template<typename T> struct eval<T,Sparse> { - typedef typename ei_traits<T>::Scalar _Scalar; + typedef typename traits<T>::Scalar _Scalar; enum { - _Flags = ei_traits<T>::Flags + _Flags = traits<T>::Flags }; public: typedef SparseMatrix<_Scalar, _Flags> type; }; -template<typename T> struct ei_plain_matrix_type<T,Sparse> +template<typename T> struct plain_matrix_type<T,Sparse> { - typedef typename ei_traits<T>::Scalar _Scalar; + typedef typename traits<T>::Scalar _Scalar; enum { - _Flags = ei_traits<T>::Flags + _Flags = traits<T>::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<typename _Scalar, int _Options, typename _Index> -struct ei_traits<SparseVector<_Scalar, _Options, _Index> > +struct traits<SparseVector<_Scalar, _Options, _Index> > { typedef _Scalar Scalar; typedef _Index Index; @@ -53,6 +55,7 @@ struct ei_traits<SparseVector<_Scalar, _Options, _Index> > SupportedAccessPatterns = InnerRandomAccessPattern }; }; +} template<typename _Scalar, int _Options, typename _Index> class SparseVector @@ -68,7 +71,7 @@ class SparseVector public: typedef SparseMatrixBase<SparseVector> SparseBase; - enum { IsColVector = ei_traits<SparseVector>::IsColVector }; + enum { IsColVector = internal::traits<SparseVector>::IsColVector }; CompressedStorage<Scalar,Index> 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<OtherDerived,2>::type OtherCopy; +// typedef typename internal::nested<OtherDerived,2>::type OtherCopy; // OtherCopy otherCopy(other.derived()); -// typedef typename ei_cleantype<OtherCopy>::type _OtherCopy; +// typedef typename internal::cleantype<OtherCopy>::type _OtherCopy; // // resize(other.rows(), other.cols()); // Eigen::Map<VectorXi>(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)<other.m_data.index(j)) @@ -351,7 +354,7 @@ class SparseVector /** \deprecated use insertBack(Index,Index) */ EIGEN_DEPRECATED Scalar& fill(Index r, Index c) { - ei_assert(r==0 || c==0); + eigen_assert(r==0 || c==0); return fill(IsColVector ? r : c); } @@ -365,7 +368,7 @@ class SparseVector /** \deprecated use insert(Index,Index) */ EIGEN_DEPRECATED Scalar& fillrand(Index r, Index c) { - ei_assert(r==0 || c==0); + eigen_assert(r==0 || c==0); return fillrand(IsColVector ? r : c); } @@ -386,7 +389,7 @@ class SparseVector<Scalar,_Options,_Index>::InnerIterator InnerIterator(const SparseVector& vec, Index outer=0) : m_data(vec.m_data), m_id(0), m_end(static_cast<Index>(m_data.size())) { - ei_assert(outer==0); + eigen_assert(outer==0); } InnerIterator(const CompressedStorage<Scalar,Index>& 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<typename MatrixType> -struct ei_traits<SparseView<MatrixType> > : ei_traits<MatrixType> +struct traits<SparseView<MatrixType> > : traits<MatrixType> { typedef int Index; typedef Sparse StorageKind; enum { - Flags = int(ei_traits<MatrixType>::Flags) & (RowMajorBit) + Flags = int(traits<MatrixType>::Flags) & (RowMajorBit) }; }; +} // end namespace internal + template<typename MatrixType> class SparseView : public SparseMatrixBase<SparseView<MatrixType> > { typedef typename MatrixType::Nested MatrixTypeNested; - typedef typename ei_cleantype<MatrixTypeNested>::type _MatrixTypeNested; + typedef typename internal::cleantype<MatrixTypeNested>::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<typename Lhs, typename Rhs, int Mode, int UpLo = (Mode & Lower) ? Lower : (Mode & Upper) ? Upper : -1, - int StorageOrder = int(ei_traits<Lhs>::Flags) & RowMajorBit> -struct ei_sparse_solve_triangular_selector; + int StorageOrder = int(traits<Lhs>::Flags) & RowMajorBit> +struct sparse_solve_triangular_selector; // forward substitution, row-major template<typename Lhs, typename Rhs, int Mode> -struct ei_sparse_solve_triangular_selector<Lhs,Rhs,Mode,Lower,RowMajor> +struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Lower,RowMajor> { typedef typename Rhs::Scalar Scalar; static void run(const Lhs& lhs, Rhs& other) @@ -60,7 +62,7 @@ struct ei_sparse_solve_triangular_selector<Lhs,Rhs,Mode,Lower,RowMajor> 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<Lhs,Rhs,Mode,Lower,RowMajor> // backward substitution, row-major template<typename Lhs, typename Rhs, int Mode> -struct ei_sparse_solve_triangular_selector<Lhs,Rhs,Mode,Upper,RowMajor> +struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Upper,RowMajor> { typedef typename Rhs::Scalar Scalar; static void run(const Lhs& lhs, Rhs& other) @@ -93,7 +95,7 @@ struct ei_sparse_solve_triangular_selector<Lhs,Rhs,Mode,Upper,RowMajor> 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<Lhs,Rhs,Mode,Upper,RowMajor> // forward substitution, col-major template<typename Lhs, typename Rhs, int Mode> -struct ei_sparse_solve_triangular_selector<Lhs,Rhs,Mode,Lower,ColMajor> +struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Lower,ColMajor> { typedef typename Rhs::Scalar Scalar; static void run(const Lhs& lhs, Rhs& other) @@ -118,7 +120,7 @@ struct ei_sparse_solve_triangular_selector<Lhs,Rhs,Mode,Lower,ColMajor> 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<Lhs,Rhs,Mode,Lower,ColMajor> // backward substitution, col-major template<typename Lhs, typename Rhs, int Mode> -struct ei_sparse_solve_triangular_selector<Lhs,Rhs,Mode,Upper,ColMajor> +struct sparse_solve_triangular_selector<Lhs,Rhs,Mode,Upper,ColMajor> { typedef typename Rhs::Scalar Scalar; static void run(const Lhs& lhs, Rhs& other) @@ -160,22 +162,24 @@ struct ei_sparse_solve_triangular_selector<Lhs,Rhs,Mode,Upper,ColMajor> } }; +} // end namespace internal + template<typename ExpressionType,int Mode> template<typename OtherDerived> void SparseTriangularView<ExpressionType,Mode>::solveInPlace(MatrixBase<OtherDerived>& 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<OtherDerived>::Flags & RowMajorBit }; + enum { copy = internal::traits<OtherDerived>::Flags & RowMajorBit }; - typedef typename ei_meta_if<copy, - typename ei_plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::ret OtherCopy; + typedef typename internal::meta_if<copy, + typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::ret OtherCopy; OtherCopy otherCopy(other.derived()); - ei_sparse_solve_triangular_selector<ExpressionType, typename ei_unref<OtherCopy>::type, Mode>::run(m_matrix, otherCopy); + internal::sparse_solve_triangular_selector<ExpressionType, typename internal::unref<OtherCopy>::type, Mode>::run(m_matrix, otherCopy); if (copy) other = otherCopy; @@ -183,16 +187,18 @@ void SparseTriangularView<ExpressionType,Mode>::solveInPlace(MatrixBase<OtherDer template<typename ExpressionType,int Mode> template<typename OtherDerived> -typename ei_plain_matrix_type_column_major<OtherDerived>::type +typename internal::plain_matrix_type_column_major<OtherDerived>::type SparseTriangularView<ExpressionType,Mode>::solve(const MatrixBase<OtherDerived>& other) const { - typename ei_plain_matrix_type_column_major<OtherDerived>::type res(other); + typename internal::plain_matrix_type_column_major<OtherDerived>::type res(other); solveInPlace(res); return res; } // pure sparse path +namespace internal { + template<typename Lhs, typename Rhs, int Mode, int UpLo = (Mode & Lower) ? Lower @@ -200,15 +206,15 @@ template<typename Lhs, typename Rhs, int Mode, ? Upper : -1, int StorageOrder = int(Lhs::Flags) & (RowMajorBit)> -struct ei_sparse_solve_triangular_sparse_selector; +struct sparse_solve_triangular_sparse_selector; // forward substitution, col-major template<typename Lhs, typename Rhs, int Mode, int UpLo> -struct ei_sparse_solve_triangular_sparse_selector<Lhs,Rhs,Mode,UpLo,ColMajor> +struct sparse_solve_triangular_sparse_selector<Lhs,Rhs,Mode,UpLo,ColMajor> { typedef typename Rhs::Scalar Scalar; - typedef typename ei_promote_index_type<typename ei_traits<Lhs>::Index, - typename ei_traits<Rhs>::Index>::type Index; + typedef typename promote_index_type<typename traits<Lhs>::Index, + typename traits<Rhs>::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<Lhs,Rhs,Mode,UpLo,ColMajor> { 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<Lhs,Rhs,Mode,UpLo,ColMajor> } }; +} // end namespace internal + template<typename ExpressionType,int Mode> template<typename OtherDerived> void SparseTriangularView<ExpressionType,Mode>::solveInPlace(SparseMatrixBase<OtherDerived>& 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<OtherDerived>::Flags & RowMajorBit }; +// enum { copy = internal::traits<OtherDerived>::Flags & RowMajorBit }; -// typedef typename ei_meta_if<copy, -// typename ei_plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::ret OtherCopy; +// typedef typename internal::meta_if<copy, +// typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::ret OtherCopy; // OtherCopy otherCopy(other.derived()); - ei_sparse_solve_triangular_sparse_selector<ExpressionType, OtherDerived, Mode>::run(m_matrix, other.derived()); + internal::sparse_solve_triangular_sparse_selector<ExpressionType, OtherDerived, Mode>::run(m_matrix, other.derived()); // if (copy) // other = otherCopy; @@ -319,10 +327,10 @@ void SparseMatrixBase<Derived>::solveTriangularInPlace(MatrixBase<OtherDerived>& /** \deprecated */ template<typename Derived> template<typename OtherDerived> -typename ei_plain_matrix_type_column_major<OtherDerived>::type +typename internal::plain_matrix_type_column_major<OtherDerived>::type SparseMatrixBase<Derived>::solveTriangular(const MatrixBase<OtherDerived>& other) const { - typename ei_plain_matrix_type_column_major<OtherDerived>::type res(other); + typename internal::plain_matrix_type_column_major<OtherDerived>::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 T> - class aligned_allocator_indirection : public EIGEN_ALIGNED_ALLOCATOR<T> - { - 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 T> + class aligned_allocator_indirection : public EIGEN_ALIGNED_ALLOCATOR<T> + { + 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<class U> - struct rebind - { - typedef aligned_allocator_indirection<U> other; - }; + template<class U> + struct rebind + { + typedef aligned_allocator_indirection<U> other; + }; - aligned_allocator_indirection() {} - aligned_allocator_indirection(const aligned_allocator_indirection& ) : EIGEN_ALIGNED_ALLOCATOR<T>() {} - aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR<T>& ) {} - template<class U> - aligned_allocator_indirection(const aligned_allocator_indirection<U>& ) {} - template<class U> - aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR<U>& ) {} - ~aligned_allocator_indirection() {} - }; + aligned_allocator_indirection() {} + aligned_allocator_indirection(const aligned_allocator_indirection& ) : EIGEN_ALIGNED_ALLOCATOR<T>() {} + aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR<T>& ) {} + template<class U> + aligned_allocator_indirection(const aligned_allocator_indirection<U>& ) {} + template<class U> + aligned_allocator_indirection(const EIGEN_ALIGNED_ALLOCATOR<U>& ) {} + ~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<T> - template<typename T> 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<T*>(this); } - inline operator const T& () const { return *static_cast<const T*>(this); } - template<typename OtherT> - 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<T> + namespace internal { + template<typename T> 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<T*>(this); } + inline operator const T& () const { return *static_cast<const T*>(this); } + template<typename OtherT> + 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<typename DecompositionType> -struct ei_traits<ei_image_retval_base<DecompositionType> > +struct traits<image_retval_base<DecompositionType> > { typedef typename DecompositionType::MatrixType MatrixType; typedef Matrix< @@ -43,15 +45,15 @@ struct ei_traits<ei_image_retval_base<DecompositionType> > > ReturnType; }; -template<typename _DecompositionType> struct ei_image_retval_base - : public ReturnByValue<ei_image_retval_base<_DecompositionType> > +template<typename _DecompositionType> struct image_retval_base + : public ReturnByValue<image_retval_base<_DecompositionType> > { typedef _DecompositionType DecompositionType; typedef typename DecompositionType::MatrixType MatrixType; - typedef ReturnByValue<ei_image_retval_base> Base; + typedef ReturnByValue<image_retval_base> 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<typename _DecompositionType> struct ei_image_retval_base template<typename Dest> inline void evalTo(Dest& dst) const { - static_cast<const ei_image_retval<DecompositionType>*>(this)->evalTo(dst); + static_cast<const image_retval<DecompositionType>*>(this)->evalTo(dst); } protected: @@ -74,18 +76,20 @@ template<typename _DecompositionType> 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<DecompositionType> Base; \ + typedef Eigen::internal::image_retval_base<DecompositionType> 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<typename DecompositionType> -struct ei_traits<ei_kernel_retval_base<DecompositionType> > +struct traits<kernel_retval_base<DecompositionType> > { typedef typename DecompositionType::MatrixType MatrixType; typedef Matrix< @@ -45,14 +47,14 @@ struct ei_traits<ei_kernel_retval_base<DecompositionType> > > ReturnType; }; -template<typename _DecompositionType> struct ei_kernel_retval_base - : public ReturnByValue<ei_kernel_retval_base<_DecompositionType> > +template<typename _DecompositionType> struct kernel_retval_base + : public ReturnByValue<kernel_retval_base<_DecompositionType> > { typedef _DecompositionType DecompositionType; - typedef ReturnByValue<ei_kernel_retval_base> Base; + typedef ReturnByValue<kernel_retval_base> 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<typename _DecompositionType> struct ei_kernel_retval_base template<typename Dest> inline void evalTo(Dest& dst) const { - static_cast<const ei_kernel_retval<DecompositionType>*>(this)->evalTo(dst); + static_cast<const kernel_retval<DecompositionType>*>(this)->evalTo(dst); } protected: @@ -73,16 +75,18 @@ template<typename _DecompositionType> 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<DecompositionType> Base; \ + typedef Eigen::internal::kernel_retval_base<DecompositionType> 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<typename DecompositionType, typename Rhs> -struct ei_traits<ei_solve_retval_base<DecompositionType, Rhs> > +struct traits<solve_retval_base<DecompositionType, Rhs> > { typedef typename DecompositionType::MatrixType MatrixType; typedef Matrix<typename Rhs::Scalar, @@ -40,15 +42,15 @@ struct ei_traits<ei_solve_retval_base<DecompositionType, Rhs> > Rhs::MaxColsAtCompileTime> ReturnType; }; -template<typename _DecompositionType, typename Rhs> struct ei_solve_retval_base - : public ReturnByValue<ei_solve_retval_base<_DecompositionType, Rhs> > +template<typename _DecompositionType, typename Rhs> struct solve_retval_base + : public ReturnByValue<solve_retval_base<_DecompositionType, Rhs> > { - typedef typename ei_cleantype<typename Rhs::Nested>::type RhsNestedCleaned; + typedef typename cleantype<typename Rhs::Nested>::type RhsNestedCleaned; typedef _DecompositionType DecompositionType; - typedef ReturnByValue<ei_solve_retval_base> Base; + typedef ReturnByValue<solve_retval_base> 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<typename _DecompositionType, typename Rhs> struct ei_solve_retval_base template<typename Dest> inline void evalTo(Dest& dst) const { - static_cast<const ei_solve_retval<DecompositionType,Rhs>*>(this)->evalTo(dst); + static_cast<const solve_retval<DecompositionType,Rhs>*>(this)->evalTo(dst); } protected: @@ -67,17 +69,19 @@ template<typename _DecompositionType, typename Rhs> 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<DecompositionType,Rhs> Base; \ + typedef Eigen::internal::solve_retval_base<DecompositionType,Rhs> 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<OtherDerived> &other) const * \sa MatrixBase::cwiseQuotient */ template<typename OtherDerived> -EIGEN_STRONG_INLINE const CwiseBinaryOp<ei_scalar_quotient_op<Scalar>, Derived, OtherDerived> +EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, Derived, OtherDerived> operator/(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const { - return CwiseBinaryOp<ei_scalar_quotient_op<Scalar>, Derived, OtherDerived>(derived(), other.derived()); + return CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, 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<OtherDerived> &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<ei_scalar_add_op<Scalar>, Derived> +inline const CwiseUnaryOp<internal::scalar_add_op<Scalar>, Derived> operator+(const Scalar& scalar) const { - return CwiseUnaryOp<ei_scalar_add_op<Scalar>, Derived>(derived(), ei_scalar_add_op<Scalar>(scalar)); + return CwiseUnaryOp<internal::scalar_add_op<Scalar>, Derived>(derived(), internal::scalar_add_op<Scalar>(scalar)); } -friend inline const CwiseUnaryOp<ei_scalar_add_op<Scalar>, Derived> +friend inline const CwiseUnaryOp<internal::scalar_add_op<Scalar>, Derived> operator+(const Scalar& scalar,const EIGEN_CURRENT_STORAGE_BASE_CLASS<Derived>& other) { return other + scalar; @@ -130,13 +130,13 @@ operator+(const Scalar& scalar,const EIGEN_CURRENT_STORAGE_BASE_CLASS<Derived>& * * \sa operator+(), operator-=() */ -inline const CwiseUnaryOp<ei_scalar_add_op<Scalar>, Derived> +inline const CwiseUnaryOp<internal::scalar_add_op<Scalar>, Derived> operator-(const Scalar& scalar) const { return *this + (-scalar); } -friend inline const CwiseUnaryOp<ei_scalar_add_op<Scalar>, CwiseUnaryOp<ei_scalar_opposite_op<Scalar>,Derived> > +friend inline const CwiseUnaryOp<internal::scalar_add_op<Scalar>, CwiseUnaryOp<internal::scalar_opposite_op<Scalar>,Derived> > operator-(const Scalar& scalar,const EIGEN_CURRENT_STORAGE_BASE_CLASS<Derived>& 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<ei_scalar_abs_op<Scalar>, Derived> +EIGEN_STRONG_INLINE const CwiseUnaryOp<internal::scalar_abs_op<Scalar>, Derived> abs() const { return derived(); @@ -20,7 +20,7 @@ abs() const * * \sa abs(), square() */ -EIGEN_STRONG_INLINE const CwiseUnaryOp<ei_scalar_abs2_op<Scalar>, Derived> +EIGEN_STRONG_INLINE const CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, Derived> abs2() const { return derived(); @@ -33,7 +33,7 @@ abs2() const * * \sa pow(), log(), sin(), cos() */ -inline const CwiseUnaryOp<ei_scalar_exp_op<Scalar>, Derived> +inline const CwiseUnaryOp<internal::scalar_exp_op<Scalar>, Derived> exp() const { return derived(); @@ -46,7 +46,7 @@ exp() const * * \sa exp() */ -inline const CwiseUnaryOp<ei_scalar_log_op<Scalar>, Derived> +inline const CwiseUnaryOp<internal::scalar_log_op<Scalar>, Derived> log() const { return derived(); @@ -59,7 +59,7 @@ log() const * * \sa pow(), square() */ -inline const CwiseUnaryOp<ei_scalar_sqrt_op<Scalar>, Derived> +inline const CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, Derived> sqrt() const { return derived(); @@ -72,7 +72,7 @@ sqrt() const * * \sa sin(), exp() */ -inline const CwiseUnaryOp<ei_scalar_cos_op<Scalar>, Derived> +inline const CwiseUnaryOp<internal::scalar_cos_op<Scalar>, Derived> cos() const { return derived(); @@ -86,7 +86,7 @@ cos() const * * \sa cos(), exp() */ -inline const CwiseUnaryOp<ei_scalar_sin_op<Scalar>, Derived> +inline const CwiseUnaryOp<internal::scalar_sin_op<Scalar>, Derived> sin() const { return derived(); @@ -100,11 +100,11 @@ sin() const * * \sa exp(), log() */ -inline const CwiseUnaryOp<ei_scalar_pow_op<Scalar>, Derived> +inline const CwiseUnaryOp<internal::scalar_pow_op<Scalar>, Derived> pow(const Scalar& exponent) const { - return CwiseUnaryOp<ei_scalar_pow_op<Scalar>,Derived> - (derived(), ei_scalar_pow_op<Scalar>(exponent)); + return CwiseUnaryOp<internal::scalar_pow_op<Scalar>,Derived> + (derived(), internal::scalar_pow_op<Scalar>(exponent)); } @@ -115,7 +115,7 @@ pow(const Scalar& exponent) const * * \sa operator/(), operator*() */ -inline const CwiseUnaryOp<ei_scalar_inverse_op<Scalar>, Derived> +inline const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, Derived> inverse() const { return derived(); @@ -128,7 +128,7 @@ inverse() const * * \sa operator/(), operator*(), abs2() */ -inline const CwiseUnaryOp<ei_scalar_square_op<Scalar>, Derived> +inline const CwiseUnaryOp<internal::scalar_square_op<Scalar>, Derived> square() const { return derived(); @@ -141,7 +141,7 @@ square() const * * \sa square(), pow() */ -inline const CwiseUnaryOp<ei_scalar_cube_op<Scalar>, Derived> +inline const CwiseUnaryOp<internal::scalar_cube_op<Scalar>, 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<Derived, ei_traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ColXpr; +typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, 1, !IsRowMajor> ColXpr; /** \internal expression type of a row */ -typedef Block<Derived, 1, ei_traits<Derived>::ColsAtCompileTime, IsRowMajor> RowXpr; +typedef Block<Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowXpr; /** \internal expression type of a block of whole columns */ -typedef Block<Derived, ei_traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr; +typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr; /** \internal expression type of a block of whole rows */ -typedef Block<Derived, Dynamic, ei_traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr; +typedef Block<Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr; /** \internal expression type of a block of whole columns */ -template<int N> struct NColsBlockXpr { typedef Block<Derived, ei_traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; }; +template<int N> struct NColsBlockXpr { typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; }; /** \internal expression type of a block of whole rows */ -template<int N> struct NRowsBlockXpr { typedef Block<Derived, N, ei_traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; }; +template<int N> struct NRowsBlockXpr { typedef Block<Derived, N, internal::traits<Derived>::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<ei_scalar_multiple_op<Scalar>, Derived> ScalarMultipleReturnType; +typedef CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, Derived> ScalarMultipleReturnType; /** \internal Represents a quotient of an expression by a scalar*/ -typedef CwiseUnaryOp<ei_scalar_quotient1_op<Scalar>, Derived> ScalarQuotient1ReturnType; +typedef CwiseUnaryOp<internal::scalar_quotient1_op<Scalar>, Derived> ScalarQuotient1ReturnType; /** \internal the return type of conjugate() */ -typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex, - const CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Derived>, +typedef typename internal::meta_if<NumTraits<Scalar>::IsComplex, + const CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, Derived>, const Derived& >::ret ConjugateReturnType; /** \internal the return type of real() const */ -typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex, - const CwiseUnaryOp<ei_scalar_real_op<Scalar>, Derived>, +typedef typename internal::meta_if<NumTraits<Scalar>::IsComplex, + const CwiseUnaryOp<internal::scalar_real_op<Scalar>, Derived>, const Derived& >::ret RealReturnType; /** \internal the return type of real() */ -typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex, - CwiseUnaryView<ei_scalar_real_ref_op<Scalar>, Derived>, +typedef typename internal::meta_if<NumTraits<Scalar>::IsComplex, + CwiseUnaryView<internal::scalar_real_ref_op<Scalar>, Derived>, Derived& >::ret NonConstRealReturnType; /** \internal the return type of imag() const */ -typedef CwiseUnaryOp<ei_scalar_imag_op<Scalar>, Derived> ImagReturnType; +typedef CwiseUnaryOp<internal::scalar_imag_op<Scalar>, Derived> ImagReturnType; /** \internal the return type of imag() */ -typedef CwiseUnaryView<ei_scalar_imag_ref_op<Scalar>, Derived> NonConstImagReturnType; +typedef CwiseUnaryView<internal::scalar_imag_ref_op<Scalar>, Derived> NonConstImagReturnType; #endif // not EIGEN_PARSED_BY_DOXYGEN /** \returns an expression of the opposite of \c *this */ -inline const CwiseUnaryOp<ei_scalar_opposite_op<typename ei_traits<Derived>::Scalar>,Derived> +inline const CwiseUnaryOp<internal::scalar_opposite_op<typename internal::traits<Derived>::Scalar>,Derived> operator-() const { return derived(); } @@ -63,8 +63,8 @@ operator-() const { return derived(); } inline const ScalarMultipleReturnType operator*(const Scalar& scalar) const { - return CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived> - (derived(), ei_scalar_multiple_op<Scalar>(scalar)); + return CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, Derived> + (derived(), internal::scalar_multiple_op<Scalar>(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<ei_scalar_quotient1_op<typename ei_traits<Derived>::Scalar>, Derived> +inline const CwiseUnaryOp<internal::scalar_quotient1_op<typename internal::traits<Derived>::Scalar>, Derived> operator/(const Scalar& scalar) const { - return CwiseUnaryOp<ei_scalar_quotient1_op<Scalar>, Derived> - (derived(), ei_scalar_quotient1_op<Scalar>(scalar)); + return CwiseUnaryOp<internal::scalar_quotient1_op<Scalar>, Derived> + (derived(), internal::scalar_quotient1_op<Scalar>(scalar)); } /** Overloaded for efficient real matrix times complex scalar value */ -inline const CwiseUnaryOp<ei_scalar_multiple2_op<Scalar,std::complex<Scalar> >, Derived> +inline const CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >, Derived> operator*(const std::complex<Scalar>& scalar) const { - return CwiseUnaryOp<ei_scalar_multiple2_op<Scalar,std::complex<Scalar> >, Derived> - (*static_cast<const Derived*>(this), ei_scalar_multiple2_op<Scalar,std::complex<Scalar> >(scalar)); + return CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >, Derived> + (*static_cast<const Derived*>(this), internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >(scalar)); } inline friend const ScalarMultipleReturnType operator*(const Scalar& scalar, const StorageBaseType& matrix) { return matrix*scalar; } -inline friend const CwiseUnaryOp<ei_scalar_multiple2_op<Scalar,std::complex<Scalar> >, Derived> +inline friend const CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >, Derived> operator*(const std::complex<Scalar>& scalar, const StorageBaseType& matrix) { return matrix*scalar; } @@ -103,7 +103,7 @@ operator*(const std::complex<Scalar>& scalar, const StorageBaseType& matrix) * \sa class CwiseUnaryOp */ template<typename NewType> -typename ei_cast_return_type<Derived,const CwiseUnaryOp<ei_scalar_cast_op<typename ei_traits<Derived>::Scalar, NewType>, Derived> >::type +typename internal::cast_return_type<Derived,const CwiseUnaryOp<internal::scalar_cast_op<typename internal::traits<Derived>::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<OtherDerived> &other) const * \sa class CwiseBinaryOp, max() */ template<typename OtherDerived> -EIGEN_STRONG_INLINE const CwiseBinaryOp<ei_scalar_min_op<Scalar>, Derived, OtherDerived> +EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar>, Derived, OtherDerived> cwiseMin(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const { - return CwiseBinaryOp<ei_scalar_min_op<Scalar>, Derived, OtherDerived>(derived(), other.derived()); + return CwiseBinaryOp<internal::scalar_min_op<Scalar>, 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<OtherDerived> &other) const * \sa class CwiseBinaryOp, min() */ template<typename OtherDerived> -EIGEN_STRONG_INLINE const CwiseBinaryOp<ei_scalar_max_op<Scalar>, Derived, OtherDerived> +EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar>, Derived, OtherDerived> cwiseMax(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const { - return CwiseBinaryOp<ei_scalar_max_op<Scalar>, Derived, OtherDerived>(derived(), other.derived()); + return CwiseBinaryOp<internal::scalar_max_op<Scalar>, 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<OtherDerived> &other) const * \sa class CwiseBinaryOp, cwiseProduct(), cwiseInverse() */ template<typename OtherDerived> -EIGEN_STRONG_INLINE const CwiseBinaryOp<ei_scalar_quotient_op<Scalar>, Derived, OtherDerived> +EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, Derived, OtherDerived> cwiseQuotient(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const { - return CwiseBinaryOp<ei_scalar_quotient_op<Scalar>, Derived, OtherDerived>(derived(), other.derived()); + return CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, 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<ei_scalar_abs_op<Scalar>,Derived> +EIGEN_STRONG_INLINE const CwiseUnaryOp<internal::scalar_abs_op<Scalar>,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<ei_scalar_abs2_op<Scalar>,Derived> +EIGEN_STRONG_INLINE const CwiseUnaryOp<internal::scalar_abs2_op<Scalar>,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<ei_scalar_sqrt_op<Scalar>,Derived> +inline const CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>,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<ei_scalar_inverse_op<Scalar>,Derived> +inline const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>,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<float>(0,1) < density) ? ei_random<Scalar>() : 0; + Scalar v = (internal::random<float>(0,1) < density) ? internal::random<Scalar>() : 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<int> aux; for(int i = 0; i < nnzPerCol; i++) { - int k = ei_random<int>(0,rows-1); + int k = internal::random<int>(0,rows-1); while (aux.find(k)!=aux.end()) - k = ei_random<int>(0,rows-1); + k = internal::random<int>(0,rows-1); aux.insert(k); - dst.insert(k,j) = ei_random<Scalar>(); + dst.insert(k,j) = internal::random<Scalar>(); } } 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<int>(1,64); - N = ei_random<int>(1,768); - K = ei_random<int>(1,768); + M = internal::random<int>(1,64); + N = internal::random<int>(1,768); + K = internal::random<int>(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<int>(0,covMat.rows()-1); - int c = ei_random<int>(0,covMat.cols()-1); + int r = internal::random<int>(0,covMat.rows()-1); + int c = internal::random<int>(0,covMat.cols()-1); for (int t=0; t<TRIES; ++t) { timerNoSqrt.start(); diff --git a/bench/benchEigenSolver.cpp b/bench/benchEigenSolver.cpp index de2fa600e..dd78c7e01 100644 --- a/bench/benchEigenSolver.cpp +++ b/bench/benchEigenSolver.cpp @@ -48,8 +48,8 @@ __attribute__ ((noinline)) void benchEigenSolver(const MatrixType& m) BenchTimer timerSa, timerStd; Scalar acc = 0; - int r = ei_random<int>(0,covMat.rows()-1); - int c = ei_random<int>(0,covMat.cols()-1); + int r = internal::random<int>(0,covMat.rows()-1); + int c = internal::random<int>(0,covMat.cols()-1); { SelfAdjointEigenSolver<SquareMatrixType> ei(covMat); for (int t=0; t<TRIES; ++t) diff --git a/bench/benchVecAdd.cpp b/bench/benchVecAdd.cpp index 755c75ed5..ce8e1e911 100644 --- a/bench/benchVecAdd.cpp +++ b/bench/benchVecAdd.cpp @@ -22,9 +22,9 @@ int main(int argc, char* argv[]) { int size = SIZE * 8; int size2 = size * size; - Scalar* a = ei_aligned_new<Scalar>(size2); - Scalar* b = ei_aligned_new<Scalar>(size2+4)+1; - Scalar* c = ei_aligned_new<Scalar>(size2); + Scalar* a = internal::aligned_new<Scalar>(size2); + Scalar* b = internal::aligned_new<Scalar>(size2+4)+1; + Scalar* c = internal::aligned_new<Scalar>(size2); for (int i=0; i<size; ++i) { @@ -90,46 +90,46 @@ void benchVec(VectorXf& a, VectorXf& b, VectorXf& c) void benchVec(Scalar* a, Scalar* b, Scalar* c, int size) { - typedef ei_packet_traits<Scalar>::type PacketScalar; - const int PacketSize = ei_packet_traits<Scalar>::size; + typedef internal::packet_traits<Scalar>::type PacketScalar; + const int PacketSize = internal::packet_traits<Scalar>::size; PacketScalar a0, a1, a2, a3, b0, b1, b2, b3; for (int k=0; k<REPEAT; ++k) for (int i=0; i<size; i+=PacketSize*8) { -// a0 = ei_pload(&a[i]); -// b0 = ei_pload(&b[i]); -// a1 = ei_pload(&a[i+1*PacketSize]); -// b1 = ei_pload(&b[i+1*PacketSize]); -// a2 = ei_pload(&a[i+2*PacketSize]); -// b2 = ei_pload(&b[i+2*PacketSize]); -// a3 = ei_pload(&a[i+3*PacketSize]); -// b3 = ei_pload(&b[i+3*PacketSize]); -// ei_pstore(&a[i], ei_padd(a0, b0)); -// a0 = ei_pload(&a[i+4*PacketSize]); -// b0 = ei_pload(&b[i+4*PacketSize]); +// a0 = internal::pload(&a[i]); +// b0 = internal::pload(&b[i]); +// a1 = internal::pload(&a[i+1*PacketSize]); +// b1 = internal::pload(&b[i+1*PacketSize]); +// a2 = internal::pload(&a[i+2*PacketSize]); +// b2 = internal::pload(&b[i+2*PacketSize]); +// a3 = internal::pload(&a[i+3*PacketSize]); +// b3 = internal::pload(&b[i+3*PacketSize]); +// internal::pstore(&a[i], internal::padd(a0, b0)); +// a0 = internal::pload(&a[i+4*PacketSize]); +// b0 = internal::pload(&b[i+4*PacketSize]); // -// ei_pstore(&a[i+1*PacketSize], ei_padd(a1, b1)); -// a1 = ei_pload(&a[i+5*PacketSize]); -// b1 = ei_pload(&b[i+5*PacketSize]); +// internal::pstore(&a[i+1*PacketSize], internal::padd(a1, b1)); +// a1 = internal::pload(&a[i+5*PacketSize]); +// b1 = internal::pload(&b[i+5*PacketSize]); // -// ei_pstore(&a[i+2*PacketSize], ei_padd(a2, b2)); -// a2 = ei_pload(&a[i+6*PacketSize]); -// b2 = ei_pload(&b[i+6*PacketSize]); +// internal::pstore(&a[i+2*PacketSize], internal::padd(a2, b2)); +// a2 = internal::pload(&a[i+6*PacketSize]); +// b2 = internal::pload(&b[i+6*PacketSize]); // -// ei_pstore(&a[i+3*PacketSize], ei_padd(a3, b3)); -// a3 = ei_pload(&a[i+7*PacketSize]); -// b3 = ei_pload(&b[i+7*PacketSize]); +// internal::pstore(&a[i+3*PacketSize], internal::padd(a3, b3)); +// a3 = internal::pload(&a[i+7*PacketSize]); +// b3 = internal::pload(&b[i+7*PacketSize]); // -// ei_pstore(&a[i+4*PacketSize], ei_padd(a0, b0)); -// ei_pstore(&a[i+5*PacketSize], ei_padd(a1, b1)); -// ei_pstore(&a[i+6*PacketSize], ei_padd(a2, b2)); -// ei_pstore(&a[i+7*PacketSize], ei_padd(a3, b3)); +// internal::pstore(&a[i+4*PacketSize], internal::padd(a0, b0)); +// internal::pstore(&a[i+5*PacketSize], internal::padd(a1, b1)); +// internal::pstore(&a[i+6*PacketSize], internal::padd(a2, b2)); +// internal::pstore(&a[i+7*PacketSize], internal::padd(a3, b3)); - ei_pstore(&a[i+2*PacketSize], ei_padd(ei_ploadu(&a[i+2*PacketSize]), ei_ploadu(&b[i+2*PacketSize]))); - ei_pstore(&a[i+3*PacketSize], ei_padd(ei_ploadu(&a[i+3*PacketSize]), ei_ploadu(&b[i+3*PacketSize]))); - ei_pstore(&a[i+4*PacketSize], ei_padd(ei_ploadu(&a[i+4*PacketSize]), ei_ploadu(&b[i+4*PacketSize]))); - ei_pstore(&a[i+5*PacketSize], ei_padd(ei_ploadu(&a[i+5*PacketSize]), ei_ploadu(&b[i+5*PacketSize]))); - ei_pstore(&a[i+6*PacketSize], ei_padd(ei_ploadu(&a[i+6*PacketSize]), ei_ploadu(&b[i+6*PacketSize]))); - ei_pstore(&a[i+7*PacketSize], ei_padd(ei_ploadu(&a[i+7*PacketSize]), ei_ploadu(&b[i+7*PacketSize]))); + internal::pstore(&a[i+2*PacketSize], internal::padd(internal::ploadu(&a[i+2*PacketSize]), internal::ploadu(&b[i+2*PacketSize]))); + internal::pstore(&a[i+3*PacketSize], internal::padd(internal::ploadu(&a[i+3*PacketSize]), internal::ploadu(&b[i+3*PacketSize]))); + internal::pstore(&a[i+4*PacketSize], internal::padd(internal::ploadu(&a[i+4*PacketSize]), internal::ploadu(&b[i+4*PacketSize]))); + internal::pstore(&a[i+5*PacketSize], internal::padd(internal::ploadu(&a[i+5*PacketSize]), internal::ploadu(&b[i+5*PacketSize]))); + internal::pstore(&a[i+6*PacketSize], internal::padd(internal::ploadu(&a[i+6*PacketSize]), internal::ploadu(&b[i+6*PacketSize]))); + internal::pstore(&a[i+7*PacketSize], internal::padd(internal::ploadu(&a[i+7*PacketSize]), internal::ploadu(&b[i+7*PacketSize]))); } } diff --git a/bench/bench_gemm.cpp b/bench/bench_gemm.cpp index bc3089b9f..65fe4da1e 100644 --- a/bench/bench_gemm.cpp +++ b/bench/bench_gemm.cpp @@ -116,11 +116,11 @@ EIGEN_DONT_INLINE void gemm(const A& a, const B& b, C& c) int main(int argc, char ** argv) { - std::ptrdiff_t l1 = ei_queryL1CacheSize(); - std::ptrdiff_t l2 = ei_queryTopLevelCacheSize(); + std::ptrdiff_t l1 = internal::queryL1CacheSize(); + std::ptrdiff_t l2 = internal::queryTopLevelCacheSize(); std::cout << "L1 cache size = " << (l1>0 ? l1/1024 : -1) << " KB\n"; std::cout << "L2/L3 cache size = " << (l2>0 ? l2/1024 : -1) << " KB\n"; - typedef ei_gebp_traits<Scalar,Scalar> Traits; + typedef internal::gebp_traits<Scalar,Scalar> 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<n;++i) { - Scalar ax = ei_abs(v.coeff(i)); + Scalar ax = internal::abs(v.coeff(i)); if (scale >= 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<typename T> @@ -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<typename T> @@ -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<Scalar>::type Packet; - const int ps = ei_packet_traits<Scalar>::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<Scalar>::type Packet; + const int ps = internal::packet_traits<Scalar>::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<v.size(); j+=ps) { - Packet ax = ei_pabs(v.template packet<Aligned>(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<Aligned>(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>()); - double yd = based * ei_abs(ei_random<double>()); + double yf = basef * internal::abs(internal::random<double>()); + double yd = based * internal::abs(internal::random<double>()); 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<s; ++i) { - vf[i] = ei_abs(ei_random<double>()) * std::pow(double(10), ei_random<int>(ef0,ef1)); - vd[i] = ei_abs(ei_random<double>()) * std::pow(double(10), ei_random<int>(ed0,ed1)); + vf[i] = internal::abs(internal::random<double>()) * std::pow(double(10), internal::random<int>(ef0,ef1)); + vd[i] = internal::abs(internal::random<double>()) * std::pow(double(10), internal::random<int>(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<long double>()) << "\t" << sqsumNorm(vd.cast<long double>()) << "\n"; std::cout << "hypotNorm\t" << hypotNorm(vf) << "\t" << hypotNorm(vd) << "\t" << hypotNorm(vf.cast<long double>()) << "\t" << hypotNorm(vd.cast<long double>()) << "\n"; std::cout << "blueNorm\t" << blueNorm(vf) << "\t" << blueNorm(vd) << "\t" << blueNorm(vf.cast<long double>()) << "\t" << blueNorm(vd.cast<long double>()) << "\n"; @@ -273,7 +273,7 @@ int main(int argc, char** argv) { int tries = 10; int iters = 100000; - double y = 1.1345743233455785456788e12 * ei_random<double>(); + double y = 1.1345743233455785456788e12 * internal::random<double>(); 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<int>(0,rows-1); - int c = ei_random<int>(0,cols-1); + int r = internal::random<int>(0,rows-1); + int c = internal::random<int>(0,cols-1); for (int t=0; t<TRIES; ++t) { timerB.start(); diff --git a/bench/benchmarkSlice.cpp b/bench/benchmarkSlice.cpp index 3d04b6fd5..c5b89c545 100644 --- a/bench/benchmarkSlice.cpp +++ b/bench/benchmarkSlice.cpp @@ -24,10 +24,10 @@ int main(int argc, char *argv[]) for(int a = 0; a < REPEAT; a++) { int r, c, nr, nc; - r = Eigen::ei_random<int>(0,10); - c = Eigen::ei_random<int>(0,10); - nr = Eigen::ei_random<int>(50,80); - nc = Eigen::ei_random<int>(50,80); + r = Eigen::internal::random<int>(0,10); + c = Eigen::internal::random<int>(0,10); + nr = Eigen::internal::random<int>(50,80); + nc = Eigen::internal::random<int>(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<Lower>() * B); -// ei_product_selfadjoint_vector<real,0,LowerTriangularBit,false,false>(N,A.data(),N, B.data(), 1, X.data(), 1); +// internal::product_selfadjoint_vector<real,0,LowerTriangularBit,false,false>(N,A.data(),N, B.data(), 1, X.data(), 1); } template<typename Dest, typename Src> static void triassign(Dest& dst, const Src& src) { typedef typename Dest::Scalar Scalar; - typedef typename ei_packet_traits<Scalar>::type Packet; + typedef typename internal::packet_traits<Scalar>::type Packet; const int PacketSize = sizeof(Packet)/sizeof(Scalar); int size = dst.cols(); for(int j=0; j<size; j+=1) @@ -121,7 +121,7 @@ public : Scalar* A0 = dst.data() + j*dst.stride(); int starti = j; int alignedEnd = starti; - int alignedStart = (starti) + ei_first_aligned(&A0[starti], size-starti); + int alignedStart = (starti) + internal::first_aligned(&A0[starti], size-starti); alignedEnd = alignedStart + ((size-alignedStart)/(2*PacketSize))*(PacketSize*2); // do the non-vectorizable part of the assignment @@ -155,7 +155,7 @@ public : } static EIGEN_DONT_INLINE void syr2(gene_matrix & A, gene_vector & X, gene_vector & Y, int N){ - // ei_product_selfadjoint_rank2_update<real,0,LowerTriangularBit>(N,A.data(),N, X.data(), 1, Y.data(), 1, -1); + // internal::product_selfadjoint_rank2_update<real,0,LowerTriangularBit>(N,A.data(),N, X.data(), 1, Y.data(), 1, -1); for(int j=0; j<N; ++j) A.col(j).tail(N-j) += X[j] * Y.tail(N-j) + Y[j] * X.tail(N-j); } @@ -166,7 +166,7 @@ public : } static EIGEN_DONT_INLINE void rot(gene_vector & A, gene_vector & B, real c, real s, int N){ - ei_apply_rotation_in_the_plane(A, B, JacobiRotation<real>(c,s)); + internal::apply_rotation_in_the_plane(A, B, JacobiRotation<real>(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<Lower>::blocked(C); + internal::llt_inplace<Lower>::blocked(C); //C = X.llt().matrixL(); // C = X; // Cholesky<gene_matrix>::computeInPlace(C); @@ -218,14 +218,14 @@ public : Matrix<DenseIndex,1,Dynamic> 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<gene_matrix>::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<real> { public : - typedef typename ei_packet_traits<real>::type Packet; - static const int PacketSize = ei_packet_traits<real>::size; + typedef typename internal::packet_traits<real>::type Packet; + static const int PacketSize = internal::packet_traits<real>::size; typedef typename f77_interface_base<real>::stl_matrix stl_matrix; typedef typename f77_interface_base<real>::stl_vector stl_vector; @@ -38,16 +38,16 @@ public : typedef typename f77_interface_base<real>::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;j<N;j++) for (int i=0;i<N;i++) A[i+N*j] = A_stl[j][i]; @@ -55,7 +55,7 @@ public : static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){ int N = B_stl.size(); - B = (real*)ei_aligned_malloc(N*sizeof(real)); + B = (real*)internal::aligned_malloc(N*sizeof(real)); for (int i=0;i<N;i++) B[i] = B_stl[i]; } @@ -84,10 +84,10 @@ public : register real* __restrict__ A2 = A + (i+2)*N; register real* __restrict__ A3 = A + (i+3)*N; - Packet ptmp0 = ei_pset1(B[i]); - Packet ptmp1 = ei_pset1(B[i+1]); - Packet ptmp2 = ei_pset1(B[i+2]); - Packet ptmp3 = ei_pset1(B[i+3]); + Packet ptmp0 = internal::pset1(B[i]); + Packet ptmp1 = internal::pset1(B[i+1]); + Packet ptmp2 = internal::pset1(B[i+2]); + Packet ptmp3 = internal::pset1(B[i+3]); // register Packet ptmp0, ptmp1, ptmp2, ptmp3; // asm( // @@ -162,73 +162,73 @@ public : register Packet A13; for (int j = 0;j<ANP;j+=2*PacketSize) { -// A00 = ei_pload(&A0[j]); -// A01 = ei_ploadu(&A1[j]); -// A02 = ei_ploadu(&A2[j]); -// A03 = ei_ploadu(&A3[j]); -// A10 = ei_pload(&A0[j+PacketSize]); -// A11 = ei_ploadu(&A1[j+PacketSize]); -// A12 = ei_ploadu(&A2[j+PacketSize]); -// A13 = ei_ploadu(&A3[j+PacketSize]); +// A00 = internal::pload(&A0[j]); +// A01 = internal::ploadu(&A1[j]); +// A02 = internal::ploadu(&A2[j]); +// A03 = internal::ploadu(&A3[j]); +// A10 = internal::pload(&A0[j+PacketSize]); +// A11 = internal::ploadu(&A1[j+PacketSize]); +// A12 = internal::ploadu(&A2[j+PacketSize]); +// A13 = internal::ploadu(&A3[j+PacketSize]); // -// A00 = ei_pmul(ptmp0, A00); -// A01 = ei_pmul(ptmp1, A01); -// A02 = ei_pmul(ptmp2, A02); -// A03 = ei_pmul(ptmp3, A03); -// A10 = ei_pmul(ptmp0, A10); -// A11 = ei_pmul(ptmp1, A11); -// A12 = ei_pmul(ptmp2, A12); -// A13 = ei_pmul(ptmp3, A13); +// A00 = internal::pmul(ptmp0, A00); +// A01 = internal::pmul(ptmp1, A01); +// A02 = internal::pmul(ptmp2, A02); +// A03 = internal::pmul(ptmp3, A03); +// A10 = internal::pmul(ptmp0, A10); +// A11 = internal::pmul(ptmp1, A11); +// A12 = internal::pmul(ptmp2, A12); +// A13 = internal::pmul(ptmp3, A13); // -// A00 = ei_padd(A00,A01); -// A02 = ei_padd(A02,A03); -// A00 = ei_padd(A00,ei_pload(&X[j])); -// A00 = ei_padd(A00,A02); -// ei_pstore(&X[j],A00); +// A00 = internal::padd(A00,A01); +// A02 = internal::padd(A02,A03); +// A00 = internal::padd(A00,internal::pload(&X[j])); +// A00 = internal::padd(A00,A02); +// internal::pstore(&X[j],A00); // -// A10 = ei_padd(A10,A11); -// A12 = ei_padd(A12,A13); -// A10 = ei_padd(A10,ei_pload(&X[j+PacketSize])); -// A10 = ei_padd(A10,A12); -// ei_pstore(&X[j+PacketSize],A10); - - ei_pstore(&X[j], - ei_padd(ei_pload(&X[j]), - ei_padd( - ei_padd(ei_pmul(ptmp0,ei_pload(&A0[j])),ei_pmul(ptmp1,ei_ploadu(&A1[j]))), - ei_padd(ei_pmul(ptmp2,ei_ploadu(&A2[j])),ei_pmul(ptmp3,ei_ploadu(&A3[j]))) ))); - - ei_pstore(&X[j+PacketSize], - ei_padd(ei_pload(&X[j+PacketSize]), - ei_padd( - ei_padd(ei_pmul(ptmp0,ei_pload(&A0[j+PacketSize])),ei_pmul(ptmp1,ei_ploadu(&A1[j+PacketSize]))), - ei_padd(ei_pmul(ptmp2,ei_ploadu(&A2[j+PacketSize])),ei_pmul(ptmp3,ei_ploadu(&A3[j+PacketSize]))) ))); +// A10 = internal::padd(A10,A11); +// A12 = internal::padd(A12,A13); +// A10 = internal::padd(A10,internal::pload(&X[j+PacketSize])); +// A10 = internal::padd(A10,A12); +// internal::pstore(&X[j+PacketSize],A10); + + internal::pstore(&X[j], + internal::padd(internal::pload(&X[j]), + internal::padd( + internal::padd(internal::pmul(ptmp0,internal::pload(&A0[j])),internal::pmul(ptmp1,internal::ploadu(&A1[j]))), + internal::padd(internal::pmul(ptmp2,internal::ploadu(&A2[j])),internal::pmul(ptmp3,internal::ploadu(&A3[j]))) ))); + + internal::pstore(&X[j+PacketSize], + internal::padd(internal::pload(&X[j+PacketSize]), + internal::padd( + internal::padd(internal::pmul(ptmp0,internal::pload(&A0[j+PacketSize])),internal::pmul(ptmp1,internal::ploadu(&A1[j+PacketSize]))), + internal::padd(internal::pmul(ptmp2,internal::ploadu(&A2[j+PacketSize])),internal::pmul(ptmp3,internal::ploadu(&A3[j+PacketSize]))) ))); } for (int j = ANP;j<AN;j+=PacketSize) - ei_pstore(&X[j], - ei_padd(ei_pload(&X[j]), - ei_padd( - ei_padd(ei_pmul(ptmp0,ei_pload(&A0[j])),ei_pmul(ptmp1,ei_ploadu(&A1[j]))), - ei_padd(ei_pmul(ptmp2,ei_ploadu(&A2[j])),ei_pmul(ptmp3,ei_ploadu(&A3[j]))) ))); + internal::pstore(&X[j], + internal::padd(internal::pload(&X[j]), + internal::padd( + internal::padd(internal::pmul(ptmp0,internal::pload(&A0[j])),internal::pmul(ptmp1,internal::ploadu(&A1[j]))), + internal::padd(internal::pmul(ptmp2,internal::ploadu(&A2[j])),internal::pmul(ptmp3,internal::ploadu(&A3[j]))) ))); } // process remaining scalars for (int j=AN;j<N;j++) - X[j] += ei_pfirst(ptmp0) * A0[j] + ei_pfirst(ptmp1) * A1[j] + ei_pfirst(ptmp2) * A2[j] + ei_pfirst(ptmp3) * A3[j]; + X[j] += internal::pfirst(ptmp0) * A0[j] + internal::pfirst(ptmp1) * A1[j] + internal::pfirst(ptmp2) * A2[j] + internal::pfirst(ptmp3) * A3[j]; } for (int i=bound;i<N;i++) { real tmp0 = B[i]; - Packet ptmp0 = ei_pset1(tmp0); + Packet ptmp0 = internal::pset1(tmp0); int iN0 = i*N; if (AN>0) { bool aligned0 = (iN0 % PacketSize) == 0; if (aligned0) for (int j = 0;j<AN;j+=PacketSize) - ei_pstore(&X[j], ei_padd(ei_pmul(ptmp0,ei_pload(&A[j+iN0])),ei_pload(&X[j]))); + internal::pstore(&X[j], internal::padd(internal::pmul(ptmp0,internal::pload(&A[j+iN0])),internal::pload(&X[j]))); else for (int j = 0;j<AN;j+=PacketSize) - ei_pstore(&X[j], ei_padd(ei_pmul(ptmp0,ei_ploadu(&A[j+iN0])),ei_pload(&X[j]))); + internal::pstore(&X[j], internal::padd(internal::pmul(ptmp0,internal::ploadu(&A[j+iN0])),internal::pload(&X[j]))); } // process remaining scalars for (int j=AN;j<N;j++) @@ -254,18 +254,18 @@ public : register real* __restrict__ A1 = A + (j+1)*N; real t0 = B[j]; - Packet ptmp0 = ei_pset1(t0); + Packet ptmp0 = internal::pset1(t0); real t1 = B[j+1]; - Packet ptmp1 = ei_pset1(t1); + Packet ptmp1 = internal::pset1(t1); real t2 = 0; - Packet ptmp2 = ei_pset1(t2); + Packet ptmp2 = internal::pset1(t2); real t3 = 0; - Packet ptmp3 = ei_pset1(t3); + Packet ptmp3 = internal::pset1(t3); int starti = j+2; int alignedEnd = starti; - int alignedStart = (starti) + ei_first_aligned(&X[starti], N-starti); + int alignedStart = (starti) + internal::first_aligned(&X[starti], N-starti); alignedEnd = alignedStart + ((N-alignedStart)/(PacketSize))*(PacketSize); X[j] += t0 * A0[j]; @@ -282,21 +282,21 @@ public : } asm("#begin symv"); for (size_t i=alignedStart; i<alignedEnd; i+=PacketSize) { - Packet A0i = ei_ploadu(&A0[i]); - Packet A1i = ei_ploadu(&A1[i]); -// Packet A0i1 = ei_ploadu(&A0[i+PacketSize]); - Packet Xi = ei_pload(&X[i]); - Packet Bi = ei_pload/*u*/(&B[i]); -// Packet Xi1 = ei_pload(&X[i+PacketSize]); -// Packet Bi1 = ei_pload/*u*/(&B[i+PacketSize]); - Xi = ei_padd(ei_padd(Xi, ei_pmul(ptmp0, A0i)), ei_pmul(ptmp1, A1i)); - ptmp2 = ei_padd(ptmp2, ei_pmul(A0i, Bi)); - ptmp3 = ei_padd(ptmp3, ei_pmul(A1i, Bi)); -// Xi1 = ei_padd(Xi1, ei_pmul(ptmp1, A0i1)); -// ptmp2 = ei_padd(ptmp2, ei_pmul(A0i1, Bi1)); + Packet A0i = internal::ploadu(&A0[i]); + Packet A1i = internal::ploadu(&A1[i]); +// Packet A0i1 = internal::ploadu(&A0[i+PacketSize]); + Packet Xi = internal::pload(&X[i]); + Packet Bi = internal::pload/*u*/(&B[i]); +// Packet Xi1 = internal::pload(&X[i+PacketSize]); +// Packet Bi1 = internal::pload/*u*/(&B[i+PacketSize]); + Xi = internal::padd(internal::padd(Xi, internal::pmul(ptmp0, A0i)), internal::pmul(ptmp1, A1i)); + ptmp2 = internal::padd(ptmp2, internal::pmul(A0i, Bi)); + ptmp3 = internal::padd(ptmp3, internal::pmul(A1i, Bi)); +// Xi1 = internal::padd(Xi1, internal::pmul(ptmp1, A0i1)); +// ptmp2 = internal::padd(ptmp2, internal::pmul(A0i1, Bi1)); // - ei_pstore(&X[i],Xi); -// ei_pstore(&X[i+PacketSize],Xi1); + internal::pstore(&X[i],Xi); +// internal::pstore(&X[i+PacketSize],Xi1); // asm( // "prefetchnta 64(%[A0],%[i],4) \n\t" // //"movups (%[A0],%[i],4), %%xmm8 \n\t" @@ -341,8 +341,8 @@ public : } - X[j] += t2 + ei_predux(ptmp2); - X[j+1] += t3 + ei_predux(ptmp3); + X[j] += t2 + internal::predux(ptmp2); + X[j+1] += t3 + internal::predux(ptmp3); } for (int j=bound;j<N;j++) { @@ -372,13 +372,13 @@ public : // for (int i=0;i<bound;i+=4) // { // real tmp0 = B[i]; -// Packet ptmp0 = ei_pset1(tmp0); +// Packet ptmp0 = internal::pset1(tmp0); // real tmp1 = B[i+1]; -// Packet ptmp1 = ei_pset1(tmp1); +// Packet ptmp1 = internal::pset1(tmp1); // real tmp2 = B[i+2]; -// Packet ptmp2 = ei_pset1(tmp2); +// Packet ptmp2 = internal::pset1(tmp2); // real tmp3 = B[i+3]; -// Packet ptmp3 = ei_pset1(tmp3); +// Packet ptmp3 = internal::pset1(tmp3); // int iN0 = i*N; // int iN1 = (i+1)*N; // int iN2 = (i+2)*N; @@ -392,59 +392,59 @@ public : // { // for (int j = 0;j<AN;j+=PacketSize) // { -// ei_pstore(&X[j], -// ei_padd(ei_pload(&X[j]), -// ei_padd( -// ei_padd(ei_pmul(ptmp0,ei_pload(&A[j+iN0])),ei_pmul(ptmp1,ei_pload(&A[j+iN1]))), -// ei_padd(ei_pmul(ptmp2,ei_pload(&A[j+iN2])),ei_pmul(ptmp3,ei_pload(&A[j+iN3]))) ))); +// internal::pstore(&X[j], +// internal::padd(internal::pload(&X[j]), +// internal::padd( +// internal::padd(internal::pmul(ptmp0,internal::pload(&A[j+iN0])),internal::pmul(ptmp1,internal::pload(&A[j+iN1]))), +// internal::padd(internal::pmul(ptmp2,internal::pload(&A[j+iN2])),internal::pmul(ptmp3,internal::pload(&A[j+iN3]))) ))); // } // } // else if (aligned1==2) // { // for (int j = 0;j<AN;j+=PacketSize) // { -// ei_pstore(&X[j], -// ei_padd(ei_pload(&X[j]), -// ei_padd( -// ei_padd(ei_pmul(ptmp0,ei_pload(&A[j+iN0])),ei_pmul(ptmp1,ei_ploadu(&A[j+iN1]))), -// ei_padd(ei_pmul(ptmp2,ei_pload(&A[j+iN2])),ei_pmul(ptmp3,ei_ploadu(&A[j+iN3]))) ))); +// internal::pstore(&X[j], +// internal::padd(internal::pload(&X[j]), +// internal::padd( +// internal::padd(internal::pmul(ptmp0,internal::pload(&A[j+iN0])),internal::pmul(ptmp1,internal::ploadu(&A[j+iN1]))), +// internal::padd(internal::pmul(ptmp2,internal::pload(&A[j+iN2])),internal::pmul(ptmp3,internal::ploadu(&A[j+iN3]))) ))); // } // } // else // { // for (int j = 0;j<ANP;j+=2*PacketSize) // { -// ei_pstore(&X[j], -// ei_padd(ei_pload(&X[j]), -// ei_padd( -// ei_padd(ei_pmul(ptmp0,ei_pload(&A[j+iN0])),ei_pmul(ptmp1,ei_ploadu(&A[j+iN1]))), -// ei_padd(ei_pmul(ptmp2,ei_ploadu(&A[j+iN2])),ei_pmul(ptmp3,ei_ploadu(&A[j+iN3]))) ))); +// internal::pstore(&X[j], +// internal::padd(internal::pload(&X[j]), +// internal::padd( +// internal::padd(internal::pmul(ptmp0,internal::pload(&A[j+iN0])),internal::pmul(ptmp1,internal::ploadu(&A[j+iN1]))), +// internal::padd(internal::pmul(ptmp2,internal::ploadu(&A[j+iN2])),internal::pmul(ptmp3,internal::ploadu(&A[j+iN3]))) ))); // -// ei_pstore(&X[j+PacketSize], -// ei_padd(ei_pload(&X[j+PacketSize]), -// ei_padd( -// ei_padd(ei_pmul(ptmp0,ei_pload(&A[j+PacketSize+iN0])),ei_pmul(ptmp1,ei_ploadu(&A[j+PacketSize+iN1]))), -// ei_padd(ei_pmul(ptmp2,ei_ploadu(&A[j+PacketSize+iN2])),ei_pmul(ptmp3,ei_ploadu(&A[j+PacketSize+iN3]))) ))); +// internal::pstore(&X[j+PacketSize], +// internal::padd(internal::pload(&X[j+PacketSize]), +// internal::padd( +// internal::padd(internal::pmul(ptmp0,internal::pload(&A[j+PacketSize+iN0])),internal::pmul(ptmp1,internal::ploadu(&A[j+PacketSize+iN1]))), +// internal::padd(internal::pmul(ptmp2,internal::ploadu(&A[j+PacketSize+iN2])),internal::pmul(ptmp3,internal::ploadu(&A[j+PacketSize+iN3]))) ))); // -// // ei_pstore(&X[j+2*PacketSize], -// // ei_padd(ei_pload(&X[j+2*PacketSize]), -// // ei_padd( -// // ei_padd(ei_pmul(ptmp0,ei_pload(&A[j+2*PacketSize+iN0])),ei_pmul(ptmp1,ei_ploadu(&A[j+2*PacketSize+iN1]))), -// // ei_padd(ei_pmul(ptmp2,ei_ploadu(&A[j+2*PacketSize+iN2])),ei_pmul(ptmp3,ei_ploadu(&A[j+2*PacketSize+iN3]))) ))); +// // internal::pstore(&X[j+2*PacketSize], +// // internal::padd(internal::pload(&X[j+2*PacketSize]), +// // internal::padd( +// // internal::padd(internal::pmul(ptmp0,internal::pload(&A[j+2*PacketSize+iN0])),internal::pmul(ptmp1,internal::ploadu(&A[j+2*PacketSize+iN1]))), +// // internal::padd(internal::pmul(ptmp2,internal::ploadu(&A[j+2*PacketSize+iN2])),internal::pmul(ptmp3,internal::ploadu(&A[j+2*PacketSize+iN3]))) ))); // // -// // ei_pstore(&X[j+3*PacketSize], -// // ei_padd(ei_pload(&X[j+3*PacketSize]), -// // ei_padd( -// // ei_padd(ei_pmul(ptmp0,ei_pload(&A[j+3*PacketSize+iN0])),ei_pmul(ptmp1,ei_ploadu(&A[j+3*PacketSize+iN1]))), -// // ei_padd(ei_pmul(ptmp2,ei_ploadu(&A[j+3*PacketSize+iN2])),ei_pmul(ptmp3,ei_ploadu(&A[j+3*PacketSize+iN3]))) ))); +// // internal::pstore(&X[j+3*PacketSize], +// // internal::padd(internal::pload(&X[j+3*PacketSize]), +// // internal::padd( +// // internal::padd(internal::pmul(ptmp0,internal::pload(&A[j+3*PacketSize+iN0])),internal::pmul(ptmp1,internal::ploadu(&A[j+3*PacketSize+iN1]))), +// // internal::padd(internal::pmul(ptmp2,internal::ploadu(&A[j+3*PacketSize+iN2])),internal::pmul(ptmp3,internal::ploadu(&A[j+3*PacketSize+iN3]))) ))); // // } // for (int j = ANP;j<AN;j+=PacketSize) -// ei_pstore(&X[j], -// ei_padd(ei_pload(&X[j]), -// ei_padd( -// ei_padd(ei_pmul(ptmp0,ei_ploadu(&A[j+iN0])),ei_pmul(ptmp1,ei_ploadu(&A[j+iN1]))), -// ei_padd(ei_pmul(ptmp2,ei_ploadu(&A[j+iN2])),ei_pmul(ptmp3,ei_ploadu(&A[j+iN3]))) ))); +// internal::pstore(&X[j], +// internal::padd(internal::pload(&X[j]), +// internal::padd( +// internal::padd(internal::pmul(ptmp0,internal::ploadu(&A[j+iN0])),internal::pmul(ptmp1,internal::ploadu(&A[j+iN1]))), +// internal::padd(internal::pmul(ptmp2,internal::ploadu(&A[j+iN2])),internal::pmul(ptmp3,internal::ploadu(&A[j+iN3]))) ))); // } // } // // process remaining scalars @@ -454,17 +454,17 @@ public : // for (int i=bound;i<N;i++) // { // real tmp0 = B[i]; -// Packet ptmp0 = ei_pset1(tmp0); +// Packet ptmp0 = internal::pset1(tmp0); // int iN0 = i*N; // if (AN>0) // { // bool aligned0 = (iN0 % PacketSize) == 0; // if (aligned0) // for (int j = 0;j<AN;j+=PacketSize) -// ei_pstore(&X[j], ei_padd(ei_pmul(ptmp0,ei_pload(&A[j+iN0])),ei_pload(&X[j]))); +// internal::pstore(&X[j], internal::padd(internal::pmul(ptmp0,internal::pload(&A[j+iN0])),internal::pload(&X[j]))); // else // for (int j = 0;j<AN;j+=PacketSize) -// ei_pstore(&X[j], ei_padd(ei_pmul(ptmp0,ei_ploadu(&A[j+iN0])),ei_pload(&X[j]))); +// internal::pstore(&X[j], internal::padd(internal::pmul(ptmp0,internal::ploadu(&A[j+iN0])),internal::pload(&X[j]))); // } // // process remaining scalars // for (int j=AN;j<N;j++) @@ -483,9 +483,9 @@ public : // for (int i=0;i<N;i+=2) // { // real tmp0 = B[i]; -// Packet ptmp0 = ei_pset1(tmp0); +// Packet ptmp0 = internal::pset1(tmp0); // real tmp1 = B[i+1]; -// Packet ptmp1 = ei_pset1(tmp1); +// Packet ptmp1 = internal::pset1(tmp1); // int iN0 = i*N; // int iN1 = (i+1)*N; // if (AN>0) @@ -497,27 +497,27 @@ public : // { // for (int j = 0;j<AN;j+=PacketSize) // { -// ei_pstore(&X[j], -// ei_padd(ei_pmul(ptmp0,ei_pload(&A[j+iN0])), -// ei_padd(ei_pmul(ptmp1,ei_pload(&A[j+iN1])),ei_pload(&X[j])))); +// internal::pstore(&X[j], +// internal::padd(internal::pmul(ptmp0,internal::pload(&A[j+iN0])), +// internal::padd(internal::pmul(ptmp1,internal::pload(&A[j+iN1])),internal::pload(&X[j])))); // } // } // else if (aligned0) // { // for (int j = 0;j<AN;j+=PacketSize) // { -// ei_pstore(&X[j], -// ei_padd(ei_pmul(ptmp0,ei_pload(&A[j+iN0])), -// ei_padd(ei_pmul(ptmp1,ei_ploadu(&A[j+iN1])),ei_pload(&X[j])))); +// internal::pstore(&X[j], +// internal::padd(internal::pmul(ptmp0,internal::pload(&A[j+iN0])), +// internal::padd(internal::pmul(ptmp1,internal::ploadu(&A[j+iN1])),internal::pload(&X[j])))); // } // } // else if (aligned1) // { // for (int j = 0;j<AN;j+=PacketSize) // { -// ei_pstore(&X[j], -// ei_padd(ei_pmul(ptmp0,ei_ploadu(&A[j+iN0])), -// ei_padd(ei_pmul(ptmp1,ei_pload(&A[j+iN1])),ei_pload(&X[j])))); +// internal::pstore(&X[j], +// internal::padd(internal::pmul(ptmp0,internal::ploadu(&A[j+iN0])), +// internal::padd(internal::pmul(ptmp1,internal::pload(&A[j+iN1])),internal::pload(&X[j])))); // } // } // else @@ -525,26 +525,26 @@ public : // int ANP = (AN/(4*PacketSize))*4*PacketSize; // for (int j = 0;j<ANP;j+=4*PacketSize) // { -// ei_pstore(&X[j], -// ei_padd(ei_pmul(ptmp0,ei_ploadu(&A[j+iN0])), -// ei_padd(ei_pmul(ptmp1,ei_ploadu(&A[j+iN1])),ei_pload(&X[j])))); +// internal::pstore(&X[j], +// internal::padd(internal::pmul(ptmp0,internal::ploadu(&A[j+iN0])), +// internal::padd(internal::pmul(ptmp1,internal::ploadu(&A[j+iN1])),internal::pload(&X[j])))); // -// ei_pstore(&X[j+PacketSize], -// ei_padd(ei_pmul(ptmp0,ei_ploadu(&A[j+PacketSize+iN0])), -// ei_padd(ei_pmul(ptmp1,ei_ploadu(&A[j+PacketSize+iN1])),ei_pload(&X[j+PacketSize])))); +// internal::pstore(&X[j+PacketSize], +// internal::padd(internal::pmul(ptmp0,internal::ploadu(&A[j+PacketSize+iN0])), +// internal::padd(internal::pmul(ptmp1,internal::ploadu(&A[j+PacketSize+iN1])),internal::pload(&X[j+PacketSize])))); // -// ei_pstore(&X[j+2*PacketSize], -// ei_padd(ei_pmul(ptmp0,ei_ploadu(&A[j+2*PacketSize+iN0])), -// ei_padd(ei_pmul(ptmp1,ei_ploadu(&A[j+2*PacketSize+iN1])),ei_pload(&X[j+2*PacketSize])))); +// internal::pstore(&X[j+2*PacketSize], +// internal::padd(internal::pmul(ptmp0,internal::ploadu(&A[j+2*PacketSize+iN0])), +// internal::padd(internal::pmul(ptmp1,internal::ploadu(&A[j+2*PacketSize+iN1])),internal::pload(&X[j+2*PacketSize])))); // -// ei_pstore(&X[j+3*PacketSize], -// ei_padd(ei_pmul(ptmp0,ei_ploadu(&A[j+3*PacketSize+iN0])), -// ei_padd(ei_pmul(ptmp1,ei_ploadu(&A[j+3*PacketSize+iN1])),ei_pload(&X[j+3*PacketSize])))); +// internal::pstore(&X[j+3*PacketSize], +// internal::padd(internal::pmul(ptmp0,internal::ploadu(&A[j+3*PacketSize+iN0])), +// internal::padd(internal::pmul(ptmp1,internal::ploadu(&A[j+3*PacketSize+iN1])),internal::pload(&X[j+3*PacketSize])))); // } // for (int j = ANP;j<AN;j+=PacketSize) -// ei_pstore(&X[j], -// ei_padd(ei_pmul(ptmp0,ei_ploadu(&A[j+iN0])), -// ei_padd(ei_pmul(ptmp1,ei_ploadu(&A[j+iN1])),ei_pload(&X[j])))); +// internal::pstore(&X[j], +// internal::padd(internal::pmul(ptmp0,internal::ploadu(&A[j+iN0])), +// internal::padd(internal::pmul(ptmp1,internal::ploadu(&A[j+iN1])),internal::pload(&X[j])))); // } // } // // process remaining scalars @@ -555,17 +555,17 @@ public : // for (int i=remaining;i<N;i++) // { // real tmp0 = B[i]; -// Packet ptmp0 = ei_pset1(tmp0); +// Packet ptmp0 = internal::pset1(tmp0); // int iN0 = i*N; // if (AN>0) // { // bool aligned0 = (iN0 % PacketSize) == 0; // if (aligned0) // for (int j = 0;j<AN;j+=PacketSize) -// ei_pstore(&X[j], ei_padd(ei_pmul(ptmp0,ei_pload(&A[j+iN0])),ei_pload(&X[j]))); +// internal::pstore(&X[j], internal::padd(internal::pmul(ptmp0,internal::pload(&A[j+iN0])),internal::pload(&X[j]))); // else // for (int j = 0;j<AN;j+=PacketSize) -// ei_pstore(&X[j], ei_padd(ei_pmul(ptmp0,ei_ploadu(&A[j+iN0])),ei_pload(&X[j]))); +// internal::pstore(&X[j], internal::padd(internal::pmul(ptmp0,internal::ploadu(&A[j+iN0])),internal::pload(&X[j]))); // } // // process remaining scalars // for (int j=AN;j<N;j++) @@ -583,7 +583,7 @@ public : // for (int i=0;i<N;i++) // { // real tmp = B[i]; -// Packet ptmp = ei_pset1(tmp); +// Packet ptmp = internal::pset1(tmp); // int iN = i*N; // if (AN>0) // { @@ -595,45 +595,45 @@ public : // int ANP = (AN/(8*PacketSize))*8*PacketSize; // for (int j = 0;j<ANP;j+=PacketSize*8) // { -// A0 = ei_pload(&A[j+iN]); -// X0 = ei_pload(&X[j]); -// A1 = ei_pload(&A[j+PacketSize+iN]); -// X1 = ei_pload(&X[j+PacketSize]); -// A2 = ei_pload(&A[j+2*PacketSize+iN]); -// X2 = ei_pload(&X[j+2*PacketSize]); -// ei_pstore(&X[j], ei_padd(X0, ei_pmul(ptmp,A0))); -// A0 = ei_pload(&A[j+3*PacketSize+iN]); -// X0 = ei_pload(&X[j+3*PacketSize]); -// ei_pstore(&X[j+PacketSize], ei_padd(ei_pload(&X1), ei_pmul(ptmp,A1))); -// A1 = ei_pload(&A[j+4*PacketSize+iN]); -// X1 = ei_pload(&X[j+4*PacketSize]); -// ei_pstore(&X[j+2*PacketSize], ei_padd(ei_pload(&X2), ei_pmul(ptmp,A2))); -// A2 = ei_pload(&A[j+5*PacketSize+iN]); -// X2 = ei_pload(&X[j+5*PacketSize]); -// ei_pstore(&X[j+3*PacketSize], ei_padd(ei_pload(&X0), ei_pmul(ptmp,A0))); -// A0 = ei_pload(&A[j+6*PacketSize+iN]); -// X0 = ei_pload(&X[j+6*PacketSize]); -// ei_pstore(&X[j+4*PacketSize], ei_padd(ei_pload(&X1), ei_pmul(ptmp,A1))); -// A1 = ei_pload(&A[j+7*PacketSize+iN]); -// X1 = ei_pload(&X[j+7*PacketSize]); -// ei_pstore(&X[j+5*PacketSize], ei_padd(ei_pload(&X2), ei_pmul(ptmp,A2))); -// ei_pstore(&X[j+6*PacketSize], ei_padd(ei_pload(&X0), ei_pmul(ptmp,A0))); -// ei_pstore(&X[j+7*PacketSize], ei_padd(ei_pload(&X1), ei_pmul(ptmp,A1))); +// A0 = internal::pload(&A[j+iN]); +// X0 = internal::pload(&X[j]); +// A1 = internal::pload(&A[j+PacketSize+iN]); +// X1 = internal::pload(&X[j+PacketSize]); +// A2 = internal::pload(&A[j+2*PacketSize+iN]); +// X2 = internal::pload(&X[j+2*PacketSize]); +// internal::pstore(&X[j], internal::padd(X0, internal::pmul(ptmp,A0))); +// A0 = internal::pload(&A[j+3*PacketSize+iN]); +// X0 = internal::pload(&X[j+3*PacketSize]); +// internal::pstore(&X[j+PacketSize], internal::padd(internal::pload(&X1), internal::pmul(ptmp,A1))); +// A1 = internal::pload(&A[j+4*PacketSize+iN]); +// X1 = internal::pload(&X[j+4*PacketSize]); +// internal::pstore(&X[j+2*PacketSize], internal::padd(internal::pload(&X2), internal::pmul(ptmp,A2))); +// A2 = internal::pload(&A[j+5*PacketSize+iN]); +// X2 = internal::pload(&X[j+5*PacketSize]); +// internal::pstore(&X[j+3*PacketSize], internal::padd(internal::pload(&X0), internal::pmul(ptmp,A0))); +// A0 = internal::pload(&A[j+6*PacketSize+iN]); +// X0 = internal::pload(&X[j+6*PacketSize]); +// internal::pstore(&X[j+4*PacketSize], internal::padd(internal::pload(&X1), internal::pmul(ptmp,A1))); +// A1 = internal::pload(&A[j+7*PacketSize+iN]); +// X1 = internal::pload(&X[j+7*PacketSize]); +// internal::pstore(&X[j+5*PacketSize], internal::padd(internal::pload(&X2), internal::pmul(ptmp,A2))); +// internal::pstore(&X[j+6*PacketSize], internal::padd(internal::pload(&X0), internal::pmul(ptmp,A0))); +// internal::pstore(&X[j+7*PacketSize], internal::padd(internal::pload(&X1), internal::pmul(ptmp,A1))); // // -// // ei_pstore(&X[j], ei_padd(ei_pload(&X[j]), ei_pmul(ptmp,ei_pload(&A[j+iN])))); -// // ei_pstore(&X[j+PacketSize], ei_padd(ei_pload(&X[j+PacketSize]), ei_pmul(ptmp,ei_pload(&A[j+PacketSize+iN])))); -// // ei_pstore(&X[j+2*PacketSize], ei_padd(ei_pload(&X[j+2*PacketSize]), ei_pmul(ptmp,ei_pload(&A[j+2*PacketSize+iN])))); -// // ei_pstore(&X[j+3*PacketSize], ei_padd(ei_pload(&X[j+3*PacketSize]), ei_pmul(ptmp,ei_pload(&A[j+3*PacketSize+iN])))); -// // ei_pstore(&X[j+4*PacketSize], ei_padd(ei_pload(&X[j+4*PacketSize]), ei_pmul(ptmp,ei_pload(&A[j+4*PacketSize+iN])))); -// // ei_pstore(&X[j+5*PacketSize], ei_padd(ei_pload(&X[j+5*PacketSize]), ei_pmul(ptmp,ei_pload(&A[j+5*PacketSize+iN])))); -// // ei_pstore(&X[j+6*PacketSize], ei_padd(ei_pload(&X[j+6*PacketSize]), ei_pmul(ptmp,ei_pload(&A[j+6*PacketSize+iN])))); -// // ei_pstore(&X[j+7*PacketSize], ei_padd(ei_pload(&X[j+7*PacketSize]), ei_pmul(ptmp,ei_pload(&A[j+7*PacketSize+iN])))); +// // internal::pstore(&X[j], internal::padd(internal::pload(&X[j]), internal::pmul(ptmp,internal::pload(&A[j+iN])))); +// // internal::pstore(&X[j+PacketSize], internal::padd(internal::pload(&X[j+PacketSize]), internal::pmul(ptmp,internal::pload(&A[j+PacketSize+iN])))); +// // internal::pstore(&X[j+2*PacketSize], internal::padd(internal::pload(&X[j+2*PacketSize]), internal::pmul(ptmp,internal::pload(&A[j+2*PacketSize+iN])))); +// // internal::pstore(&X[j+3*PacketSize], internal::padd(internal::pload(&X[j+3*PacketSize]), internal::pmul(ptmp,internal::pload(&A[j+3*PacketSize+iN])))); +// // internal::pstore(&X[j+4*PacketSize], internal::padd(internal::pload(&X[j+4*PacketSize]), internal::pmul(ptmp,internal::pload(&A[j+4*PacketSize+iN])))); +// // internal::pstore(&X[j+5*PacketSize], internal::padd(internal::pload(&X[j+5*PacketSize]), internal::pmul(ptmp,internal::pload(&A[j+5*PacketSize+iN])))); +// // internal::pstore(&X[j+6*PacketSize], internal::padd(internal::pload(&X[j+6*PacketSize]), internal::pmul(ptmp,internal::pload(&A[j+6*PacketSize+iN])))); +// // internal::pstore(&X[j+7*PacketSize], internal::padd(internal::pload(&X[j+7*PacketSize]), internal::pmul(ptmp,internal::pload(&A[j+7*PacketSize+iN])))); // } // for (int j = ANP;j<AN;j+=PacketSize) -// ei_pstore(&X[j], ei_padd(ei_pload(&X[j]), ei_pmul(ptmp,ei_pload(&A[j+iN])))); +// internal::pstore(&X[j], internal::padd(internal::pload(&X[j]), internal::pmul(ptmp,internal::pload(&A[j+iN])))); // #else // for (int j = 0;j<AN;j+=PacketSize) -// ei_pstore(&X[j], ei_padd(ei_pload(&X[j]), ei_pmul(ptmp,ei_pload(&A[j+iN])))); +// internal::pstore(&X[j], internal::padd(internal::pload(&X[j]), internal::pmul(ptmp,internal::pload(&A[j+iN])))); // #endif // } // else @@ -642,20 +642,20 @@ public : // int ANP = (AN/(8*PacketSize))*8*PacketSize; // for (int j = 0;j<ANP;j+=PacketSize*8) // { -// ei_pstore(&X[j], ei_padd(ei_pload(&X[j]), ei_pmul(ptmp,ei_ploadu(&A[j+iN])))); -// ei_pstore(&X[j+PacketSize], ei_padd(ei_pload(&X[j+PacketSize]), ei_pmul(ptmp,ei_ploadu(&A[j+PacketSize+iN])))); -// ei_pstore(&X[j+2*PacketSize], ei_padd(ei_pload(&X[j+2*PacketSize]), ei_pmul(ptmp,ei_ploadu(&A[j+2*PacketSize+iN])))); -// ei_pstore(&X[j+3*PacketSize], ei_padd(ei_pload(&X[j+3*PacketSize]), ei_pmul(ptmp,ei_ploadu(&A[j+3*PacketSize+iN])))); -// ei_pstore(&X[j+4*PacketSize], ei_padd(ei_pload(&X[j+4*PacketSize]), ei_pmul(ptmp,ei_ploadu(&A[j+4*PacketSize+iN])))); -// ei_pstore(&X[j+5*PacketSize], ei_padd(ei_pload(&X[j+5*PacketSize]), ei_pmul(ptmp,ei_ploadu(&A[j+5*PacketSize+iN])))); -// ei_pstore(&X[j+6*PacketSize], ei_padd(ei_pload(&X[j+6*PacketSize]), ei_pmul(ptmp,ei_ploadu(&A[j+6*PacketSize+iN])))); -// ei_pstore(&X[j+7*PacketSize], ei_padd(ei_pload(&X[j+7*PacketSize]), ei_pmul(ptmp,ei_ploadu(&A[j+7*PacketSize+iN])))); +// internal::pstore(&X[j], internal::padd(internal::pload(&X[j]), internal::pmul(ptmp,internal::ploadu(&A[j+iN])))); +// internal::pstore(&X[j+PacketSize], internal::padd(internal::pload(&X[j+PacketSize]), internal::pmul(ptmp,internal::ploadu(&A[j+PacketSize+iN])))); +// internal::pstore(&X[j+2*PacketSize], internal::padd(internal::pload(&X[j+2*PacketSize]), internal::pmul(ptmp,internal::ploadu(&A[j+2*PacketSize+iN])))); +// internal::pstore(&X[j+3*PacketSize], internal::padd(internal::pload(&X[j+3*PacketSize]), internal::pmul(ptmp,internal::ploadu(&A[j+3*PacketSize+iN])))); +// internal::pstore(&X[j+4*PacketSize], internal::padd(internal::pload(&X[j+4*PacketSize]), internal::pmul(ptmp,internal::ploadu(&A[j+4*PacketSize+iN])))); +// internal::pstore(&X[j+5*PacketSize], internal::padd(internal::pload(&X[j+5*PacketSize]), internal::pmul(ptmp,internal::ploadu(&A[j+5*PacketSize+iN])))); +// internal::pstore(&X[j+6*PacketSize], internal::padd(internal::pload(&X[j+6*PacketSize]), internal::pmul(ptmp,internal::ploadu(&A[j+6*PacketSize+iN])))); +// internal::pstore(&X[j+7*PacketSize], internal::padd(internal::pload(&X[j+7*PacketSize]), internal::pmul(ptmp,internal::ploadu(&A[j+7*PacketSize+iN])))); // } // for (int j = ANP;j<AN;j+=PacketSize) -// ei_pstore(&X[j], ei_padd(ei_pload(&X[j]), ei_pmul(ptmp,ei_ploadu(&A[j+iN])))); +// internal::pstore(&X[j], internal::padd(internal::pload(&X[j]), internal::pmul(ptmp,internal::ploadu(&A[j+iN])))); // #else // for (int j = 0;j<AN;j+=PacketSize) -// ei_pstore(&X[j], ei_padd(ei_pload(&X[j]), ei_pmul(ptmp,ei_ploadu(&A[j+iN])))); +// internal::pstore(&X[j], internal::padd(internal::pload(&X[j]), internal::pmul(ptmp,internal::ploadu(&A[j+iN])))); // #endif // } // } @@ -673,13 +673,13 @@ public : for (int i=0;i<bound;i+=4) { real tmp0 = 0; - Packet ptmp0 = ei_pset1(real(0)); + Packet ptmp0 = internal::pset1(real(0)); real tmp1 = 0; - Packet ptmp1 = ei_pset1(real(0)); + Packet ptmp1 = internal::pset1(real(0)); real tmp2 = 0; - Packet ptmp2 = ei_pset1(real(0)); + Packet ptmp2 = internal::pset1(real(0)); real tmp3 = 0; - Packet ptmp3 = ei_pset1(real(0)); + Packet ptmp3 = internal::pset1(real(0)); int iN0 = i*N; int iN1 = (i+1)*N; int iN2 = (i+2)*N; @@ -691,39 +691,39 @@ public : { for (int j = 0;j<AN;j+=PacketSize) { - Packet b = ei_pload(&B[j]); - ptmp0 = ei_padd(ptmp0, ei_pmul(b, ei_pload(&A[j+iN0]))); - ptmp1 = ei_padd(ptmp1, ei_pmul(b, ei_pload(&A[j+iN1]))); - ptmp2 = ei_padd(ptmp2, ei_pmul(b, ei_pload(&A[j+iN2]))); - ptmp3 = ei_padd(ptmp3, ei_pmul(b, ei_pload(&A[j+iN3]))); + Packet b = internal::pload(&B[j]); + ptmp0 = internal::padd(ptmp0, internal::pmul(b, internal::pload(&A[j+iN0]))); + ptmp1 = internal::padd(ptmp1, internal::pmul(b, internal::pload(&A[j+iN1]))); + ptmp2 = internal::padd(ptmp2, internal::pmul(b, internal::pload(&A[j+iN2]))); + ptmp3 = internal::padd(ptmp3, internal::pmul(b, internal::pload(&A[j+iN3]))); } } else if (align1==2) { for (int j = 0;j<AN;j+=PacketSize) { - Packet b = ei_pload(&B[j]); - ptmp0 = ei_padd(ptmp0, ei_pmul(b, ei_pload(&A[j+iN0]))); - ptmp1 = ei_padd(ptmp1, ei_pmul(b, ei_ploadu(&A[j+iN1]))); - ptmp2 = ei_padd(ptmp2, ei_pmul(b, ei_pload(&A[j+iN2]))); - ptmp3 = ei_padd(ptmp3, ei_pmul(b, ei_ploadu(&A[j+iN3]))); + Packet b = internal::pload(&B[j]); + ptmp0 = internal::padd(ptmp0, internal::pmul(b, internal::pload(&A[j+iN0]))); + ptmp1 = internal::padd(ptmp1, internal::pmul(b, internal::ploadu(&A[j+iN1]))); + ptmp2 = internal::padd(ptmp2, internal::pmul(b, internal::pload(&A[j+iN2]))); + ptmp3 = internal::padd(ptmp3, internal::pmul(b, internal::ploadu(&A[j+iN3]))); } } else { for (int j = 0;j<AN;j+=PacketSize) { - Packet b = ei_pload(&B[j]); - ptmp0 = ei_padd(ptmp0, ei_pmul(b, ei_pload(&A[j+iN0]))); - ptmp1 = ei_padd(ptmp1, ei_pmul(b, ei_ploadu(&A[j+iN1]))); - ptmp2 = ei_padd(ptmp2, ei_pmul(b, ei_ploadu(&A[j+iN2]))); - ptmp3 = ei_padd(ptmp3, ei_pmul(b, ei_ploadu(&A[j+iN3]))); + Packet b = internal::pload(&B[j]); + ptmp0 = internal::padd(ptmp0, internal::pmul(b, internal::pload(&A[j+iN0]))); + ptmp1 = internal::padd(ptmp1, internal::pmul(b, internal::ploadu(&A[j+iN1]))); + ptmp2 = internal::padd(ptmp2, internal::pmul(b, internal::ploadu(&A[j+iN2]))); + ptmp3 = internal::padd(ptmp3, internal::pmul(b, internal::ploadu(&A[j+iN3]))); } } - tmp0 = ei_predux(ptmp0); - tmp1 = ei_predux(ptmp1); - tmp2 = ei_predux(ptmp2); - tmp3 = ei_predux(ptmp3); + tmp0 = internal::predux(ptmp0); + tmp1 = internal::predux(ptmp1); + tmp2 = internal::predux(ptmp2); + tmp3 = internal::predux(ptmp3); } // process remaining scalars for (int j=AN;j<N;j++) @@ -742,17 +742,17 @@ public : for (int i=bound;i<N;i++) { real tmp0 = 0; - Packet ptmp0 = ei_pset1(real(0)); + Packet ptmp0 = internal::pset1(real(0)); int iN0 = i*N; if (AN>0) { if (iN0 % PacketSize==0) for (int j = 0;j<AN;j+=PacketSize) - ptmp0 = ei_padd(ptmp0, ei_pmul(ei_pload(&B[j]), ei_pload(&A[j+iN0]))); + ptmp0 = internal::padd(ptmp0, internal::pmul(internal::pload(&B[j]), internal::pload(&A[j+iN0]))); else for (int j = 0;j<AN;j+=PacketSize) - ptmp0 = ei_padd(ptmp0, ei_pmul(ei_pload(&B[j]), ei_ploadu(&A[j+iN0]))); - tmp0 = ei_predux(ptmp0); + ptmp0 = internal::padd(ptmp0, internal::pmul(internal::pload(&B[j]), internal::ploadu(&A[j+iN0]))); + tmp0 = internal::predux(ptmp0); } // process remaining scalars for (int j=AN;j<N;j++) @@ -769,7 +769,7 @@ public : // for (int i=0;i<N;i++) // { // real tmp = 0; -// Packet ptmp = ei_pset1(real(0)); +// Packet ptmp = internal::pset1(real(0)); // int iN = i*N; // if (AN>0) // { @@ -781,21 +781,21 @@ public : // for (int j = 0;j<ANP;j+=PacketSize*8) // { // ptmp = -// ei_padd(ei_pmul(ei_pload(&B[j]), ei_pload(&A[j+iN])), -// ei_padd(ei_pmul(ei_pload(&B[j+PacketSize]), ei_pload(&A[j+PacketSize+iN])), -// ei_padd(ei_pmul(ei_pload(&B[j+2*PacketSize]), ei_pload(&A[j+2*PacketSize+iN])), -// ei_padd(ei_pmul(ei_pload(&B[j+3*PacketSize]), ei_pload(&A[j+3*PacketSize+iN])), -// ei_padd(ei_pmul(ei_pload(&B[j+4*PacketSize]), ei_pload(&A[j+4*PacketSize+iN])), -// ei_padd(ei_pmul(ei_pload(&B[j+5*PacketSize]), ei_pload(&A[j+5*PacketSize+iN])), -// ei_padd(ei_pmul(ei_pload(&B[j+6*PacketSize]), ei_pload(&A[j+6*PacketSize+iN])), -// ei_padd(ei_pmul(ei_pload(&B[j+7*PacketSize]), ei_pload(&A[j+7*PacketSize+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j]), internal::pload(&A[j+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j+PacketSize]), internal::pload(&A[j+PacketSize+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j+2*PacketSize]), internal::pload(&A[j+2*PacketSize+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j+3*PacketSize]), internal::pload(&A[j+3*PacketSize+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j+4*PacketSize]), internal::pload(&A[j+4*PacketSize+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j+5*PacketSize]), internal::pload(&A[j+5*PacketSize+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j+6*PacketSize]), internal::pload(&A[j+6*PacketSize+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j+7*PacketSize]), internal::pload(&A[j+7*PacketSize+iN])), // ptmp)))))))); // } // for (int j = ANP;j<AN;j+=PacketSize) -// ptmp = ei_padd(ptmp, ei_pmul(ei_pload(&B[j]), ei_pload(&A[j+iN]))); +// ptmp = internal::padd(ptmp, internal::pmul(internal::pload(&B[j]), internal::pload(&A[j+iN]))); // #else // for (int j = 0;j<AN;j+=PacketSize) -// ptmp = ei_padd(ptmp, ei_pmul(ei_pload(&B[j]), ei_pload(&A[j+iN]))); +// ptmp = internal::padd(ptmp, internal::pmul(internal::pload(&B[j]), internal::pload(&A[j+iN]))); // #endif // } // else @@ -805,24 +805,24 @@ public : // for (int j = 0;j<ANP;j+=PacketSize*8) // { // ptmp = -// ei_padd(ei_pmul(ei_pload(&B[j]), ei_ploadu(&A[j+iN])), -// ei_padd(ei_pmul(ei_pload(&B[j+PacketSize]), ei_ploadu(&A[j+PacketSize+iN])), -// ei_padd(ei_pmul(ei_pload(&B[j+2*PacketSize]), ei_ploadu(&A[j+2*PacketSize+iN])), -// ei_padd(ei_pmul(ei_pload(&B[j+3*PacketSize]), ei_ploadu(&A[j+3*PacketSize+iN])), -// ei_padd(ei_pmul(ei_pload(&B[j+4*PacketSize]), ei_ploadu(&A[j+4*PacketSize+iN])), -// ei_padd(ei_pmul(ei_pload(&B[j+5*PacketSize]), ei_ploadu(&A[j+5*PacketSize+iN])), -// ei_padd(ei_pmul(ei_pload(&B[j+6*PacketSize]), ei_ploadu(&A[j+6*PacketSize+iN])), -// ei_padd(ei_pmul(ei_pload(&B[j+7*PacketSize]), ei_ploadu(&A[j+7*PacketSize+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j]), internal::ploadu(&A[j+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j+PacketSize]), internal::ploadu(&A[j+PacketSize+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j+2*PacketSize]), internal::ploadu(&A[j+2*PacketSize+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j+3*PacketSize]), internal::ploadu(&A[j+3*PacketSize+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j+4*PacketSize]), internal::ploadu(&A[j+4*PacketSize+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j+5*PacketSize]), internal::ploadu(&A[j+5*PacketSize+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j+6*PacketSize]), internal::ploadu(&A[j+6*PacketSize+iN])), +// internal::padd(internal::pmul(internal::pload(&B[j+7*PacketSize]), internal::ploadu(&A[j+7*PacketSize+iN])), // ptmp)))))))); // } // for (int j = ANP;j<AN;j+=PacketSize) -// ptmp = ei_padd(ptmp, ei_pmul(ei_pload(&B[j]), ei_ploadu(&A[j+iN]))); +// ptmp = internal::padd(ptmp, internal::pmul(internal::pload(&B[j]), internal::ploadu(&A[j+iN]))); // #else // for (int j = 0;j<AN;j+=PacketSize) -// ptmp = ei_padd(ptmp, ei_pmul(ei_pload(&B[j]), ei_ploadu(&A[j+iN]))); +// ptmp = internal::padd(ptmp, internal::pmul(internal::pload(&B[j]), internal::ploadu(&A[j+iN]))); // #endif // } -// tmp = ei_predux(ptmp); +// tmp = internal::predux(ptmp); // } // // process remaining scalars // for (int j=AN;j<N;j++) @@ -835,7 +835,7 @@ public : int AN = (N/PacketSize)*PacketSize; if (AN>0) { - 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<ANP;j+=PacketSize*peelSize) { - x0 = ei_pload(X+j); - x1 = ei_pload(X1+j); - x2 = ei_pload(X2+j); - - y0 = ei_pload(Y+j); - y1 = ei_pload(Y1+j); - y2 = ei_pload(Y2+j); - - y0 = ei_pmadd(pcoef, x0, y0); - y1 = ei_pmadd(pcoef, x1, y1); - y2 = ei_pmadd(pcoef, x2, y2); - - ei_pstore(Y+j, y0); - ei_pstore(Y1+j, y1); - ei_pstore(Y2+j, y2); -// ei_pstore(&Y[j+2*PacketSize], ei_padd(ei_pload(&Y[j+2*PacketSize]), ei_pmul(pcoef,ei_pload(&X[j+2*PacketSize])))); -// ei_pstore(&Y[j+3*PacketSize], ei_padd(ei_pload(&Y[j+3*PacketSize]), ei_pmul(pcoef,ei_pload(&X[j+3*PacketSize])))); -// ei_pstore(&Y[j+4*PacketSize], ei_padd(ei_pload(&Y[j+4*PacketSize]), ei_pmul(pcoef,ei_pload(&X[j+4*PacketSize])))); -// ei_pstore(&Y[j+5*PacketSize], ei_padd(ei_pload(&Y[j+5*PacketSize]), ei_pmul(pcoef,ei_pload(&X[j+5*PacketSize])))); -// ei_pstore(&Y[j+6*PacketSize], ei_padd(ei_pload(&Y[j+6*PacketSize]), ei_pmul(pcoef,ei_pload(&X[j+6*PacketSize])))); -// ei_pstore(&Y[j+7*PacketSize], ei_padd(ei_pload(&Y[j+7*PacketSize]), ei_pmul(pcoef,ei_pload(&X[j+7*PacketSize])))); + x0 = internal::pload(X+j); + x1 = internal::pload(X1+j); + x2 = internal::pload(X2+j); + + y0 = internal::pload(Y+j); + y1 = internal::pload(Y1+j); + y2 = internal::pload(Y2+j); + + y0 = internal::pmadd(pcoef, x0, y0); + y1 = internal::pmadd(pcoef, x1, y1); + y2 = internal::pmadd(pcoef, x2, y2); + + internal::pstore(Y+j, y0); + internal::pstore(Y1+j, y1); + internal::pstore(Y2+j, y2); +// internal::pstore(&Y[j+2*PacketSize], internal::padd(internal::pload(&Y[j+2*PacketSize]), internal::pmul(pcoef,internal::pload(&X[j+2*PacketSize])))); +// internal::pstore(&Y[j+3*PacketSize], internal::padd(internal::pload(&Y[j+3*PacketSize]), internal::pmul(pcoef,internal::pload(&X[j+3*PacketSize])))); +// internal::pstore(&Y[j+4*PacketSize], internal::padd(internal::pload(&Y[j+4*PacketSize]), internal::pmul(pcoef,internal::pload(&X[j+4*PacketSize])))); +// internal::pstore(&Y[j+5*PacketSize], internal::padd(internal::pload(&Y[j+5*PacketSize]), internal::pmul(pcoef,internal::pload(&X[j+5*PacketSize])))); +// internal::pstore(&Y[j+6*PacketSize], internal::padd(internal::pload(&Y[j+6*PacketSize]), internal::pmul(pcoef,internal::pload(&X[j+6*PacketSize])))); +// internal::pstore(&Y[j+7*PacketSize], internal::padd(internal::pload(&Y[j+7*PacketSize]), internal::pmul(pcoef,internal::pload(&X[j+7*PacketSize])))); } for (int j = ANP;j<AN;j+=PacketSize) - ei_pstore(&Y[j], ei_padd(ei_pload(&Y[j]), ei_pmul(pcoef,ei_pload(&X[j])))); + internal::pstore(&Y[j], internal::padd(internal::pload(&Y[j]), internal::pmul(pcoef,internal::pload(&X[j])))); #else for (int j = 0;j<AN;j+=PacketSize) - ei_pstore(&Y[j], ei_padd(ei_pload(&Y[j]), ei_pmul(pcoef,ei_pload(&X[j])))); + internal::pstore(&Y[j], internal::padd(internal::pload(&Y[j]), internal::pmul(pcoef,internal::pload(&X[j])))); #endif } // process remaining scalars diff --git a/bench/check_cache_queries.cpp b/bench/check_cache_queries.cpp index d2e75048a..029d44cf6 100644 --- a/bench/check_cache_queries.cpp +++ b/bench/check_cache_queries.cpp @@ -17,10 +17,10 @@ using namespace std; int main() { - cout << "Eigen's L1 = " << ei_queryL1CacheSize() << endl; - cout << "Eigen's L2/L3 = " << ei_queryTopLevelCacheSize() << endl; + cout << "Eigen's L1 = " << internal::queryL1CacheSize() << endl; + cout << "Eigen's L2/L3 = " << internal::queryTopLevelCacheSize() << endl; int l1, l2, l3; - ei_queryCacheSizes(l1, l2, l3); + internal::queryCacheSizes(l1, l2, l3); cout << "Eigen's L1, L2, L3 = " << l1 << " " << l2 << " " << l3 << endl; #ifdef EIGEN_CPUID @@ -40,14 +40,14 @@ int main() cout << endl; int max_funcs = abcd[0]; - ei_queryCacheSizes_intel_codes(l1, l2, l3); + internal::queryCacheSizes_intel_codes(l1, l2, l3); cout << "Eigen's intel codes L1, L2, L3 = " << l1 << " " << l2 << " " << l3 << endl; if(max_funcs>=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>(); 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>(); 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<typename Quat> 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<typename Quat> 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<Scalar>(10,20); + dst.fill(j,j) = internal::random<Scalar>(10,20); for(int i = j+1; i < rows; i++) { - Scalar v = (ei_random<float>(0,1) < density) ? ei_random<Scalar>() : 0; + Scalar v = (internal::random<float>(0,1) < density) ? internal::random<Scalar>() : 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<cols; ++j) for (int i=j; i<rows; ++i) - if (!ei_isMuchSmallerThan(ei_abs(chol.matrixL()(i,j)), 0.1)) + if (!internal::isMuchSmallerThan(internal::abs(chol.matrixL()(i,j)), 0.1)) count++; std::cout << "dense: " << "nnz = " << count << "\n"; // std::cout << "dense:\n" << m1 << "\n\n" << chol.matrixL() << endl; diff --git a/bench/sparse_randomsetter.cpp b/bench/sparse_randomsetter.cpp index 61753d8c2..19a76e38d 100644 --- a/bench/sparse_randomsetter.cpp +++ b/bench/sparse_randomsetter.cpp @@ -51,7 +51,7 @@ void dostuff(const char* name, EigenSparseMatrix& sm1) SetterType* set1 = new SetterType(sm1); t.reset(); t.start(); for (int k=0; k<nentries; ++k) - (*set1)(ei_random<int>(0,rows-1),ei_random<int>(0,cols-1)) += 1; + (*set1)(internal::random<int>(0,rows-1),internal::random<int>(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<nentries; ++k) - dummy = ei_random<int>(0,rows-1) + ei_random<int>(0,cols-1); + dummy = internal::random<int>(0,rows-1) + internal::random<int>(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<EigenSparseMatrix,GnuHashMapTraits,Bits> set1(sm1); // t.reset(); t.start(); // for (int k=0; k<n; ++k) -// set1(ei_random<int>(0,rows-1),ei_random<int>(0,cols-1)) += 1; +// set1(internal::random<int>(0,rows-1),internal::random<int>(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<EigenSparseMatrix,GoogleDenseHashMapTraits,Bits> set1(sm1); // t.reset(); t.start(); // for (int k=0; k<n; ++k) -// set1(ei_random<int>(0,rows-1),ei_random<int>(0,cols-1)) += 1; +// set1(internal::random<int>(0,rows-1),internal::random<int>(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<EigenSparseMatrix,GoogleSparseHashMapTraits,Bits> set1(sm1); // t.reset(); t.start(); // for (int k=0; k<n; ++k) -// set1(ei_random<int>(0,rows-1),ei_random<int>(0,cols-1)) += 1; +// set1(internal::random<int>(0,rows-1),internal::random<int>(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<cols*NBPERROW; ) { // DynamicSparseMatrix<int> stencil(SIZE,SIZE); - Vector2i ij(ei_random<int>(0,rows-1),ei_random<int>(0,cols-1)); + Vector2i ij(internal::random<int>(0,rows-1),internal::random<int>(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<n; ++i) { - int i = ei_random<int>(0,pool.size()); + int i = internal::random<int>(0,pool.size()); coords.push_back(pool[i]); - values.push_back(ei_random<Scalar>()); + values.push_back(internal::random<Scalar>()); } } else @@ -100,8 +100,8 @@ int main(int argc, char *argv[]) for (int j=0; j<cols; ++j) for (int i=0; i<NBPERROW; ++i) { - coords.push_back(Vector2i(ei_random<int>(0,rows-1),j)); - values.push_back(ei_random<Scalar>()); + coords.push_back(Vector2i(internal::random<int>(0,rows-1),j)); + values.push_back(internal::random<Scalar>()); } } 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<float>(0,1) < density) ? ei_random<Scalar>() : 0; + Scalar v = (internal::random<float>(0,1) < density) ? internal::random<Scalar>() : 0; if (v!=0) dst.fill(i,j) = v; } - dst.fill(j,j) = ei_random<Scalar>(); + dst.fill(j,j) = internal::random<Scalar>(); } 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<ei_scalar_norm1_op > +template<> struct internal::functor_traits<internal::scalar_norm1_op > { enum { Cost = 3 * NumTraits<Scalar>::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<ei_scalar_norm1_op>().sum(); - else return vector(x,*n,std::abs(*incx)).unaryExpr<ei_scalar_norm1_op>().sum(); + if(*incx==1) return vector(x,*n).unaryExpr<internal::scalar_norm1_op>().sum(); + else return vector(x,*n,std::abs(*incx)).unaryExpr<internal::scalar_norm1_op>().sum(); } #endif @@ -233,9 +233,9 @@ int EIGEN_BLAS_FUNC(rot)(int *n, RealScalar *px, int *incx, RealScalar *py, int Reverse<StridedVectorType> rvx(vx); Reverse<StridedVectorType> rvy(vy); - if(*incx<0 && *incy>0) ei_apply_rotation_in_the_plane(rvx, vy, JacobiRotation<Scalar>(c,s)); - else if(*incx>0 && *incy<0) ei_apply_rotation_in_the_plane(vx, rvy, JacobiRotation<Scalar>(c,s)); - else ei_apply_rotation_in_the_plane(vx, vy, JacobiRotation<Scalar>(c,s)); + if(*incx<0 && *incy>0) internal::apply_rotation_in_the_plane(rvx, vy, JacobiRotation<Scalar>(c,s)); + else if(*incx>0 && *incy<0) internal::apply_rotation_in_the_plane(vx, rvy, JacobiRotation<Scalar>(c,s)); + else internal::apply_rotation_in_the_plane(vx, vy, JacobiRotation<Scalar>(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<Scalar, UpperTriangular|0, false,ColMajor,ColMajor>::run); -// func[TR | (UP << 2) | (NUNIT << 3)] = (ei_triangular_solve_vector<Scalar, UpperTriangular|0, false,RowMajor,ColMajor>::run); -// func[ADJ | (UP << 2) | (NUNIT << 3)] = (ei_triangular_solve_vector<Scalar, UpperTriangular|0, Conj, RowMajor,ColMajor>::run); +// func[NOTR | (UP << 2) | (NUNIT << 3)] = (internal::triangular_solve_vector<Scalar, UpperTriangular|0, false,ColMajor,ColMajor>::run); +// func[TR | (UP << 2) | (NUNIT << 3)] = (internal::triangular_solve_vector<Scalar, UpperTriangular|0, false,RowMajor,ColMajor>::run); +// func[ADJ | (UP << 2) | (NUNIT << 3)] = (internal::triangular_solve_vector<Scalar, UpperTriangular|0, Conj, RowMajor,ColMajor>::run); // -// func[NOTR | (LO << 2) | (NUNIT << 3)] = (ei_triangular_solve_vector<Scalar, LowerTriangular|0, false,ColMajor,ColMajor>::run); -// func[TR | (LO << 2) | (NUNIT << 3)] = (ei_triangular_solve_vector<Scalar, LowerTriangular|0, false,RowMajor,ColMajor>::run); -// func[ADJ | (LO << 2) | (NUNIT << 3)] = (ei_triangular_solve_vector<Scalar, LowerTriangular|0, Conj, RowMajor,ColMajor>::run); +// func[NOTR | (LO << 2) | (NUNIT << 3)] = (internal::triangular_solve_vector<Scalar, LowerTriangular|0, false,ColMajor,ColMajor>::run); +// func[TR | (LO << 2) | (NUNIT << 3)] = (internal::triangular_solve_vector<Scalar, LowerTriangular|0, false,RowMajor,ColMajor>::run); +// func[ADJ | (LO << 2) | (NUNIT << 3)] = (internal::triangular_solve_vector<Scalar, LowerTriangular|0, Conj, RowMajor,ColMajor>::run); // -// func[NOTR | (UP << 3) | (UNIT << 3)] = (ei_triangular_solve_vector<Scalar, UpperTriangular|UnitDiagBit,false,ColMajor,ColMajor>::run); -// func[TR | (UP << 2) | (UNIT << 3)] = (ei_triangular_solve_vector<Scalar, UpperTriangular|UnitDiagBit,false,RowMajor,ColMajor>::run); -// func[ADJ | (UP << 2) | (UNIT << 3)] = (ei_triangular_solve_vector<Scalar, UpperTriangular|UnitDiagBit,Conj, RowMajor,ColMajor>::run); +// func[NOTR | (UP << 3) | (UNIT << 3)] = (internal::triangular_solve_vector<Scalar, UpperTriangular|UnitDiagBit,false,ColMajor,ColMajor>::run); +// func[TR | (UP << 2) | (UNIT << 3)] = (internal::triangular_solve_vector<Scalar, UpperTriangular|UnitDiagBit,false,RowMajor,ColMajor>::run); +// func[ADJ | (UP << 2) | (UNIT << 3)] = (internal::triangular_solve_vector<Scalar, UpperTriangular|UnitDiagBit,Conj, RowMajor,ColMajor>::run); // -// func[NOTR | (LO << 2) | (UNIT << 3)] = (ei_triangular_solve_vector<Scalar, LowerTriangular|UnitDiagBit,false,ColMajor,ColMajor>::run); -// func[TR | (LO << 2) | (UNIT << 3)] = (ei_triangular_solve_vector<Scalar, LowerTriangular|UnitDiagBit,false,RowMajor,ColMajor>::run); -// func[ADJ | (LO << 2) | (UNIT << 3)] = (ei_triangular_solve_vector<Scalar, LowerTriangular|UnitDiagBit,Conj, RowMajor,ColMajor>::run); +// func[NOTR | (LO << 2) | (UNIT << 3)] = (internal::triangular_solve_vector<Scalar, LowerTriangular|UnitDiagBit,false,ColMajor,ColMajor>::run); +// func[TR | (LO << 2) | (UNIT << 3)] = (internal::triangular_solve_vector<Scalar, LowerTriangular|UnitDiagBit,false,RowMajor,ColMajor>::run); +// func[ADJ | (LO << 2) | (UNIT << 3)] = (internal::triangular_solve_vector<Scalar, LowerTriangular|UnitDiagBit,Conj, RowMajor,ColMajor>::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<Scalar,UpperTriangular|0, true, ColMajor,false,ColMajor,false,ColMajor>::run); -// func[TR | (UP << 2) | (NUNIT << 3)] = (ei_product_triangular_matrix_vector<Scalar,UpperTriangular|0, true, RowMajor,false,ColMajor,false,ColMajor>::run); -// func[ADJ | (UP << 2) | (NUNIT << 3)] = (ei_product_triangular_matrix_vector<Scalar,UpperTriangular|0, true, RowMajor,Conj, ColMajor,false,ColMajor>::run); +// func[NOTR | (UP << 2) | (NUNIT << 3)] = (internal::product_triangular_matrix_vector<Scalar,UpperTriangular|0, true, ColMajor,false,ColMajor,false,ColMajor>::run); +// func[TR | (UP << 2) | (NUNIT << 3)] = (internal::product_triangular_matrix_vector<Scalar,UpperTriangular|0, true, RowMajor,false,ColMajor,false,ColMajor>::run); +// func[ADJ | (UP << 2) | (NUNIT << 3)] = (internal::product_triangular_matrix_vector<Scalar,UpperTriangular|0, true, RowMajor,Conj, ColMajor,false,ColMajor>::run); // -// func[NOTR | (LO << 2) | (NUNIT << 3)] = (ei_product_triangular_matrix_vector<Scalar,LowerTriangular|0, true, ColMajor,false,ColMajor,false,ColMajor>::run); -// func[TR | (LO << 2) | (NUNIT << 3)] = (ei_product_triangular_matrix_vector<Scalar,LowerTriangular|0, true, RowMajor,false,ColMajor,false,ColMajor>::run); -// func[ADJ | (LO << 2) | (NUNIT << 3)] = (ei_product_triangular_matrix_vector<Scalar,LowerTriangular|0, true, RowMajor,Conj, ColMajor,false,ColMajor>::run); +// func[NOTR | (LO << 2) | (NUNIT << 3)] = (internal::product_triangular_matrix_vector<Scalar,LowerTriangular|0, true, ColMajor,false,ColMajor,false,ColMajor>::run); +// func[TR | (LO << 2) | (NUNIT << 3)] = (internal::product_triangular_matrix_vector<Scalar,LowerTriangular|0, true, RowMajor,false,ColMajor,false,ColMajor>::run); +// func[ADJ | (LO << 2) | (NUNIT << 3)] = (internal::product_triangular_matrix_vector<Scalar,LowerTriangular|0, true, RowMajor,Conj, ColMajor,false,ColMajor>::run); // -// func[NOTR | (UP << 2) | (UNIT << 3)] = (ei_product_triangular_matrix_vector<Scalar,UpperTriangular|UnitDiagBit,true, ColMajor,false,ColMajor,false,ColMajor>::run); -// func[TR | (UP << 2) | (UNIT << 3)] = (ei_product_triangular_matrix_vector<Scalar,UpperTriangular|UnitDiagBit,true, RowMajor,false,ColMajor,false,ColMajor>::run); -// func[ADJ | (UP << 2) | (UNIT << 3)] = (ei_product_triangular_matrix_vector<Scalar,UpperTriangular|UnitDiagBit,true, RowMajor,Conj, ColMajor,false,ColMajor>::run); +// func[NOTR | (UP << 2) | (UNIT << 3)] = (internal::product_triangular_matrix_vector<Scalar,UpperTriangular|UnitDiagBit,true, ColMajor,false,ColMajor,false,ColMajor>::run); +// func[TR | (UP << 2) | (UNIT << 3)] = (internal::product_triangular_matrix_vector<Scalar,UpperTriangular|UnitDiagBit,true, RowMajor,false,ColMajor,false,ColMajor>::run); +// func[ADJ | (UP << 2) | (UNIT << 3)] = (internal::product_triangular_matrix_vector<Scalar,UpperTriangular|UnitDiagBit,true, RowMajor,Conj, ColMajor,false,ColMajor>::run); // -// func[NOTR | (LO << 2) | (UNIT << 3)] = (ei_product_triangular_matrix_vector<Scalar,LowerTriangular|UnitDiagBit,true, ColMajor,false,ColMajor,false,ColMajor>::run); -// func[TR | (LO << 2) | (UNIT << 3)] = (ei_product_triangular_matrix_vector<Scalar,LowerTriangular|UnitDiagBit,true, RowMajor,false,ColMajor,false,ColMajor>::run); -// func[ADJ | (LO << 2) | (UNIT << 3)] = (ei_product_triangular_matrix_vector<Scalar,LowerTriangular|UnitDiagBit,true, RowMajor,Conj, ColMajor,false,ColMajor>::run); +// func[NOTR | (LO << 2) | (UNIT << 3)] = (internal::product_triangular_matrix_vector<Scalar,LowerTriangular|UnitDiagBit,true, ColMajor,false,ColMajor,false,ColMajor>::run); +// func[TR | (LO << 2) | (UNIT << 3)] = (internal::product_triangular_matrix_vector<Scalar,LowerTriangular|UnitDiagBit,true, RowMajor,false,ColMajor,false,ColMajor>::run); +// func[ADJ | (LO << 2) | (UNIT << 3)] = (internal::product_triangular_matrix_vector<Scalar,LowerTriangular|UnitDiagBit,true, RowMajor,Conj, ColMajor,false,ColMajor>::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<Scalar,ColMajor,ColMajor,false,UpperTriangular>::run); -// func[LO] = (ei_selfadjoint_product<Scalar,ColMajor,ColMajor,false,LowerTriangular>::run); +// func[UP] = (internal::selfadjoint_product<Scalar,ColMajor,ColMajor,false,UpperTriangular>::run); +// func[LO] = (internal::selfadjoint_product<Scalar,ColMajor,ColMajor,false,LowerTriangular>::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<Scalar,ColMajor,ColMajor,false,UpperTriangular>::run); -// func[LO] = (ei_selfadjoint_product<Scalar,ColMajor,ColMajor,false,LowerTriangular>::run); +// func[UP] = (internal::selfadjoint_product<Scalar,ColMajor,ColMajor,false,UpperTriangular>::run); +// func[LO] = (internal::selfadjoint_product<Scalar,ColMajor,ColMajor,false,LowerTriangular>::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<Scalar,Scalar>&, Eigen::GemmParallelInfo<DenseIndex>*); + typedef void (*functype)(DenseIndex, DenseIndex, DenseIndex, const Scalar *, DenseIndex, const Scalar *, DenseIndex, Scalar *, DenseIndex, Scalar, internal::level3_blocking<Scalar,Scalar>&, Eigen::GemmParallelInfo<DenseIndex>*); 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<DenseIndex,Scalar,ColMajor,false,Scalar,ColMajor,false,ColMajor>::run); - func[TR | (NOTR << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,false,Scalar,ColMajor,false,ColMajor>::run); - func[ADJ | (NOTR << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,Conj, Scalar,ColMajor,false,ColMajor>::run); - func[NOTR | (TR << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,ColMajor,false,Scalar,RowMajor,false,ColMajor>::run); - func[TR | (TR << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,false,Scalar,RowMajor,false,ColMajor>::run); - func[ADJ | (TR << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,Conj, Scalar,RowMajor,false,ColMajor>::run); - func[NOTR | (ADJ << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,ColMajor,false,Scalar,RowMajor,Conj, ColMajor>::run); - func[TR | (ADJ << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,false,Scalar,RowMajor,Conj, ColMajor>::run); - func[ADJ | (ADJ << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,Conj, Scalar,RowMajor,Conj, ColMajor>::run); + func[NOTR | (NOTR << 2)] = (internal::general_matrix_matrix_product<DenseIndex,Scalar,ColMajor,false,Scalar,ColMajor,false,ColMajor>::run); + func[TR | (NOTR << 2)] = (internal::general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,false,Scalar,ColMajor,false,ColMajor>::run); + func[ADJ | (NOTR << 2)] = (internal::general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,Conj, Scalar,ColMajor,false,ColMajor>::run); + func[NOTR | (TR << 2)] = (internal::general_matrix_matrix_product<DenseIndex,Scalar,ColMajor,false,Scalar,RowMajor,false,ColMajor>::run); + func[TR | (TR << 2)] = (internal::general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,false,Scalar,RowMajor,false,ColMajor>::run); + func[ADJ | (TR << 2)] = (internal::general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,Conj, Scalar,RowMajor,false,ColMajor>::run); + func[NOTR | (ADJ << 2)] = (internal::general_matrix_matrix_product<DenseIndex,Scalar,ColMajor,false,Scalar,RowMajor,Conj, ColMajor>::run); + func[TR | (ADJ << 2)] = (internal::general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,false,Scalar,RowMajor,Conj, ColMajor>::run); + func[ADJ | (ADJ << 2)] = (internal::general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,Conj, Scalar,RowMajor,Conj, ColMajor>::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<ColMajor,Scalar,Scalar,Dynamic,Dynamic,Dynamic> blocking(*m,*n,*k); + internal::gemm_blocking_space<ColMajor,Scalar,Scalar,Dynamic,Dynamic,Dynamic> 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<Scalar,DenseIndex,OnTheLeft, Upper|0, false,ColMajor,ColMajor>::run); - func[TR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|0, false,RowMajor,ColMajor>::run); - func[ADJ | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|0, Conj, RowMajor,ColMajor>::run); + func[NOTR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|0, false,ColMajor,ColMajor>::run); + func[TR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|0, false,RowMajor,ColMajor>::run); + func[ADJ | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|0, Conj, RowMajor,ColMajor>::run); - func[NOTR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|0, false,ColMajor,ColMajor>::run); - func[TR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|0, false,RowMajor,ColMajor>::run); - func[ADJ | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|0, Conj, RowMajor,ColMajor>::run); + func[NOTR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|0, false,ColMajor,ColMajor>::run); + func[TR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|0, false,RowMajor,ColMajor>::run); + func[ADJ | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|0, Conj, RowMajor,ColMajor>::run); - func[NOTR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|0, false,ColMajor,ColMajor>::run); - func[TR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|0, false,RowMajor,ColMajor>::run); - func[ADJ | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|0, Conj, RowMajor,ColMajor>::run); + func[NOTR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|0, false,ColMajor,ColMajor>::run); + func[TR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|0, false,RowMajor,ColMajor>::run); + func[ADJ | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|0, Conj, RowMajor,ColMajor>::run); - func[NOTR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|0, false,ColMajor,ColMajor>::run); - func[TR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|0, false,RowMajor,ColMajor>::run); - func[ADJ | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|0, Conj, RowMajor,ColMajor>::run); + func[NOTR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|0, false,ColMajor,ColMajor>::run); + func[TR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|0, false,RowMajor,ColMajor>::run); + func[ADJ | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|0, Conj, RowMajor,ColMajor>::run); - func[NOTR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|UnitDiag,false,ColMajor,ColMajor>::run); - func[TR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|UnitDiag,false,RowMajor,ColMajor>::run); - func[ADJ | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|UnitDiag,Conj, RowMajor,ColMajor>::run); + func[NOTR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|UnitDiag,false,ColMajor,ColMajor>::run); + func[TR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|UnitDiag,false,RowMajor,ColMajor>::run); + func[ADJ | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|UnitDiag,Conj, RowMajor,ColMajor>::run); - func[NOTR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|UnitDiag,false,ColMajor,ColMajor>::run); - func[TR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|UnitDiag,false,RowMajor,ColMajor>::run); - func[ADJ | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|UnitDiag,Conj, RowMajor,ColMajor>::run); + func[NOTR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|UnitDiag,false,ColMajor,ColMajor>::run); + func[TR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|UnitDiag,false,RowMajor,ColMajor>::run); + func[ADJ | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|UnitDiag,Conj, RowMajor,ColMajor>::run); - func[NOTR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|UnitDiag,false,ColMajor,ColMajor>::run); - func[TR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|UnitDiag,false,RowMajor,ColMajor>::run); - func[ADJ | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|UnitDiag,Conj, RowMajor,ColMajor>::run); + func[NOTR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|UnitDiag,false,ColMajor,ColMajor>::run); + func[TR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|UnitDiag,false,RowMajor,ColMajor>::run); + func[ADJ | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|UnitDiag,Conj, RowMajor,ColMajor>::run); - func[NOTR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|UnitDiag,false,ColMajor,ColMajor>::run); - func[TR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|UnitDiag,false,RowMajor,ColMajor>::run); - func[ADJ | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|UnitDiag,Conj, RowMajor,ColMajor>::run); + func[NOTR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|UnitDiag,false,ColMajor,ColMajor>::run); + func[TR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|UnitDiag,false,RowMajor,ColMajor>::run); + func[ADJ | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (internal::triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|UnitDiag,Conj, RowMajor,ColMajor>::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<Scalar,DenseIndex,Upper|0, true, ColMajor,false,ColMajor,false,ColMajor>::run); - func[TR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, true, RowMajor,false,ColMajor,false,ColMajor>::run); - func[ADJ | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, true, RowMajor,Conj, ColMajor,false,ColMajor>::run); + func[NOTR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, true, ColMajor,false,ColMajor,false,ColMajor>::run); + func[TR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, true, RowMajor,false,ColMajor,false,ColMajor>::run); + func[ADJ | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, true, RowMajor,Conj, ColMajor,false,ColMajor>::run); - func[NOTR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, false,ColMajor,false,ColMajor,false,ColMajor>::run); - func[TR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, false,ColMajor,false,RowMajor,false,ColMajor>::run); - func[ADJ | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, false,ColMajor,false,RowMajor,Conj, ColMajor>::run); + func[NOTR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, false,ColMajor,false,ColMajor,false,ColMajor>::run); + func[TR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, false,ColMajor,false,RowMajor,false,ColMajor>::run); + func[ADJ | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, false,ColMajor,false,RowMajor,Conj, ColMajor>::run); - func[NOTR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, true, ColMajor,false,ColMajor,false,ColMajor>::run); - func[TR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, true, RowMajor,false,ColMajor,false,ColMajor>::run); - func[ADJ | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, true, RowMajor,Conj, ColMajor,false,ColMajor>::run); + func[NOTR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, true, ColMajor,false,ColMajor,false,ColMajor>::run); + func[TR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, true, RowMajor,false,ColMajor,false,ColMajor>::run); + func[ADJ | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, true, RowMajor,Conj, ColMajor,false,ColMajor>::run); - func[NOTR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, false,ColMajor,false,ColMajor,false,ColMajor>::run); - func[TR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, false,ColMajor,false,RowMajor,false,ColMajor>::run); - func[ADJ | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, false,ColMajor,false,RowMajor,Conj, ColMajor>::run); + func[NOTR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, false,ColMajor,false,ColMajor,false,ColMajor>::run); + func[TR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, false,ColMajor,false,RowMajor,false,ColMajor>::run); + func[ADJ | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, false,ColMajor,false,RowMajor,Conj, ColMajor>::run); - func[NOTR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,true, ColMajor,false,ColMajor,false,ColMajor>::run); - func[TR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,true, RowMajor,false,ColMajor,false,ColMajor>::run); - func[ADJ | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,true, RowMajor,Conj, ColMajor,false,ColMajor>::run); + func[NOTR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,true, ColMajor,false,ColMajor,false,ColMajor>::run); + func[TR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,true, RowMajor,false,ColMajor,false,ColMajor>::run); + func[ADJ | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,true, RowMajor,Conj, ColMajor,false,ColMajor>::run); - func[NOTR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,false,ColMajor,false,ColMajor,false,ColMajor>::run); - func[TR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,false,ColMajor,false,RowMajor,false,ColMajor>::run); - func[ADJ | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,false,ColMajor,false,RowMajor,Conj, ColMajor>::run); + func[NOTR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,false,ColMajor,false,ColMajor,false,ColMajor>::run); + func[TR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,false,ColMajor,false,RowMajor,false,ColMajor>::run); + func[ADJ | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,false,ColMajor,false,RowMajor,Conj, ColMajor>::run); - func[NOTR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,true, ColMajor,false,ColMajor,false,ColMajor>::run); - func[TR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,true, RowMajor,false,ColMajor,false,ColMajor>::run); - func[ADJ | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,true, RowMajor,Conj, ColMajor,false,ColMajor>::run); + func[NOTR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,true, ColMajor,false,ColMajor,false,ColMajor>::run); + func[TR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,true, RowMajor,false,ColMajor,false,ColMajor>::run); + func[ADJ | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,true, RowMajor,Conj, ColMajor,false,ColMajor>::run); - func[NOTR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,false,ColMajor,false,ColMajor,false,ColMajor>::run); - func[TR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,false,ColMajor,false,RowMajor,false,ColMajor>::run); - func[ADJ | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,false,ColMajor,false,RowMajor,Conj, ColMajor>::run); + func[NOTR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,false,ColMajor,false,ColMajor,false,ColMajor>::run); + func[TR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,false,ColMajor,false,RowMajor,false,ColMajor>::run); + func[ADJ | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (internal::product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,false,ColMajor,false,RowMajor,Conj, ColMajor>::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<Scalar, DenseIndex, RowMajor,true,false, ColMajor,false,false, ColMajor>::run(*m, *n, a, *lda, b, *ldb, c, *ldc, alpha); - else if(UPLO(*uplo)==LO) ei_product_selfadjoint_matrix<Scalar, DenseIndex, ColMajor,true,false, ColMajor,false,false, ColMajor>::run(*m, *n, a, *lda, b, *ldb, c, *ldc, alpha); + if(UPLO(*uplo)==UP) internal::product_selfadjoint_matrix<Scalar, DenseIndex, RowMajor,true,false, ColMajor,false,false, ColMajor>::run(*m, *n, a, *lda, b, *ldb, c, *ldc, alpha); + else if(UPLO(*uplo)==LO) internal::product_selfadjoint_matrix<Scalar, DenseIndex, ColMajor,true,false, ColMajor,false,false, ColMajor>::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<Scalar, DenseIndex, ColMajor,false,false, RowMajor,true,false, ColMajor>::run(*m, *n, b, *ldb, a, *lda, c, *ldc, alpha); - else if(UPLO(*uplo)==LO) ei_product_selfadjoint_matrix<Scalar, DenseIndex, ColMajor,false,false, ColMajor,true,false, ColMajor>::run(*m, *n, b, *ldb, a, *lda, c, *ldc, alpha); + if(UPLO(*uplo)==UP) internal::product_selfadjoint_matrix<Scalar, DenseIndex, ColMajor,false,false, RowMajor,true,false, ColMajor>::run(*m, *n, b, *ldb, a, *lda, c, *ldc, alpha); + else if(UPLO(*uplo)==LO) internal::product_selfadjoint_matrix<Scalar, DenseIndex, ColMajor,false,false, ColMajor,true,false, ColMajor>::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<Scalar,DenseIndex,ColMajor,ColMajor,true, Upper>::run); - func[TR | (UP << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Upper>::run); - func[ADJ | (UP << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Upper>::run); + func[NOTR | (UP << 2)] = (internal::selfadjoint_product<Scalar,DenseIndex,ColMajor,ColMajor,true, Upper>::run); + func[TR | (UP << 2)] = (internal::selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Upper>::run); + func[ADJ | (UP << 2)] = (internal::selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Upper>::run); - func[NOTR | (LO << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,ColMajor,ColMajor,true, Lower>::run); - func[TR | (LO << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Lower>::run); - func[ADJ | (LO << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Lower>::run); + func[NOTR | (LO << 2)] = (internal::selfadjoint_product<Scalar,DenseIndex,ColMajor,ColMajor,true, Lower>::run); + func[TR | (LO << 2)] = (internal::selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Lower>::run); + func[ADJ | (LO << 2)] = (internal::selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Lower>::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<Scalar,DenseIndex,RowMajor,true,Conj, ColMajor,false,false, ColMajor> + if(UPLO(*uplo)==UP) internal::product_selfadjoint_matrix<Scalar,DenseIndex,RowMajor,true,Conj, ColMajor,false,false, ColMajor> ::run(*m, *n, a, *lda, b, *ldb, c, *ldc, alpha); - else if(UPLO(*uplo)==LO) ei_product_selfadjoint_matrix<Scalar,DenseIndex,ColMajor,true,false, ColMajor,false,false, ColMajor> + else if(UPLO(*uplo)==LO) internal::product_selfadjoint_matrix<Scalar,DenseIndex,ColMajor,true,false, ColMajor,false,false, ColMajor> ::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<Upper>();/*ei_product_selfadjoint_matrix<Scalar,DenseIndex,ColMajor,false,false, RowMajor,true,Conj, ColMajor> + if(UPLO(*uplo)==UP) matrix(c,*m,*n,*ldc) += alpha * matrix(b,*m,*n,*ldb) * matrix(a,*n,*n,*lda).selfadjointView<Upper>();/*internal::product_selfadjoint_matrix<Scalar,DenseIndex,ColMajor,false,false, RowMajor,true,Conj, ColMajor> ::run(*m, *n, b, *ldb, a, *lda, c, *ldc, alpha);*/ - else if(UPLO(*uplo)==LO) ei_product_selfadjoint_matrix<Scalar,DenseIndex,ColMajor,false,false, ColMajor,true,false, ColMajor> + else if(UPLO(*uplo)==LO) internal::product_selfadjoint_matrix<Scalar,DenseIndex,ColMajor,false,false, ColMajor,true,false, ColMajor> ::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<Scalar,DenseIndex,ColMajor,ColMajor,true, Upper>::run); - func[ADJ | (UP << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Upper>::run); + func[NOTR | (UP << 2)] = (internal::selfadjoint_product<Scalar,DenseIndex,ColMajor,ColMajor,true, Upper>::run); + func[ADJ | (UP << 2)] = (internal::selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Upper>::run); - func[NOTR | (LO << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,ColMajor,ColMajor,true, Lower>::run); - func[ADJ | (LO << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Lower>::run); + func[NOTR | (LO << 2)] = (internal::selfadjoint_product<Scalar,DenseIndex,ColMajor,ColMajor,true, Lower>::run); + func[ADJ | (LO << 2)] = (internal::selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Lower>::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<Upper>() += 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<Lower>() += 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<Upper>() += 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<Lower>() += 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<double> { enum { ret = 16 }; }; template<typename Real> void MandelbrotThread::render(int img_width, int img_height) { - enum { packetSize = Eigen::ei_packet_traits<Real>::size }; // number of reals in a Packet + enum { packetSize = Eigen::internal::packet_traits<Real>::size }; // number of reals in a Packet typedef Eigen::Array<Real, packetSize, 1> Packet; // wrap a Packet as a vector enum { iters_before_test = iters_before_test<Real>::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<float>::size) - : int(Eigen::ei_packet_traits<double>::size); + ? int(Eigen::internal::packet_traits<float>::size) + : int(Eigen::internal::packet_traits<double>::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<typename Scalar, typename Derived> void loadMatrix( - const Eigen::CwiseNullaryOp<Eigen::ei_scalar_identity_op<Scalar>,Derived>&, + const Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>,Derived>&, GLenum matrixTarget); /** Make the matrix \a matrixTarget the current OpenGL matrix target. @@ -86,7 +86,7 @@ class GpuHelper template<typename Scalar, typename Derived> void pushMatrix( - const Eigen::CwiseNullaryOp<Eigen::ei_scalar_identity_op<Scalar>,Derived>&, + const Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>,Derived>&, GLenum matrixTarget); /** Push and clone the OpenGL matrix \a matrixTarget @@ -161,7 +161,7 @@ void GpuHelper::multMatrix(const Matrix<Scalar,4,4, _Flags, 4,4>& mat, GLenum ma template<typename Scalar, typename Derived> void GpuHelper::loadMatrix( - const Eigen::CwiseNullaryOp<Eigen::ei_scalar_identity_op<Scalar>,Derived>&, + const Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>,Derived>&, GLenum matrixTarget) { setMatrixTarget(matrixTarget); @@ -190,7 +190,7 @@ inline void GpuHelper::pushMatrix(const Matrix<Scalar,4,4, _Flags, 4,4>& mat, GL template<typename Scalar, typename Derived> void GpuHelper::pushMatrix( - const Eigen::CwiseNullaryOp<Eigen::ei_scalar_identity_op<Scalar>,Derived>&, + const Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>,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: <pre> my_program: path/to/eigen/Eigen/src/Core/DenseStorage.h:44: -Eigen::ei_matrix_array<T, Size, MatrixOptions, Align>::ei_matrix_array() +Eigen::internal::matrix_array<T, Size, MatrixOptions, Align>::internal::matrix_array() [with T = double, int Size = 2, int MatrixOptions = 2, bool Align = true]: Assertion `(reinterpret_cast<size_t>(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<OtherDerived>& other) const template<typename OtherDerived> inline RealScalar distanceTo(const MatrixBase<OtherDerived>& 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<OtherDerived>& other) { derived() = derived().cw template<typename OtherDerived> void makeCeil(const MatrixBase<OtherDerived>& other) { derived() = derived().cwiseMax(other.derived()); } -const CwiseUnaryOp<ei_scalar_add_op<Scalar>, Derived> +const CwiseUnaryOp<internal::scalar_add_op<Scalar>, Derived> operator+(const Scalar& scalar) const -{ return CwiseUnaryOp<ei_scalar_add_op<Scalar>, Derived>(derived(), ei_scalar_add_op<Scalar>(scalar)); } +{ return CwiseUnaryOp<internal::scalar_add_op<Scalar>, Derived>(derived(), internal::scalar_add_op<Scalar>(scalar)); } -friend const CwiseUnaryOp<ei_scalar_add_op<Scalar>, Derived> +friend const CwiseUnaryOp<internal::scalar_add_op<Scalar>, Derived> operator+(const Scalar& scalar, const MatrixBase<Derived>& mat) -{ return CwiseUnaryOp<ei_scalar_add_op<Scalar>, Derived>(mat.derived(), ei_scalar_add_op<Scalar>(scalar)); } +{ return CwiseUnaryOp<internal::scalar_add_op<Scalar>, Derived>(mat.derived(), internal::scalar_add_op<Scalar>(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<T> (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. <a href="https://projects.coin-or.org/ADOL-C">Adolc</a> 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<adtl::adouble> } // 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<T>(size)), m_rows(rows) {} +inline DenseStorage(int size, int rows, int) : m_data(internal::aligned_new<T>(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<ei_scalar_sum_op<float>, VectorXf, VectorXf> +CwiseBinaryOp<internal::scalar_sum_op<float>, 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<typename OtherDerived> - const CwiseBinaryOp<ei_scalar_sum_op<typename ei_traits<Derived>::Scalar>, Derived, OtherDerived> + const CwiseBinaryOp<internal::scalar_sum_op<typename internal::traits<Derived>::Scalar>, Derived, OtherDerived> operator+(const MatrixBase<OtherDerived> &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<typename T> struct ei_traits; +template<typename T> 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\<any template parameters\>. 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\<Matrix\>::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\<any template parameters\>. 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\<Matrix\>::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<VectorXf> { // ... - const CwiseBinaryOp<ei_scalar_sum_op<float>, VectorXf, VectorXf> + const CwiseBinaryOp<internal::scalar_sum_op<float>, VectorXf, VectorXf> operator+(const MatrixBase<VectorXf> &other) const; // ... @@ -228,7 +228,7 @@ What operator= is being called here? The vector u is an object of class VectorXf template<typename OtherDerived> inline Matrix& operator=(const MatrixBase<OtherDerived>& 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\<Matrix\>. 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<ei_scalar_sum_op<float>, VectorXf, VectorXf> +CwiseBinaryOp<internal::scalar_sum_op<float>, VectorXf, VectorXf> \endcode So the full prototype of the operator= being called is: \code -VectorXf& MatrixBase<VectorXf>::operator=(const MatrixBase<CwiseBinaryOp<ei_scalar_sum_op<float>, VectorXf, VectorXf> > & other); +VectorXf& MatrixBase<VectorXf>::operator=(const MatrixBase<CwiseBinaryOp<internal::scalar_sum_op<float>, VectorXf, VectorXf> > & other); \endcode This operator= literally reads "copying a sum of two VectorXf's into another VectorXf". @@ -256,11 +256,11 @@ template<typename OtherDerived> inline Derived& MatrixBase<Derived> ::operator=(const MatrixBase<OtherDerived>& other) { - return ei_assign_selector<Derived,OtherDerived>::run(derived(), other.derived()); + return internal::assign_selector<Derived,OtherDerived>::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<typename Derived, typename OtherDerived, && int(Derived::RowsAtCompileTime) == int(OtherDerived::ColsAtCompileTime) && int(Derived::ColsAtCompileTime) == int(OtherDerived::RowsAtCompileTime) && int(Derived::SizeAtCompileTime) != 1> -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 <a href="TopicLazyEvaluation.html">here</a>, 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\<CwiseBinaryOp\> 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 <a href="TopicLazyEvaluation.html">here</a>, 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\<CwiseBinaryOp\> 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<Derived, OtherDerived, false, false> +internal::assign_selector<Derived, OtherDerived, false, false> \endcode Here's how it is defined: \code template<typename Derived, typename OtherDerived> -struct ei_assign_selector<Derived,OtherDerived,false,false> { +struct internal::assign_selector<Derived,OtherDerived,false,false> { static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.derived()); } }; \endcode @@ -302,48 +302,48 @@ inline Derived& MatrixBase<Derived> ::lazyAssign(const MatrixBase<OtherDerived>& other) { EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived) - ei_assert(rows() == other.rows() && cols() == other.cols()); - ei_assign_impl<Derived, OtherDerived>::run(derived(),other.derived()); + eigen_assert(rows() == other.rows() && cols() == other.cols()); + internal::assign_impl<Derived, OtherDerived>::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<Derived, OtherDerived>::run(derived(),other.derived()); + internal::assign_impl<Derived, OtherDerived>::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<typename Derived1, typename Derived2, - int Vectorization = ei_assign_traits<Derived1, Derived2>::Vectorization, - int Unrolling = ei_assign_traits<Derived1, Derived2>::Unrolling> -struct ei_assign_impl; + int Vectorization = internal::assign_traits<Derived1, Derived2>::Vectorization, + int Unrolling = internal::assign_traits<Derived1, Derived2>::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<Derived1, Derived2, LinearVectorization, NoUnrolling> +internal::assign_impl<Derived1, Derived2, LinearVectorization, NoUnrolling> \endcode Here is how it's defined: \code template<typename Derived1, typename Derived2> -struct ei_assign_impl<Derived1, Derived2, LinearVectorization, NoUnrolling> +struct internal::assign_impl<Derived1, Derived2, LinearVectorization, NoUnrolling> { static void run(Derived1 &dst, const Derived2 &src) { const int size = dst.size(); - const int packetSize = ei_packet_traits<typename Derived1::Scalar>::size; - const int alignedStart = ei_assign_traits<Derived1,Derived2>::DstIsAligned ? 0 - : ei_first_aligned(&dst.coeffRef(0), size); + const int packetSize = internal::packet_traits<typename Derived1::Scalar>::size; + const int alignedStart = internal::assign_traits<Derived1,Derived2>::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<Derived1, Derived2, LinearVectorization, NoUnrolling> for(int index = alignedStart; index < alignedEnd; index += packetSize) { - dst.template copyPacket<Derived2, Aligned, ei_assign_traits<Derived1,Derived2>::SrcAlignment>(index, src); + dst.template copyPacket<Derived2, Aligned, internal::assign_traits<Derived1,Derived2>::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<Derived2, Aligned, ei_assign_traits<Derived1,Derived2>::SrcAlignment>(index, src); + dst.template copyPacket<Derived2, Aligned, internal::assign_traits<Derived1,Derived2>::SrcAlignment>(index, src); } \endcode @@ -384,7 +384,7 @@ template<typename Derived> template<typename OtherDerived, int StoreMode, int LoadMode> inline void MatrixBase<Derived>::copyPacket(int index, const MatrixBase<OtherDerived>& other) { - ei_internal_assert(index >= 0 && index < size()); + eigen_internal_assert(index >= 0 && index < size()); derived().template writePacket<StoreMode>(index, other.derived().template packet<LoadMode>(index)); } @@ -397,30 +397,30 @@ First, writePacket() here is a method on the left-hand side VectorXf. So we go t template<int StoreMode> inline void writePacket(int index, const PacketScalar& x) { - ei_pstoret<Scalar, PacketScalar, StoreMode>(m_storage.data() + index, x); + internal::pstoret<Scalar, PacketScalar, StoreMode>(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<float> { typedef __m128 type; enum {size=4}; }; +template<> struct internal::packet_traits<float> { 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<typename Scalar, typename Packet, int LoadMode> -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<int LoadMode> inline PacketScalar packet(int index) const { - return ei_ploadt<Scalar, LoadMode>(m_storage.data() + index); + return internal::ploadt<Scalar, LoadMode>(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<ei_scalar_sum_op<float>, VectorXf, VectorXf> +CwiseBinaryOp<internal::scalar_sum_op<float>, VectorXf, VectorXf> \endcode -So m_functor is an object of the empty class ei_scalar_sum_op<float>. 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<float>. 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<typename Scalar> struct ei_scalar_sum_op EIGEN_EMPTY_STRUCT { +template<typename Scalar> struct internal::scalar_sum_op EIGEN_EMPTY_STRUCT { inline const Scalar operator() (const Scalar& a, const Scalar& b) const { return a + b; } template<typename PacketScalar> 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<Derived2, Aligned, ei_assign_traits<Derived1,Derived2>::SrcAlignment>(index, src); + dst.template copyPacket<Derived2, Aligned, internal::assign_traits<Derived1,Derived2>::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<Derived>::checkTransposeAliasing(const OtherDerived&) const [with OtherDerived = Eigen::Transpose<Eigen::Matrix<int, 2, 2, 0, 2, 2> >, Derived = Eigen::Matrix<int, 2, 2, 0, 2, 2>]: -Assertion `(!ei_check_transpose_aliasing_selector<Scalar,ei_blas_traits<Derived>::IsTransposed,OtherDerived>::run(ei_extract_data(derived()), other)) +Assertion `(!internal::check_transpose_aliasing_selector<Scalar,internal::blas_traits<Derived>::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 <typename Derived, typename OtherDerived> void cov(const MatrixBase<Derived>& x, const MatrixBase<Derived>& y, MatrixBase<OtherDerived> EIGEN_REF_TO_TEMPORARY C) { - typedef typename ei_traits<Derived>::Scalar Scalar; - typedef typename ei_plain_row_type<Derived>::type RowVectorType; + typedef typename internal::traits<Derived>::Scalar Scalar; + typedef typename internal::plain_row_type<Derived>::type RowVectorType; const Scalar num_observations = static_cast<Scalar>(x.rows()); @@ -141,8 +141,8 @@ This is not the case anymore, when we are using an implementation taking MatrixB template <typename Derived, typename OtherDerived> void cov(const MatrixBase<Derived>& x, const MatrixBase<Derived>& y, MatrixBase<OtherDerived> EIGEN_REF_TO_TEMPORARY C_) { - typedef typename ei_traits<Derived>::Scalar Scalar; - typedef typename ei_plain_row_type<Derived>::type RowVectorType; + typedef typename internal::traits<Derived>::Scalar Scalar; + typedef typename internal::plain_row_type<Derived>::type RowVectorType; const Scalar num_observations = static_cast<Scalar>(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<typename MatrixType> void adjoint(const MatrixType& m) Index cols = m.cols(); RealScalar largerEps = test_precision<RealScalar>(); - if (ei_is_same_type<RealScalar,float>::ret) + if (internal::is_same_type<RealScalar,float>::ret) largerEps = RealScalar(1e-3f); MatrixType m1 = MatrixType::Random(rows, cols), @@ -55,8 +55,8 @@ template<typename MatrixType> void adjoint(const MatrixType& m) v3 = VectorType::Random(rows), vzero = VectorType::Zero(rows); - Scalar s1 = ei_random<Scalar>(), - s2 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(), + s2 = internal::random<Scalar>(); // check basic compatibility of adjoint, transpose, conjugate VERIFY_IS_APPROX(m1.transpose().conjugate().adjoint(), m1); @@ -64,26 +64,26 @@ template<typename MatrixType> void adjoint(const MatrixType& m) // check multiplicative behavior VERIFY_IS_APPROX((m1.adjoint() * m2).adjoint(), m2.adjoint() * m1); - VERIFY_IS_APPROX((s1 * m1).adjoint(), ei_conj(s1) * m1.adjoint()); + VERIFY_IS_APPROX((s1 * m1).adjoint(), internal::conj(s1) * m1.adjoint()); // check basic properties of dot, norm, norm2 typedef typename NumTraits<Scalar>::Real RealScalar; - VERIFY(ei_isApprox((s1 * v1 + s2 * v2).dot(v3), ei_conj(s1) * v1.dot(v3) + ei_conj(s2) * v2.dot(v3), largerEps)); - VERIFY(ei_isApprox(v3.dot(s1 * v1 + s2 * v2), s1*v3.dot(v1)+s2*v3.dot(v2), largerEps)); - VERIFY_IS_APPROX(ei_conj(v1.dot(v2)), v2.dot(v1)); - VERIFY_IS_APPROX(ei_abs(v1.dot(v1)), v1.squaredNorm()); + VERIFY(internal::isApprox((s1 * v1 + s2 * v2).dot(v3), internal::conj(s1) * v1.dot(v3) + internal::conj(s2) * v2.dot(v3), largerEps)); + VERIFY(internal::isApprox(v3.dot(s1 * v1 + s2 * v2), s1*v3.dot(v1)+s2*v3.dot(v2), largerEps)); + VERIFY_IS_APPROX(internal::conj(v1.dot(v2)), v2.dot(v1)); + VERIFY_IS_APPROX(internal::abs(v1.dot(v1)), v1.squaredNorm()); if(!NumTraits<Scalar>::IsInteger) VERIFY_IS_APPROX(v1.squaredNorm(), v1.norm() * v1.norm()); - VERIFY_IS_MUCH_SMALLER_THAN(ei_abs(vzero.dot(v1)), static_cast<RealScalar>(1)); + VERIFY_IS_MUCH_SMALLER_THAN(internal::abs(vzero.dot(v1)), static_cast<RealScalar>(1)); // check compatibility of dot and adjoint - VERIFY(ei_isApprox(v1.dot(square * v2), (square.adjoint() * v1).dot(v2), largerEps)); + VERIFY(internal::isApprox(v1.dot(square * v2), (square.adjoint() * v1).dot(v2), largerEps)); // like in testBasicStuff, test operator() to check const-qualification - Index r = ei_random<Index>(0, rows-1), - c = ei_random<Index>(0, cols-1); - VERIFY_IS_APPROX(m1.conjugate()(r,c), ei_conj(m1(r,c))); - VERIFY_IS_APPROX(m1.adjoint()(c,r), ei_conj(m1(r,c))); + Index r = internal::random<Index>(0, rows-1), + c = internal::random<Index>(0, cols-1); + VERIFY_IS_APPROX(m1.conjugate()(r,c), internal::conj(m1(r,c))); + VERIFY_IS_APPROX(m1.adjoint()(c,r), internal::conj(m1(r,c))); if(!NumTraits<Scalar>::IsInteger) { diff --git a/test/array.cpp b/test/array.cpp index 332861168..70473bd1d 100644 --- a/test/array.cpp +++ b/test/array.cpp @@ -42,8 +42,8 @@ template<typename ArrayType> void array(const ArrayType& m) ColVectorType cv1 = ColVectorType::Random(rows); RowVectorType rv1 = RowVectorType::Random(cols); - Scalar s1 = ei_random<Scalar>(), - s2 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(), + s2 = internal::random<Scalar>(); // scalar addition VERIFY_IS_APPROX(m1 + s1, s1 + m1); @@ -62,9 +62,9 @@ template<typename ArrayType> void array(const ArrayType& m) // reductions VERIFY_IS_APPROX(m1.colwise().sum().sum(), m1.sum()); VERIFY_IS_APPROX(m1.rowwise().sum().sum(), m1.sum()); - if (!ei_isApprox(m1.sum(), (m1+m2).sum())) + if (!internal::isApprox(m1.sum(), (m1+m2).sum())) VERIFY_IS_NOT_APPROX(((m1+m2).rowwise().sum()).sum(), m1.sum()); - VERIFY_IS_APPROX(m1.colwise().sum(), m1.colwise().redux(ei_scalar_sum_op<Scalar>())); + VERIFY_IS_APPROX(m1.colwise().sum(), m1.colwise().redux(internal::scalar_sum_op<Scalar>())); // vector-wise ops m3 = m1; @@ -87,8 +87,8 @@ template<typename ArrayType> void comparisons(const ArrayType& m) Index rows = m.rows(); Index cols = m.cols(); - Index r = ei_random<Index>(0, rows-1), - c = ei_random<Index>(0, cols-1); + Index r = internal::random<Index>(0, rows-1), + c = internal::random<Index>(0, cols-1); ArrayType m1 = ArrayType::Random(rows, cols), m2 = ArrayType::Random(rows, cols), @@ -116,7 +116,7 @@ template<typename ArrayType> void comparisons(const ArrayType& m) Scalar mid = (m1.cwiseAbs().minCoeff() + m1.cwiseAbs().maxCoeff())/Scalar(2); for (int j=0; j<cols; ++j) for (int i=0; i<rows; ++i) - m3(i,j) = ei_abs(m1(i,j))<mid ? 0 : m1(i,j); + m3(i,j) = internal::abs(m1(i,j))<mid ? 0 : m1(i,j); VERIFY_IS_APPROX( (m1.abs()<ArrayType::Constant(rows,cols,mid)) .select(ArrayType::Zero(rows,cols),m1), m3); // shorter versions: @@ -151,28 +151,28 @@ template<typename ArrayType> void array_real(const ArrayType& m) m3(rows, cols); VERIFY_IS_APPROX(m1.sin(), std::sin(m1)); - VERIFY_IS_APPROX(m1.sin(), ei_sin(m1)); + VERIFY_IS_APPROX(m1.sin(), internal::sin(m1)); VERIFY_IS_APPROX(m1.cos(), std::cos(m1)); - VERIFY_IS_APPROX(m1.cos(), ei_cos(m1)); + VERIFY_IS_APPROX(m1.cos(), internal::cos(m1)); - VERIFY_IS_APPROX(ei_cos(m1+RealScalar(3)*m2), ei_cos((m1+RealScalar(3)*m2).eval())); + VERIFY_IS_APPROX(internal::cos(m1+RealScalar(3)*m2), internal::cos((m1+RealScalar(3)*m2).eval())); VERIFY_IS_APPROX(std::cos(m1+RealScalar(3)*m2), std::cos((m1+RealScalar(3)*m2).eval())); VERIFY_IS_APPROX(m1.abs().sqrt(), std::sqrt(std::abs(m1))); - VERIFY_IS_APPROX(m1.abs().sqrt(), ei_sqrt(ei_abs(m1))); - VERIFY_IS_APPROX(m1.abs(), ei_sqrt(ei_abs2(m1))); + VERIFY_IS_APPROX(m1.abs().sqrt(), internal::sqrt(internal::abs(m1))); + VERIFY_IS_APPROX(m1.abs(), internal::sqrt(internal::abs2(m1))); - VERIFY_IS_APPROX(ei_abs2(ei_real(m1)) + ei_abs2(ei_imag(m1)), ei_abs2(m1)); - VERIFY_IS_APPROX(ei_abs2(std::real(m1)) + ei_abs2(std::imag(m1)), ei_abs2(m1)); + VERIFY_IS_APPROX(internal::abs2(internal::real(m1)) + internal::abs2(internal::imag(m1)), internal::abs2(m1)); + VERIFY_IS_APPROX(internal::abs2(std::real(m1)) + internal::abs2(std::imag(m1)), internal::abs2(m1)); if(!NumTraits<Scalar>::IsComplex) - VERIFY_IS_APPROX(ei_real(m1), m1); + VERIFY_IS_APPROX(internal::real(m1), m1); VERIFY_IS_APPROX(m1.abs().log(), std::log(std::abs(m1))); - VERIFY_IS_APPROX(m1.abs().log(), ei_log(ei_abs(m1))); + VERIFY_IS_APPROX(m1.abs().log(), internal::log(internal::abs(m1))); VERIFY_IS_APPROX(m1.exp(), std::exp(m1)); VERIFY_IS_APPROX(m1.exp() * m2.exp(), std::exp(m1+m2)); - VERIFY_IS_APPROX(m1.exp(), ei_exp(m1)); + VERIFY_IS_APPROX(m1.exp(), internal::exp(m1)); VERIFY_IS_APPROX(m1.exp() / m2.exp(), std::exp(m1-m2)); VERIFY_IS_APPROX(m1.pow(2), m1.square()); @@ -206,11 +206,11 @@ void test_array() CALL_SUBTEST_5( array_real(ArrayXXf(8, 12)) ); } - VERIFY((ei_is_same_type< ei_global_math_functions_filtering_base<int>::type, int >::ret)); - VERIFY((ei_is_same_type< ei_global_math_functions_filtering_base<float>::type, float >::ret)); - VERIFY((ei_is_same_type< ei_global_math_functions_filtering_base<Array2i>::type, ArrayBase<Array2i> >::ret)); - typedef CwiseUnaryOp<ei_scalar_sum_op<double>, ArrayXd > Xpr; - VERIFY((ei_is_same_type< ei_global_math_functions_filtering_base<Xpr>::type, + VERIFY((internal::is_same_type< internal::global_math_functions_filtering_base<int>::type, int >::ret)); + VERIFY((internal::is_same_type< internal::global_math_functions_filtering_base<float>::type, float >::ret)); + VERIFY((internal::is_same_type< internal::global_math_functions_filtering_base<Array2i>::type, ArrayBase<Array2i> >::ret)); + typedef CwiseUnaryOp<internal::scalar_sum_op<double>, ArrayXd > Xpr; + VERIFY((internal::is_same_type< internal::global_math_functions_filtering_base<Xpr>::type, ArrayBase<Xpr> >::ret)); } diff --git a/test/array_for_matrix.cpp b/test/array_for_matrix.cpp index 3699b861a..b7671ccda 100644 --- a/test/array_for_matrix.cpp +++ b/test/array_for_matrix.cpp @@ -42,8 +42,8 @@ template<typename MatrixType> void array_for_matrix(const MatrixType& m) ColVectorType cv1 = ColVectorType::Random(rows); RowVectorType rv1 = RowVectorType::Random(cols); - Scalar s1 = ei_random<Scalar>(), - s2 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(), + s2 = internal::random<Scalar>(); // scalar addition VERIFY_IS_APPROX(m1.array() + s1, s1 + m1.array()); @@ -59,9 +59,9 @@ template<typename MatrixType> void array_for_matrix(const MatrixType& m) // reductions VERIFY_IS_APPROX(m1.colwise().sum().sum(), m1.sum()); VERIFY_IS_APPROX(m1.rowwise().sum().sum(), m1.sum()); - if (!ei_isApprox(m1.sum(), (m1+m2).sum())) + if (!internal::isApprox(m1.sum(), (m1+m2).sum())) VERIFY_IS_NOT_APPROX(((m1+m2).rowwise().sum()).sum(), m1.sum()); - VERIFY_IS_APPROX(m1.colwise().sum(), m1.colwise().redux(ei_scalar_sum_op<Scalar>())); + VERIFY_IS_APPROX(m1.colwise().sum(), m1.colwise().redux(internal::scalar_sum_op<Scalar>())); // vector-wise ops m3 = m1; @@ -88,8 +88,8 @@ template<typename MatrixType> void comparisons(const MatrixType& m) Index rows = m.rows(); Index cols = m.cols(); - Index r = ei_random<Index>(0, rows-1), - c = ei_random<Index>(0, cols-1); + Index r = internal::random<Index>(0, rows-1), + c = internal::random<Index>(0, cols-1); MatrixType m1 = MatrixType::Random(rows, cols), m2 = MatrixType::Random(rows, cols), @@ -117,7 +117,7 @@ template<typename MatrixType> void comparisons(const MatrixType& m) Scalar mid = (m1.cwiseAbs().minCoeff() + m1.cwiseAbs().maxCoeff())/Scalar(2); for (int j=0; j<cols; ++j) for (int i=0; i<rows; ++i) - m3(i,j) = ei_abs(m1(i,j))<mid ? 0 : m1(i,j); + m3(i,j) = internal::abs(m1(i,j))<mid ? 0 : m1(i,j); VERIFY_IS_APPROX( (m1.array().abs()<MatrixType::Constant(rows,cols,mid).array()) .select(MatrixType::Zero(rows,cols),m1), m3); // shorter versions: @@ -144,8 +144,8 @@ template<typename VectorType> void lpNorm(const VectorType& v) VERIFY_IS_APPROX(u.template lpNorm<Infinity>(), u.cwiseAbs().maxCoeff()); VERIFY_IS_APPROX(u.template lpNorm<1>(), u.cwiseAbs().sum()); - VERIFY_IS_APPROX(u.template lpNorm<2>(), ei_sqrt(u.array().abs().square().sum())); - VERIFY_IS_APPROX(ei_pow(u.template lpNorm<5>(), typename VectorType::RealScalar(5)), u.array().abs().pow(5).sum()); + VERIFY_IS_APPROX(u.template lpNorm<2>(), internal::sqrt(u.array().abs().square().sum())); + VERIFY_IS_APPROX(internal::pow(u.template lpNorm<5>(), typename VectorType::RealScalar(5)), u.array().abs().pow(5).sum()); } void test_array_for_matrix() diff --git a/test/array_replicate.cpp b/test/array_replicate.cpp index cafdafef5..b3520b58c 100644 --- a/test/array_replicate.cpp +++ b/test/array_replicate.cpp @@ -47,8 +47,8 @@ template<typename MatrixType> void replicate(const MatrixType& m) MatrixX x1, x2; VectorX vx1; - int f1 = ei_random<int>(1,10), - f2 = ei_random<int>(1,10); + int f1 = internal::random<int>(1,10), + f2 = internal::random<int>(1,10); x1.resize(rows*f1,cols*f2); for(int j=0; j<f2; j++) diff --git a/test/array_reverse.cpp b/test/array_reverse.cpp index 1461900c3..fdede3760 100644 --- a/test/array_reverse.cpp +++ b/test/array_reverse.cpp @@ -104,10 +104,10 @@ template<typename MatrixType> void reverse(const MatrixType& m) } } - Scalar x = ei_random<Scalar>(); + Scalar x = internal::random<Scalar>(); - Index r = ei_random<Index>(0, rows-1), - c = ei_random<Index>(0, cols-1); + Index r = internal::random<Index>(0, rows-1), + c = internal::random<Index>(0, cols-1); m1.reverse()(r, c) = x; VERIFY_IS_APPROX(x, m1(rows - 1 - r, cols - 1 - c)); diff --git a/test/bandmatrix.cpp b/test/bandmatrix.cpp index 2f228cdd2..6dfaa1879 100644 --- a/test/bandmatrix.cpp +++ b/test/bandmatrix.cpp @@ -78,10 +78,10 @@ void test_bandmatrix() typedef BandMatrix<float>::Index Index; for(int i = 0; i < 10*g_repeat ; i++) { - Index rows = ei_random<Index>(1,10); - Index cols = ei_random<Index>(1,10); - Index sups = ei_random<Index>(0,cols-1); - Index subs = ei_random<Index>(0,rows-1); + Index rows = internal::random<Index>(1,10); + Index cols = internal::random<Index>(1,10); + Index sups = internal::random<Index>(0,cols-1); + Index subs = internal::random<Index>(0,rows-1); CALL_SUBTEST(bandmatrix(BandMatrix<float>(rows,cols,sups,subs)) ); } } diff --git a/test/basicstuff.cpp b/test/basicstuff.cpp index 4ff4a24fa..175f54009 100644 --- a/test/basicstuff.cpp +++ b/test/basicstuff.cpp @@ -50,10 +50,10 @@ template<typename MatrixType> void basicStuff(const MatrixType& m) vzero = VectorType::Zero(rows); SquareMatrixType sm1 = SquareMatrixType::Random(rows,rows), sm2(rows,rows); - Scalar x = ei_random<Scalar>(); + Scalar x = internal::random<Scalar>(); - Index r = ei_random<Index>(0, rows-1), - c = ei_random<Index>(0, cols-1); + Index r = internal::random<Index>(0, rows-1), + c = internal::random<Index>(0, cols-1); m1.coeffRef(r,c) = x; VERIFY_IS_APPROX(x, m1.coeff(r,c)); @@ -156,14 +156,14 @@ template<typename MatrixType> void basicStuffComplex(const MatrixType& m) Index rows = m.rows(); Index cols = m.cols(); - Scalar s1 = ei_random<Scalar>(), - s2 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(), + s2 = internal::random<Scalar>(); - VERIFY(ei_real(s1)==ei_real_ref(s1)); - VERIFY(ei_imag(s1)==ei_imag_ref(s1)); - ei_real_ref(s1) = ei_real(s2); - ei_imag_ref(s1) = ei_imag(s2); - VERIFY(ei_isApprox(s1, s2, NumTraits<RealScalar>::epsilon())); + VERIFY(internal::real(s1)==internal::real_ref(s1)); + VERIFY(internal::imag(s1)==internal::imag_ref(s1)); + internal::real_ref(s1) = internal::real(s2); + internal::imag_ref(s1) = internal::imag(s2); + VERIFY(internal::isApprox(s1, s2, NumTraits<RealScalar>::epsilon())); // extended precision in Intel FPUs means that s1 == s2 in the line above is not guaranteed. RealMatrixType rm1 = RealMatrixType::Random(rows,cols), @@ -200,14 +200,14 @@ void test_basicstuff() for(int i = 0; i < g_repeat; i++) { CALL_SUBTEST_1( basicStuff(Matrix<float, 1, 1>()) ); CALL_SUBTEST_2( basicStuff(Matrix4d()) ); - CALL_SUBTEST_3( basicStuff(MatrixXcf(ei_random<int>(1,100), ei_random<int>(1,100))) ); - CALL_SUBTEST_4( basicStuff(MatrixXi(ei_random<int>(1,100), ei_random<int>(1,100))) ); - CALL_SUBTEST_5( basicStuff(MatrixXcd(ei_random<int>(1,100), ei_random<int>(1,100))) ); + CALL_SUBTEST_3( basicStuff(MatrixXcf(internal::random<int>(1,100), internal::random<int>(1,100))) ); + CALL_SUBTEST_4( basicStuff(MatrixXi(internal::random<int>(1,100), internal::random<int>(1,100))) ); + CALL_SUBTEST_5( basicStuff(MatrixXcd(internal::random<int>(1,100), internal::random<int>(1,100))) ); CALL_SUBTEST_6( basicStuff(Matrix<float, 100, 100>()) ); - CALL_SUBTEST_7( basicStuff(Matrix<long double,Dynamic,Dynamic>(ei_random<int>(1,100),ei_random<int>(1,100))) ); + CALL_SUBTEST_7( basicStuff(Matrix<long double,Dynamic,Dynamic>(internal::random<int>(1,100),internal::random<int>(1,100))) ); - CALL_SUBTEST_3( basicStuffComplex(MatrixXcf(ei_random<int>(1,100), ei_random<int>(1,100))) ); - CALL_SUBTEST_5( basicStuffComplex(MatrixXcd(ei_random<int>(1,100), ei_random<int>(1,100))) ); + CALL_SUBTEST_3( basicStuffComplex(MatrixXcf(internal::random<int>(1,100), internal::random<int>(1,100))) ); + CALL_SUBTEST_5( basicStuffComplex(MatrixXcd(internal::random<int>(1,100), internal::random<int>(1,100))) ); } CALL_SUBTEST_2(casting()); diff --git a/test/block.cpp b/test/block.cpp index 1c2e080ad..6c5681683 100644 --- a/test/block.cpp +++ b/test/block.cpp @@ -48,12 +48,12 @@ template<typename MatrixType> void block(const MatrixType& m) v3 = VectorType::Random(rows), vzero = VectorType::Zero(rows); - Scalar s1 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(); - Index r1 = ei_random<Index>(0,rows-1); - Index r2 = ei_random<Index>(r1,rows-1); - Index c1 = ei_random<Index>(0,cols-1); - Index c2 = ei_random<Index>(c1,cols-1); + Index r1 = internal::random<Index>(0,rows-1); + Index r2 = internal::random<Index>(r1,rows-1); + Index c1 = internal::random<Index>(0,cols-1); + Index c2 = internal::random<Index>(c1,cols-1); //check row() and col() VERIFY_IS_EQUAL(m1.col(c1).transpose(), m1.transpose().row(c1)); @@ -100,16 +100,16 @@ template<typename MatrixType> void block(const MatrixType& m) VERIFY_IS_EQUAL(v1.template tail<2>(), v1.tail(2)); VERIFY_IS_EQUAL(v1.template tail<2>(), v1.segment(i,2)); VERIFY_IS_EQUAL(v1.template tail<2>(), v1.template segment<2>(i)); - i = ei_random<Index>(0,rows-2); + i = internal::random<Index>(0,rows-2); VERIFY_IS_EQUAL(v1.segment(i,2), v1.template segment<2>(i)); } // stress some basic stuffs with block matrices - VERIFY(ei_real(ones.col(c1).sum()) == RealScalar(rows)); - VERIFY(ei_real(ones.row(r1).sum()) == RealScalar(cols)); + VERIFY(internal::real(ones.col(c1).sum()) == RealScalar(rows)); + VERIFY(internal::real(ones.row(r1).sum()) == RealScalar(cols)); - VERIFY(ei_real(ones.col(c1).dot(ones.col(c2))) == RealScalar(rows)); - VERIFY(ei_real(ones.row(r1).dot(ones.row(r2))) == RealScalar(cols)); + VERIFY(internal::real(ones.col(c1).dot(ones.col(c2))) == RealScalar(rows)); + VERIFY(internal::real(ones.row(r1).dot(ones.row(r2))) == RealScalar(cols)); // now test some block-inside-of-block. @@ -197,10 +197,10 @@ void data_and_stride(const MatrixType& m) Index rows = m.rows(); Index cols = m.cols(); - Index r1 = ei_random<Index>(0,rows-1); - Index r2 = ei_random<Index>(r1,rows-1); - Index c1 = ei_random<Index>(0,cols-1); - Index c2 = ei_random<Index>(c1,cols-1); + Index r1 = internal::random<Index>(0,rows-1); + Index r2 = internal::random<Index>(r1,rows-1); + Index c1 = internal::random<Index>(0,cols-1); + Index c2 = internal::random<Index>(c1,cols-1); MatrixType m1 = MatrixType::Random(rows, cols); compare_using_data_and_stride(m1.block(r1, c1, r2-r1+1, c2-c1+1)); @@ -224,8 +224,8 @@ void test_block() CALL_SUBTEST_8( block(Matrix<float,Dynamic,4>(3, 4)) ); #ifndef EIGEN_DEFAULT_TO_ROW_MAJOR - CALL_SUBTEST_6( data_and_stride(MatrixXf(ei_random(5,50), ei_random(5,50))) ); - CALL_SUBTEST_7( data_and_stride(Matrix<int,Dynamic,Dynamic,RowMajor>(ei_random(5,50), ei_random(5,50))) ); + CALL_SUBTEST_6( data_and_stride(MatrixXf(internal::random(5,50), internal::random(5,50))) ); + CALL_SUBTEST_7( data_and_stride(Matrix<int,Dynamic,Dynamic,RowMajor>(internal::random(5,50), internal::random(5,50))) ); #endif } } diff --git a/test/cholesky.cpp b/test/cholesky.cpp index 46140bb11..0a0424aa1 100644 --- a/test/cholesky.cpp +++ b/test/cholesky.cpp @@ -78,7 +78,7 @@ template<typename MatrixType> void cholesky(const MatrixType& m) //symm.template part<StrictlyLower>().setZero(); #ifdef HAS_GSL -// if (ei_is_same_type<RealScalar,double>::ret) +// if (internal::is_same_type<RealScalar,double>::ret) // { // typedef GslTraits<Scalar> Gsl; // typename Gsl::Matrix gMatA=0, gSymm=0; @@ -128,7 +128,7 @@ template<typename MatrixType> void cholesky(const MatrixType& m) // LDLT { - int sign = ei_random<int>()%2 ? 1 : -1; + int sign = internal::random<int>()%2 ? 1 : -1; if(sign == -1) { @@ -226,7 +226,7 @@ template<typename MatrixType> void cholesky_cplx(const MatrixType& m) // LDLT { - int sign = ei_random<int>()%2 ? 1 : -1; + int sign = internal::random<int>()%2 ? 1 : -1; if(sign == -1) { @@ -273,9 +273,9 @@ void test_cholesky() CALL_SUBTEST_3( cholesky(Matrix2d()) ); CALL_SUBTEST_4( cholesky(Matrix3f()) ); CALL_SUBTEST_5( cholesky(Matrix4d()) ); - s = ei_random<int>(1,200); + s = internal::random<int>(1,200); CALL_SUBTEST_2( cholesky(MatrixXd(s,s)) ); - s = ei_random<int>(1,100); + s = internal::random<int>(1,100); CALL_SUBTEST_6( cholesky_cplx(MatrixXcd(s,s)) ); } diff --git a/test/conservative_resize.cpp b/test/conservative_resize.cpp index f428021dd..781cf5aad 100644 --- a/test/conservative_resize.cpp +++ b/test/conservative_resize.cpp @@ -52,8 +52,8 @@ void run_matrix_tests() // random shrinking ... for (int i=0; i<25; ++i) { - const Index rows = ei_random<Index>(1,50); - const Index cols = ei_random<Index>(1,50); + const Index rows = internal::random<Index>(1,50); + const Index cols = internal::random<Index>(1,50); m = n = MatrixType::Random(50,50); m.conservativeResize(rows,cols); VERIFY_IS_APPROX(m, n.block(0,0,rows,cols)); @@ -62,8 +62,8 @@ void run_matrix_tests() // random growing with zeroing ... for (int i=0; i<25; ++i) { - const Index rows = ei_random<Index>(50,75); - const Index cols = ei_random<Index>(50,75); + const Index rows = internal::random<Index>(50,75); + const Index cols = internal::random<Index>(50,75); m = n = MatrixType::Random(50,50); m.conservativeResizeLike(MatrixType::Zero(rows,cols)); VERIFY_IS_APPROX(m.block(0,0,n.rows(),n.cols()), n); @@ -91,7 +91,7 @@ void run_vector_tests() // random shrinking ... for (int i=0; i<50; ++i) { - const int size = ei_random<int>(1,50); + const int size = internal::random<int>(1,50); m = n = MatrixType::Random(50); m.conservativeResize(size); VERIFY_IS_APPROX(m, n.segment(0,size)); @@ -100,7 +100,7 @@ void run_vector_tests() // random growing with zeroing ... for (int i=0; i<50; ++i) { - const int size = ei_random<int>(50,100); + const int size = internal::random<int>(50,100); m = n = MatrixType::Random(50); m.conservativeResizeLike(MatrixType::Zero(size)); VERIFY_IS_APPROX(m.segment(0,50), n); diff --git a/test/corners.cpp b/test/corners.cpp index fe2b205d7..8d12c6146 100644 --- a/test/corners.cpp +++ b/test/corners.cpp @@ -34,8 +34,8 @@ template<typename MatrixType> void corners(const MatrixType& m) Index rows = m.rows(); Index cols = m.cols(); - Index r = ei_random<Index>(1,rows); - Index c = ei_random<Index>(1,cols); + Index r = internal::random<Index>(1,rows); + Index c = internal::random<Index>(1,cols); MatrixType matrix = MatrixType::Random(rows,cols); const MatrixType const_matrix = MatrixType::Random(rows,cols); @@ -45,10 +45,10 @@ template<typename MatrixType> void corners(const MatrixType& m) COMPARE_CORNER(bottomLeftCorner(r,c), block(rows-r,0,r,c)); COMPARE_CORNER(bottomRightCorner(r,c), block(rows-r,cols-c,r,c)); - Index sr = ei_random<Index>(1,rows) - 1; - Index nr = ei_random<Index>(1,rows-sr); - Index sc = ei_random<Index>(1,cols) - 1; - Index nc = ei_random<Index>(1,cols-sc); + Index sr = internal::random<Index>(1,rows) - 1; + Index nr = internal::random<Index>(1,rows-sr); + Index sc = internal::random<Index>(1,cols) - 1; + Index nc = internal::random<Index>(1,cols-sc); COMPARE_CORNER(topRows(r), block(0,0,r,cols)); COMPARE_CORNER(middleRows(sr,nr), block(sr,0,nr,cols)); diff --git a/test/cwiseop.cpp b/test/cwiseop.cpp index 7533b7566..c63ace1cc 100644 --- a/test/cwiseop.cpp +++ b/test/cwiseop.cpp @@ -60,10 +60,10 @@ template<typename MatrixType> void cwiseops(const MatrixType& m) vones = VectorType::Ones(rows), v3(rows); - Index r = ei_random<Index>(0, rows-1), - c = ei_random<Index>(0, cols-1); + Index r = internal::random<Index>(0, rows-1), + c = internal::random<Index>(0, cols-1); - Scalar s1 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(); // test Zero, Ones, Constant, and the set* variants m3 = MatrixType::Constant(rows, cols, s1); diff --git a/test/determinant.cpp b/test/determinant.cpp index 8112131b7..dcf64387d 100644 --- a/test/determinant.cpp +++ b/test/determinant.cpp @@ -38,14 +38,14 @@ template<typename MatrixType> void determinant(const MatrixType& m) m1.setRandom(); m2.setRandom(); typedef typename MatrixType::Scalar Scalar; - Scalar x = ei_random<Scalar>(); + Scalar x = internal::random<Scalar>(); VERIFY_IS_APPROX(MatrixType::Identity(size, size).determinant(), Scalar(1)); VERIFY_IS_APPROX((m1*m2).eval().determinant(), m1.determinant() * m2.determinant()); if(size==1) return; - Index i = ei_random<Index>(0, size-1); + Index i = internal::random<Index>(0, size-1); Index j; do { - j = ei_random<Index>(0, size-1); + j = internal::random<Index>(0, size-1); } while(j==i); m2 = m1; m2.row(i).swap(m2.row(j)); @@ -54,7 +54,7 @@ template<typename MatrixType> void determinant(const MatrixType& m) m2.col(i).swap(m2.col(j)); VERIFY_IS_APPROX(m2.determinant(), -m1.determinant()); VERIFY_IS_APPROX(m2.determinant(), m2.transpose().determinant()); - VERIFY_IS_APPROX(ei_conj(m2.determinant()), m2.adjoint().determinant()); + VERIFY_IS_APPROX(internal::conj(m2.determinant()), m2.adjoint().determinant()); m2 = m1; m2.row(i) += x*m2.row(j); VERIFY_IS_APPROX(m2.determinant(), m1.determinant()); diff --git a/test/diagonalmatrices.cpp b/test/diagonalmatrices.cpp index 8408dda44..9d6f069c6 100644 --- a/test/diagonalmatrices.cpp +++ b/test/diagonalmatrices.cpp @@ -66,8 +66,8 @@ template<typename MatrixType> void diagonalmatrices(const MatrixType& m) sq_m1.transpose() = ldm1; VERIFY_IS_APPROX(sq_m1, ldm1.toDenseMatrix()); - Index i = ei_random<Index>(0, rows-1); - Index j = ei_random<Index>(0, cols-1); + Index i = internal::random<Index>(0, rows-1); + Index j = internal::random<Index>(0, cols-1); VERIFY_IS_APPROX( ((ldm1 * m1)(i,j)) , ldm1.diagonal()(i) * m1(i,j) ); VERIFY_IS_APPROX( ((ldm1 * (m1+m2))(i,j)) , ldm1.diagonal()(i) * (m1+m2)(i,j) ); diff --git a/test/dynalloc.cpp b/test/dynalloc.cpp index 26813ba0b..cd0062aac 100644 --- a/test/dynalloc.cpp +++ b/test/dynalloc.cpp @@ -34,11 +34,11 @@ void check_handmade_aligned_malloc() { for(int i = 1; i < 1000; i++) { - char *p = (char*)ei_handmade_aligned_malloc(i); + char *p = (char*)internal::handmade_aligned_malloc(i); VERIFY(size_t(p)%ALIGNMENT==0); // if the buffer is wrongly allocated this will give a bad write --> check with valgrind for(int j = 0; j < i; j++) p[j]=0; - ei_handmade_aligned_free(p); + internal::handmade_aligned_free(p); } } @@ -46,11 +46,11 @@ void check_aligned_malloc() { for(int i = 1; i < 1000; i++) { - char *p = (char*)ei_aligned_malloc(i); + char *p = (char*)internal::aligned_malloc(i); VERIFY(size_t(p)%ALIGNMENT==0); // if the buffer is wrongly allocated this will give a bad write --> check with valgrind for(int j = 0; j < i; j++) p[j]=0; - ei_aligned_free(p); + internal::aligned_free(p); } } @@ -58,11 +58,11 @@ void check_aligned_new() { for(int i = 1; i < 1000; i++) { - float *p = ei_aligned_new<float>(i); + float *p = internal::aligned_new<float>(i); VERIFY(size_t(p)%ALIGNMENT==0); // if the buffer is wrongly allocated this will give a bad write --> check with valgrind for(int j = 0; j < i; j++) p[j]=0; - ei_aligned_delete(p,i); + internal::aligned_delete(p,i); } } diff --git a/test/eigen2support.cpp b/test/eigen2support.cpp index 6684d1b9a..1c3686013 100644 --- a/test/eigen2support.cpp +++ b/test/eigen2support.cpp @@ -38,8 +38,8 @@ template<typename MatrixType> void eigen2support(const MatrixType& m) m2 = MatrixType::Random(rows, cols), m3(rows, cols); - Scalar s1 = ei_random<Scalar>(), - s2 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(), + s2 = internal::random<Scalar>(); // scalar addition VERIFY_IS_APPROX(m1.cwise() + s1, s1 + m1.cwise()); diff --git a/test/eigensolver_selfadjoint.cpp b/test/eigensolver_selfadjoint.cpp index 3215d2184..9a40ed529 100644 --- a/test/eigensolver_selfadjoint.cpp +++ b/test/eigensolver_selfadjoint.cpp @@ -63,7 +63,7 @@ template<typename MatrixType> void selfadjointeigensolver(const MatrixType& m) GeneralizedSelfAdjointEigenSolver<MatrixType> eiSymmGen(symmA, symmB); #ifdef HAS_GSL - if (ei_is_same_type<RealScalar,double>::ret) + if (internal::is_same_type<RealScalar,double>::ret) { // restore symmA and symmB. symmA = MatrixType(symmA.template selfadjointView<Lower>()); diff --git a/test/first_aligned.cpp b/test/first_aligned.cpp index 687f4a5dc..b4ccb22cd 100644 --- a/test/first_aligned.cpp +++ b/test/first_aligned.cpp @@ -27,8 +27,8 @@ template<typename Scalar> void test_first_aligned_helper(Scalar *array, int size) { - const int packet_size = sizeof(Scalar) * ei_packet_traits<Scalar>::size; - VERIFY(((size_t(array) + sizeof(Scalar) * ei_first_aligned(array, size)) % packet_size) == 0); + const int packet_size = sizeof(Scalar) * internal::packet_traits<Scalar>::size; + VERIFY(((size_t(array) + sizeof(Scalar) * internal::first_aligned(array, size)) % packet_size) == 0); } template<typename Scalar> @@ -36,7 +36,7 @@ void test_none_aligned_helper(Scalar *array, int size) { EIGEN_UNUSED_VARIABLE(array); EIGEN_UNUSED_VARIABLE(size); - VERIFY(ei_packet_traits<Scalar>::size == 1 || ei_first_aligned(array, size) == size); + VERIFY(internal::packet_traits<Scalar>::size == 1 || internal::first_aligned(array, size) == size); } struct some_non_vectorizable_type { float x; }; diff --git a/test/geo_alignedbox.cpp b/test/geo_alignedbox.cpp index 65c232b96..738ca3150 100644 --- a/test/geo_alignedbox.cpp +++ b/test/geo_alignedbox.cpp @@ -46,7 +46,7 @@ template<typename BoxType> void alignedbox(const BoxType& _box) VectorType p1 = VectorType::Random(dim); while( p1 == p0 ){ p1 = VectorType::Random(dim); } - RealScalar s1 = ei_random<RealScalar>(0,1); + RealScalar s1 = internal::random<RealScalar>(0,1); BoxType b0(dim); BoxType b1(VectorType::Random(dim),VectorType::Random(dim)); @@ -124,7 +124,7 @@ void specificTest1() VERIFY_IS_APPROX( 14.0f, box.volume() ); VERIFY_IS_APPROX( 53.0f, box.diagonal().squaredNorm() ); - VERIFY_IS_APPROX( ei_sqrt( 53.0f ), box.diagonal().norm() ); + VERIFY_IS_APPROX( internal::sqrt( 53.0f ), box.diagonal().norm() ); VERIFY_IS_APPROX( m, box.corner( BoxType::BottomLeft ) ); VERIFY_IS_APPROX( M, box.corner( BoxType::TopRight ) ); diff --git a/test/geo_eulerangles.cpp b/test/geo_eulerangles.cpp index bbc9ebb81..f82cb8fbe 100644 --- a/test/geo_eulerangles.cpp +++ b/test/geo_eulerangles.cpp @@ -34,7 +34,7 @@ template<typename Scalar> void eulerangles(void) typedef Quaternion<Scalar> Quaternionx; typedef AngleAxis<Scalar> AngleAxisx; - Scalar a = ei_random<Scalar>(-Scalar(M_PI), Scalar(M_PI)); + Scalar a = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI)); Quaternionx q1; q1 = AngleAxisx(a, Vector3::Random().normalized()); Matrix3 m; diff --git a/test/geo_homogeneous.cpp b/test/geo_homogeneous.cpp index a0fee2f0c..7e93d843e 100644 --- a/test/geo_homogeneous.cpp +++ b/test/geo_homogeneous.cpp @@ -42,7 +42,7 @@ template<typename Scalar,int Size> void homogeneous(void) typedef Matrix<Scalar,Size+1,Size> T3MatrixType; Scalar largeEps = test_precision<Scalar>(); - if (ei_is_same_type<Scalar,float>::ret) + if (internal::is_same_type<Scalar,float>::ret) largeEps = 1e-3f; VectorType v0 = VectorType::Random(), diff --git a/test/geo_hyperplane.cpp b/test/geo_hyperplane.cpp index bed6f5b40..23027f38e 100644 --- a/test/geo_hyperplane.cpp +++ b/test/geo_hyperplane.cpp @@ -51,8 +51,8 @@ template<typename HyperplaneType> void hyperplane(const HyperplaneType& _plane) HyperplaneType pl1(n1, p1); HyperplaneType pl2 = pl1; - Scalar s0 = ei_random<Scalar>(); - Scalar s1 = ei_random<Scalar>(); + Scalar s0 = internal::random<Scalar>(); + Scalar s1 = internal::random<Scalar>(); VERIFY_IS_APPROX( n1.dot(n1), Scalar(1) ); @@ -103,8 +103,8 @@ template<typename Scalar> void lines() Vector center = Vector::Random(); Vector u = Vector::Random(); Vector v = Vector::Random(); - Scalar a = ei_random<Scalar>(); - while (ei_abs(a-1) < 1e-4) a = ei_random<Scalar>(); + Scalar a = internal::random<Scalar>(); + while (internal::abs(a-1) < 1e-4) a = internal::random<Scalar>(); while (u.norm() < 1e-4) u = Vector::Random(); while (v.norm() < 1e-4) v = Vector::Random(); diff --git a/test/geo_orthomethods.cpp b/test/geo_orthomethods.cpp index 8ed7195ec..9152d99c8 100644 --- a/test/geo_orthomethods.cpp +++ b/test/geo_orthomethods.cpp @@ -55,7 +55,7 @@ template<typename Scalar> void orthomethods_3() mat3.setRandom(); Vector3 vec3 = Vector3::Random(); Matrix3 mcross; - int i = ei_random<int>(0,2); + int i = internal::random<int>(0,2); mcross = mat3.colwise().cross(vec3); VERIFY_IS_APPROX(mcross.col(i), mat3.col(i).cross(vec3)); mcross = mat3.rowwise().cross(vec3); @@ -97,7 +97,7 @@ template<typename Scalar, int Size> void orthomethods(int size=Size) // colwise/rowwise cross product Vector3 vec3 = Vector3::Random(); - int i = ei_random<int>(0,size-1); + int i = internal::random<int>(0,size-1); Matrix3N mat3N(3,size), mcross3N(3,size); mat3N.setRandom(); diff --git a/test/geo_parametrizedline.cpp b/test/geo_parametrizedline.cpp index 3ffc378a6..36b38b979 100644 --- a/test/geo_parametrizedline.cpp +++ b/test/geo_parametrizedline.cpp @@ -48,8 +48,8 @@ template<typename LineType> void parametrizedline(const LineType& _line) LineType l0(p0, d0); - Scalar s0 = ei_random<Scalar>(); - Scalar s1 = ei_abs(ei_random<Scalar>()); + Scalar s0 = internal::random<Scalar>(); + Scalar s1 = internal::abs(internal::random<Scalar>()); VERIFY_IS_MUCH_SMALLER_THAN( l0.distance(p0), RealScalar(1) ); VERIFY_IS_MUCH_SMALLER_THAN( l0.distance(p0+s0*d0), RealScalar(1) ); diff --git a/test/geo_quaternion.cpp b/test/geo_quaternion.cpp index bfe15320a..6ad9a099d 100644 --- a/test/geo_quaternion.cpp +++ b/test/geo_quaternion.cpp @@ -40,17 +40,17 @@ template<typename Scalar> void quaternion(void) typedef AngleAxis<Scalar> AngleAxisx; Scalar largeEps = test_precision<Scalar>(); - if (ei_is_same_type<Scalar,float>::ret) + if (internal::is_same_type<Scalar,float>::ret) largeEps = 1e-3f; - Scalar eps = ei_random<Scalar>() * Scalar(1e-2); + Scalar eps = internal::random<Scalar>() * Scalar(1e-2); Vector3 v0 = Vector3::Random(), v1 = Vector3::Random(), v2 = Vector3::Random(), v3 = Vector3::Random(); - Scalar a = ei_random<Scalar>(-Scalar(M_PI), Scalar(M_PI)); + Scalar a = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI)); // Quaternion: Identity(), setIdentity(); Quaternionx q1, q2; @@ -66,13 +66,13 @@ template<typename Scalar> void quaternion(void) q2 = AngleAxisx(a, v1.normalized()); // angular distance - Scalar refangle = ei_abs(AngleAxisx(q1.inverse()*q2).angle()); + Scalar refangle = internal::abs(AngleAxisx(q1.inverse()*q2).angle()); if (refangle>Scalar(M_PI)) refangle = Scalar(2)*Scalar(M_PI) - refangle; if((q1.coeffs()-q2.coeffs()).norm() > 10*largeEps) { - VERIFY(ei_isApprox(q1.angularDistance(q2), refangle, largeEps)); + VERIFY(internal::isApprox(q1.angularDistance(q2), refangle, largeEps)); } // rotation matrix conversion @@ -96,7 +96,7 @@ template<typename Scalar> void quaternion(void) VERIFY_IS_APPROX( v2.normalized(),(q2.setFromTwoVectors(v1, v2)*v1).normalized()); VERIFY_IS_APPROX( v1.normalized(),(q2.setFromTwoVectors(v1, v1)*v1).normalized()); VERIFY_IS_APPROX(-v1.normalized(),(q2.setFromTwoVectors(v1,-v1)*v1).normalized()); - if (ei_is_same_type<Scalar,double>::ret) + if (internal::is_same_type<Scalar,double>::ret) { v3 = (v1.array()+eps).matrix(); VERIFY_IS_APPROX( v3.normalized(),(q2.setFromTwoVectors(v1, v3)*v1).normalized()); diff --git a/test/geo_transformations.cpp b/test/geo_transformations.cpp index b9ea6bb91..bc850e8dc 100644 --- a/test/geo_transformations.cpp +++ b/test/geo_transformations.cpp @@ -51,7 +51,7 @@ template<typename Scalar, int Mode> void non_projective_only(void) typedef Translation<Scalar,3> Translation3; Scalar largeEps = test_precision<Scalar>(); - if (ei_is_same_type<Scalar,float>::ret) + if (internal::is_same_type<Scalar,float>::ret) largeEps = 1e-2f; Vector3 v0 = Vector3::Random(), @@ -59,7 +59,7 @@ template<typename Scalar, int Mode> void non_projective_only(void) Transform3 t0, t1, t2; - Scalar a = ei_random<Scalar>(-Scalar(M_PI), Scalar(M_PI)); + Scalar a = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI)); Quaternionx q1, q2; @@ -126,7 +126,7 @@ template<typename Scalar, int Mode> void transformations(void) typedef Translation<Scalar,3> Translation3; Scalar largeEps = test_precision<Scalar>(); - if (ei_is_same_type<Scalar,float>::ret) + if (internal::is_same_type<Scalar,float>::ret) largeEps = 1e-2f; Vector3 v0 = Vector3::Random(), @@ -135,12 +135,12 @@ template<typename Scalar, int Mode> void transformations(void) Vector2 u0 = Vector2::Random(); Matrix3 matrot1, m; - Scalar a = ei_random<Scalar>(-Scalar(M_PI), Scalar(M_PI)); - Scalar s0 = ei_random<Scalar>(); + Scalar a = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI)); + Scalar s0 = internal::random<Scalar>(); VERIFY_IS_APPROX(v0, AngleAxisx(a, v0.normalized()) * v0); VERIFY_IS_APPROX(-v0, AngleAxisx(Scalar(M_PI), v0.unitOrthogonal()) * v0); - VERIFY_IS_APPROX(ei_cos(a)*v0.squaredNorm(), v0.dot(AngleAxisx(a, v0.unitOrthogonal()) * v0)); + VERIFY_IS_APPROX(internal::cos(a)*v0.squaredNorm(), v0.dot(AngleAxisx(a, v0.unitOrthogonal()) * v0)); m = AngleAxisx(a, v0.normalized()).toRotationMatrix().adjoint(); VERIFY_IS_APPROX(Matrix3::Identity(), m * AngleAxisx(a, v0.normalized())); VERIFY_IS_APPROX(Matrix3::Identity(), AngleAxisx(a, v0.normalized()) * m); @@ -180,8 +180,8 @@ template<typename Scalar, int Mode> void transformations(void) // Transform // TODO complete the tests ! a = 0; - while (ei_abs(a)<Scalar(0.1)) - a = ei_random<Scalar>(-Scalar(0.4)*Scalar(M_PI), Scalar(0.4)*Scalar(M_PI)); + while (internal::abs(a)<Scalar(0.1)) + a = internal::random<Scalar>(-Scalar(0.4)*Scalar(M_PI), Scalar(0.4)*Scalar(M_PI)); q1 = AngleAxisx(a, v0.normalized()); Transform3 t0, t1, t2; @@ -227,7 +227,7 @@ template<typename Scalar, int Mode> void transformations(void) tmat4.matrix()(3,3) = Scalar(1); VERIFY_IS_APPROX(tmat3.matrix(), tmat4.matrix()); - Scalar a3 = ei_random<Scalar>(-Scalar(M_PI), Scalar(M_PI)); + Scalar a3 = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI)); Vector3 v3 = Vector3::Random().normalized(); AngleAxisx aa3(a3, v3); Transform3 t3(aa3); @@ -274,7 +274,7 @@ template<typename Scalar, int Mode> void transformations(void) Vector2 v20 = Vector2::Random(); Vector2 v21 = Vector2::Random(); for (int k=0; k<2; ++k) - if (ei_abs(v21[k])<Scalar(1e-3)) v21[k] = Scalar(1e-3); + if (internal::abs(v21[k])<Scalar(1e-3)) v21[k] = Scalar(1e-3); t21.setIdentity(); t21.linear() = Rotation2D<Scalar>(a).toRotationMatrix(); VERIFY_IS_APPROX(t20.fromPositionOrientationScale(v20,a,v21).matrix(), @@ -411,7 +411,7 @@ template<typename Scalar, int Mode> void transformations(void) AngleAxis<double> aa1d = aa1.template cast<double>(); VERIFY_IS_APPROX(aa1d.template cast<Scalar>(),aa1); - Rotation2D<Scalar> r2d1(ei_random<Scalar>()); + Rotation2D<Scalar> r2d1(internal::random<Scalar>()); Rotation2D<float> r2d1f = r2d1.template cast<float>(); VERIFY_IS_APPROX(r2d1f.template cast<Scalar>(),r2d1); Rotation2D<double> r2d1d = r2d1.template cast<double>(); diff --git a/test/hessenberg.cpp b/test/hessenberg.cpp index 35df3d58d..51e758bb3 100644 --- a/test/hessenberg.cpp +++ b/test/hessenberg.cpp @@ -69,8 +69,8 @@ void test_hessenberg() CALL_SUBTEST_1(( hessenberg<std::complex<double>,1>() )); CALL_SUBTEST_2(( hessenberg<std::complex<double>,2>() )); CALL_SUBTEST_3(( hessenberg<std::complex<float>,4>() )); - CALL_SUBTEST_4(( hessenberg<float,Dynamic>(ei_random<int>(1,320)) )); - CALL_SUBTEST_5(( hessenberg<std::complex<double>,Dynamic>(ei_random<int>(1,320)) )); + CALL_SUBTEST_4(( hessenberg<float,Dynamic>(internal::random<int>(1,320)) )); + CALL_SUBTEST_5(( hessenberg<std::complex<double>,Dynamic>(internal::random<int>(1,320)) )); // Test problem size constructors CALL_SUBTEST_6(HessenbergDecomposition<MatrixXf>(10)); diff --git a/test/householder.cpp b/test/householder.cpp index 1f22c6c53..244ae8e5f 100644 --- a/test/householder.cpp +++ b/test/householder.cpp @@ -39,7 +39,7 @@ template<typename MatrixType> void householder(const MatrixType& m) typedef typename MatrixType::Scalar Scalar; typedef typename NumTraits<Scalar>::Real RealScalar; typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType; - typedef Matrix<Scalar, ei_decrement_size<MatrixType::RowsAtCompileTime>::ret, 1> EssentialVectorType; + typedef Matrix<Scalar, internal::decrement_size<MatrixType::RowsAtCompileTime>::ret, 1> EssentialVectorType; typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> SquareMatrixType; typedef Matrix<Scalar, Dynamic, MatrixType::ColsAtCompileTime> HBlockMatrixType; typedef Matrix<Scalar, Dynamic, 1> HCoeffsVectorType; @@ -77,8 +77,8 @@ template<typename MatrixType> void householder(const MatrixType& m) m1.applyHouseholderOnTheLeft(essential,beta,tmp); VERIFY_IS_APPROX(m1.norm(), m2.norm()); if(rows>=2) VERIFY_IS_MUCH_SMALLER_THAN(m1.block(1,0,rows-1,cols).norm(), m1.norm()); - VERIFY_IS_MUCH_SMALLER_THAN(ei_imag(m1(0,0)), ei_real(m1(0,0))); - VERIFY_IS_APPROX(ei_real(m1(0,0)), alpha); + VERIFY_IS_MUCH_SMALLER_THAN(internal::imag(m1(0,0)), internal::real(m1(0,0))); + VERIFY_IS_APPROX(internal::real(m1(0,0)), alpha); v1 = VectorType::Random(rows); if(even) v1.tail(rows-1).setZero(); @@ -89,12 +89,12 @@ template<typename MatrixType> void householder(const MatrixType& m) m3.applyHouseholderOnTheRight(essential,beta,tmp); VERIFY_IS_APPROX(m3.norm(), m4.norm()); if(rows>=2) VERIFY_IS_MUCH_SMALLER_THAN(m3.block(0,1,rows,rows-1).norm(), m3.norm()); - VERIFY_IS_MUCH_SMALLER_THAN(ei_imag(m3(0,0)), ei_real(m3(0,0))); - VERIFY_IS_APPROX(ei_real(m3(0,0)), alpha); + VERIFY_IS_MUCH_SMALLER_THAN(internal::imag(m3(0,0)), internal::real(m3(0,0))); + VERIFY_IS_APPROX(internal::real(m3(0,0)), alpha); // test householder sequence on the left with a shift - Index shift = ei_random<Index>(0, std::max<Index>(rows-2,0)); + Index shift = internal::random<Index>(0, std::max<Index>(rows-2,0)); Index brows = rows - shift; m1.setRandom(rows, cols); HBlockMatrixType hbm = m1.block(shift,0,brows,cols); diff --git a/test/integer_types.cpp b/test/integer_types.cpp index 14f8eaa6e..b27bb0a2a 100644 --- a/test/integer_types.cpp +++ b/test/integer_types.cpp @@ -54,7 +54,7 @@ template<typename MatrixType> void signed_integer_type_tests(const MatrixType& m Scalar s1; do { - s1 = ei_random<Scalar>(); + s1 = internal::random<Scalar>(); } while(s1 == 0); VERIFY_IS_EQUAL(-(-m1), m1); @@ -126,7 +126,7 @@ template<typename MatrixType> void integer_type_tests(const MatrixType& m) Scalar s1; do { - s1 = ei_random<Scalar>(); + s1 = internal::random<Scalar>(); } while(s1 == 0); VERIFY_IS_EQUAL(m1+m1, 2*m1); diff --git a/test/inverse.cpp b/test/inverse.cpp index df11c0a4a..f0c69e78c 100644 --- a/test/inverse.cpp +++ b/test/inverse.cpp @@ -79,7 +79,7 @@ template<typename MatrixType> void inverse(const MatrixType& m) MatrixType m3 = v3*v3.transpose(), m4(rows,cols); m3.computeInverseAndDetWithCheck(m4, det, invertible); VERIFY( rows==1 ? invertible : !invertible ); - VERIFY_IS_MUCH_SMALLER_THAN(ei_abs(det-m3.determinant()), RealScalar(1)); + VERIFY_IS_MUCH_SMALLER_THAN(internal::abs(det-m3.determinant()), RealScalar(1)); m3.computeInverseWithCheck(m4, invertible); VERIFY( rows==1 ? invertible : !invertible ); #endif @@ -107,9 +107,9 @@ void test_inverse() CALL_SUBTEST_3( inverse(Matrix3f()) ); CALL_SUBTEST_4( inverse(Matrix4f()) ); CALL_SUBTEST_4( inverse(Matrix<float,4,4,DontAlign>()) ); - s = ei_random<int>(50,320); + s = internal::random<int>(50,320); CALL_SUBTEST_5( inverse(MatrixXf(s,s)) ); - s = ei_random<int>(25,100); + s = internal::random<int>(25,100); CALL_SUBTEST_6( inverse(MatrixXcd(s,s)) ); CALL_SUBTEST_7( inverse(Matrix4d()) ); CALL_SUBTEST_7( inverse(Matrix<double,4,4,DontAlign>()) ); diff --git a/test/jacobi.cpp b/test/jacobi.cpp index 623a5ac6c..6464c63c5 100644 --- a/test/jacobi.cpp +++ b/test/jacobi.cpp @@ -48,29 +48,29 @@ void jacobi(const MatrixType& m = MatrixType()) JacobiRotation<JacobiScalar> rot(c, s); { - Index p = ei_random<Index>(0, rows-1); + Index p = internal::random<Index>(0, rows-1); Index q; do { - q = ei_random<Index>(0, rows-1); + q = internal::random<Index>(0, rows-1); } while (q == p); MatrixType b = a; b.applyOnTheLeft(p, q, rot); - VERIFY_IS_APPROX(b.row(p), c * a.row(p) + ei_conj(s) * a.row(q)); - VERIFY_IS_APPROX(b.row(q), -s * a.row(p) + ei_conj(c) * a.row(q)); + VERIFY_IS_APPROX(b.row(p), c * a.row(p) + internal::conj(s) * a.row(q)); + VERIFY_IS_APPROX(b.row(q), -s * a.row(p) + internal::conj(c) * a.row(q)); } { - Index p = ei_random<Index>(0, cols-1); + Index p = internal::random<Index>(0, cols-1); Index q; do { - q = ei_random<Index>(0, cols-1); + q = internal::random<Index>(0, cols-1); } while (q == p); MatrixType b = a; b.applyOnTheRight(p, q, rot); VERIFY_IS_APPROX(b.col(p), c * a.col(p) - s * a.col(q)); - VERIFY_IS_APPROX(b.col(q), ei_conj(s) * a.col(p) + ei_conj(c) * a.col(q)); + VERIFY_IS_APPROX(b.col(q), internal::conj(s) * a.col(p) + internal::conj(c) * a.col(q)); } } @@ -82,8 +82,8 @@ void test_jacobi() CALL_SUBTEST_3(( jacobi<Matrix4cf, float>() )); CALL_SUBTEST_3(( jacobi<Matrix4cf, std::complex<float> >() )); - int r = ei_random<int>(2, 20), - c = ei_random<int>(2, 20); + int r = internal::random<int>(2, 20), + c = internal::random<int>(2, 20); CALL_SUBTEST_4(( jacobi<MatrixXf, float>(MatrixXf(r,c)) )); CALL_SUBTEST_5(( jacobi<MatrixXcd, double>(MatrixXcd(r,c)) )); CALL_SUBTEST_5(( jacobi<MatrixXcd, std::complex<double> >(MatrixXcd(r,c)) )); diff --git a/test/jacobisvd.cpp b/test/jacobisvd.cpp index 79a05b368..681852ffa 100644 --- a/test/jacobisvd.cpp +++ b/test/jacobisvd.cpp @@ -94,7 +94,7 @@ void jacobisvd_solve(const MatrixType& m, unsigned int computationOptions) typedef Matrix<Scalar, RowsAtCompileTime, Dynamic> RhsType; typedef Matrix<Scalar, ColsAtCompileTime, Dynamic> SolutionType; - RhsType rhs = RhsType::Random(rows, ei_random<Index>(1, cols)); + RhsType rhs = RhsType::Random(rows, internal::random<Index>(1, cols)); JacobiSVD<MatrixType, QRPreconditioner> svd(m, computationOptions); SolutionType x = svd.solve(rhs); // evaluate normal equation which works also for least-squares solutions @@ -230,11 +230,11 @@ void jacobisvd_inf_nan() svd.compute(MatrixType::Constant(10,10,some_nan), ComputeFullU | ComputeFullV); MatrixType m = MatrixType::Zero(10,10); - m(ei_random<int>(0,9), ei_random<int>(0,9)) = some_inf; + m(internal::random<int>(0,9), internal::random<int>(0,9)) = some_inf; svd.compute(m, ComputeFullU | ComputeFullV); m = MatrixType::Zero(10,10); - m(ei_random<int>(0,9), ei_random<int>(0,9)) = some_nan; + m(internal::random<int>(0,9), internal::random<int>(0,9)) = some_nan; svd.compute(m, ComputeFullU | ComputeFullV); } @@ -267,8 +267,8 @@ void test_jacobisvd() CALL_SUBTEST_5(( jacobisvd<Matrix<float,3,5> >() )); CALL_SUBTEST_6(( jacobisvd<Matrix<double,Dynamic,2> >(Matrix<double,Dynamic,2>(10,2)) )); - int r = ei_random<int>(1, 30), - c = ei_random<int>(1, 30); + int r = internal::random<int>(1, 30), + c = internal::random<int>(1, 30); CALL_SUBTEST_7(( jacobisvd<MatrixXf>(MatrixXf(r,c)) )); CALL_SUBTEST_8(( jacobisvd<MatrixXcd>(MatrixXcd(r,c)) )); (void) r; @@ -278,8 +278,8 @@ void test_jacobisvd() CALL_SUBTEST_7( jacobisvd_inf_nan<MatrixXf>() ); } - CALL_SUBTEST_7(( jacobisvd<MatrixXf>(MatrixXf(ei_random<int>(100, 150), ei_random<int>(100, 150))) )); - CALL_SUBTEST_8(( jacobisvd<MatrixXcd>(MatrixXcd(ei_random<int>(80, 100), ei_random<int>(80, 100))) )); + CALL_SUBTEST_7(( jacobisvd<MatrixXf>(MatrixXf(internal::random<int>(100, 150), internal::random<int>(100, 150))) )); + CALL_SUBTEST_8(( jacobisvd<MatrixXcd>(MatrixXcd(internal::random<int>(80, 100), internal::random<int>(80, 100))) )); // test matrixbase method CALL_SUBTEST_1(( jacobisvd_method<Matrix2cd>() )); diff --git a/test/linearstructure.cpp b/test/linearstructure.cpp index b5c58bdaa..312102701 100644 --- a/test/linearstructure.cpp +++ b/test/linearstructure.cpp @@ -42,11 +42,11 @@ template<typename MatrixType> void linearStructure(const MatrixType& m) m3(rows, cols), mzero = MatrixType::Zero(rows, cols); - Scalar s1 = ei_random<Scalar>(); - while (ei_abs(s1)<1e-3) s1 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(); + while (internal::abs(s1)<1e-3) s1 = internal::random<Scalar>(); - Index r = ei_random<Index>(0, rows-1), - c = ei_random<Index>(0, cols-1); + Index r = internal::random<Index>(0, rows-1), + c = internal::random<Index>(0, cols-1); VERIFY_IS_APPROX(-(-m1), m1); VERIFY_IS_APPROX(m1+m1, 2*m1); diff --git a/test/lu.cpp b/test/lu.cpp index 8cb3cbbee..eac7c1ee6 100644 --- a/test/lu.cpp +++ b/test/lu.cpp @@ -37,7 +37,7 @@ template<typename MatrixType> void lu_non_invertible() Index rows, cols, cols2; if(MatrixType::RowsAtCompileTime==Dynamic) { - rows = ei_random<Index>(2,200); + rows = internal::random<Index>(2,200); } else { @@ -45,8 +45,8 @@ template<typename MatrixType> void lu_non_invertible() } if(MatrixType::ColsAtCompileTime==Dynamic) { - cols = ei_random<Index>(2,200); - cols2 = ei_random<int>(2,200); + cols = internal::random<Index>(2,200); + cols2 = internal::random<int>(2,200); } else { @@ -57,14 +57,14 @@ template<typename MatrixType> void lu_non_invertible() RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime }; - typedef typename ei_kernel_retval_base<FullPivLU<MatrixType> >::ReturnType KernelMatrixType; - typedef typename ei_image_retval_base<FullPivLU<MatrixType> >::ReturnType ImageMatrixType; + typedef typename internal::kernel_retval_base<FullPivLU<MatrixType> >::ReturnType KernelMatrixType; + typedef typename internal::image_retval_base<FullPivLU<MatrixType> >::ReturnType ImageMatrixType; typedef Matrix<typename MatrixType::Scalar, ColsAtCompileTime, ColsAtCompileTime> CMatrixType; typedef Matrix<typename MatrixType::Scalar, RowsAtCompileTime, RowsAtCompileTime> RMatrixType; - Index rank = ei_random<Index>(1, std::min(rows, cols)-1); + Index rank = internal::random<Index>(1, std::min(rows, cols)-1); // The image of the zero matrix should consist of a single (zero) column vector VERIFY((MatrixType::Zero(rows,cols).fullPivLu().image(MatrixType::Zero(rows,cols)).cols() == 1)); @@ -117,7 +117,7 @@ template<typename MatrixType> void lu_invertible() */ typedef typename MatrixType::Scalar Scalar; typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar; - int size = ei_random<int>(1,200); + int size = internal::random<int>(1,200); MatrixType m1(size, size), m2(size, size), m3(size, size); FullPivLU<MatrixType> lu; @@ -149,7 +149,7 @@ template<typename MatrixType> void lu_partial_piv() typedef typename MatrixType::Index Index; typedef typename MatrixType::Scalar Scalar; typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar; - Index rows = ei_random<Index>(1,4); + Index rows = internal::random<Index>(1,4); Index cols = rows; MatrixType m1(cols, rows); diff --git a/test/main.h b/test/main.h index 8fa4ca8b5..e03838714 100644 --- a/test/main.h +++ b/test/main.h @@ -71,10 +71,10 @@ namespace Eigen static bool no_more_assert = false; static bool report_on_cerr_on_assert_failure = true; - struct ei_assert_exception + struct eigen_assert_exception { - ei_assert_exception(void) {} - ~ei_assert_exception() { Eigen::no_more_assert = false; } + eigen_assert_exception(void) {} + ~eigen_assert_exception() { Eigen::no_more_assert = false; } }; } @@ -89,52 +89,52 @@ namespace Eigen namespace Eigen { - static bool ei_push_assert = false; - static std::vector<std::string> ei_assert_list; + static bool internal::push_assert = false; + static std::vector<std::string> eigen_assert_list; } - #define ei_assert(a) \ + #define eigen_assert(a) \ if( (!(a)) && (!no_more_assert) ) \ { \ if(report_on_cerr_on_assert_failure) \ std::cerr << #a << " " __FILE__ << "(" << __LINE__ << ")\n"; \ Eigen::no_more_assert = true; \ - throw Eigen::ei_assert_exception(); \ + throw Eigen::eigen_assert_exception(); \ } \ - else if (Eigen::ei_push_assert) \ + else if (Eigen::internal::push_assert) \ { \ - ei_assert_list.push_back(std::string(EI_PP_MAKE_STRING(__FILE__)" ("EI_PP_MAKE_STRING(__LINE__)") : "#a) ); \ + eigen_assert_list.push_back(std::string(EI_PP_MAKE_STRING(__FILE__)" ("EI_PP_MAKE_STRING(__LINE__)") : "#a) ); \ } #define VERIFY_RAISES_ASSERT(a) \ { \ Eigen::no_more_assert = false; \ - Eigen::ei_assert_list.clear(); \ - Eigen::ei_push_assert = true; \ + Eigen::eigen_assert_list.clear(); \ + Eigen::internal::push_assert = true; \ Eigen::report_on_cerr_on_assert_failure = false; \ try { \ a; \ std::cerr << "One of the following asserts should have been triggered:\n"; \ - for (uint ai=0 ; ai<ei_assert_list.size() ; ++ai) \ - std::cerr << " " << ei_assert_list[ai] << "\n"; \ + for (uint ai=0 ; ai<eigen_assert_list.size() ; ++ai) \ + std::cerr << " " << eigen_assert_list[ai] << "\n"; \ VERIFY(Eigen::should_raise_an_assert && # a); \ - } catch (Eigen::ei_assert_exception) { \ - Eigen::ei_push_assert = false; VERIFY(true); \ + } catch (Eigen::eigen_assert_exception) { \ + Eigen::internal::push_assert = false; VERIFY(true); \ } \ Eigen::report_on_cerr_on_assert_failure = true; \ - Eigen::ei_push_assert = false; \ + Eigen::internal::push_assert = false; \ } #else // EIGEN_DEBUG_ASSERTS - #define ei_assert(a) \ + #define eigen_assert(a) \ if( (!(a)) && (!no_more_assert) ) \ { \ Eigen::no_more_assert = true; \ if(report_on_cerr_on_assert_failure) \ assert(a); \ else \ - throw Eigen::ei_assert_exception(); \ + throw Eigen::eigen_assert_exception(); \ } #define VERIFY_RAISES_ASSERT(a) { \ @@ -144,7 +144,7 @@ namespace Eigen a; \ VERIFY(Eigen::should_raise_an_assert && # a); \ } \ - catch (Eigen::ei_assert_exception&) { VERIFY(true); } \ + catch (Eigen::eigen_assert_exception&) { VERIFY(true); } \ Eigen::report_on_cerr_on_assert_failure = true; \ } @@ -170,12 +170,12 @@ namespace Eigen } } while (0) #define VERIFY_IS_EQUAL(a, b) VERIFY(test_is_equal(a, b)) -#define VERIFY_IS_APPROX(a, b) VERIFY(test_ei_isApprox(a, b)) -#define VERIFY_IS_NOT_APPROX(a, b) VERIFY(!test_ei_isApprox(a, b)) -#define VERIFY_IS_MUCH_SMALLER_THAN(a, b) VERIFY(test_ei_isMuchSmallerThan(a, b)) -#define VERIFY_IS_NOT_MUCH_SMALLER_THAN(a, b) VERIFY(!test_ei_isMuchSmallerThan(a, b)) -#define VERIFY_IS_APPROX_OR_LESS_THAN(a, b) VERIFY(test_ei_isApproxOrLessThan(a, b)) -#define VERIFY_IS_NOT_APPROX_OR_LESS_THAN(a, b) VERIFY(!test_ei_isApproxOrLessThan(a, b)) +#define VERIFY_IS_APPROX(a, b) VERIFY(test_isApprox(a, b)) +#define VERIFY_IS_NOT_APPROX(a, b) VERIFY(!test_isApprox(a, b)) +#define VERIFY_IS_MUCH_SMALLER_THAN(a, b) VERIFY(test_isMuchSmallerThan(a, b)) +#define VERIFY_IS_NOT_MUCH_SMALLER_THAN(a, b) VERIFY(!test_isMuchSmallerThan(a, b)) +#define VERIFY_IS_APPROX_OR_LESS_THAN(a, b) VERIFY(test_isApproxOrLessThan(a, b)) +#define VERIFY_IS_NOT_APPROX_OR_LESS_THAN(a, b) VERIFY(!test_isApproxOrLessThan(a, b)) #define VERIFY_IS_UNITARY(a) VERIFY(test_isUnitary(a)) @@ -290,82 +290,82 @@ template<> inline float test_precision<std::complex<float> >() { return test_pre template<> inline double test_precision<std::complex<double> >() { return test_precision<double>(); } template<> inline long double test_precision<long double>() { return 1e-6; } -inline bool test_ei_isApprox(const int& a, const int& b) -{ return ei_isApprox(a, b, test_precision<int>()); } -inline bool test_ei_isMuchSmallerThan(const int& a, const int& b) -{ return ei_isMuchSmallerThan(a, b, test_precision<int>()); } -inline bool test_ei_isApproxOrLessThan(const int& a, const int& b) -{ return ei_isApproxOrLessThan(a, b, test_precision<int>()); } - -inline bool test_ei_isApprox(const float& a, const float& b) -{ return ei_isApprox(a, b, test_precision<float>()); } -inline bool test_ei_isMuchSmallerThan(const float& a, const float& b) -{ return ei_isMuchSmallerThan(a, b, test_precision<float>()); } -inline bool test_ei_isApproxOrLessThan(const float& a, const float& b) -{ return ei_isApproxOrLessThan(a, b, test_precision<float>()); } - -inline bool test_ei_isApprox(const double& a, const double& b) +inline bool test_isApprox(const int& a, const int& b) +{ return internal::isApprox(a, b, test_precision<int>()); } +inline bool test_isMuchSmallerThan(const int& a, const int& b) +{ return internal::isMuchSmallerThan(a, b, test_precision<int>()); } +inline bool test_isApproxOrLessThan(const int& a, const int& b) +{ return internal::isApproxOrLessThan(a, b, test_precision<int>()); } + +inline bool test_isApprox(const float& a, const float& b) +{ return internal::isApprox(a, b, test_precision<float>()); } +inline bool test_isMuchSmallerThan(const float& a, const float& b) +{ return internal::isMuchSmallerThan(a, b, test_precision<float>()); } +inline bool test_isApproxOrLessThan(const float& a, const float& b) +{ return internal::isApproxOrLessThan(a, b, test_precision<float>()); } + +inline bool test_isApprox(const double& a, const double& b) { - bool ret = ei_isApprox(a, b, test_precision<double>()); + bool ret = internal::isApprox(a, b, test_precision<double>()); if (!ret) std::cerr << std::endl << " actual = " << a << std::endl << " expected = " << b << std::endl << std::endl; return ret; } -inline bool test_ei_isMuchSmallerThan(const double& a, const double& b) -{ return ei_isMuchSmallerThan(a, b, test_precision<double>()); } -inline bool test_ei_isApproxOrLessThan(const double& a, const double& b) -{ return ei_isApproxOrLessThan(a, b, test_precision<double>()); } +inline bool test_isMuchSmallerThan(const double& a, const double& b) +{ return internal::isMuchSmallerThan(a, b, test_precision<double>()); } +inline bool test_isApproxOrLessThan(const double& a, const double& b) +{ return internal::isApproxOrLessThan(a, b, test_precision<double>()); } -inline bool test_ei_isApprox(const std::complex<float>& a, const std::complex<float>& b) -{ return ei_isApprox(a, b, test_precision<std::complex<float> >()); } -inline bool test_ei_isMuchSmallerThan(const std::complex<float>& a, const std::complex<float>& b) -{ return ei_isMuchSmallerThan(a, b, test_precision<std::complex<float> >()); } +inline bool test_isApprox(const std::complex<float>& a, const std::complex<float>& b) +{ return internal::isApprox(a, b, test_precision<std::complex<float> >()); } +inline bool test_isMuchSmallerThan(const std::complex<float>& a, const std::complex<float>& b) +{ return internal::isMuchSmallerThan(a, b, test_precision<std::complex<float> >()); } -inline bool test_ei_isApprox(const std::complex<double>& a, const std::complex<double>& b) -{ return ei_isApprox(a, b, test_precision<std::complex<double> >()); } -inline bool test_ei_isMuchSmallerThan(const std::complex<double>& a, const std::complex<double>& b) -{ return ei_isMuchSmallerThan(a, b, test_precision<std::complex<double> >()); } +inline bool test_isApprox(const std::complex<double>& a, const std::complex<double>& b) +{ return internal::isApprox(a, b, test_precision<std::complex<double> >()); } +inline bool test_isMuchSmallerThan(const std::complex<double>& a, const std::complex<double>& b) +{ return internal::isMuchSmallerThan(a, b, test_precision<std::complex<double> >()); } -inline bool test_ei_isApprox(const long double& a, const long double& b) +inline bool test_isApprox(const long double& a, const long double& b) { - bool ret = ei_isApprox(a, b, test_precision<long double>()); + bool ret = internal::isApprox(a, b, test_precision<long double>()); if (!ret) std::cerr << std::endl << " actual = " << a << std::endl << " expected = " << b << std::endl << std::endl; return ret; } -inline bool test_ei_isMuchSmallerThan(const long double& a, const long double& b) -{ return ei_isMuchSmallerThan(a, b, test_precision<long double>()); } -inline bool test_ei_isApproxOrLessThan(const long double& a, const long double& b) -{ return ei_isApproxOrLessThan(a, b, test_precision<long double>()); } +inline bool test_isMuchSmallerThan(const long double& a, const long double& b) +{ return internal::isMuchSmallerThan(a, b, test_precision<long double>()); } +inline bool test_isApproxOrLessThan(const long double& a, const long double& b) +{ return internal::isApproxOrLessThan(a, b, test_precision<long double>()); } template<typename Type1, typename Type2> -inline bool test_ei_isApprox(const Type1& a, const Type2& b) +inline bool test_isApprox(const Type1& a, const Type2& b) { return a.isApprox(b, test_precision<typename Type1::Scalar>()); } template<typename Derived1, typename Derived2> -inline bool test_ei_isMuchSmallerThan(const MatrixBase<Derived1>& m1, +inline bool test_isMuchSmallerThan(const MatrixBase<Derived1>& m1, const MatrixBase<Derived2>& m2) { - return m1.isMuchSmallerThan(m2, test_precision<typename ei_traits<Derived1>::Scalar>()); + return m1.isMuchSmallerThan(m2, test_precision<typename internal::traits<Derived1>::Scalar>()); } template<typename Derived> -inline bool test_ei_isMuchSmallerThan(const MatrixBase<Derived>& m, - const typename NumTraits<typename ei_traits<Derived>::Scalar>::Real& s) +inline bool test_isMuchSmallerThan(const MatrixBase<Derived>& m, + const typename NumTraits<typename internal::traits<Derived>::Scalar>::Real& s) { - return m.isMuchSmallerThan(s, test_precision<typename ei_traits<Derived>::Scalar>()); + return m.isMuchSmallerThan(s, test_precision<typename internal::traits<Derived>::Scalar>()); } template<typename Derived> inline bool test_isUnitary(const MatrixBase<Derived>& m) { - return m.isUnitary(test_precision<typename ei_traits<Derived>::Scalar>()); + return m.isUnitary(test_precision<typename internal::traits<Derived>::Scalar>()); } template<typename T, typename U> @@ -388,8 +388,8 @@ bool test_is_equal(const T& actual, const U& expected) template<typename MatrixType> void createRandomPIMatrixOfRank(typename MatrixType::Index desired_rank, typename MatrixType::Index rows, typename MatrixType::Index cols, MatrixType& m) { - typedef typename ei_traits<MatrixType>::Index Index; - typedef typename ei_traits<MatrixType>::Scalar Scalar; + typedef typename internal::traits<MatrixType>::Index Index; + typedef typename internal::traits<MatrixType>::Scalar Scalar; enum { Rows = MatrixType::RowsAtCompileTime, Cols = MatrixType::ColsAtCompileTime }; typedef Matrix<Scalar, Dynamic, 1> VectorType; diff --git a/test/map.cpp b/test/map.cpp index 9b0301ec0..aa954167a 100644 --- a/test/map.cpp +++ b/test/map.cpp @@ -32,8 +32,8 @@ template<typename VectorType> void map_class_vector(const VectorType& m) Index size = m.size(); // test Map.h - Scalar* array1 = ei_aligned_new<Scalar>(size); - Scalar* array2 = ei_aligned_new<Scalar>(size); + Scalar* array1 = internal::aligned_new<Scalar>(size); + Scalar* array2 = internal::aligned_new<Scalar>(size); Scalar* array3 = new Scalar[size+1]; Scalar* array3unaligned = size_t(array3)%16 == 0 ? array3+1 : array3; @@ -49,8 +49,8 @@ template<typename VectorType> void map_class_vector(const VectorType& m) VERIFY_RAISES_ASSERT((Map<VectorType,Aligned>(array3unaligned, size))) #endif - ei_aligned_delete(array1, size); - ei_aligned_delete(array2, size); + internal::aligned_delete(array1, size); + internal::aligned_delete(array2, size); delete[] array3; } @@ -62,9 +62,9 @@ template<typename MatrixType> void map_class_matrix(const MatrixType& m) Index rows = m.rows(), cols = m.cols(), size = rows*cols; // test Map.h - Scalar* array1 = ei_aligned_new<Scalar>(size); + Scalar* array1 = internal::aligned_new<Scalar>(size); for(int i = 0; i < size; i++) array1[i] = Scalar(1); - Scalar* array2 = ei_aligned_new<Scalar>(size); + Scalar* array2 = internal::aligned_new<Scalar>(size); for(int i = 0; i < size; i++) array2[i] = Scalar(1); Scalar* array3 = new Scalar[size+1]; for(int i = 0; i < size+1; i++) array3[i] = Scalar(1); @@ -78,8 +78,8 @@ template<typename MatrixType> void map_class_matrix(const MatrixType& m) MatrixType ma3 = Map<MatrixType>(array3unaligned, rows, cols); VERIFY_IS_EQUAL(ma1, ma3); - ei_aligned_delete(array1, size); - ei_aligned_delete(array2, size); + internal::aligned_delete(array1, size); + internal::aligned_delete(array2, size); delete[] array3; } @@ -91,8 +91,8 @@ template<typename VectorType> void map_static_methods(const VectorType& m) Index size = m.size(); // test Map.h - Scalar* array1 = ei_aligned_new<Scalar>(size); - Scalar* array2 = ei_aligned_new<Scalar>(size); + Scalar* array1 = internal::aligned_new<Scalar>(size); + Scalar* array2 = internal::aligned_new<Scalar>(size); Scalar* array3 = new Scalar[size+1]; Scalar* array3unaligned = size_t(array3)%16 == 0 ? array3+1 : array3; @@ -105,8 +105,8 @@ template<typename VectorType> void map_static_methods(const VectorType& m) VERIFY_IS_EQUAL(ma1, ma2); VERIFY_IS_EQUAL(ma1, ma3); - ei_aligned_delete(array1, size); - ei_aligned_delete(array2, size); + internal::aligned_delete(array1, size); + internal::aligned_delete(array2, size); delete[] array3; } @@ -123,8 +123,8 @@ void test_map() CALL_SUBTEST_1( map_class_matrix(Matrix<float, 1, 1>()) ); CALL_SUBTEST_2( map_class_matrix(Matrix4d()) ); CALL_SUBTEST_11( map_class_matrix(Matrix<float,3,5>()) ); - CALL_SUBTEST_4( map_class_matrix(MatrixXcf(ei_random<int>(1,10),ei_random<int>(1,10))) ); - CALL_SUBTEST_5( map_class_matrix(MatrixXi(ei_random<int>(1,10),ei_random<int>(1,10))) ); + CALL_SUBTEST_4( map_class_matrix(MatrixXcf(internal::random<int>(1,10),internal::random<int>(1,10))) ); + CALL_SUBTEST_5( map_class_matrix(MatrixXi(internal::random<int>(1,10),internal::random<int>(1,10))) ); CALL_SUBTEST_6( map_static_methods(Matrix<double, 1, 1>()) ); CALL_SUBTEST_7( map_static_methods(Vector3f()) ); diff --git a/test/mapstride.cpp b/test/mapstride.cpp index 072b2134c..8ccd758f8 100644 --- a/test/mapstride.cpp +++ b/test/mapstride.cpp @@ -35,7 +35,7 @@ template<typename VectorType> void map_class_vector(const VectorType& m) Index arraysize = 3*size; - Scalar* array = ei_aligned_new<Scalar>(arraysize); + Scalar* array = internal::aligned_new<Scalar>(arraysize); { Map<VectorType, Aligned, InnerStride<3> > map(array, size); @@ -57,7 +57,7 @@ template<typename VectorType> void map_class_vector(const VectorType& m) } } - ei_aligned_delete(array, arraysize); + internal::aligned_delete(array, arraysize); } template<typename MatrixType> void map_class_matrix(const MatrixType& _m) @@ -71,7 +71,7 @@ template<typename MatrixType> void map_class_matrix(const MatrixType& _m) Index arraysize = 2*(rows+4)*(cols+4); - Scalar* array = ei_aligned_new<Scalar>(arraysize); + Scalar* array = internal::aligned_new<Scalar>(arraysize); // test no inner stride and some dynamic outer stride { @@ -119,7 +119,7 @@ template<typename MatrixType> void map_class_matrix(const MatrixType& _m) } } - ei_aligned_delete(array, arraysize); + internal::aligned_delete(array, arraysize); } void test_mapstride() @@ -135,7 +135,7 @@ void test_mapstride() CALL_SUBTEST_2( map_class_matrix(Matrix4d()) ); CALL_SUBTEST_3( map_class_matrix(Matrix<float,3,5>()) ); CALL_SUBTEST_3( map_class_matrix(Matrix<float,4,8>()) ); - CALL_SUBTEST_4( map_class_matrix(MatrixXcf(ei_random<int>(1,10),ei_random<int>(1,10))) ); - CALL_SUBTEST_5( map_class_matrix(MatrixXi(5,5)));//ei_random<int>(1,10),ei_random<int>(1,10))) ); + CALL_SUBTEST_4( map_class_matrix(MatrixXcf(internal::random<int>(1,10),internal::random<int>(1,10))) ); + CALL_SUBTEST_5( map_class_matrix(MatrixXi(5,5)));//internal::random<int>(1,10),internal::random<int>(1,10))) ); } } diff --git a/test/meta.cpp b/test/meta.cpp index 88d549a8a..ba2167677 100644 --- a/test/meta.cpp +++ b/test/meta.cpp @@ -29,33 +29,33 @@ void test_meta() typedef float & FloatRef; typedef const float & ConstFloatRef; - VERIFY((ei_meta_if<(3<4),ei_meta_true, ei_meta_false>::ret::ret)); - VERIFY(( ei_is_same_type<float,float>::ret)); - VERIFY((!ei_is_same_type<float,double>::ret)); - VERIFY((!ei_is_same_type<float,float&>::ret)); - VERIFY((!ei_is_same_type<float,const float&>::ret)); + VERIFY((internal::meta_if<(3<4),internal::meta_true, internal::meta_false>::ret::ret)); + VERIFY(( internal::is_same_type<float,float>::ret)); + VERIFY((!internal::is_same_type<float,double>::ret)); + VERIFY((!internal::is_same_type<float,float&>::ret)); + VERIFY((!internal::is_same_type<float,const float&>::ret)); - VERIFY(( ei_is_same_type<float,ei_cleantype<const float&>::type >::ret)); - VERIFY(( ei_is_same_type<float,ei_cleantype<const float*>::type >::ret)); - VERIFY(( ei_is_same_type<float,ei_cleantype<const float*&>::type >::ret)); - VERIFY(( ei_is_same_type<float,ei_cleantype<float**>::type >::ret)); - VERIFY(( ei_is_same_type<float,ei_cleantype<float**&>::type >::ret)); - VERIFY(( ei_is_same_type<float,ei_cleantype<float* const *&>::type >::ret)); - VERIFY(( ei_is_same_type<float,ei_cleantype<float* const>::type >::ret)); + VERIFY(( internal::is_same_type<float,internal::cleantype<const float&>::type >::ret)); + VERIFY(( internal::is_same_type<float,internal::cleantype<const float*>::type >::ret)); + VERIFY(( internal::is_same_type<float,internal::cleantype<const float*&>::type >::ret)); + VERIFY(( internal::is_same_type<float,internal::cleantype<float**>::type >::ret)); + VERIFY(( internal::is_same_type<float,internal::cleantype<float**&>::type >::ret)); + VERIFY(( internal::is_same_type<float,internal::cleantype<float* const *&>::type >::ret)); + VERIFY(( internal::is_same_type<float,internal::cleantype<float* const>::type >::ret)); - VERIFY(( ei_is_same_type<float*,ei_unconst<const float*>::type >::ret)); - VERIFY(( ei_is_same_type<float&,ei_unconst<const float&>::type >::ret)); - VERIFY(( ei_is_same_type<float&,ei_unconst<ConstFloatRef>::type >::ret)); + VERIFY(( internal::is_same_type<float*,internal::unconst<const float*>::type >::ret)); + VERIFY(( internal::is_same_type<float&,internal::unconst<const float&>::type >::ret)); + VERIFY(( internal::is_same_type<float&,internal::unconst<ConstFloatRef>::type >::ret)); - VERIFY(( ei_is_same_type<float&,ei_unconst<float&>::type >::ret)); - VERIFY(( ei_is_same_type<float,ei_unref<float&>::type >::ret)); - VERIFY(( ei_is_same_type<const float,ei_unref<const float&>::type >::ret)); - VERIFY(( ei_is_same_type<float,ei_unpointer<float*>::type >::ret)); - VERIFY(( ei_is_same_type<const float,ei_unpointer<const float*>::type >::ret)); - VERIFY(( ei_is_same_type<float,ei_unpointer<float* const >::type >::ret)); + VERIFY(( internal::is_same_type<float&,internal::unconst<float&>::type >::ret)); + VERIFY(( internal::is_same_type<float,internal::unref<float&>::type >::ret)); + VERIFY(( internal::is_same_type<const float,internal::unref<const float&>::type >::ret)); + VERIFY(( internal::is_same_type<float,internal::unpointer<float*>::type >::ret)); + VERIFY(( internal::is_same_type<const float,internal::unpointer<const float*>::type >::ret)); + VERIFY(( internal::is_same_type<float,internal::unpointer<float* const >::type >::ret)); - VERIFY(ei_meta_sqrt<1>::ret == 1); - #define VERIFY_META_SQRT(X) VERIFY(ei_meta_sqrt<X>::ret == int(ei_sqrt(double(X)))) + VERIFY(internal::meta_sqrt<1>::ret == 1); + #define VERIFY_META_SQRT(X) VERIFY(internal::meta_sqrt<X>::ret == int(internal::sqrt(double(X)))) VERIFY_META_SQRT(2); VERIFY_META_SQRT(3); VERIFY_META_SQRT(4); diff --git a/test/miscmatrices.cpp b/test/miscmatrices.cpp index b14bca61c..327ceaedb 100644 --- a/test/miscmatrices.cpp +++ b/test/miscmatrices.cpp @@ -36,7 +36,7 @@ template<typename MatrixType> void miscMatrices(const MatrixType& m) Index rows = m.rows(); Index cols = m.cols(); - Index r = ei_random<Index>(0, rows-1), r2 = ei_random<Index>(0, rows-1), c = ei_random<Index>(0, cols-1); + Index r = internal::random<Index>(0, rows-1), r2 = internal::random<Index>(0, rows-1), c = internal::random<Index>(0, cols-1); VERIFY_IS_APPROX(MatrixType::Ones(rows,cols)(r,c), static_cast<Scalar>(1)); MatrixType m1 = MatrixType::Ones(rows,cols); VERIFY_IS_APPROX(m1(r,c), static_cast<Scalar>(1)); diff --git a/test/mixingtypes.cpp b/test/mixingtypes.cpp index 7673348b4..0ebd00d1d 100644 --- a/test/mixingtypes.cpp +++ b/test/mixingtypes.cpp @@ -59,10 +59,10 @@ template<int SizeAtCompileType> void mixingtypes(int size = SizeAtCompileType) Vec_d vd = vf.template cast<double>(); Vec_cf vcf = Vec_cf::Random(size,1); Vec_cd vcd = vcf.template cast<complex<double> >(); - float sf = ei_random<float>(); - double sd = ei_random<double>(); - complex<float> scf = ei_random<complex<float> >(); - complex<double> scd = ei_random<complex<double> >(); + float sf = internal::random<float>(); + double sd = internal::random<double>(); + complex<float> scf = internal::random<complex<float> >(); + complex<double> scd = internal::random<complex<double> >(); mf+mf; @@ -144,5 +144,5 @@ void test_mixingtypes() { CALL_SUBTEST_1(mixingtypes<3>()); CALL_SUBTEST_2(mixingtypes<4>()); - CALL_SUBTEST_3(mixingtypes<Dynamic>(ei_random<int>(1,310))); + CALL_SUBTEST_3(mixingtypes<Dynamic>(internal::random<int>(1,310))); } diff --git a/test/nomalloc.cpp b/test/nomalloc.cpp index b4c0ff741..0e3caa4ae 100644 --- a/test/nomalloc.cpp +++ b/test/nomalloc.cpp @@ -62,10 +62,10 @@ template<typename MatrixType> void nomalloc(const MatrixType& m) v2 = VectorType::Random(rows), vzero = VectorType::Zero(rows); - Scalar s1 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(); - Index r = ei_random<Index>(0, rows-1), - c = ei_random<Index>(0, cols-1); + Index r = internal::random<Index>(0, rows-1), + c = internal::random<Index>(0, cols-1); VERIFY_IS_APPROX((m1+m2)*s1, s1*m1+s1*m2); VERIFY_IS_APPROX((m1+m2)(r,c), (m1(r,c))+(m2(r,c))); diff --git a/test/nullary.cpp b/test/nullary.cpp index b0a416b25..cc842203e 100644 --- a/test/nullary.cpp +++ b/test/nullary.cpp @@ -49,10 +49,10 @@ bool equalsIdentity(const MatrixType& A) template<typename VectorType> void testVectorType(const VectorType& base) { - typedef typename ei_traits<VectorType>::Index Index; - typedef typename ei_traits<VectorType>::Scalar Scalar; - Scalar low = ei_random<Scalar>(-500,500); - Scalar high = ei_random<Scalar>(-500,500); + typedef typename internal::traits<VectorType>::Index Index; + typedef typename internal::traits<VectorType>::Scalar Scalar; + Scalar low = internal::random<Scalar>(-500,500); + Scalar high = internal::random<Scalar>(-500,500); if (low>high) std::swap(low,high); const Index size = base.size(); const Scalar step = (high-low)/(size-1); diff --git a/test/packetmath.cpp b/test/packetmath.cpp index 0eb3d7f51..3d1fc2850 100644 --- a/test/packetmath.cpp +++ b/test/packetmath.cpp @@ -27,11 +27,15 @@ // using namespace Eigen; -template<typename T> T ei_negate(const T& x) { return -x; } +namespace Eigen { +namespace internal { +template<typename T> T negate(const T& x) { return -x; } +} +} template<typename Scalar> bool isApproxAbs(const Scalar& a, const Scalar& b, const typename NumTraits<Scalar>::Real& refvalue) { - return ei_isMuchSmallerThan(a-b, refvalue); + return internal::isMuchSmallerThan(a-b, refvalue); } template<typename Scalar> bool areApproxAbs(const Scalar* a, const Scalar* b, int size, const typename NumTraits<Scalar>::Real& refvalue) @@ -51,7 +55,7 @@ template<typename Scalar> bool areApprox(const Scalar* a, const Scalar* b, int s { for (int i=0; i<size; ++i) { - if (!ei_isApprox(a[i],b[i])) + if (!internal::isApprox(a[i],b[i])) { std::cout << "a[" << i << "]: " << a[i] << " != b[" << i << "]: " << b[i] << std::endl; return false; @@ -64,14 +68,14 @@ template<typename Scalar> bool areApprox(const Scalar* a, const Scalar* b, int s #define CHECK_CWISE2(REFOP, POP) { \ for (int i=0; i<PacketSize; ++i) \ ref[i] = REFOP(data1[i], data1[i+PacketSize]); \ - ei_pstore(data2, POP(ei_pload<Packet>(data1), ei_pload<Packet>(data1+PacketSize))); \ + internal::pstore(data2, POP(internal::pload<Packet>(data1), internal::pload<Packet>(data1+PacketSize))); \ VERIFY(areApprox(ref, data2, PacketSize) && #POP); \ } #define CHECK_CWISE1(REFOP, POP) { \ for (int i=0; i<PacketSize; ++i) \ ref[i] = REFOP(data1[i]); \ - ei_pstore(data2, POP(ei_pload<Packet>(data1))); \ + internal::pstore(data2, POP(internal::pload<Packet>(data1))); \ VERIFY(areApprox(ref, data2, PacketSize) && #POP); \ } @@ -79,10 +83,10 @@ template<bool Cond,typename Packet> struct packet_helper { template<typename T> - inline Packet load(const T* from) const { return ei_pload<Packet>(from); } + inline Packet load(const T* from) const { return internal::pload<Packet>(from); } template<typename T> - inline void store(T* to, const Packet& x) const { ei_pstore(to,x); } + inline void store(T* to, const Packet& x) const { internal::pstore(to,x); } }; template<typename Packet> @@ -110,150 +114,150 @@ struct packet_helper<false,Packet> template<typename Scalar> void packetmath() { - typedef typename ei_packet_traits<Scalar>::type Packet; - const int PacketSize = ei_packet_traits<Scalar>::size; + typedef typename internal::packet_traits<Scalar>::type Packet; + const int PacketSize = internal::packet_traits<Scalar>::size; typedef typename NumTraits<Scalar>::Real RealScalar; const int size = PacketSize*4; - EIGEN_ALIGN16 Scalar data1[ei_packet_traits<Scalar>::size*4]; - EIGEN_ALIGN16 Scalar data2[ei_packet_traits<Scalar>::size*4]; + EIGEN_ALIGN16 Scalar data1[internal::packet_traits<Scalar>::size*4]; + EIGEN_ALIGN16 Scalar data2[internal::packet_traits<Scalar>::size*4]; EIGEN_ALIGN16 Packet packets[PacketSize*2]; - EIGEN_ALIGN16 Scalar ref[ei_packet_traits<Scalar>::size*4]; + EIGEN_ALIGN16 Scalar ref[internal::packet_traits<Scalar>::size*4]; RealScalar refvalue = 0; for (int i=0; i<size; ++i) { - data1[i] = ei_random<Scalar>(); - data2[i] = ei_random<Scalar>(); - refvalue = std::max(refvalue,ei_abs(data1[i])); + data1[i] = internal::random<Scalar>(); + data2[i] = internal::random<Scalar>(); + refvalue = std::max(refvalue,internal::abs(data1[i])); } - ei_pstore(data2, ei_pload<Packet>(data1)); + internal::pstore(data2, internal::pload<Packet>(data1)); VERIFY(areApprox(data1, data2, PacketSize) && "aligned load/store"); for (int offset=0; offset<PacketSize; ++offset) { - ei_pstore(data2, ei_ploadu<Packet>(data1+offset)); - VERIFY(areApprox(data1+offset, data2, PacketSize) && "ei_ploadu"); + internal::pstore(data2, internal::ploadu<Packet>(data1+offset)); + VERIFY(areApprox(data1+offset, data2, PacketSize) && "internal::ploadu"); } for (int offset=0; offset<PacketSize; ++offset) { - ei_pstoreu(data2+offset, ei_pload<Packet>(data1)); - VERIFY(areApprox(data1, data2+offset, PacketSize) && "ei_pstoreu"); + internal::pstoreu(data2+offset, internal::pload<Packet>(data1)); + VERIFY(areApprox(data1, data2+offset, PacketSize) && "internal::pstoreu"); } for (int offset=0; offset<PacketSize; ++offset) { - packets[0] = ei_pload<Packet>(data1); - packets[1] = ei_pload<Packet>(data1+PacketSize); - if (offset==0) ei_palign<0>(packets[0], packets[1]); - else if (offset==1) ei_palign<1>(packets[0], packets[1]); - else if (offset==2) ei_palign<2>(packets[0], packets[1]); - else if (offset==3) ei_palign<3>(packets[0], packets[1]); - ei_pstore(data2, packets[0]); + packets[0] = internal::pload<Packet>(data1); + packets[1] = internal::pload<Packet>(data1+PacketSize); + if (offset==0) internal::palign<0>(packets[0], packets[1]); + else if (offset==1) internal::palign<1>(packets[0], packets[1]); + else if (offset==2) internal::palign<2>(packets[0], packets[1]); + else if (offset==3) internal::palign<3>(packets[0], packets[1]); + internal::pstore(data2, packets[0]); for (int i=0; i<PacketSize; ++i) ref[i] = data1[i+offset]; typedef Matrix<Scalar, PacketSize, 1> Vector; - VERIFY(areApprox(ref, data2, PacketSize) && "ei_palign"); + VERIFY(areApprox(ref, data2, PacketSize) && "internal::palign"); } - CHECK_CWISE2(REF_ADD, ei_padd); - CHECK_CWISE2(REF_SUB, ei_psub); - CHECK_CWISE2(REF_MUL, ei_pmul); + CHECK_CWISE2(REF_ADD, internal::padd); + CHECK_CWISE2(REF_SUB, internal::psub); + CHECK_CWISE2(REF_MUL, internal::pmul); #ifndef EIGEN_VECTORIZE_ALTIVEC - if (!ei_is_same_type<Scalar,int>::ret) - CHECK_CWISE2(REF_DIV, ei_pdiv); + if (!internal::is_same_type<Scalar,int>::ret) + CHECK_CWISE2(REF_DIV, internal::pdiv); #endif - CHECK_CWISE1(ei_negate, ei_pnegate); - CHECK_CWISE1(ei_conj, ei_pconj); + CHECK_CWISE1(internal::negate, internal::pnegate); + CHECK_CWISE1(internal::conj, internal::pconj); for (int i=0; i<PacketSize; ++i) ref[i] = data1[0]; - ei_pstore(data2, ei_pset1<Packet>(data1[0])); - VERIFY(areApprox(ref, data2, PacketSize) && "ei_pset1"); + internal::pstore(data2, internal::pset1<Packet>(data1[0])); + VERIFY(areApprox(ref, data2, PacketSize) && "internal::pset1"); - VERIFY(ei_isApprox(data1[0], ei_pfirst(ei_pload<Packet>(data1))) && "ei_pfirst"); + VERIFY(internal::isApprox(data1[0], internal::pfirst(internal::pload<Packet>(data1))) && "internal::pfirst"); ref[0] = 0; for (int i=0; i<PacketSize; ++i) ref[0] += data1[i]; - VERIFY(isApproxAbs(ref[0], ei_predux(ei_pload<Packet>(data1)), refvalue) && "ei_predux"); + VERIFY(isApproxAbs(ref[0], internal::predux(internal::pload<Packet>(data1)), refvalue) && "internal::predux"); ref[0] = 1; for (int i=0; i<PacketSize; ++i) ref[0] *= data1[i]; - VERIFY(ei_isApprox(ref[0], ei_predux_mul(ei_pload<Packet>(data1))) && "ei_predux_mul"); + VERIFY(internal::isApprox(ref[0], internal::predux_mul(internal::pload<Packet>(data1))) && "internal::predux_mul"); for (int j=0; j<PacketSize; ++j) { ref[j] = 0; for (int i=0; i<PacketSize; ++i) ref[j] += data1[i+j*PacketSize]; - packets[j] = ei_pload<Packet>(data1+j*PacketSize); + packets[j] = internal::pload<Packet>(data1+j*PacketSize); } - ei_pstore(data2, ei_preduxp(packets)); - VERIFY(areApproxAbs(ref, data2, PacketSize, refvalue) && "ei_preduxp"); + internal::pstore(data2, internal::preduxp(packets)); + VERIFY(areApproxAbs(ref, data2, PacketSize, refvalue) && "internal::preduxp"); for (int i=0; i<PacketSize; ++i) ref[i] = data1[PacketSize-i-1]; - ei_pstore(data2, ei_preverse(ei_pload<Packet>(data1))); - VERIFY(areApprox(ref, data2, PacketSize) && "ei_preverse"); + internal::pstore(data2, internal::preverse(internal::pload<Packet>(data1))); + VERIFY(areApprox(ref, data2, PacketSize) && "internal::preverse"); } template<typename Scalar> void packetmath_real() { - typedef typename ei_packet_traits<Scalar>::type Packet; - const int PacketSize = ei_packet_traits<Scalar>::size; + typedef typename internal::packet_traits<Scalar>::type Packet; + const int PacketSize = internal::packet_traits<Scalar>::size; const int size = PacketSize*4; - EIGEN_ALIGN16 Scalar data1[ei_packet_traits<Scalar>::size*4]; - EIGEN_ALIGN16 Scalar data2[ei_packet_traits<Scalar>::size*4]; - EIGEN_ALIGN16 Scalar ref[ei_packet_traits<Scalar>::size*4]; + EIGEN_ALIGN16 Scalar data1[internal::packet_traits<Scalar>::size*4]; + EIGEN_ALIGN16 Scalar data2[internal::packet_traits<Scalar>::size*4]; + EIGEN_ALIGN16 Scalar ref[internal::packet_traits<Scalar>::size*4]; for (int i=0; i<size; ++i) { - data1[i] = ei_random<Scalar>(-1e3,1e3); - data2[i] = ei_random<Scalar>(-1e3,1e3); + data1[i] = internal::random<Scalar>(-1e3,1e3); + data2[i] = internal::random<Scalar>(-1e3,1e3); } - CHECK_CWISE1_IF(ei_packet_traits<Scalar>::HasSin, ei_sin, ei_psin); - CHECK_CWISE1_IF(ei_packet_traits<Scalar>::HasCos, ei_cos, ei_pcos); + CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasSin, internal::sin, internal::psin); + CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasCos, internal::cos, internal::pcos); for (int i=0; i<size; ++i) { - data1[i] = ei_random<Scalar>(-87,88); - data2[i] = ei_random<Scalar>(-87,88); + data1[i] = internal::random<Scalar>(-87,88); + data2[i] = internal::random<Scalar>(-87,88); } - CHECK_CWISE1_IF(ei_packet_traits<Scalar>::HasExp, ei_exp, ei_pexp); + CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasExp, internal::exp, internal::pexp); for (int i=0; i<size; ++i) { - data1[i] = ei_random<Scalar>(0,1e6); - data2[i] = ei_random<Scalar>(0,1e6); + data1[i] = internal::random<Scalar>(0,1e6); + data2[i] = internal::random<Scalar>(0,1e6); } - CHECK_CWISE1_IF(ei_packet_traits<Scalar>::HasLog, ei_log, ei_plog); - CHECK_CWISE1_IF(ei_packet_traits<Scalar>::HasSqrt, ei_sqrt, ei_psqrt); + CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasLog, internal::log, internal::plog); + CHECK_CWISE1_IF(internal::packet_traits<Scalar>::HasSqrt, internal::sqrt, internal::psqrt); ref[0] = data1[0]; for (int i=0; i<PacketSize; ++i) ref[0] = std::min(ref[0],data1[i]); - VERIFY(ei_isApprox(ref[0], ei_predux_min(ei_pload<Packet>(data1))) && "ei_predux_min"); + VERIFY(internal::isApprox(ref[0], internal::predux_min(internal::pload<Packet>(data1))) && "internal::predux_min"); - CHECK_CWISE2(std::min, ei_pmin); - CHECK_CWISE2(std::max, ei_pmax); - CHECK_CWISE1(ei_abs, ei_pabs); + CHECK_CWISE2(std::min, internal::pmin); + CHECK_CWISE2(std::max, internal::pmax); + CHECK_CWISE1(internal::abs, internal::pabs); ref[0] = data1[0]; for (int i=0; i<PacketSize; ++i) ref[0] = std::max(ref[0],data1[i]); - VERIFY(ei_isApprox(ref[0], ei_predux_max(ei_pload<Packet>(data1))) && "ei_predux_max"); + VERIFY(internal::isApprox(ref[0], internal::predux_max(internal::pload<Packet>(data1))) && "internal::predux_max"); } template<typename Scalar> void packetmath_complex() { - typedef typename ei_packet_traits<Scalar>::type Packet; - const int PacketSize = ei_packet_traits<Scalar>::size; + typedef typename internal::packet_traits<Scalar>::type Packet; + const int PacketSize = internal::packet_traits<Scalar>::size; const int size = PacketSize*4; EIGEN_ALIGN16 Scalar data1[PacketSize*4]; @@ -263,52 +267,52 @@ template<typename Scalar> void packetmath_complex() for (int i=0; i<size; ++i) { - data1[i] = ei_random<Scalar>() * Scalar(1e2); - data2[i] = ei_random<Scalar>() * Scalar(1e2); + data1[i] = internal::random<Scalar>() * Scalar(1e2); + data2[i] = internal::random<Scalar>() * Scalar(1e2); } { - ei_conj_helper<Scalar,Scalar,false,false> cj; - ei_conj_helper<Packet,Packet,false,false> pcj; + internal::conj_helper<Scalar,Scalar,false,false> cj; + internal::conj_helper<Packet,Packet,false,false> pcj; for(int i=0;i<PacketSize;++i) { ref[i] = data1[i] * data2[i]; - VERIFY(ei_isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper"); + VERIFY(internal::isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper"); } - ei_pstore(pval,pcj.pmul(ei_pload<Packet>(data1),ei_pload<Packet>(data2))); + internal::pstore(pval,pcj.pmul(internal::pload<Packet>(data1),internal::pload<Packet>(data2))); VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper"); } { - ei_conj_helper<Scalar,Scalar,true,false> cj; - ei_conj_helper<Packet,Packet,true,false> pcj; + internal::conj_helper<Scalar,Scalar,true,false> cj; + internal::conj_helper<Packet,Packet,true,false> pcj; for(int i=0;i<PacketSize;++i) { - ref[i] = ei_conj(data1[i]) * data2[i]; - VERIFY(ei_isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper"); + ref[i] = internal::conj(data1[i]) * data2[i]; + VERIFY(internal::isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper"); } - ei_pstore(pval,pcj.pmul(ei_pload<Packet>(data1),ei_pload<Packet>(data2))); + internal::pstore(pval,pcj.pmul(internal::pload<Packet>(data1),internal::pload<Packet>(data2))); VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper"); } { - ei_conj_helper<Scalar,Scalar,false,true> cj; - ei_conj_helper<Packet,Packet,false,true> pcj; + internal::conj_helper<Scalar,Scalar,false,true> cj; + internal::conj_helper<Packet,Packet,false,true> pcj; for(int i=0;i<PacketSize;++i) { - ref[i] = data1[i] * ei_conj(data2[i]); - VERIFY(ei_isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper"); + ref[i] = data1[i] * internal::conj(data2[i]); + VERIFY(internal::isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper"); } - ei_pstore(pval,pcj.pmul(ei_pload<Packet>(data1),ei_pload<Packet>(data2))); + internal::pstore(pval,pcj.pmul(internal::pload<Packet>(data1),internal::pload<Packet>(data2))); VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper"); } { - ei_conj_helper<Scalar,Scalar,true,true> cj; - ei_conj_helper<Packet,Packet,true,true> pcj; + internal::conj_helper<Scalar,Scalar,true,true> cj; + internal::conj_helper<Packet,Packet,true,true> pcj; for(int i=0;i<PacketSize;++i) { - ref[i] = ei_conj(data1[i]) * ei_conj(data2[i]); - VERIFY(ei_isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper"); + ref[i] = internal::conj(data1[i]) * internal::conj(data2[i]); + VERIFY(internal::isApprox(ref[i], cj.pmul(data1[i],data2[i])) && "conj_helper"); } - ei_pstore(pval,pcj.pmul(ei_pload<Packet>(data1),ei_pload<Packet>(data2))); + internal::pstore(pval,pcj.pmul(internal::pload<Packet>(data1),internal::pload<Packet>(data2))); VERIFY(areApprox(ref, pval, PacketSize) && "conj_helper"); } diff --git a/test/permutationmatrices.cpp b/test/permutationmatrices.cpp index 880cd87a9..b9b3bbbca 100644 --- a/test/permutationmatrices.cpp +++ b/test/permutationmatrices.cpp @@ -34,9 +34,9 @@ void randomPermutationVector(PermutationVectorType& v, typename PermutationVecto if(size == 1) return; for(Index n = 0; n < 3 * size; ++n) { - Index i = ei_random<Index>(0, size-1); + Index i = internal::random<Index>(0, size-1); Index j; - do j = ei_random<Index>(0, size-1); while(j==i); + do j = internal::random<Index>(0, size-1); while(j==i); std::swap(v(i), v(j)); } } @@ -108,17 +108,17 @@ template<typename MatrixType> void permutationmatrices(const MatrixType& m) if(rows>1 && cols>1) { lp2 = lp; - Index i = ei_random<Index>(0, rows-1); + Index i = internal::random<Index>(0, rows-1); Index j; - do j = ei_random<Index>(0, rows-1); while(j==i); + do j = internal::random<Index>(0, rows-1); while(j==i); lp2.applyTranspositionOnTheLeft(i, j); lm = lp; lm.row(i).swap(lm.row(j)); VERIFY_IS_APPROX(lm, lp2.toDenseMatrix().template cast<Scalar>()); RightPermutationType rp2 = rp; - i = ei_random<Index>(0, cols-1); - do j = ei_random<Index>(0, cols-1); while(j==i); + i = internal::random<Index>(0, cols-1); + do j = internal::random<Index>(0, cols-1); while(j==i); rp2.applyTranspositionOnTheRight(i, j); rm = rp; rm.col(i).swap(rm.col(j)); diff --git a/test/prec_inverse_4x4.cpp b/test/prec_inverse_4x4.cpp index 8b1aa8869..c40cf7399 100644 --- a/test/prec_inverse_4x4.cpp +++ b/test/prec_inverse_4x4.cpp @@ -53,7 +53,7 @@ template<typename MatrixType> void inverse_general_4x4(int repeat) RealScalar absdet; do { m = MatrixType::Random(); - absdet = ei_abs(m.determinant()); + absdet = internal::abs(m.determinant()); } while(absdet < NumTraits<Scalar>::epsilon()); MatrixType inv = m.inverse(); double error = double( (m*inv-MatrixType::Identity()).norm() * absdet / NumTraits<Scalar>::epsilon() ); diff --git a/test/product.h b/test/product.h index 804ce131d..101766b18 100644 --- a/test/product.h +++ b/test/product.h @@ -69,11 +69,11 @@ template<typename MatrixType> void product(const MatrixType& m) ColVectorType vc2 = ColVectorType::Random(cols), vcres(cols); OtherMajorMatrixType tm1 = m1; - Scalar s1 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(); - Index r = ei_random<Index>(0, rows-1), - c = ei_random<Index>(0, cols-1), - c2 = ei_random<Index>(0, cols-1); + Index r = internal::random<Index>(0, rows-1), + c = internal::random<Index>(0, cols-1), + c2 = internal::random<Index>(0, cols-1); // begin testing Product.h: only associativity for now // (we use Transpose.h but this doesn't count as a test for it) diff --git a/test/product_extra.cpp b/test/product_extra.cpp index de105946e..fcedacb2c 100644 --- a/test/product_extra.cpp +++ b/test/product_extra.cpp @@ -50,15 +50,15 @@ template<typename MatrixType> void product_extra(const MatrixType& m) ColVectorType vc2 = ColVectorType::Random(cols), vcres(cols); OtherMajorMatrixType tm1 = m1; - Scalar s1 = ei_random<Scalar>(), - s2 = ei_random<Scalar>(), - s3 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(), + s2 = internal::random<Scalar>(), + s3 = internal::random<Scalar>(); VERIFY_IS_APPROX(m3.noalias() = m1 * m2.adjoint(), m1 * m2.adjoint().eval()); VERIFY_IS_APPROX(m3.noalias() = m1.adjoint() * square.adjoint(), m1.adjoint().eval() * square.adjoint().eval()); VERIFY_IS_APPROX(m3.noalias() = m1.adjoint() * m2, m1.adjoint().eval() * m2); VERIFY_IS_APPROX(m3.noalias() = (s1 * m1.adjoint()) * m2, (s1 * m1.adjoint()).eval() * m2); - VERIFY_IS_APPROX(m3.noalias() = ((s1 * m1).adjoint()) * m2, (ei_conj(s1) * m1.adjoint()).eval() * m2); + VERIFY_IS_APPROX(m3.noalias() = ((s1 * m1).adjoint()) * m2, (internal::conj(s1) * m1.adjoint()).eval() * m2); VERIFY_IS_APPROX(m3.noalias() = (- m1.adjoint() * s1) * (s3 * m2), (- m1.adjoint() * s1).eval() * (s3 * m2).eval()); VERIFY_IS_APPROX(m3.noalias() = (s2 * m1.adjoint() * s1) * m2, (s2 * m1.adjoint() * s1).eval() * m2); VERIFY_IS_APPROX(m3.noalias() = (-m1*s2) * s1*m2.adjoint(), (-m1*s2).eval() * (s1*m2.adjoint()).eval()); @@ -101,12 +101,12 @@ template<typename MatrixType> void product_extra(const MatrixType& m) (-m1.adjoint()*s2).eval() * (s1 * v1.adjoint()).eval()); // test the vector-matrix product with non aligned starts - Index i = ei_random<Index>(0,m1.rows()-2); - Index j = ei_random<Index>(0,m1.cols()-2); - Index r = ei_random<Index>(1,m1.rows()-i); - Index c = ei_random<Index>(1,m1.cols()-j); - Index i2 = ei_random<Index>(0,m1.rows()-1); - Index j2 = ei_random<Index>(0,m1.cols()-1); + Index i = internal::random<Index>(0,m1.rows()-2); + Index j = internal::random<Index>(0,m1.cols()-2); + Index r = internal::random<Index>(1,m1.rows()-i); + Index c = internal::random<Index>(1,m1.cols()-j); + Index i2 = internal::random<Index>(0,m1.rows()-1); + Index j2 = internal::random<Index>(0,m1.cols()-1); VERIFY_IS_APPROX(m1.col(j2).adjoint() * m1.block(0,j,m1.rows(),c), m1.col(j2).adjoint().eval() * m1.block(0,j,m1.rows(),c).eval()); VERIFY_IS_APPROX(m1.block(i,0,r,m1.cols()) * m1.row(i2).adjoint(), m1.block(i,0,r,m1.cols()).eval() * m1.row(i2).adjoint().eval()); @@ -119,9 +119,9 @@ template<typename MatrixType> void product_extra(const MatrixType& m) void test_product_extra() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST_1( product_extra(MatrixXf(ei_random<int>(1,320), ei_random<int>(1,320))) ); - CALL_SUBTEST_2( product_extra(MatrixXd(ei_random<int>(1,320), ei_random<int>(1,320))) ); - CALL_SUBTEST_3( product_extra(MatrixXcf(ei_random<int>(1,150), ei_random<int>(1,150))) ); - CALL_SUBTEST_4( product_extra(MatrixXcd(ei_random<int>(1,150), ei_random<int>(1,150))) ); + CALL_SUBTEST_1( product_extra(MatrixXf(internal::random<int>(1,320), internal::random<int>(1,320))) ); + CALL_SUBTEST_2( product_extra(MatrixXd(internal::random<int>(1,320), internal::random<int>(1,320))) ); + CALL_SUBTEST_3( product_extra(MatrixXcf(internal::random<int>(1,150), internal::random<int>(1,150))) ); + CALL_SUBTEST_4( product_extra(MatrixXcd(internal::random<int>(1,150), internal::random<int>(1,150))) ); } } diff --git a/test/product_large.cpp b/test/product_large.cpp index 2c5523913..8ed937068 100644 --- a/test/product_large.cpp +++ b/test/product_large.cpp @@ -27,11 +27,11 @@ void test_product_large() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST_1( product(MatrixXf(ei_random<int>(1,320), ei_random<int>(1,320))) ); - CALL_SUBTEST_2( product(MatrixXd(ei_random<int>(1,320), ei_random<int>(1,320))) ); - CALL_SUBTEST_3( product(MatrixXi(ei_random<int>(1,320), ei_random<int>(1,320))) ); - CALL_SUBTEST_4( product(MatrixXcf(ei_random<int>(1,150), ei_random<int>(1,150))) ); - CALL_SUBTEST_5( product(Matrix<float,Dynamic,Dynamic,RowMajor>(ei_random<int>(1,320), ei_random<int>(1,320))) ); + CALL_SUBTEST_1( product(MatrixXf(internal::random<int>(1,320), internal::random<int>(1,320))) ); + CALL_SUBTEST_2( product(MatrixXd(internal::random<int>(1,320), internal::random<int>(1,320))) ); + CALL_SUBTEST_3( product(MatrixXi(internal::random<int>(1,320), internal::random<int>(1,320))) ); + CALL_SUBTEST_4( product(MatrixXcf(internal::random<int>(1,150), internal::random<int>(1,150))) ); + CALL_SUBTEST_5( product(Matrix<float,Dynamic,Dynamic,RowMajor>(internal::random<int>(1,320), internal::random<int>(1,320))) ); } #if defined EIGEN_TEST_PART_6 @@ -53,16 +53,16 @@ void test_product_large() { // check the functions to setup blocking sizes compile and do not segfault // FIXME check they do what they are supposed to do !! - std::ptrdiff_t l1 = ei_random<int>(10000,20000); - std::ptrdiff_t l2 = ei_random<int>(1000000,2000000); + std::ptrdiff_t l1 = internal::random<int>(10000,20000); + std::ptrdiff_t l2 = internal::random<int>(1000000,2000000); setCpuCacheSizes(l1,l2); VERIFY(l1==l1CacheSize()); VERIFY(l2==l2CacheSize()); - std::ptrdiff_t k1 = ei_random<int>(10,100)*16; - std::ptrdiff_t m1 = ei_random<int>(10,100)*16; - std::ptrdiff_t n1 = ei_random<int>(10,100)*16; + std::ptrdiff_t k1 = internal::random<int>(10,100)*16; + std::ptrdiff_t m1 = internal::random<int>(10,100)*16; + std::ptrdiff_t n1 = internal::random<int>(10,100)*16; // only makes sure it compiles fine - computeProductBlockingSizes<float,float>(k1,m1,n1); + internal::computeProductBlockingSizes<float,float>(k1,m1,n1); } { diff --git a/test/product_notemporary.cpp b/test/product_notemporary.cpp index 9175694ba..e5dd964c0 100644 --- a/test/product_notemporary.cpp +++ b/test/product_notemporary.cpp @@ -57,14 +57,14 @@ template<typename MatrixType> void product_notemporary(const MatrixType& m) ColVectorType vc2 = ColVectorType::Random(cols), cvres(cols); RowMajorMatrixType rm3(rows, cols); - Scalar s1 = ei_random<Scalar>(), - s2 = ei_random<Scalar>(), - s3 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(), + s2 = internal::random<Scalar>(), + s3 = internal::random<Scalar>(); - Index c0 = ei_random<Index>(4,cols-8), - c1 = ei_random<Index>(8,cols-c0), - r0 = ei_random<Index>(4,cols-8), - r1 = ei_random<Index>(8,rows-r0); + Index c0 = internal::random<Index>(4,cols-8), + c1 = internal::random<Index>(8,cols-c0), + r0 = internal::random<Index>(4,cols-8), + r1 = internal::random<Index>(8,rows-r0); VERIFY_EVALUATION_COUNT( m3 = (m1 * m2.adjoint()), 1); VERIFY_EVALUATION_COUNT( m3.noalias() = m1 * m2.adjoint(), 0); @@ -128,13 +128,13 @@ void test_product_notemporary() { int s; for(int i = 0; i < g_repeat; i++) { - s = ei_random<int>(16,320); + s = internal::random<int>(16,320); CALL_SUBTEST_1( product_notemporary(MatrixXf(s, s)) ); - s = ei_random<int>(16,320); + s = internal::random<int>(16,320); CALL_SUBTEST_2( product_notemporary(MatrixXd(s, s)) ); - s = ei_random<int>(16,120); + s = internal::random<int>(16,120); CALL_SUBTEST_3( product_notemporary(MatrixXcf(s,s)) ); - s = ei_random<int>(16,120); + s = internal::random<int>(16,120); CALL_SUBTEST_4( product_notemporary(MatrixXcd(s,s)) ); } } diff --git a/test/product_selfadjoint.cpp b/test/product_selfadjoint.cpp index c84582484..2e1fc7ec0 100644 --- a/test/product_selfadjoint.cpp +++ b/test/product_selfadjoint.cpp @@ -47,9 +47,9 @@ template<typename MatrixType> void product_selfadjoint(const MatrixType& m) r2 = RowVectorType::Random(rows); RhsMatrixType m4 = RhsMatrixType::Random(rows,10); - Scalar s1 = ei_random<Scalar>(), - s2 = ei_random<Scalar>(), - s3 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(), + s2 = internal::random<Scalar>(), + s3 = internal::random<Scalar>(); m1 = (m1.adjoint() + m1).eval(); @@ -83,13 +83,13 @@ void test_product_selfadjoint() CALL_SUBTEST_1( product_selfadjoint(Matrix<float, 1, 1>()) ); CALL_SUBTEST_2( product_selfadjoint(Matrix<float, 2, 2>()) ); CALL_SUBTEST_3( product_selfadjoint(Matrix3d()) ); - s = ei_random<int>(1,150); + s = internal::random<int>(1,150); CALL_SUBTEST_4( product_selfadjoint(MatrixXcf(s, s)) ); - s = ei_random<int>(1,150); + s = internal::random<int>(1,150); CALL_SUBTEST_5( product_selfadjoint(MatrixXcd(s,s)) ); - s = ei_random<int>(1,320); + s = internal::random<int>(1,320); CALL_SUBTEST_6( product_selfadjoint(MatrixXd(s,s)) ); - s = ei_random<int>(1,320); + s = internal::random<int>(1,320); CALL_SUBTEST_7( product_selfadjoint(Matrix<float,Dynamic,Dynamic,RowMajor>(s,s)) ); } } diff --git a/test/product_symm.cpp b/test/product_symm.cpp index 5ddae30c0..21c2f605b 100644 --- a/test/product_symm.cpp +++ b/test/product_symm.cpp @@ -47,8 +47,8 @@ template<typename Scalar, int Size, int OtherSize> void symm(int size = Size, in Rhs2 rhs2 = Rhs2::Random(othersize, rows), rhs22(othersize, rows), rhs23(othersize, rows); Rhs3 rhs3 = Rhs3::Random(cols, othersize), rhs32(cols, othersize), rhs33(cols, othersize); - Scalar s1 = ei_random<Scalar>(), - s2 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(), + s2 = internal::random<Scalar>(); m2 = m1.template triangularView<Lower>(); m3 = m2.template selfadjointView<Lower>(); @@ -98,14 +98,14 @@ void test_product_symm() { for(int i = 0; i < g_repeat ; i++) { - CALL_SUBTEST_1(( symm<float,Dynamic,Dynamic>(ei_random<int>(1,320),ei_random<int>(1,320)) )); - CALL_SUBTEST_2(( symm<double,Dynamic,Dynamic>(ei_random<int>(1,320),ei_random<int>(1,320)) )); - CALL_SUBTEST_3(( symm<std::complex<float>,Dynamic,Dynamic>(ei_random<int>(1,200),ei_random<int>(1,200)) )); - CALL_SUBTEST_4(( symm<std::complex<double>,Dynamic,Dynamic>(ei_random<int>(1,200),ei_random<int>(1,200)) )); - - CALL_SUBTEST_5(( symm<float,Dynamic,1>(ei_random<int>(1,320)) )); - CALL_SUBTEST_6(( symm<double,Dynamic,1>(ei_random<int>(1,320)) )); - CALL_SUBTEST_7(( symm<std::complex<float>,Dynamic,1>(ei_random<int>(1,320)) )); - CALL_SUBTEST_8(( symm<std::complex<double>,Dynamic,1>(ei_random<int>(1,320)) )); + CALL_SUBTEST_1(( symm<float,Dynamic,Dynamic>(internal::random<int>(1,320),internal::random<int>(1,320)) )); + CALL_SUBTEST_2(( symm<double,Dynamic,Dynamic>(internal::random<int>(1,320),internal::random<int>(1,320)) )); + CALL_SUBTEST_3(( symm<std::complex<float>,Dynamic,Dynamic>(internal::random<int>(1,200),internal::random<int>(1,200)) )); + CALL_SUBTEST_4(( symm<std::complex<double>,Dynamic,Dynamic>(internal::random<int>(1,200),internal::random<int>(1,200)) )); + + CALL_SUBTEST_5(( symm<float,Dynamic,1>(internal::random<int>(1,320)) )); + CALL_SUBTEST_6(( symm<double,Dynamic,1>(internal::random<int>(1,320)) )); + CALL_SUBTEST_7(( symm<std::complex<float>,Dynamic,1>(internal::random<int>(1,320)) )); + CALL_SUBTEST_8(( symm<std::complex<double>,Dynamic,1>(internal::random<int>(1,320)) )); } } diff --git a/test/product_syrk.cpp b/test/product_syrk.cpp index 575b21cac..951a254ed 100644 --- a/test/product_syrk.cpp +++ b/test/product_syrk.cpp @@ -39,11 +39,11 @@ template<typename MatrixType> void syrk(const MatrixType& m) MatrixType m1 = MatrixType::Random(rows, cols), m2 = MatrixType::Random(rows, cols); - Rhs1 rhs1 = Rhs1::Random(ei_random<int>(1,320), cols); - Rhs2 rhs2 = Rhs2::Random(rows, ei_random<int>(1,320)); - Rhs3 rhs3 = Rhs3::Random(ei_random<int>(1,320), rows); + Rhs1 rhs1 = Rhs1::Random(internal::random<int>(1,320), cols); + Rhs2 rhs2 = Rhs2::Random(rows, internal::random<int>(1,320)); + Rhs3 rhs3 = Rhs3::Random(internal::random<int>(1,320), rows); - Scalar s1 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(); m2.setZero(); VERIFY_IS_APPROX((m2.template selfadjointView<Lower>().rankUpdate(rhs2,s1)._expression()), @@ -75,13 +75,13 @@ void test_product_syrk() for(int i = 0; i < g_repeat ; i++) { int s; - s = ei_random<int>(1,320); + s = internal::random<int>(1,320); CALL_SUBTEST_1( syrk(MatrixXf(s, s)) ); - s = ei_random<int>(1,320); + s = internal::random<int>(1,320); CALL_SUBTEST_2( syrk(MatrixXd(s, s)) ); - s = ei_random<int>(1,200); + s = internal::random<int>(1,200); CALL_SUBTEST_3( syrk(MatrixXcf(s, s)) ); - s = ei_random<int>(1,200); + s = internal::random<int>(1,200); CALL_SUBTEST_4( syrk(MatrixXcd(s, s)) ); } } diff --git a/test/product_trmm.cpp b/test/product_trmm.cpp index e4790fb66..e117f6931 100644 --- a/test/product_trmm.cpp +++ b/test/product_trmm.cpp @@ -32,15 +32,15 @@ template<typename Scalar> void trmm(int size,int /*othersize*/) typedef Matrix<Scalar,Dynamic,Dynamic,RowMajor> MatrixRowMaj; DenseIndex rows = size; - DenseIndex cols = ei_random<DenseIndex>(1,size); + DenseIndex cols = internal::random<DenseIndex>(1,size); MatrixColMaj triV(rows,cols), triH(cols,rows), upTri(cols,rows), loTri(rows,cols), unitUpTri(cols,rows), unitLoTri(rows,cols), strictlyUpTri(cols,rows), strictlyLoTri(rows,cols); MatrixColMaj ge1(rows,cols), ge2(cols,rows), ge3; MatrixRowMaj rge3; - Scalar s1 = ei_random<Scalar>(), - s2 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(), + s2 = internal::random<Scalar>(); triV.setRandom(); triH.setRandom(); @@ -65,7 +65,7 @@ template<typename Scalar> void trmm(int size,int /*othersize*/) VERIFY_IS_APPROX( ge3 = ge1.adjoint() * triV.template triangularView<Lower>(), ge1.adjoint() * loTri); VERIFY_IS_APPROX( ge3 = triH.template triangularView<Upper>() * ge2.adjoint(), upTri * ge2.adjoint()); VERIFY_IS_APPROX(rge3.noalias() = triH.template triangularView<Upper>() * ge2.adjoint(), upTri * ge2.adjoint()); - VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView<Upper>() * ge2.adjoint(), ei_conj(s1) * loTri.adjoint() * ge2.adjoint()); + VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView<Upper>() * ge2.adjoint(), internal::conj(s1) * loTri.adjoint() * ge2.adjoint()); VERIFY_IS_APPROX(rge3.noalias() = triV.adjoint().template triangularView<Upper>() * ge2.adjoint(), loTri.adjoint() * ge2.adjoint()); VERIFY_IS_APPROX( ge3 = triH.adjoint().template triangularView<Lower>() * ge1.adjoint(), upTri.adjoint() * ge1.adjoint()); VERIFY_IS_APPROX(rge3.noalias() = triH.adjoint().template triangularView<Lower>() * ge1.adjoint(), upTri.adjoint() * ge1.adjoint()); @@ -73,21 +73,21 @@ template<typename Scalar> void trmm(int size,int /*othersize*/) VERIFY_IS_APPROX( ge3 = triV.template triangularView<UnitLower>() * ge2, unitLoTri * ge2); VERIFY_IS_APPROX( rge3.noalias() = ge2 * triV.template triangularView<UnitLower>(), ge2 * unitLoTri); VERIFY_IS_APPROX( ge3 = ge2 * triV.template triangularView<UnitLower>(), ge2 * unitLoTri); - VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView<UnitUpper>() * ge2.adjoint(), ei_conj(s1) * unitLoTri.adjoint() * ge2.adjoint()); + VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView<UnitUpper>() * ge2.adjoint(), internal::conj(s1) * unitLoTri.adjoint() * ge2.adjoint()); VERIFY_IS_APPROX( ge3 = triV.template triangularView<StrictlyLower>() * ge2, strictlyLoTri * ge2); VERIFY_IS_APPROX( rge3.noalias() = ge2 * triV.template triangularView<StrictlyLower>(), ge2 * strictlyLoTri); VERIFY_IS_APPROX( ge3 = ge2 * triV.template triangularView<StrictlyLower>(), ge2 * strictlyLoTri); - VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView<StrictlyUpper>() * ge2.adjoint(), ei_conj(s1) * strictlyLoTri.adjoint() * ge2.adjoint()); + VERIFY_IS_APPROX( ge3 = (s1*triV).adjoint().template triangularView<StrictlyUpper>() * ge2.adjoint(), internal::conj(s1) * strictlyLoTri.adjoint() * ge2.adjoint()); } void test_product_trmm() { for(int i = 0; i < g_repeat ; i++) { - CALL_SUBTEST_1((trmm<float>(ei_random<int>(1,320),ei_random<int>(1,320)))); - CALL_SUBTEST_2((trmm<double>(ei_random<int>(1,320),ei_random<int>(1,320)))); - CALL_SUBTEST_3((trmm<std::complex<float> >(ei_random<int>(1,200),ei_random<int>(1,200)))); - CALL_SUBTEST_4((trmm<std::complex<double> >(ei_random<int>(1,200),ei_random<int>(1,200)))); + CALL_SUBTEST_1((trmm<float>(internal::random<int>(1,320),internal::random<int>(1,320)))); + CALL_SUBTEST_2((trmm<double>(internal::random<int>(1,320),internal::random<int>(1,320)))); + CALL_SUBTEST_3((trmm<std::complex<float> >(internal::random<int>(1,200),internal::random<int>(1,200)))); + CALL_SUBTEST_4((trmm<std::complex<double> >(internal::random<int>(1,200),internal::random<int>(1,200)))); } } diff --git a/test/product_trmv.cpp b/test/product_trmv.cpp index d32e96c55..cfb7355ff 100644 --- a/test/product_trmv.cpp +++ b/test/product_trmv.cpp @@ -40,7 +40,7 @@ template<typename MatrixType> void trmv(const MatrixType& m) m3(rows, cols); VectorType v1 = VectorType::Random(rows); - Scalar s1 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(); m1 = MatrixType::Random(rows, cols); @@ -93,11 +93,11 @@ void test_product_trmv() CALL_SUBTEST_1( trmv(Matrix<float, 1, 1>()) ); CALL_SUBTEST_2( trmv(Matrix<float, 2, 2>()) ); CALL_SUBTEST_3( trmv(Matrix3d()) ); - s = ei_random<int>(1,200); + s = internal::random<int>(1,200); CALL_SUBTEST_4( trmv(MatrixXcf(s,s)) ); - s = ei_random<int>(1,200); + s = internal::random<int>(1,200); CALL_SUBTEST_5( trmv(MatrixXcd(s,s)) ); - s = ei_random<int>(1,320); + s = internal::random<int>(1,320); CALL_SUBTEST_6( trmv(Matrix<float,Dynamic,Dynamic,RowMajor>(s, s)) ); } } diff --git a/test/product_trsolve.cpp b/test/product_trsolve.cpp index 352f54751..e7ada23a5 100644 --- a/test/product_trsolve.cpp +++ b/test/product_trsolve.cpp @@ -80,13 +80,13 @@ void test_product_trsolve() for(int i = 0; i < g_repeat ; i++) { // matrices - CALL_SUBTEST_1((trsolve<float,Dynamic,Dynamic>(ei_random<int>(1,320),ei_random<int>(1,320)))); - CALL_SUBTEST_2((trsolve<double,Dynamic,Dynamic>(ei_random<int>(1,320),ei_random<int>(1,320)))); - CALL_SUBTEST_3((trsolve<std::complex<float>,Dynamic,Dynamic>(ei_random<int>(1,200),ei_random<int>(1,200)))); - CALL_SUBTEST_4((trsolve<std::complex<double>,Dynamic,Dynamic>(ei_random<int>(1,200),ei_random<int>(1,200)))); + CALL_SUBTEST_1((trsolve<float,Dynamic,Dynamic>(internal::random<int>(1,320),internal::random<int>(1,320)))); + CALL_SUBTEST_2((trsolve<double,Dynamic,Dynamic>(internal::random<int>(1,320),internal::random<int>(1,320)))); + CALL_SUBTEST_3((trsolve<std::complex<float>,Dynamic,Dynamic>(internal::random<int>(1,200),internal::random<int>(1,200)))); + CALL_SUBTEST_4((trsolve<std::complex<double>,Dynamic,Dynamic>(internal::random<int>(1,200),internal::random<int>(1,200)))); // vectors - CALL_SUBTEST_5((trsolve<std::complex<double>,Dynamic,1>(ei_random<int>(1,320)))); + CALL_SUBTEST_5((trsolve<std::complex<double>,Dynamic,1>(internal::random<int>(1,320)))); CALL_SUBTEST_6((trsolve<float,1,1>())); CALL_SUBTEST_7((trsolve<float,1,2>())); CALL_SUBTEST_8((trsolve<std::complex<float>,4,1>())); diff --git a/test/qr.cpp b/test/qr.cpp index 09fb81dde..85707a06d 100644 --- a/test/qr.cpp +++ b/test/qr.cpp @@ -71,12 +71,12 @@ template<typename MatrixType> void qr_invertible() typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar; typedef typename MatrixType::Scalar Scalar; - int size = ei_random<int>(10,50); + int size = internal::random<int>(10,50); MatrixType m1(size, size), m2(size, size), m3(size, size); m1 = MatrixType::Random(size,size); - if (ei_is_same_type<RealScalar,float>::ret) + if (internal::is_same_type<RealScalar,float>::ret) { // let's build a matrix more stable to inverse MatrixType a = MatrixType::Random(size,size*2); @@ -90,13 +90,13 @@ template<typename MatrixType> void qr_invertible() // now construct a matrix with prescribed determinant m1.setZero(); - for(int i = 0; i < size; i++) m1(i,i) = ei_random<Scalar>(); - RealScalar absdet = ei_abs(m1.diagonal().prod()); + for(int i = 0; i < size; i++) m1(i,i) = internal::random<Scalar>(); + RealScalar absdet = internal::abs(m1.diagonal().prod()); m3 = qr.householderQ(); // get a unitary m1 = m3 * m1 * m3; qr.compute(m1); VERIFY_IS_APPROX(absdet, qr.absDeterminant()); - VERIFY_IS_APPROX(ei_log(absdet), qr.logAbsDeterminant()); + VERIFY_IS_APPROX(internal::log(absdet), qr.logAbsDeterminant()); } template<typename MatrixType> void qr_verify_assert() @@ -114,8 +114,8 @@ template<typename MatrixType> void qr_verify_assert() void test_qr() { for(int i = 0; i < g_repeat; i++) { - CALL_SUBTEST_1( qr(MatrixXf(ei_random<int>(1,200),ei_random<int>(1,200))) ); - CALL_SUBTEST_2( qr(MatrixXcd(ei_random<int>(1,200),ei_random<int>(1,200))) ); + CALL_SUBTEST_1( qr(MatrixXf(internal::random<int>(1,200),internal::random<int>(1,200))) ); + CALL_SUBTEST_2( qr(MatrixXcd(internal::random<int>(1,200),internal::random<int>(1,200))) ); CALL_SUBTEST_3(( qr_fixedsize<Matrix<float,3,4>, 2 >() )); CALL_SUBTEST_4(( qr_fixedsize<Matrix<double,6,2>, 4 >() )); CALL_SUBTEST_5(( qr_fixedsize<Matrix<double,2,5>, 7 >() )); diff --git a/test/qr_colpivoting.cpp b/test/qr_colpivoting.cpp index a499412cd..13495594b 100644 --- a/test/qr_colpivoting.cpp +++ b/test/qr_colpivoting.cpp @@ -30,8 +30,8 @@ template<typename MatrixType> void qr() { typedef typename MatrixType::Index Index; - Index rows = ei_random<Index>(2,200), cols = ei_random<Index>(2,200), cols2 = ei_random<Index>(2,200); - Index rank = ei_random<Index>(1, std::min(rows, cols)-1); + Index rows = internal::random<Index>(2,200), cols = internal::random<Index>(2,200), cols2 = internal::random<Index>(2,200); + Index rank = internal::random<Index>(1, std::min(rows, cols)-1); typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::RealScalar RealScalar; @@ -64,7 +64,7 @@ template<typename MatrixType, int Cols2> void qr_fixedsize() { enum { Rows = MatrixType::RowsAtCompileTime, Cols = MatrixType::ColsAtCompileTime }; typedef typename MatrixType::Scalar Scalar; - int rank = ei_random<int>(1, std::min(int(Rows), int(Cols))-1); + int rank = internal::random<int>(1, std::min(int(Rows), int(Cols))-1); Matrix<Scalar,Rows,Cols> m1; createRandomPIMatrixOfRank(rank,Rows,Cols,m1); ColPivHouseholderQR<Matrix<Scalar,Rows,Cols> > qr(m1); @@ -90,12 +90,12 @@ template<typename MatrixType> void qr_invertible() typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar; typedef typename MatrixType::Scalar Scalar; - int size = ei_random<int>(10,50); + int size = internal::random<int>(10,50); MatrixType m1(size, size), m2(size, size), m3(size, size); m1 = MatrixType::Random(size,size); - if (ei_is_same_type<RealScalar,float>::ret) + if (internal::is_same_type<RealScalar,float>::ret) { // let's build a matrix more stable to inverse MatrixType a = MatrixType::Random(size,size*2); @@ -109,13 +109,13 @@ template<typename MatrixType> void qr_invertible() // now construct a matrix with prescribed determinant m1.setZero(); - for(int i = 0; i < size; i++) m1(i,i) = ei_random<Scalar>(); - RealScalar absdet = ei_abs(m1.diagonal().prod()); + for(int i = 0; i < size; i++) m1(i,i) = internal::random<Scalar>(); + RealScalar absdet = internal::abs(m1.diagonal().prod()); m3 = qr.householderQ(); // get a unitary m1 = m3 * m1 * m3; qr.compute(m1); VERIFY_IS_APPROX(absdet, qr.absDeterminant()); - VERIFY_IS_APPROX(ei_log(absdet), qr.logAbsDeterminant()); + VERIFY_IS_APPROX(internal::log(absdet), qr.logAbsDeterminant()); } template<typename MatrixType> void qr_verify_assert() diff --git a/test/qr_fullpivoting.cpp b/test/qr_fullpivoting.cpp index 340b73037..f77ac86a9 100644 --- a/test/qr_fullpivoting.cpp +++ b/test/qr_fullpivoting.cpp @@ -30,8 +30,8 @@ template<typename MatrixType> void qr() { typedef typename MatrixType::Index Index; - Index rows = ei_random<Index>(20,200), cols = ei_random<int>(20,200), cols2 = ei_random<int>(20,200); - Index rank = ei_random<Index>(1, std::min(rows, cols)-1); + Index rows = internal::random<Index>(20,200), cols = internal::random<int>(20,200), cols2 = internal::random<int>(20,200); + Index rank = internal::random<Index>(1, std::min(rows, cols)-1); typedef typename MatrixType::Scalar Scalar; typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> MatrixQType; @@ -69,12 +69,12 @@ template<typename MatrixType> void qr_invertible() typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar; typedef typename MatrixType::Scalar Scalar; - int size = ei_random<int>(10,50); + int size = internal::random<int>(10,50); MatrixType m1(size, size), m2(size, size), m3(size, size); m1 = MatrixType::Random(size,size); - if (ei_is_same_type<RealScalar,float>::ret) + if (internal::is_same_type<RealScalar,float>::ret) { // let's build a matrix more stable to inverse MatrixType a = MatrixType::Random(size,size*2); @@ -92,13 +92,13 @@ template<typename MatrixType> void qr_invertible() // now construct a matrix with prescribed determinant m1.setZero(); - for(int i = 0; i < size; i++) m1(i,i) = ei_random<Scalar>(); - RealScalar absdet = ei_abs(m1.diagonal().prod()); + for(int i = 0; i < size; i++) m1(i,i) = internal::random<Scalar>(); + RealScalar absdet = internal::abs(m1.diagonal().prod()); m3 = qr.matrixQ(); // get a unitary m1 = m3 * m1 * m3; qr.compute(m1); VERIFY_IS_APPROX(absdet, qr.absDeterminant()); - VERIFY_IS_APPROX(ei_log(absdet), qr.logAbsDeterminant()); + VERIFY_IS_APPROX(internal::log(absdet), qr.logAbsDeterminant()); } template<typename MatrixType> void qr_verify_assert() diff --git a/test/redux.cpp b/test/redux.cpp index 9a1df71a8..b9004fbd2 100644 --- a/test/redux.cpp +++ b/test/redux.cpp @@ -37,28 +37,28 @@ template<typename MatrixType> void matrixRedux(const MatrixType& m) VERIFY_IS_MUCH_SMALLER_THAN(MatrixType::Zero(rows, cols).sum(), Scalar(1)); VERIFY_IS_APPROX(MatrixType::Ones(rows, cols).sum(), Scalar(float(rows*cols))); // the float() here to shut up excessive MSVC warning about int->complex conversion being lossy - Scalar s(0), p(1), minc(ei_real(m1.coeff(0))), maxc(ei_real(m1.coeff(0))); + Scalar s(0), p(1), minc(internal::real(m1.coeff(0))), maxc(internal::real(m1.coeff(0))); for(int j = 0; j < cols; j++) for(int i = 0; i < rows; i++) { s += m1(i,j); p *= m1(i,j); - minc = std::min(ei_real(minc), ei_real(m1(i,j))); - maxc = std::max(ei_real(maxc), ei_real(m1(i,j))); + minc = std::min(internal::real(minc), internal::real(m1(i,j))); + maxc = std::max(internal::real(maxc), internal::real(m1(i,j))); } const Scalar mean = s/Scalar(RealScalar(rows*cols)); VERIFY_IS_APPROX(m1.sum(), s); VERIFY_IS_APPROX(m1.mean(), mean); VERIFY_IS_APPROX(m1.prod(), p); - VERIFY_IS_APPROX(m1.real().minCoeff(), ei_real(minc)); - VERIFY_IS_APPROX(m1.real().maxCoeff(), ei_real(maxc)); + VERIFY_IS_APPROX(m1.real().minCoeff(), internal::real(minc)); + VERIFY_IS_APPROX(m1.real().maxCoeff(), internal::real(maxc)); // test slice vectorization assuming assign is ok - Index r0 = ei_random<Index>(0,rows-1); - Index c0 = ei_random<Index>(0,cols-1); - Index r1 = ei_random<Index>(r0+1,rows)-r0; - Index c1 = ei_random<Index>(c0+1,cols)-c0; + Index r0 = internal::random<Index>(0,rows-1); + Index c0 = internal::random<Index>(0,cols-1); + Index r1 = internal::random<Index>(r0+1,rows)-r0; + Index c1 = internal::random<Index>(c0+1,cols)-c0; VERIFY_IS_APPROX(m1.block(r0,c0,r1,c1).sum(), m1.block(r0,c0,r1,c1).eval().sum()); VERIFY_IS_APPROX(m1.block(r0,c0,r1,c1).mean(), m1.block(r0,c0,r1,c1).eval().mean()); VERIFY_IS_APPROX(m1.block(r0,c0,r1,c1).prod(), m1.block(r0,c0,r1,c1).eval().prod()); @@ -81,13 +81,13 @@ template<typename VectorType> void vectorRedux(const VectorType& w) for(int i = 1; i < size; i++) { Scalar s(0), p(1); - RealScalar minc(ei_real(v.coeff(0))), maxc(ei_real(v.coeff(0))); + RealScalar minc(internal::real(v.coeff(0))), maxc(internal::real(v.coeff(0))); for(int j = 0; j < i; j++) { s += v[j]; p *= v[j]; - minc = std::min(minc, ei_real(v[j])); - maxc = std::max(maxc, ei_real(v[j])); + minc = std::min(minc, internal::real(v[j])); + maxc = std::max(maxc, internal::real(v[j])); } VERIFY_IS_APPROX(s, v.head(i).sum()); VERIFY_IS_APPROX(p, v.head(i).prod()); @@ -98,15 +98,15 @@ template<typename VectorType> void vectorRedux(const VectorType& w) for(int i = 0; i < size-1; i++) { Scalar s(0), p(1); - RealScalar minc(ei_real(v.coeff(i))), maxc(ei_real(v.coeff(i))); + RealScalar minc(internal::real(v.coeff(i))), maxc(internal::real(v.coeff(i))); for(int j = i; j < size; j++) { s += v[j]; p *= v[j]; - minc = std::min(minc, ei_real(v[j])); - maxc = std::max(maxc, ei_real(v[j])); + minc = std::min(minc, internal::real(v[j])); + maxc = std::max(maxc, internal::real(v[j])); } - VERIFY_IS_MUCH_SMALLER_THAN(ei_abs(s - v.tail(size-i).sum()), Scalar(1)); + VERIFY_IS_MUCH_SMALLER_THAN(internal::abs(s - v.tail(size-i).sum()), Scalar(1)); VERIFY_IS_APPROX(p, v.tail(size-i).prod()); VERIFY_IS_APPROX(minc, v.real().tail(size-i).minCoeff()); VERIFY_IS_APPROX(maxc, v.real().tail(size-i).maxCoeff()); @@ -115,13 +115,13 @@ template<typename VectorType> void vectorRedux(const VectorType& w) for(int i = 0; i < size/2; i++) { Scalar s(0), p(1); - RealScalar minc(ei_real(v.coeff(i))), maxc(ei_real(v.coeff(i))); + RealScalar minc(internal::real(v.coeff(i))), maxc(internal::real(v.coeff(i))); for(int j = i; j < size-i; j++) { s += v[j]; p *= v[j]; - minc = std::min(minc, ei_real(v[j])); - maxc = std::max(maxc, ei_real(v[j])); + minc = std::min(minc, internal::real(v[j])); + maxc = std::max(maxc, internal::real(v[j])); } VERIFY_IS_APPROX(s, v.segment(i, size-2*i).sum()); VERIFY_IS_APPROX(p, v.segment(i, size-2*i).prod()); diff --git a/test/schur_complex.cpp b/test/schur_complex.cpp index 7c4dcb21a..a2a89fd67 100644 --- a/test/schur_complex.cpp +++ b/test/schur_complex.cpp @@ -80,7 +80,7 @@ template<typename MatrixType> void schur(int size = MatrixType::ColsAtCompileTim void test_schur_complex() { CALL_SUBTEST_1(( schur<Matrix4cd>() )); - CALL_SUBTEST_2(( schur<MatrixXcf>(ei_random<int>(1,50)) )); + CALL_SUBTEST_2(( schur<MatrixXcf>(internal::random<int>(1,50)) )); CALL_SUBTEST_3(( schur<Matrix<std::complex<float>, 1, 1> >() )); CALL_SUBTEST_4(( schur<Matrix<float, 3, 3, Eigen::RowMajor> >() )); diff --git a/test/schur_real.cpp b/test/schur_real.cpp index ab1dd1b85..b61c698c2 100644 --- a/test/schur_real.cpp +++ b/test/schur_real.cpp @@ -99,7 +99,7 @@ template<typename MatrixType> void schur(int size = MatrixType::ColsAtCompileTim void test_schur_real() { CALL_SUBTEST_1(( schur<Matrix4f>() )); - CALL_SUBTEST_2(( schur<MatrixXd>(ei_random<int>(1,50)) )); + CALL_SUBTEST_2(( schur<MatrixXd>(internal::random<int>(1,50)) )); CALL_SUBTEST_3(( schur<Matrix<float, 1, 1> >() )); CALL_SUBTEST_4(( schur<Matrix<double, 3, 3, Eigen::RowMajor> >() )); diff --git a/test/selfadjoint.cpp b/test/selfadjoint.cpp index b1a910b0b..a92ad96b5 100644 --- a/test/selfadjoint.cpp +++ b/test/selfadjoint.cpp @@ -56,7 +56,7 @@ void test_selfadjoint() { for(int i = 0; i < g_repeat ; i++) { - int s = ei_random<int>(1,20); EIGEN_UNUSED_VARIABLE(s); + int s = internal::random<int>(1,20); EIGEN_UNUSED_VARIABLE(s); CALL_SUBTEST_1( selfadjoint(Matrix<float, 1, 1>()) ); CALL_SUBTEST_2( selfadjoint(Matrix<float, 2, 2>()) ); diff --git a/test/smallvectors.cpp b/test/smallvectors.cpp index d6dc8e97c..144944162 100644 --- a/test/smallvectors.cpp +++ b/test/smallvectors.cpp @@ -29,10 +29,10 @@ template<typename Scalar> void smallVectors() typedef Matrix<Scalar, 1, 2> V2; typedef Matrix<Scalar, 3, 1> V3; typedef Matrix<Scalar, 1, 4> V4; - Scalar x1 = ei_random<Scalar>(), - x2 = ei_random<Scalar>(), - x3 = ei_random<Scalar>(), - x4 = ei_random<Scalar>(); + Scalar x1 = internal::random<Scalar>(), + x2 = internal::random<Scalar>(), + x3 = internal::random<Scalar>(), + x4 = internal::random<Scalar>(); V2 v2(x1, x2); V3 v3(x1, x2, x3); V4 v4(x1, x2, x3, x4); diff --git a/test/sparse.h b/test/sparse.h index 4733e4d10..1489f2a0e 100644 --- a/test/sparse.h +++ b/test/sparse.h @@ -71,10 +71,10 @@ initSparse(double density, sparseMat.startVec(j); for(int i=0; i<refMat.rows(); i++) { - Scalar v = (ei_random<double>(0,1) < density) ? ei_random<Scalar>() : Scalar(0); + Scalar v = (internal::random<double>(0,1) < density) ? internal::random<Scalar>() : Scalar(0); if ((flags&ForceNonZeroDiag) && (i==j)) { - v = ei_random<Scalar>()*Scalar(3.); + v = internal::random<Scalar>()*Scalar(3.); v = v*v + Scalar(5.); } if ((flags & MakeLowerTriangular) && j>i) @@ -83,7 +83,7 @@ initSparse(double density, v = Scalar(0); if ((flags&ForceRealDiag) && (i==j)) - v = ei_real(v); + v = internal::real(v); if (v!=Scalar(0)) { @@ -116,10 +116,10 @@ initSparse(double density, sparseMat.startVec(j); // not needed for DynamicSparseMatrix for(int i=0; i<refMat.rows(); i++) { - Scalar v = (ei_random<double>(0,1) < density) ? ei_random<Scalar>() : Scalar(0); + Scalar v = (internal::random<double>(0,1) < density) ? internal::random<Scalar>() : Scalar(0); if ((flags&ForceNonZeroDiag) && (i==j)) { - v = ei_random<Scalar>()*Scalar(3.); + v = internal::random<Scalar>()*Scalar(3.); v = v*v + Scalar(5.); } if ((flags & MakeLowerTriangular) && j>i) @@ -128,7 +128,7 @@ initSparse(double density, v = Scalar(0); if ((flags&ForceRealDiag) && (i==j)) - v = ei_real(v); + v = internal::real(v); if (v!=Scalar(0)) { @@ -157,7 +157,7 @@ initSparse(double density, sparseVec.setZero(); for(int i=0; i<refVec.size(); i++) { - Scalar v = (ei_random<double>(0,1) < density) ? ei_random<Scalar>() : Scalar(0); + Scalar v = (internal::random<double>(0,1) < density) ? internal::random<Scalar>() : Scalar(0); if (v!=Scalar(0)) { sparseVec.insertBack(i) = v; diff --git a/test/sparse_basic.cpp b/test/sparse_basic.cpp index 8c93909c6..8dfa0baff 100644 --- a/test/sparse_basic.cpp +++ b/test/sparse_basic.cpp @@ -41,7 +41,7 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re SparseMatrixType m(rows, cols); DenseMatrix refMat = DenseMatrix::Zero(rows, cols); DenseVector vec1 = DenseVector::Random(rows); - Scalar s1 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(); std::vector<Vector2i> zeroCoords; std::vector<Vector2i> nonzeroCoords; @@ -54,7 +54,7 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re for (int i=0; i<(int)zeroCoords.size(); ++i) { VERIFY_IS_MUCH_SMALLER_THAN( m.coeff(zeroCoords[i].x(),zeroCoords[i].y()), eps ); - if(ei_is_same_type<SparseMatrixType,SparseMatrix<Scalar,Flags> >::ret) + if(internal::is_same_type<SparseMatrixType,SparseMatrix<Scalar,Flags> >::ret) VERIFY_RAISES_ASSERT( m.coeffRef(zeroCoords[0].x(),zeroCoords[0].y()) = 5 ); } VERIFY_IS_APPROX(m, refMat); @@ -67,10 +67,10 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re // test InnerIterators and Block expressions for (int t=0; t<10; ++t) { - int j = ei_random<int>(0,cols-1); - int i = ei_random<int>(0,rows-1); - int w = ei_random<int>(1,cols-j-1); - int h = ei_random<int>(1,rows-i-1); + int j = internal::random<int>(0,cols-1); + int i = internal::random<int>(0,rows-1); + int w = internal::random<int>(1,cols-j-1); + int h = internal::random<int>(1,rows-i-1); // VERIFY_IS_APPROX(m.block(i,j,h,w), refMat.block(i,j,h,w)); for(int c=0; c<w; c++) @@ -114,9 +114,9 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re { for (int k=0; k<rows/2; ++k) { - int i = ei_random<int>(0,rows-1); + int i = internal::random<int>(0,rows-1); if (m1.coeff(i,j)==Scalar(0)) - m2.insert(i,j) = m1(i,j) = ei_random<Scalar>(); + m2.insert(i,j) = m1(i,j) = internal::random<Scalar>(); } } m2.finalize(); @@ -131,10 +131,10 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re m2.reserve(10); for (int k=0; k<rows*cols; ++k) { - int i = ei_random<int>(0,rows-1); - int j = ei_random<int>(0,cols-1); + int i = internal::random<int>(0,rows-1); + int j = internal::random<int>(0,cols-1); if (m1.coeff(i,j)==Scalar(0)) - m2.insert(i,j) = m1(i,j) = ei_random<Scalar>(); + m2.insert(i,j) = m1(i,j) = internal::random<Scalar>(); } m2.finalize(); VERIFY_IS_APPROX(m2,m1); @@ -190,8 +190,8 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re DenseMatrix refMat2 = DenseMatrix::Zero(rows, rows); SparseMatrixType m2(rows, rows); initSparse<Scalar>(density, refMat2, m2); - int j0 = ei_random(0,rows-1); - int j1 = ei_random(0,rows-1); + int j0 = internal::random(0,rows-1); + int j1 = internal::random(0,rows-1); VERIFY_IS_APPROX(m2.innerVector(j0), refMat2.col(j0)); VERIFY_IS_APPROX(m2.innerVector(j0)+m2.innerVector(j1), refMat2.col(j0)+refMat2.col(j1)); //m2.innerVector(j0) = 2*m2.innerVector(j1); @@ -204,9 +204,9 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re DenseMatrix refMat2 = DenseMatrix::Zero(rows, rows); SparseMatrixType m2(rows, rows); initSparse<Scalar>(density, refMat2, m2); - int j0 = ei_random(0,rows-2); - int j1 = ei_random(0,rows-2); - int n0 = ei_random<int>(1,rows-std::max(j0,j1)); + int j0 = internal::random(0,rows-2); + int j1 = internal::random(0,rows-2); + int n0 = internal::random<int>(1,rows-std::max(j0,j1)); VERIFY_IS_APPROX(m2.innerVectors(j0,n0), refMat2.block(0,j0,rows,n0)); VERIFY_IS_APPROX(m2.innerVectors(j0,n0)+m2.innerVectors(j1,n0), refMat2.block(0,j0,rows,n0)+refMat2.block(0,j1,rows,n0)); @@ -226,7 +226,7 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re m2.startVec(j); for (int i=0; i<m2.innerSize(); ++i) { - float x = ei_random<float>(0,1); + float x = internal::random<float>(0,1); if (x<0.1) { // do nothing diff --git a/test/sparse_product.cpp b/test/sparse_product.cpp index d4809711c..ce42c5f52 100644 --- a/test/sparse_product.cpp +++ b/test/sparse_product.cpp @@ -36,8 +36,8 @@ template<typename SparseMatrixType> void sparse_product(const SparseMatrixType& typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix; typedef Matrix<Scalar,Dynamic,1> DenseVector; - Scalar s1 = ei_random<Scalar>(); - Scalar s2 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(); + Scalar s2 = internal::random<Scalar>(); // test matrix-matrix product { @@ -54,7 +54,7 @@ template<typename SparseMatrixType> void sparse_product(const SparseMatrixType& initSparse<Scalar>(density, refMat3, m3); initSparse<Scalar>(density, refMat4, m4); - int c = ei_random<int>(0,rows-1); + int c = internal::random<int>(0,rows-1); VERIFY_IS_APPROX(m4=m2*m3, refMat4=refMat2*refMat3); VERIFY_IS_APPROX(m4=m2.transpose()*m3, refMat4=refMat2.transpose()*refMat3); diff --git a/test/sparse_solvers.cpp b/test/sparse_solvers.cpp index ed54feddc..aba61e6c0 100644 --- a/test/sparse_solvers.cpp +++ b/test/sparse_solvers.cpp @@ -111,7 +111,7 @@ void test_sparse_solvers() { for(int i = 0; i < g_repeat; i++) { CALL_SUBTEST_1(sparse_solvers<double>(8, 8) ); - int s = ei_random<int>(1,300); + int s = internal::random<int>(1,300); CALL_SUBTEST_2(sparse_solvers<std::complex<double> >(s,s) ); CALL_SUBTEST_1(sparse_solvers<double>(s,s) ); } diff --git a/test/sparse_vector.cpp b/test/sparse_vector.cpp index a5101398c..be85740c0 100644 --- a/test/sparse_vector.cpp +++ b/test/sparse_vector.cpp @@ -48,7 +48,7 @@ template<typename Scalar> void sparse_vector(int rows, int cols) initSparse<Scalar>(densityVec, refV2, v2); initSparse<Scalar>(densityVec, refV3, v3); - Scalar s1 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(); // test coeff and coeffRef for (unsigned int i=0; i<zerocoords.size(); ++i) diff --git a/test/stable_norm.cpp b/test/stable_norm.cpp index f3e671c3b..69e4a1b12 100644 --- a/test/stable_norm.cpp +++ b/test/stable_norm.cpp @@ -55,7 +55,7 @@ template<typename MatrixType> void stable_norm(const MatrixType& m) Index rows = m.rows(); Index cols = m.cols(); - Scalar big = ei_random<Scalar>() * (std::numeric_limits<RealScalar>::max() * RealScalar(1e-4)); + Scalar big = internal::random<Scalar>() * (std::numeric_limits<RealScalar>::max() * RealScalar(1e-4)); Scalar small = static_cast<RealScalar>(1)/big; MatrixType vzero = MatrixType::Zero(rows, cols), @@ -75,33 +75,33 @@ template<typename MatrixType> void stable_norm(const MatrixType& m) // test isFinite VERIFY(!isFinite( std::numeric_limits<RealScalar>::infinity())); - VERIFY(!isFinite(ei_sqrt(-ei_abs(big)))); + VERIFY(!isFinite(internal::sqrt(-internal::abs(big)))); // test overflow - VERIFY(isFinite(ei_sqrt(size)*ei_abs(big))); + VERIFY(isFinite(internal::sqrt(size)*internal::abs(big))); #ifdef EIGEN_VECTORIZE_SSE // since x87 FPU uses 80bits of precision overflow is not detected - if(ei_packet_traits<Scalar>::size>1) + if(internal::packet_traits<Scalar>::size>1) { - VERIFY_IS_NOT_APPROX(static_cast<Scalar>(vbig.norm()), ei_sqrt(size)*big); // here the default norm must fail + VERIFY_IS_NOT_APPROX(static_cast<Scalar>(vbig.norm()), internal::sqrt(size)*big); // here the default norm must fail } #endif - VERIFY_IS_APPROX(vbig.stableNorm(), ei_sqrt(size)*ei_abs(big)); - VERIFY_IS_APPROX(vbig.blueNorm(), ei_sqrt(size)*ei_abs(big)); - VERIFY_IS_APPROX(vbig.hypotNorm(), ei_sqrt(size)*ei_abs(big)); + VERIFY_IS_APPROX(vbig.stableNorm(), internal::sqrt(size)*internal::abs(big)); + VERIFY_IS_APPROX(vbig.blueNorm(), internal::sqrt(size)*internal::abs(big)); + VERIFY_IS_APPROX(vbig.hypotNorm(), internal::sqrt(size)*internal::abs(big)); // test underflow - VERIFY(isFinite(ei_sqrt(size)*ei_abs(small))); + VERIFY(isFinite(internal::sqrt(size)*internal::abs(small))); #ifdef EIGEN_VECTORIZE_SSE // since x87 FPU uses 80bits of precision underflow is not detected - if(ei_packet_traits<Scalar>::size>1) + if(internal::packet_traits<Scalar>::size>1) { - VERIFY_IS_NOT_APPROX(static_cast<Scalar>(vsmall.norm()), ei_sqrt(size)*small); // here the default norm must fail + VERIFY_IS_NOT_APPROX(static_cast<Scalar>(vsmall.norm()), internal::sqrt(size)*small); // here the default norm must fail } #endif - VERIFY_IS_APPROX(vsmall.stableNorm(), ei_sqrt(size)*ei_abs(small)); - VERIFY_IS_APPROX(vsmall.blueNorm(), ei_sqrt(size)*ei_abs(small)); - VERIFY_IS_APPROX(vsmall.hypotNorm(), ei_sqrt(size)*ei_abs(small)); + VERIFY_IS_APPROX(vsmall.stableNorm(), internal::sqrt(size)*internal::abs(small)); + VERIFY_IS_APPROX(vsmall.blueNorm(), internal::sqrt(size)*internal::abs(small)); + VERIFY_IS_APPROX(vsmall.hypotNorm(), internal::sqrt(size)*internal::abs(small)); // Test compilation of cwise() version VERIFY_IS_APPROX(vrand.colwise().stableNorm(), vrand.colwise().norm()); @@ -117,8 +117,8 @@ void test_stable_norm() for(int i = 0; i < g_repeat; i++) { CALL_SUBTEST_1( stable_norm(Matrix<float, 1, 1>()) ); CALL_SUBTEST_2( stable_norm(Vector4d()) ); - CALL_SUBTEST_3( stable_norm(VectorXd(ei_random<int>(10,2000))) ); - CALL_SUBTEST_4( stable_norm(VectorXf(ei_random<int>(10,2000))) ); - CALL_SUBTEST_5( stable_norm(VectorXcd(ei_random<int>(10,2000))) ); + CALL_SUBTEST_3( stable_norm(VectorXd(internal::random<int>(10,2000))) ); + CALL_SUBTEST_4( stable_norm(VectorXf(internal::random<int>(10,2000))) ); + CALL_SUBTEST_5( stable_norm(VectorXcd(internal::random<int>(10,2000))) ); } } diff --git a/test/swap.cpp b/test/swap.cpp index 74543a662..4a575e7d7 100644 --- a/test/swap.cpp +++ b/test/swap.cpp @@ -42,7 +42,7 @@ template<typename MatrixType> void swap(const MatrixType& m) typedef typename other_matrix_type<MatrixType>::type OtherMatrixType; typedef typename MatrixType::Scalar Scalar; - ei_assert((!ei_is_same_type<MatrixType,OtherMatrixType>::ret)); + eigen_assert((!internal::is_same_type<MatrixType,OtherMatrixType>::ret)); typename MatrixType::Index rows = m.rows(); typename MatrixType::Index cols = m.cols(); diff --git a/test/triangular.cpp b/test/triangular.cpp index bf5db4e27..0c69749e0 100644 --- a/test/triangular.cpp +++ b/test/triangular.cpp @@ -88,7 +88,7 @@ template<typename MatrixType> void triangular_square(const MatrixType& m) m1 = MatrixType::Random(rows, cols); for (int i=0; i<rows; ++i) - while (ei_abs2(m1(i,i))<1e-1) m1(i,i) = ei_random<Scalar>(); + while (internal::abs2(m1(i,i))<1e-1) m1(i,i) = internal::random<Scalar>(); Transpose<MatrixType> trm4(m4); // test back and forward subsitution with a vector as the rhs @@ -239,8 +239,8 @@ void test_triangular() { for(int i = 0; i < g_repeat ; i++) { - int r = ei_random<int>(2,20); EIGEN_UNUSED_VARIABLE(r); - int c = ei_random<int>(2,20); EIGEN_UNUSED_VARIABLE(c); + int r = internal::random<int>(2,20); EIGEN_UNUSED_VARIABLE(r); + int c = internal::random<int>(2,20); EIGEN_UNUSED_VARIABLE(c); CALL_SUBTEST_1( triangular_square(Matrix<float, 1, 1>()) ); CALL_SUBTEST_2( triangular_square(Matrix<float, 2, 2>()) ); diff --git a/test/umeyama.cpp b/test/umeyama.cpp index 6c710bc88..abbb1fc7f 100644 --- a/test/umeyama.cpp +++ b/test/umeyama.cpp @@ -82,7 +82,7 @@ Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> randMatrixUnitary(int size) } if (max_tries == 0) - ei_assert(false && "randMatrixUnitary: Could not construct unitary matrix!"); + eigen_assert(false && "randMatrixUnitary: Could not construct unitary matrix!"); return Q; } @@ -100,7 +100,7 @@ Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> randMatrixSpecialUnitary(int si MatrixType Q = randMatrixUnitary<Scalar>(size); // tweak the first column to make the determinant be 1 - Q.col(0) *= ei_conj(Q.determinant()); + Q.col(0) *= internal::conj(Q.determinant()); return Q; } @@ -108,13 +108,13 @@ Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> randMatrixSpecialUnitary(int si template <typename MatrixType> void run_test(int dim, int num_elements) { - typedef typename ei_traits<MatrixType>::Scalar Scalar; + typedef typename internal::traits<MatrixType>::Scalar Scalar; typedef Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> MatrixX; typedef Matrix<Scalar, Eigen::Dynamic, 1> VectorX; // MUST be positive because in any other case det(cR_t) may become negative for // odd dimensions! - const Scalar c = ei_abs(ei_random<Scalar>()); + const Scalar c = internal::abs(internal::random<Scalar>()); MatrixX R = randMatrixSpecialUnitary<Scalar>(dim); VectorX t = Scalar(50)*VectorX::Random(dim,1); @@ -147,7 +147,7 @@ void run_fixed_size_test(int num_elements) // MUST be positive because in any other case det(cR_t) may become negative for // odd dimensions! - const Scalar c = ei_abs(ei_random<Scalar>()); + const Scalar c = internal::abs(internal::random<Scalar>()); FixedMatrix R = randMatrixSpecialUnitary<Scalar>(dim); FixedVector t = Scalar(50)*FixedVector::Random(dim,1); @@ -175,7 +175,7 @@ void test_umeyama() { for (int i=0; i<g_repeat; ++i) { - const int num_elements = ei_random<int>(40,500); + const int num_elements = internal::random<int>(40,500); // works also for dimensions bigger than 3... for (int dim=2; dim<8; ++dim) diff --git a/test/vectorization_logic.cpp b/test/vectorization_logic.cpp index 2b23d4082..1a00af840 100644 --- a/test/vectorization_logic.cpp +++ b/test/vectorization_logic.cpp @@ -46,15 +46,15 @@ std::string demangle_unrolling(int t) template<typename Dst, typename Src> bool test_assign(const Dst&, const Src&, int traversal, int unrolling) { - ei_assign_traits<Dst,Src>::debug(); - bool res = ei_assign_traits<Dst,Src>::Traversal==traversal - && ei_assign_traits<Dst,Src>::Unrolling==unrolling; + internal::assign_traits<Dst,Src>::debug(); + bool res = internal::assign_traits<Dst,Src>::Traversal==traversal + && internal::assign_traits<Dst,Src>::Unrolling==unrolling; if(!res) { std::cerr << " Expected Traversal == " << demangle_traversal(traversal) - << " got " << demangle_traversal(ei_assign_traits<Dst,Src>::Traversal) << "\n"; + << " got " << demangle_traversal(internal::assign_traits<Dst,Src>::Traversal) << "\n"; std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling) - << " got " << demangle_unrolling(ei_assign_traits<Dst,Src>::Unrolling) << "\n"; + << " got " << demangle_unrolling(internal::assign_traits<Dst,Src>::Unrolling) << "\n"; } return res; } @@ -62,15 +62,15 @@ bool test_assign(const Dst&, const Src&, int traversal, int unrolling) template<typename Dst, typename Src> bool test_assign(int traversal, int unrolling) { - ei_assign_traits<Dst,Src>::debug(); - bool res = ei_assign_traits<Dst,Src>::Traversal==traversal - && ei_assign_traits<Dst,Src>::Unrolling==unrolling; + internal::assign_traits<Dst,Src>::debug(); + bool res = internal::assign_traits<Dst,Src>::Traversal==traversal + && internal::assign_traits<Dst,Src>::Unrolling==unrolling; if(!res) { std::cerr << " Expected Traversal == " << demangle_traversal(traversal) - << " got " << demangle_traversal(ei_assign_traits<Dst,Src>::Traversal) << "\n"; + << " got " << demangle_traversal(internal::assign_traits<Dst,Src>::Traversal) << "\n"; std::cerr << " Expected Unrolling == " << demangle_unrolling(unrolling) - << " got " << demangle_unrolling(ei_assign_traits<Dst,Src>::Unrolling) << "\n"; + << " got " << demangle_unrolling(internal::assign_traits<Dst,Src>::Unrolling) << "\n"; } return res; } @@ -78,7 +78,7 @@ bool test_assign(int traversal, int unrolling) template<typename Xpr> bool test_redux(const Xpr&, int traversal, int unrolling) { - typedef ei_redux_traits<ei_scalar_sum_op<typename Xpr::Scalar>,Xpr> traits; + typedef internal::redux_traits<internal::scalar_sum_op<typename Xpr::Scalar>,Xpr> traits; bool res = traits::Traversal==traversal && traits::Unrolling==unrolling; if(!res) { @@ -90,10 +90,10 @@ bool test_redux(const Xpr&, int traversal, int unrolling) return res; } -template<typename Scalar, bool Enable = ei_packet_traits<Scalar>::Vectorizable> struct vectorization_logic +template<typename Scalar, bool Enable = internal::packet_traits<Scalar>::Vectorizable> struct vectorization_logic { enum { - PacketSize = ei_packet_traits<Scalar>::size + PacketSize = internal::packet_traits<Scalar>::size }; static void run() { @@ -221,7 +221,7 @@ void test_vectorization_logic() vectorization_logic<std::complex<float> >::run(); vectorization_logic<std::complex<double> >::run(); - if(ei_packet_traits<float>::Vectorizable) + if(internal::packet_traits<float>::Vectorizable) { VERIFY(test_assign(Matrix<float,3,3>(),Matrix<float,3,3>()+Matrix<float,3,3>(), LinearTraversal,CompleteUnrolling)); @@ -230,7 +230,7 @@ void test_vectorization_logic() DefaultTraversal,CompleteUnrolling)); } - if(ei_packet_traits<double>::Vectorizable) + if(internal::packet_traits<double>::Vectorizable) { VERIFY(test_assign(Matrix<double,3,3>(),Matrix<double,3,3>()+Matrix<double,3,3>(), LinearTraversal,CompleteUnrolling)); diff --git a/test/visitor.cpp b/test/visitor.cpp index 1ddabc63d..2552c6c26 100644 --- a/test/visitor.cpp +++ b/test/visitor.cpp @@ -38,7 +38,7 @@ template<typename MatrixType> void matrixVisitor(const MatrixType& p) for(Index i = 0; i < m.size(); i++) for(Index i2 = 0; i2 < i; i2++) while(m(i) == m(i2)) // yes, == - m(i) = ei_random<Scalar>(); + m(i) = internal::random<Scalar>(); Scalar minc = Scalar(1000), maxc = Scalar(-1000); Index minrow=0,mincol=0,maxrow=0,maxcol=0; @@ -85,7 +85,7 @@ template<typename VectorType> void vectorVisitor(const VectorType& w) for(Index i = 0; i < size; i++) for(Index i2 = 0; i2 < i; i2++) while(v(i) == v(i2)) // yes, == - v(i) = ei_random<Scalar>(); + v(i) = internal::random<Scalar>(); Scalar minc = Scalar(1000), maxc = Scalar(-1000); Index minidx=0,maxidx=0; 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<adtl::adouble> 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<typename _Scalar> class AlignedVector3; -template<typename _Scalar> struct ei_traits<AlignedVector3<_Scalar> > - : ei_traits<Matrix<_Scalar,3,1,0,4,1> > +namespace internal { +template<typename _Scalar> struct traits<AlignedVector3<_Scalar> > + : traits<Matrix<_Scalar,3,1,0,4,1> > { }; +} template<typename _Scalar> class AlignedVector3 : public MatrixBase<AlignedVector3<_Scalar> > @@ -151,8 +153,8 @@ template<typename _Scalar> 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<typename _Scalar> 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 <fftw3.h> namespace Eigen { # include "src/FFT/ei_fftw_impl.h" - //template <typename T> typedef struct ei_fftw_impl default_fft_impl; this does not work - template <typename T> struct default_fft_impl : public ei_fftw_impl<T> {}; + //template <typename T> typedef struct internal::fftw_impl default_fft_impl; this does not work + template <typename T> struct default_fft_impl : public internal::fftw_impl<T> {}; } #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 <typename T> struct default_fft_impl : public ei_imklfft_impl {}; + template <typename T> 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 <typename T> - struct default_fft_impl : public ei_kissfft_impl<T> {}; + struct default_fft_impl : public internal::kissfft_impl<T> {}; } #endif @@ -115,16 +115,18 @@ namespace Eigen { template<typename T_SrcMat,typename T_FftIfc> struct fft_fwd_proxy; template<typename T_SrcMat,typename T_FftIfc> struct fft_inv_proxy; +namespace internal { template<typename T_SrcMat,typename T_FftIfc> -struct ei_traits< fft_fwd_proxy<T_SrcMat,T_FftIfc> > +struct traits< fft_fwd_proxy<T_SrcMat,T_FftIfc> > { typedef typename T_SrcMat::PlainObject ReturnType; }; template<typename T_SrcMat,typename T_FftIfc> -struct ei_traits< fft_inv_proxy<T_SrcMat,T_FftIfc> > +struct traits< fft_inv_proxy<T_SrcMat,T_FftIfc> > { typedef typename T_SrcMat::PlainObject ReturnType; }; +} template<typename T_SrcMat,typename T_FftIfc> 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<dst_type, Complex>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type<dst_type, Complex>::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<src_type, Complex>::ret), + EIGEN_STATIC_ASSERT((internal::is_same_type<src_type, Complex>::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<mpfr::mpreal>() + namespace internal { + + template<> mpfr::mpreal random<mpfr::mpreal>() { #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<double>()); + return mpfr::mpreal(random<double>()); #endif } - template<> mpfr::mpreal ei_random<mpfr::mpreal>(const mpfr::mpreal& a, const mpfr::mpreal& b) + template<> mpfr::mpreal random<mpfr::mpreal>(const mpfr::mpreal& a, const mpfr::mpreal& b) { - return a + (b-a) * ei_random<mpfr::mpreal>(); + return a + (b-a) * random<mpfr::mpreal>(); } + + } // 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<Derived> MatrixBase<Derived>::matrixFunction(typename ei_stem_function<typename ei_traits<Derived>::Scalar>::type f) const +const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::matrixFunction(typename internal::stem_function<typename internal::traits<Derived>::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<typename XprType, typename Scalar, int Rows, int Cols> \ -struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<XprType,Scalar,Rows,Cols,false> { \ +struct EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)<XprType,Scalar,Rows,Cols,false> { \ inline static void run(const XprType& p) { \ - EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<typename ei_plain_matrix_type_column_major<XprType>::type>::run(p); } \ + EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)<typename internal::plain_matrix_type_column_major<XprType>::type>::run(p); } \ }; \ \ template<typename Derived> inline void FUNC(const Eigen::DenseBase<Derived>& p) { \ - EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<Derived>::run(p.derived()); \ + EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)<Derived>::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)<XprType, SCALAR, ROWS, COLS, true> { \ + template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)<XprType, SCALAR, ROWS, COLS, true> { \ 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)<XprType, SCALAR, SIZE, 1, true> { \ + template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)<XprType, SCALAR, SIZE, 1, true> { \ inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); } \ }; \ - template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<XprType, SCALAR, 1, SIZE, true> { \ + template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)<XprType, SCALAR, 1, SIZE, true> { \ inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); } \ }; @@ -202,6 +202,9 @@ template<typename Derived> void glRotate(const RotationBase<Derived,3>& 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<typename XprType, typename Scalar, int Rows, int Cols> \ -struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<XprType,Scalar,Rows,Cols,false> { \ +struct EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)<XprType,Scalar,Rows,Cols,false> { \ inline static void run(ARG1 a,EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { \ - EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<typename ei_plain_matrix_type_column_major<XprType>::type>::run(a,p); } \ + EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<typename internal::plain_matrix_type_column_major<XprType>::type>::run(a,p); } \ }; \ \ +} // end namespace internal \ + \ template<typename Derived> inline void FUNC(ARG1 a,EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) Eigen::DenseBase<Derived>& p) { \ - EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<Derived>::run(a,p.derived()); \ + EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)<Derived>::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)<XprType, SCALAR, ROWS, COLS, true> { \ +namespace internal { \ + template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, ROWS, COLS, true> { \ 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)<XprType, SCALAR, SIZE, 1, true> { \ +namespace internal { \ + template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, SIZE, 1, true> { \ 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)<XprType, SCALAR, 1, SIZE, true> { \ + template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, 1, SIZE, true> { \ 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<typename A, typename B> -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<typename A, typename B> -void ei_make_coherent(const A& a, const B&b) +void make_coherent(const A& a, const B&b) { - ei_make_coherent_impl<A,B>::run(a.const_cast_derived(), b.const_cast_derived()); + make_coherent_impl<A,B>::run(a.const_cast_derived(), b.const_cast_derived()); } +template<typename _DerType, bool Enable> 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<typename _DerType, bool Enable> struct ei_auto_diff_special_op; - - template<typename _DerType> class AutoDiffScalar - : public ei_auto_diff_special_op - <_DerType, !ei_is_same_type<typename ei_traits<typename ei_cleantype<_DerType>::type>::Scalar, - typename NumTraits<typename ei_traits<typename ei_cleantype<_DerType>::type>::Scalar>::Real>::ret> + : public internal::auto_diff_special_op + <_DerType, !internal::is_same_type<typename internal::traits<typename internal::cleantype<_DerType>::type>::Scalar, + typename NumTraits<typename internal::traits<typename internal::cleantype<_DerType>::type>::Scalar>::Real>::ret> { public: - typedef ei_auto_diff_special_op - <_DerType, !ei_is_same_type<typename ei_traits<typename ei_cleantype<_DerType>::type>::Scalar, - typename NumTraits<typename ei_traits<typename ei_cleantype<_DerType>::type>::Scalar>::Real>::ret> Base; - typedef typename ei_cleantype<_DerType>::type DerType; - typedef typename ei_traits<DerType>::Scalar Scalar; + typedef internal::auto_diff_special_op + <_DerType, !internal::is_same_type<typename internal::traits<typename internal::cleantype<_DerType>::type>::Scalar, + typename NumTraits<typename internal::traits<typename internal::cleantype<_DerType>::type>::Scalar>::Real>::ret> Base; + typedef typename internal::cleantype<_DerType>::type DerType; + typedef typename internal::traits<DerType>::Scalar Scalar; typedef typename NumTraits<Scalar>::Real Real; using Base::operator+; @@ -175,11 +178,11 @@ class AutoDiffScalar } template<typename OtherDerType> - inline const AutoDiffScalar<CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerType,typename ei_cleantype<OtherDerType>::type> > + inline const AutoDiffScalar<CwiseBinaryOp<internal::scalar_sum_op<Scalar>,DerType,typename internal::cleantype<OtherDerType>::type> > operator+(const AutoDiffScalar<OtherDerType>& other) const { - ei_make_coherent(m_derivatives, other.derivatives()); - return AutoDiffScalar<CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerType,typename ei_cleantype<OtherDerType>::type> >( + internal::make_coherent(m_derivatives, other.derivatives()); + return AutoDiffScalar<CwiseBinaryOp<internal::scalar_sum_op<Scalar>,DerType,typename internal::cleantype<OtherDerType>::type> >( m_value + other.value(), m_derivatives + other.derivatives()); } @@ -193,11 +196,11 @@ class AutoDiffScalar } template<typename OtherDerType> - inline const AutoDiffScalar<CwiseBinaryOp<ei_scalar_difference_op<Scalar>, DerType,typename ei_cleantype<OtherDerType>::type> > + inline const AutoDiffScalar<CwiseBinaryOp<internal::scalar_difference_op<Scalar>, DerType,typename internal::cleantype<OtherDerType>::type> > operator-(const AutoDiffScalar<OtherDerType>& other) const { - ei_make_coherent(m_derivatives, other.derivatives()); - return AutoDiffScalar<CwiseBinaryOp<ei_scalar_difference_op<Scalar>, DerType,typename ei_cleantype<OtherDerType>::type> >( + internal::make_coherent(m_derivatives, other.derivatives()); + return AutoDiffScalar<CwiseBinaryOp<internal::scalar_difference_op<Scalar>, DerType,typename internal::cleantype<OtherDerType>::type> >( m_value - other.value(), m_derivatives - other.derivatives()); } @@ -211,105 +214,105 @@ class AutoDiffScalar } template<typename OtherDerType> - inline const AutoDiffScalar<CwiseUnaryOp<ei_scalar_opposite_op<Scalar>, DerType> > + inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, DerType> > operator-() const { - return AutoDiffScalar<CwiseUnaryOp<ei_scalar_opposite_op<Scalar>, DerType> >( + return AutoDiffScalar<CwiseUnaryOp<internal::scalar_opposite_op<Scalar>, DerType> >( -m_value, -m_derivatives); } - inline const AutoDiffScalar<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType> > + inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, DerType> > operator*(const Scalar& other) const { - return AutoDiffScalar<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType> >( + return AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, DerType> >( m_value * other, (m_derivatives * other)); } - friend inline const AutoDiffScalar<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType> > + friend inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, DerType> > operator*(const Scalar& other, const AutoDiffScalar& a) { - return AutoDiffScalar<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType> >( + return AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, DerType> >( a.value() * other, a.derivatives() * other); } -// inline const AutoDiffScalar<typename CwiseUnaryOp<ei_scalar_multiple_op<Real>, DerType>::Type > +// inline const AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type > // operator*(const Real& other) const // { -// return AutoDiffScalar<typename CwiseUnaryOp<ei_scalar_multiple_op<Real>, DerType>::Type >( +// return AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >( // m_value * other, // (m_derivatives * other)); // } // -// friend inline const AutoDiffScalar<typename CwiseUnaryOp<ei_scalar_multiple_op<Real>, DerType>::Type > +// friend inline const AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type > // operator*(const Real& other, const AutoDiffScalar& a) // { -// return AutoDiffScalar<typename CwiseUnaryOp<ei_scalar_multiple_op<Real>, DerType>::Type >( +// return AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >( // a.value() * other, // a.derivatives() * other); // } - inline const AutoDiffScalar<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType> > + inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, DerType> > operator/(const Scalar& other) const { - return AutoDiffScalar<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType> >( + return AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, DerType> >( m_value / other, (m_derivatives * (Scalar(1)/other))); } - friend inline const AutoDiffScalar<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType> > + friend inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, DerType> > operator/(const Scalar& other, const AutoDiffScalar& a) { - return AutoDiffScalar<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType> >( + return AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, DerType> >( other / a.value(), a.derivatives() * (-Scalar(1)/other)); } -// inline const AutoDiffScalar<typename CwiseUnaryOp<ei_scalar_multiple_op<Real>, DerType>::Type > +// inline const AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type > // operator/(const Real& other) const // { -// return AutoDiffScalar<typename CwiseUnaryOp<ei_scalar_multiple_op<Real>, DerType>::Type >( +// return AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >( // m_value / other, // (m_derivatives * (Real(1)/other))); // } // -// friend inline const AutoDiffScalar<typename CwiseUnaryOp<ei_scalar_multiple_op<Real>, DerType>::Type > +// friend inline const AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type > // operator/(const Real& other, const AutoDiffScalar& a) // { -// return AutoDiffScalar<typename CwiseUnaryOp<ei_scalar_multiple_op<Real>, DerType>::Type >( +// return AutoDiffScalar<typename CwiseUnaryOp<internal::scalar_multiple_op<Real>, DerType>::Type >( // other / a.value(), // a.derivatives() * (-Real(1)/other)); // } template<typename OtherDerType> - inline const AutoDiffScalar<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, - CwiseBinaryOp<ei_scalar_difference_op<Scalar>, - CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType>, - CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, typename ei_cleantype<OtherDerType>::type > > > > + inline const AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, + CwiseBinaryOp<internal::scalar_difference_op<Scalar>, + CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, DerType>, + CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, typename internal::cleantype<OtherDerType>::type > > > > operator/(const AutoDiffScalar<OtherDerType>& other) const { - ei_make_coherent(m_derivatives, other.derivatives()); - return AutoDiffScalar<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, - CwiseBinaryOp<ei_scalar_difference_op<Scalar>, - CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType>, - CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, typename ei_cleantype<OtherDerType>::type > > > >( + internal::make_coherent(m_derivatives, other.derivatives()); + return AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, + CwiseBinaryOp<internal::scalar_difference_op<Scalar>, + CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, DerType>, + CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, typename internal::cleantype<OtherDerType>::type > > > >( m_value / other.value(), ((m_derivatives * other.value()) - (m_value * other.derivatives())) * (Scalar(1)/(other.value()*other.value()))); } template<typename OtherDerType> - inline const AutoDiffScalar<CwiseBinaryOp<ei_scalar_sum_op<Scalar>, - CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType>, - CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, typename ei_cleantype<OtherDerType>::type> > > + inline const AutoDiffScalar<CwiseBinaryOp<internal::scalar_sum_op<Scalar>, + CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, DerType>, + CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, typename internal::cleantype<OtherDerType>::type> > > operator*(const AutoDiffScalar<OtherDerType>& other) const { - ei_make_coherent(m_derivatives, other.derivatives()); - return AutoDiffScalar<CwiseBinaryOp<ei_scalar_sum_op<Scalar>, - CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType>, - CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, typename ei_cleantype<OtherDerType>::type > > >( + internal::make_coherent(m_derivatives, other.derivatives()); + return AutoDiffScalar<CwiseBinaryOp<internal::scalar_sum_op<Scalar>, + CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, DerType>, + CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, typename internal::cleantype<OtherDerType>::type > > >( m_value * other.value(), (m_derivatives * other.value()) + (m_value * other.derivatives())); } @@ -333,18 +336,19 @@ class AutoDiffScalar }; +namespace internal { template<typename _DerType> -struct ei_auto_diff_special_op<_DerType, true> -// : ei_auto_diff_scalar_op<_DerType, typename NumTraits<Scalar>::Real, -// ei_is_same_type<Scalar,typename NumTraits<Scalar>::Real>::ret> +struct auto_diff_special_op<_DerType, true> +// : auto_diff_scalar_op<_DerType, typename NumTraits<Scalar>::Real, +// is_same_type<Scalar,typename NumTraits<Scalar>::Real>::ret> { - typedef typename ei_cleantype<_DerType>::type DerType; - typedef typename ei_traits<DerType>::Scalar Scalar; + typedef typename cleantype<_DerType>::type DerType; + typedef typename traits<DerType>::Scalar Scalar; typedef typename NumTraits<Scalar>::Real Real; -// typedef ei_auto_diff_scalar_op<_DerType, typename NumTraits<Scalar>::Real, -// ei_is_same_type<Scalar,typename NumTraits<Scalar>::Real>::ret> Base; +// typedef auto_diff_scalar_op<_DerType, typename NumTraits<Scalar>::Real, +// is_same_type<Scalar,typename NumTraits<Scalar>::Real>::ret> Base; // using Base::operator+; // using Base::operator+=; @@ -374,18 +378,18 @@ struct ei_auto_diff_special_op<_DerType, true> } - inline const AutoDiffScalar<typename CwiseUnaryOp<ei_scalar_multiple2_op<Scalar,Real>, DerType>::Type > + inline const AutoDiffScalar<typename CwiseUnaryOp<scalar_multiple2_op<Scalar,Real>, DerType>::Type > operator*(const Real& other) const { - return AutoDiffScalar<typename CwiseUnaryOp<ei_scalar_multiple2_op<Scalar,Real>, DerType>::Type >( + return AutoDiffScalar<typename CwiseUnaryOp<scalar_multiple2_op<Scalar,Real>, DerType>::Type >( derived().value() * other, derived().derivatives() * other); } - friend inline const AutoDiffScalar<typename CwiseUnaryOp<ei_scalar_multiple2_op<Scalar,Real>, DerType>::Type > + friend inline const AutoDiffScalar<typename CwiseUnaryOp<scalar_multiple2_op<Scalar,Real>, DerType>::Type > operator*(const Real& other, const AutoDiffScalar<_DerType>& a) { - return AutoDiffScalar<typename CwiseUnaryOp<ei_scalar_multiple2_op<Scalar,Real>, DerType>::Type >( + return AutoDiffScalar<typename CwiseUnaryOp<scalar_multiple2_op<Scalar,Real>, DerType>::Type >( a.value() * other, a.derivatives() * other); } @@ -398,7 +402,7 @@ struct ei_auto_diff_special_op<_DerType, true> }; template<typename _DerType> -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<typename A_Scalar, int A_Rows, int A_Cols, int A_Options, int A_MaxRows, int A_MaxCols, typename B> -struct ei_make_coherent_impl<Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols>, B> { +struct make_coherent_impl<Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols>, B> { typedef Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols> 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<Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRo }; template<typename A, typename B_Scalar, int B_Rows, int B_Cols, int B_Options, int B_MaxRows, int B_MaxCols> -struct ei_make_coherent_impl<A, Matrix<B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols> > { +struct make_coherent_impl<A, Matrix<B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols> > { typedef Matrix<B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols> 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<A, Matrix<B_Scalar, B_Rows, B_Cols, B_Options, B_Ma template<typename A_Scalar, int A_Rows, int A_Cols, int A_Options, int A_MaxRows, int A_MaxCols, typename B_Scalar, int B_Rows, int B_Cols, int B_Options, int B_MaxRows, int B_MaxCols> -struct ei_make_coherent_impl<Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols>, +struct make_coherent_impl<Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols>, Matrix<B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols> > { typedef Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols> A; typedef Matrix<B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols> B; @@ -449,31 +453,33 @@ struct ei_make_coherent_impl<Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRo } }; -template<typename A_Scalar, int A_Rows, int A_Cols, int A_Options, int A_MaxRows, int A_MaxCols> struct ei_scalar_product_traits<Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols>,A_Scalar> +template<typename A_Scalar, int A_Rows, int A_Cols, int A_Options, int A_MaxRows, int A_MaxCols> struct scalar_product_traits<Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols>,A_Scalar> { typedef Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols> ReturnType; }; -template<typename A_Scalar, int A_Rows, int A_Cols, int A_Options, int A_MaxRows, int A_MaxCols> struct ei_scalar_product_traits<A_Scalar, Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols> > +template<typename A_Scalar, int A_Rows, int A_Cols, int A_Options, int A_MaxRows, int A_MaxCols> struct scalar_product_traits<A_Scalar, Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols> > { typedef Matrix<A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols> ReturnType; }; template<typename DerType, typename T> -struct ei_scalar_product_traits<AutoDiffScalar<DerType>,T> +struct scalar_product_traits<AutoDiffScalar<DerType>,T> { typedef AutoDiffScalar<DerType> ReturnType; }; -} +} // end namespace internal + +} // end namespace Eigen #define EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY(FUNC,CODE) \ template<typename DerType> \ - inline const Eigen::AutoDiffScalar<Eigen::CwiseUnaryOp<Eigen::ei_scalar_multiple_op<typename Eigen::ei_traits<typename Eigen::ei_cleantype<DerType>::type>::Scalar>, typename Eigen::ei_cleantype<DerType>::type> > \ + inline const Eigen::AutoDiffScalar<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<typename Eigen::internal::traits<typename Eigen::internal::cleantype<DerType>::type>::Scalar>, typename Eigen::internal::cleantype<DerType>::type> > \ FUNC(const Eigen::AutoDiffScalar<DerType>& x) { \ using namespace Eigen; \ - typedef typename ei_traits<typename ei_cleantype<DerType>::type>::Scalar Scalar; \ - typedef AutoDiffScalar<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, typename ei_cleantype<DerType>::type> > ReturnType; \ + typedef typename internal::traits<typename internal::cleantype<DerType>::type>::Scalar Scalar; \ + typedef AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, typename internal::cleantype<DerType>::type> > ReturnType; \ CODE; \ } @@ -500,12 +506,12 @@ namespace std return ReturnType(std::log(x.value()),x.derivatives() * (Scalar(1)/x.value()));) template<typename DerType> - inline const Eigen::AutoDiffScalar<Eigen::CwiseUnaryOp<Eigen::ei_scalar_multiple_op<typename Eigen::ei_traits<DerType>::Scalar>, DerType> > - pow(const Eigen::AutoDiffScalar<DerType>& x, typename Eigen::ei_traits<DerType>::Scalar y) + inline const Eigen::AutoDiffScalar<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<typename Eigen::internal::traits<DerType>::Scalar>, DerType> > + pow(const Eigen::AutoDiffScalar<DerType>& x, typename Eigen::internal::traits<DerType>::Scalar y) { using namespace Eigen; - typedef typename ei_traits<DerType>::Scalar Scalar; - return AutoDiffScalar<CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, DerType> >( + typedef typename internal::traits<DerType>::Scalar Scalar; + return AutoDiffScalar<CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, 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<typename DerType> -inline const AutoDiffScalar<DerType>& ei_conj(const AutoDiffScalar<DerType>& x) { return x; } +inline const AutoDiffScalar<DerType>& conj(const AutoDiffScalar<DerType>& x) { return x; } template<typename DerType> -inline const AutoDiffScalar<DerType>& ei_real(const AutoDiffScalar<DerType>& x) { return x; } +inline const AutoDiffScalar<DerType>& real(const AutoDiffScalar<DerType>& x) { return x; } template<typename DerType> -inline typename DerType::Scalar ei_imag(const AutoDiffScalar<DerType>&) { return 0.; } +inline typename DerType::Scalar imag(const AutoDiffScalar<DerType>&) { 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<typename DerType> -inline const AutoDiffScalar<CwiseUnaryOp<ei_scalar_multiple_op<typename ei_traits<DerType>::Scalar>, DerType> > -ei_pow(const AutoDiffScalar<DerType>& x, typename ei_traits<DerType>::Scalar y) +inline const AutoDiffScalar<CwiseUnaryOp<scalar_multiple_op<typename traits<DerType>::Scalar>, DerType> > +pow(const AutoDiffScalar<DerType>& x, typename traits<DerType>::Scalar y) { return std::pow(x,y);} +} // end namespace internal + #undef EIGEN_AUTODIFF_DECLARE_GLOBAL_UNARY template<typename DerType> struct NumTraits<AutoDiffScalar<DerType> > 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<typename ValueType, typename JacobianType> class AutoDiffVector { public: - //typedef typename ei_traits<ValueType>::Scalar Scalar; - typedef typename ei_traits<ValueType>::Scalar BaseScalar; + //typedef typename internal::traits<ValueType>::Scalar Scalar; + typedef typename internal::traits<ValueType>::Scalar BaseScalar; typedef AutoDiffScalar<Matrix<BaseScalar,JacobianType::RowsAtCompileTime,1> > ActiveScalar; typedef ActiveScalar Scalar; typedef AutoDiffScalar<typename JacobianType::ColXpr> CoeffType; @@ -115,13 +115,13 @@ class AutoDiffVector template<typename OtherValueType,typename OtherJacobianType> inline const AutoDiffVector< - typename MakeCwiseBinaryOp<ei_scalar_sum_op<BaseScalar>,ValueType,OtherValueType>::Type, - typename MakeCwiseBinaryOp<ei_scalar_sum_op<BaseScalar>,JacobianType,OtherJacobianType>::Type > + typename MakeCwiseBinaryOp<internal::scalar_sum_op<BaseScalar>,ValueType,OtherValueType>::Type, + typename MakeCwiseBinaryOp<internal::scalar_sum_op<BaseScalar>,JacobianType,OtherJacobianType>::Type > operator+(const AutoDiffVector<OtherValueType,OtherJacobianType>& other) const { return AutoDiffVector< - typename MakeCwiseBinaryOp<ei_scalar_sum_op<BaseScalar>,ValueType,OtherValueType>::Type, - typename MakeCwiseBinaryOp<ei_scalar_sum_op<BaseScalar>,JacobianType,OtherJacobianType>::Type >( + typename MakeCwiseBinaryOp<internal::scalar_sum_op<BaseScalar>,ValueType,OtherValueType>::Type, + typename MakeCwiseBinaryOp<internal::scalar_sum_op<BaseScalar>,JacobianType,OtherJacobianType>::Type >( m_values + other.values(), m_jacobian + other.jacobian()); } @@ -137,13 +137,13 @@ class AutoDiffVector template<typename OtherValueType,typename OtherJacobianType> inline const AutoDiffVector< - typename MakeCwiseBinaryOp<ei_scalar_difference_op<Scalar>,ValueType,OtherValueType>::Type, - typename MakeCwiseBinaryOp<ei_scalar_difference_op<Scalar>,JacobianType,OtherJacobianType>::Type > + typename MakeCwiseBinaryOp<internal::scalar_difference_op<Scalar>,ValueType,OtherValueType>::Type, + typename MakeCwiseBinaryOp<internal::scalar_difference_op<Scalar>,JacobianType,OtherJacobianType>::Type > operator-(const AutoDiffVector<OtherValueType,OtherJacobianType>& other) const { return AutoDiffVector< - typename MakeCwiseBinaryOp<ei_scalar_difference_op<Scalar>,ValueType,OtherValueType>::Type, - typename MakeCwiseBinaryOp<ei_scalar_difference_op<Scalar>,JacobianType,OtherJacobianType>::Type >( + typename MakeCwiseBinaryOp<internal::scalar_difference_op<Scalar>,ValueType,OtherValueType>::Type, + typename MakeCwiseBinaryOp<internal::scalar_difference_op<Scalar>,JacobianType,OtherJacobianType>::Type >( m_values - other.values(), m_jacobian - other.jacobian()); } @@ -158,54 +158,54 @@ class AutoDiffVector } inline const AutoDiffVector< - typename MakeCwiseUnaryOp<ei_scalar_opposite_op<Scalar>, ValueType>::Type, - typename MakeCwiseUnaryOp<ei_scalar_opposite_op<Scalar>, JacobianType>::Type > + typename MakeCwiseUnaryOp<internal::scalar_opposite_op<Scalar>, ValueType>::Type, + typename MakeCwiseUnaryOp<internal::scalar_opposite_op<Scalar>, JacobianType>::Type > operator-() const { return AutoDiffVector< - typename MakeCwiseUnaryOp<ei_scalar_opposite_op<Scalar>, ValueType>::Type, - typename MakeCwiseUnaryOp<ei_scalar_opposite_op<Scalar>, JacobianType>::Type >( + typename MakeCwiseUnaryOp<internal::scalar_opposite_op<Scalar>, ValueType>::Type, + typename MakeCwiseUnaryOp<internal::scalar_opposite_op<Scalar>, JacobianType>::Type >( -m_values, -m_jacobian); } inline const AutoDiffVector< - typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, ValueType>::Type, - typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, JacobianType>::Type> + typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, ValueType>::Type, + typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, JacobianType>::Type> operator*(const BaseScalar& other) const { return AutoDiffVector< - typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, ValueType>::Type, - typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, JacobianType>::Type >( + typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, ValueType>::Type, + typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, JacobianType>::Type >( m_values * other, m_jacobian * other); } friend inline const AutoDiffVector< - typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, ValueType>::Type, - typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, JacobianType>::Type > + typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, ValueType>::Type, + typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, JacobianType>::Type > operator*(const Scalar& other, const AutoDiffVector& v) { return AutoDiffVector< - typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, ValueType>::Type, - typename MakeCwiseUnaryOp<ei_scalar_multiple_op<Scalar>, JacobianType>::Type >( + typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, ValueType>::Type, + typename MakeCwiseUnaryOp<internal::scalar_multiple_op<Scalar>, JacobianType>::Type >( v.values() * other, v.jacobian() * other); } // template<typename OtherValueType,typename OtherJacobianType> // inline const AutoDiffVector< -// CwiseBinaryOp<ei_scalar_multiple_op<Scalar>, ValueType, OtherValueType> -// CwiseBinaryOp<ei_scalar_sum_op<Scalar>, -// CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, JacobianType>, -// CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, OtherJacobianType> > > +// CwiseBinaryOp<internal::scalar_multiple_op<Scalar>, ValueType, OtherValueType> +// CwiseBinaryOp<internal::scalar_sum_op<Scalar>, +// CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, JacobianType>, +// CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, OtherJacobianType> > > // operator*(const AutoDiffVector<OtherValueType,OtherJacobianType>& other) const // { // return AutoDiffVector< -// CwiseBinaryOp<ei_scalar_multiple_op<Scalar>, ValueType, OtherValueType> -// CwiseBinaryOp<ei_scalar_sum_op<Scalar>, -// CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, JacobianType>, -// CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, OtherJacobianType> > >( +// CwiseBinaryOp<internal::scalar_multiple_op<Scalar>, ValueType, OtherValueType> +// CwiseBinaryOp<internal::scalar_sum_op<Scalar>, +// CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, JacobianType>, +// CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, 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<typename BVH, typename Intersector> -void BVIntersect(const BVH &tree, Intersector &intersector) -{ - ei_intersect_helper(tree, intersector, tree.getRootIndex()); -} +namespace internal { #ifndef EIGEN_PARSED_BY_DOXYGEN template<typename BVH, typename Intersector> -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<typename Volume1, typename Object1, typename Object2, typename Intersector> -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<typename Volume2, typename Object2, typename Object1, typename Intersector> -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<typename BVH, typename Intersector> +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<typename BVH1::Volume, typename BVH1::Object, typename BVH2::Object, Intersector> Helper1; - typedef ei_intersector_helper2<typename BVH2::Volume, typename BVH2::Object, typename BVH1::Object, Intersector> Helper2; + typedef internal::intersector_helper1<typename BVH1::Volume, typename BVH1::Object, typename BVH2::Object, Intersector> Helper1; + typedef internal::intersector_helper2<typename BVH2::Volume, typename BVH2::Object, typename BVH1::Object, Intersector> 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 BVH, typename Minimizer> -typename Minimizer::Scalar BVMinimize(const BVH &tree, Minimizer &minimizer) -{ - return ei_minimize_helper(tree, minimizer, tree.getRootIndex(), std::numeric_limits<typename Minimizer::Scalar>::max()); -} +namespace internal { #ifndef EIGEN_PARSED_BY_DOXYGEN template<typename BVH, typename Minimizer> -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<typename Volume1, typename Object1, typename Object2, typename Minimizer> -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<typename Volume2, typename Object2, typename Object1, typename Minimizer> -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 BVH, typename Minimizer> +typename Minimizer::Scalar BVMinimize(const BVH &tree, Minimizer &minimizer) +{ + return internal::minimize_helper(tree, minimizer, tree.getRootIndex(), std::numeric_limits<typename Minimizer::Scalar>::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<typename BVH1::Volume, typename BVH1::Object, typename BVH2::Object, Minimizer> Helper1; - typedef ei_minimizer_helper2<typename BVH2::Volume, typename BVH2::Object, typename BVH1::Object, Minimizer> Helper2; + typedef internal::minimizer_helper1<typename BVH1::Volume, typename BVH1::Object, typename BVH2::Object, Minimizer> Helper1; + typedef internal::minimizer_helper2<typename BVH2::Volume, typename BVH2::Object, typename BVH1::Object, Minimizer> Helper2; typedef std::pair<Scalar, std::pair<Index1, Index2> > 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<typename Scalar, int Dim> -struct ei_vector_int_pair +struct vector_int_pair { EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar, Dim) typedef Matrix<Scalar, Dim, 1> 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<typename ObjectList, typename VolumeList, typename BoxIter> -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<typename ObjectList, typename VolumeList> -struct ei_get_boxes_helper<ObjectList, VolumeList, int> { +struct get_boxes_helper<ObjectList, VolumeList, int> { 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<typename Iter> 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<typename OIter, typename BIter> 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<typename Iter> 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<ObjectList, VolumeList, BIter>()(objects, boxBegin, boxEnd, objBoxes); + internal::get_boxes_helper<ObjectList, VolumeList, BIter>()(objects, boxBegin, boxEnd, objBoxes); objCenters.reserve(n); boxes.reserve(n - 1); @@ -176,7 +180,7 @@ public: } private: - typedef ei_vector_int_pair<Scalar, Dim> VIPair; + typedef internal::vector_int_pair<Scalar, Dim> VIPair; typedef std::vector<VIPair, aligned_allocator<VIPair> > VIPairList; typedef Matrix<Scalar, Dim, 1> 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 <http://www.gnu.org/licenses/>. - +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<T> layout is array of size 2 with real,imag template <typename T> inline - T * ei_fftw_cast(const T* p) + T * fftw_cast(const T* p) { return const_cast<T*>( p); } inline - fftw_complex * ei_fftw_cast( const std::complex<double> * p) + fftw_complex * fftw_cast( const std::complex<double> * p) { return const_cast<fftw_complex*>( reinterpret_cast<const fftw_complex*>(p) ); } inline - fftwf_complex * ei_fftw_cast( const std::complex<float> * p) + fftwf_complex * fftw_cast( const std::complex<float> * p) { return const_cast<fftwf_complex*>( reinterpret_cast<const fftwf_complex*>(p) ); } inline - fftwl_complex * ei_fftw_cast( const std::complex<long double> * p) + fftwl_complex * fftw_cast( const std::complex<long double> * p) { return const_cast<fftwl_complex*>( reinterpret_cast<const fftwl_complex*>(p) ); } template <typename T> - struct ei_fftw_plan {}; + struct fftw_plan {}; template <> - struct ei_fftw_plan<float> + struct fftw_plan<float> { 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<double> + struct fftw_plan<double> { 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<long double> + struct fftw_plan<long double> { 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 <typename _Scalar> - struct ei_fftw_impl + struct fftw_impl { typedef _Scalar Scalar; typedef std::complex<Scalar> 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<Scalar> PlanData; + typedef fftw_plan<Scalar> PlanData; typedef std::map<int64_t,PlanData> 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 <http://www.gnu.org/licenses/>. - +namespace internal { // This FFT implementation was derived from kissfft http:sourceforge.net/projects/kissfft // Copyright 2003-2009 Mark Borgerding template <typename _Scalar> -struct ei_kiss_cpx_fft +struct kiss_cpx_fft { typedef _Scalar Scalar; typedef std::complex<Scalar> Complex; @@ -274,7 +274,7 @@ struct ei_kiss_cpx_fft }; template <typename _Scalar> -struct ei_kissfft_impl +struct kissfft_impl { typedef _Scalar Scalar; typedef std::complex<Scalar> Complex; @@ -378,7 +378,7 @@ struct ei_kissfft_impl } protected: - typedef ei_kiss_cpx_fft<Scalar> PlanData; + typedef kiss_cpx_fft<Scalar> PlanData; typedef std::map<int,PlanData> 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 <Eigen/Core> +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 <typename CMatrix, typename CINVMatrix> -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<typename TMatrix, typename CMatrix, typename VectorX, typename VectorB, typename VectorF> -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<bool> 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<Scalar,RowMajor> 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<MatrixType>::Scalar Scalar; + typedef typename internal::traits<MatrixType>::Scalar Scalar; typedef typename NumTraits<Scalar>::Real RealScalar; /** \brief Reference to matrix whose exponential is to be computed. */ - typename ei_nested<MatrixType>::type m_M; + typename internal::nested<MatrixType>::type m_M; /** \brief Even-degree terms in numerator of Padé approximant. */ MatrixType m_U; @@ -327,16 +327,18 @@ template<typename Derived> struct MatrixExponentialReturnValue MatrixExponentialReturnValue& operator=(const MatrixExponentialReturnValue&); }; +namespace internal { template<typename Derived> -struct ei_traits<MatrixExponentialReturnValue<Derived> > +struct traits<MatrixExponentialReturnValue<Derived> > { typedef typename Derived::PlainObject ReturnType; }; +} template <typename Derived> const MatrixExponentialReturnValue<Derived> MatrixBase<Derived>::exp() const { - ei_assert(rows() == cols()); + eigen_assert(rows() == cols()); return MatrixExponentialReturnValue<Derived>(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 <typename MatrixType, int IsComplex = NumTraits<typename ei_traits<MatrixType>::Scalar>::IsComplex> +template <typename MatrixType, int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex> class MatrixFunction { private: - typedef typename ei_traits<MatrixType>::Index Index; - typedef typename ei_traits<MatrixType>::Scalar Scalar; - typedef typename ei_stem_function<Scalar>::type StemFunction; + typedef typename internal::traits<MatrixType>::Index Index; + typedef typename internal::traits<MatrixType>::Scalar Scalar; + typedef typename internal::stem_function<Scalar>::type StemFunction; public: @@ -76,7 +76,7 @@ class MatrixFunction<MatrixType, 0> { private: - typedef ei_traits<MatrixType> Traits; + typedef internal::traits<MatrixType> Traits; typedef typename Traits::Scalar Scalar; static const int Rows = Traits::RowsAtCompileTime; static const int Cols = Traits::ColsAtCompileTime; @@ -86,7 +86,7 @@ class MatrixFunction<MatrixType, 0> typedef std::complex<Scalar> ComplexScalar; typedef Matrix<ComplexScalar, Rows, Cols, Options, MaxRows, MaxCols> ComplexMatrix; - typedef typename ei_stem_function<Scalar>::type StemFunction; + typedef typename internal::stem_function<Scalar>::type StemFunction; public: @@ -117,7 +117,7 @@ class MatrixFunction<MatrixType, 0> } private: - typename ei_nested<MatrixType>::type m_A; /**< \brief Reference to argument of matrix function. */ + typename internal::nested<MatrixType>::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<MatrixType, 1> { private: - typedef ei_traits<MatrixType> Traits; + typedef internal::traits<MatrixType> 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<Scalar>::Real RealScalar; - typedef typename ei_stem_function<Scalar>::type StemFunction; + typedef typename internal::stem_function<Scalar>::type StemFunction; typedef Matrix<Scalar, Traits::RowsAtCompileTime, 1> VectorType; typedef Matrix<Index, Traits::RowsAtCompileTime, 1> IntVectorType; typedef Matrix<Index, Dynamic, 1> DynamicIntVectorType; @@ -167,7 +167,7 @@ class MatrixFunction<MatrixType, 1> void computeOffDiagonal(); DynMatrixType solveTriangularSylvester(const DynMatrixType& A, const DynMatrixType& B, const DynMatrixType& C); - typename ei_nested<MatrixType>::type m_A; /**< \brief Reference to argument of matrix function. */ + typename internal::nested<MatrixType>::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<MatrixType,1>::partitionEigenvalues() // Look for other element to add to the set for (Index j=i+1; j<rows; ++j) { - if (ei_abs(diag(j) - diag(i)) <= separation() && std::find(qi->begin(), 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<MatrixType,1>::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<MatrixType,1>::DynMatrixType MatrixFunction<MatrixType,1 const DynMatrixType& B, const DynMatrixType& C) { - ei_assert(A.rows() == A.cols()); - ei_assert(A.isUpperTriangular()); - ei_assert(B.rows() == B.cols()); - ei_assert(B.isUpperTriangular()); - ei_assert(C.rows() == A.rows()); - ei_assert(C.cols() == B.rows()); + eigen_assert(A.rows() == A.cols()); + eigen_assert(A.isUpperTriangular()); + eigen_assert(B.rows() == B.cols()); + eigen_assert(B.isUpperTriangular()); + eigen_assert(C.rows() == A.rows()); + eigen_assert(C.cols() == B.rows()); Index m = A.rows(); Index n = B.rows(); @@ -502,7 +502,7 @@ template<typename Derived> class MatrixFunctionReturnValue typedef typename Derived::Scalar Scalar; typedef typename Derived::Index Index; - typedef typename ei_stem_function<Scalar>::type StemFunction; + typedef typename internal::stem_function<Scalar>::type StemFunction; /** \brief Constructor. * @@ -529,58 +529,60 @@ template<typename Derived> class MatrixFunctionReturnValue Index cols() const { return m_A.cols(); } private: - typename ei_nested<Derived>::type m_A; + typename internal::nested<Derived>::type m_A; StemFunction *m_f; MatrixFunctionReturnValue& operator=(const MatrixFunctionReturnValue&); }; +namespace internal { template<typename Derived> -struct ei_traits<MatrixFunctionReturnValue<Derived> > +struct traits<MatrixFunctionReturnValue<Derived> > { typedef typename Derived::PlainObject ReturnType; }; +} /********** MatrixBase methods **********/ template <typename Derived> -const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::matrixFunction(typename ei_stem_function<typename ei_traits<Derived>::Scalar>::type f) const +const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::matrixFunction(typename internal::stem_function<typename internal::traits<Derived>::Scalar>::type f) const { - ei_assert(rows() == cols()); + eigen_assert(rows() == cols()); return MatrixFunctionReturnValue<Derived>(derived(), f); } template <typename Derived> const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::sin() const { - ei_assert(rows() == cols()); - typedef typename ei_stem_function<Scalar>::ComplexScalar ComplexScalar; + eigen_assert(rows() == cols()); + typedef typename internal::stem_function<Scalar>::ComplexScalar ComplexScalar; return MatrixFunctionReturnValue<Derived>(derived(), StdStemFunctions<ComplexScalar>::sin); } template <typename Derived> const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::cos() const { - ei_assert(rows() == cols()); - typedef typename ei_stem_function<Scalar>::ComplexScalar ComplexScalar; + eigen_assert(rows() == cols()); + typedef typename internal::stem_function<Scalar>::ComplexScalar ComplexScalar; return MatrixFunctionReturnValue<Derived>(derived(), StdStemFunctions<ComplexScalar>::cos); } template <typename Derived> const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::sinh() const { - ei_assert(rows() == cols()); - typedef typename ei_stem_function<Scalar>::ComplexScalar ComplexScalar; + eigen_assert(rows() == cols()); + typedef typename internal::stem_function<Scalar>::ComplexScalar ComplexScalar; return MatrixFunctionReturnValue<Derived>(derived(), StdStemFunctions<ComplexScalar>::sinh); } template <typename Derived> const MatrixFunctionReturnValue<Derived> MatrixBase<Derived>::cosh() const { - ei_assert(rows() == cols()); - typedef typename ei_stem_function<Scalar>::ComplexScalar ComplexScalar; + eigen_assert(rows() == cols()); + typedef typename internal::stem_function<Scalar>::ComplexScalar ComplexScalar; return MatrixFunctionReturnValue<Derived>(derived(), StdStemFunctions<ComplexScalar>::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<Scalar>::Real RealScalar; - typedef typename ei_stem_function<Scalar>::type StemFunction; + typedef typename internal::stem_function<Scalar>::type StemFunction; typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType; /** \brief Constructor @@ -99,7 +99,7 @@ MatrixType MatrixFunctionAtomic<MatrixType>::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<typename Packet> inline static Packet ei_pasin(Packet a) { return std::asin(a); } +template<typename Packet> 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<Scalar>::epsilon())) + , xtol(internal::sqrt(NumTraits<Scalar>::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<Scalar>::epsilon()) + const Scalar tol = internal::sqrt(NumTraits<Scalar>::epsilon()) ); HybridNonLinearSolverSpace::Status solveInit(FVectorType &x); @@ -92,7 +92,7 @@ public: HybridNonLinearSolverSpace::Status hybrd1( FVectorType &x, - const Scalar tol = ei_sqrt(NumTraits<Scalar>::epsilon()) + const Scalar tol = internal::sqrt(NumTraits<Scalar>::epsilon()) ); HybridNonLinearSolverSpace::Status solveNumericalDiffInit(FVectorType &x); @@ -246,7 +246,7 @@ HybridNonLinearSolver<FunctorType,Scalar>::solveOneStep(FVectorType &x) while (true) { /* determine the direction p. */ - ei_dogleg<Scalar>(R, diag, qtf, delta, wa1); + internal::dogleg<Scalar>(R, diag, qtf, delta, wa1); /* store the direction p and x + p. calculate the norm of p. */ wa1 = -wa1; @@ -266,14 +266,14 @@ HybridNonLinearSolver<FunctorType,Scalar>::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<Upper>()*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<FunctorType,Scalar>::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<FunctorType,Scalar>::solveOneStep(FVectorType &x) wa2 = (wa2-wa3)/pnorm; /* compute the qr factorization of the updated jacobian. */ - ei_r1updt<Scalar>(R, wa1, v_givens, w_givens, wa2, wa3, &sing); - ei_r1mpyq<Scalar>(n, n, fjac.data(), v_givens, w_givens); - ei_r1mpyq<Scalar>(1, n, qtf.data(), v_givens, w_givens); + internal::r1updt<Scalar>(R, wa1, v_givens, w_givens, wa2, wa3, &sing); + internal::r1mpyq<Scalar>(n, n, fjac.data(), v_givens, w_givens); + internal::r1mpyq<Scalar>(1, n, qtf.data(), v_givens, w_givens); jeval = false; } @@ -447,7 +447,7 @@ HybridNonLinearSolver<FunctorType,Scalar>::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<FunctorType,Scalar>::solveNumericalDiffOneStep(FVectorType while (true) { /* determine the direction p. */ - ei_dogleg<Scalar>(R, diag, qtf, delta, wa1); + internal::dogleg<Scalar>(R, diag, qtf, delta, wa1); /* store the direction p and x + p. calculate the norm of p. */ wa1 = -wa1; @@ -507,14 +507,14 @@ HybridNonLinearSolver<FunctorType,Scalar>::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<Upper>()*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<FunctorType,Scalar>::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<FunctorType,Scalar>::solveNumericalDiffOneStep(FVectorType wa2 = (wa2-wa3)/pnorm; /* compute the qr factorization of the updated jacobian. */ - ei_r1updt<Scalar>(R, wa1, v_givens, w_givens, wa2, wa3, &sing); - ei_r1mpyq<Scalar>(n, n, fjac.data(), v_givens, w_givens); - ei_r1mpyq<Scalar>(1, n, qtf.data(), v_givens, w_givens); + internal::r1updt<Scalar>(R, wa1, v_givens, w_givens, wa2, wa3, &sing); + internal::r1mpyq<Scalar>(n, n, fjac.data(), v_givens, w_givens); + internal::r1mpyq<Scalar>(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<Scalar>::epsilon())) - , xtol(ei_sqrt(NumTraits<Scalar>::epsilon())) + , ftol(internal::sqrt(NumTraits<Scalar>::epsilon())) + , xtol(internal::sqrt(NumTraits<Scalar>::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<Scalar>::epsilon()) + const Scalar tol = internal::sqrt(NumTraits<Scalar>::epsilon()) ); LevenbergMarquardtSpace::Status minimize(FVectorType &x); @@ -97,12 +97,12 @@ public: FunctorType &functor, FVectorType &x, Index *nfev, - const Scalar tol = ei_sqrt(NumTraits<Scalar>::epsilon()) + const Scalar tol = internal::sqrt(NumTraits<Scalar>::epsilon()) ); LevenbergMarquardtSpace::Status lmstr1( FVectorType &x, - const Scalar tol = ei_sqrt(NumTraits<Scalar>::epsilon()) + const Scalar tol = internal::sqrt(NumTraits<Scalar>::epsilon()) ); LevenbergMarquardtSpace::Status minimizeOptimumStorage(FVectorType &x); @@ -263,7 +263,7 @@ LevenbergMarquardt<FunctorType,Scalar>::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<FunctorType,Scalar>::minimizeOneStep(FVectorType &x) do { /* determine the levenberg-marquardt parameter. */ - ei_lmpar2<Scalar>(qrfac, diag, qtf, delta, par, wa1); + internal::lmpar2<Scalar>(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<FunctorType,Scalar>::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<Upper>() * (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<FunctorType,Scalar>::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<FunctorType,Scalar>::minimizeOneStep(FVectorType &x) /* tests for termination and stringent tolerances. */ if (nfev >= parameters.maxfev) return LevenbergMarquardtSpace::TooManyFunctionEvaluation; - if (ei_abs(actred) <= NumTraits<Scalar>::epsilon() && prered <= NumTraits<Scalar>::epsilon() && Scalar(.5) * ratio <= 1.) + if (internal::abs(actred) <= NumTraits<Scalar>::epsilon() && prered <= NumTraits<Scalar>::epsilon() && Scalar(.5) * ratio <= 1.) return LevenbergMarquardtSpace::FtolTooSmall; if (delta <= NumTraits<Scalar>::epsilon() * xnorm) return LevenbergMarquardtSpace::XtolTooSmall; @@ -451,7 +451,7 @@ LevenbergMarquardt<FunctorType,Scalar>::minimizeOptimumStorageOneStep(FVectorTyp Index rownb = 2; for (i = 0; i < m; ++i) { if (functor.df(x, wa3, rownb) < 0) return LevenbergMarquardtSpace::UserAsked; - ei_rwupdt<Scalar>(fjac, wa3, qtf, fvec[i]); + internal::rwupdt<Scalar>(fjac, wa3, qtf, fvec[i]); ++rownb; } ++njev; @@ -510,7 +510,7 @@ LevenbergMarquardt<FunctorType,Scalar>::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<FunctorType,Scalar>::minimizeOptimumStorageOneStep(FVectorTyp do { /* determine the levenberg-marquardt parameter. */ - ei_lmpar<Scalar>(fjac, permutation.indices(), diag, qtf, delta, par, wa1); + internal::lmpar<Scalar>(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<FunctorType,Scalar>::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<Upper>() * (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<FunctorType,Scalar>::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<FunctorType,Scalar>::minimizeOptimumStorageOneStep(FVectorTyp /* tests for termination and stringent tolerances. */ if (nfev >= parameters.maxfev) return LevenbergMarquardtSpace::TooManyFunctionEvaluation; - if (ei_abs(actred) <= NumTraits<Scalar>::epsilon() && prered <= NumTraits<Scalar>::epsilon() && Scalar(.5) * ratio <= 1.) + if (internal::abs(actred) <= NumTraits<Scalar>::epsilon() && prered <= NumTraits<Scalar>::epsilon() && Scalar(.5) * ratio <= 1.) return LevenbergMarquardtSpace::FtolTooSmall; if (delta <= NumTraits<Scalar>::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<typename Scalar> -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<Scalar>::epsilon()); + const Scalar eps = sqrt(NumTraits<Scalar>::epsilon()); const Scalar epsf = chkder_factor * NumTraits<Scalar>::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<Scalar>::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 <typename Scalar> -void ei_covar( +void covar( Matrix< Scalar, Dynamic, Dynamic > &r, const VectorXi &ipvt, - Scalar tol = ei_sqrt(NumTraits<Scalar>::epsilon()) ) + Scalar tol = sqrt(NumTraits<Scalar>::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 <typename Scalar> -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<typename FunctorType, typename Scalar> -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): (j<n); j += msum) { wa2[j] = x[j]; - h = eps * ei_abs(wa2[j]); + h = eps * abs(wa2[j]); if (h == 0.) h = eps; x[j] = wa2[j] + h; } @@ -56,7 +57,7 @@ DenseIndex ei_fdjac1( return iflag; for (j = k; (msum<0) ? (j>n): (j<n); j += msum) { x[j] = wa2[j]; - h = eps * ei_abs(wa2[j]); + h = eps * abs(wa2[j]); if (h == 0.) h = eps; fjac.col(j).setZero(); start = std::max<Index>(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 <typename Scalar> -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<Scalar>(r, ipvt, wa1, qtb, x, sdiag); + qrsolv<Scalar>(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 <typename Scalar> -void ei_lmpar2( +void lmpar2( const ColPivHouseholderQR<Matrix< Scalar, Dynamic, Dynamic> > &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<Scalar>(s, qr.colsPermutation().indices(), wa1, qtb, x, sdiag); + qrsolv<Scalar>(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 <typename Scalar> -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 <typename Scalar> -void ei_r1mpyq(DenseIndex m, DenseIndex n, Scalar *a, const std::vector<JacobiRotation<Scalar> > &v_givens, const std::vector<JacobiRotation<Scalar> > &w_givens) +void r1mpyq(DenseIndex m, DenseIndex n, Scalar *a, const std::vector<JacobiRotation<Scalar> > &v_givens, const std::vector<JacobiRotation<Scalar> > &w_givens) { typedef DenseIndex Index; @@ -22,3 +23,4 @@ void ei_r1mpyq(DenseIndex m, DenseIndex n, Scalar *a, const std::vector<JacobiRo } } +} // end namespace internal diff --git a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h index 881327af7..0b8ede119 100644 --- a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h +++ b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h @@ -1,6 +1,7 @@ +namespace internal { template <typename Scalar> -void ei_r1updt( +void r1updt( Matrix< Scalar, Dynamic, Dynamic > &s, const Matrix< Scalar, Dynamic, 1> &u, std::vector<JacobiRotation<Scalar> > &v_givens, @@ -18,7 +19,7 @@ void ei_r1updt( Scalar temp; JacobiRotation<Scalar> 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 <typename Scalar> -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<Scalar>::epsilon() ))); + const Scalar eps = internal::sqrt((std::max(epsfcn,NumTraits<Scalar>::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 <typename T> -T ei_radix(){ return 2; } +T radix(){ return 2; } template <typename T> -T ei_radix2(){ return ei_radix<T>()*ei_radix<T>(); } +T radix2(){ return radix<T>()*radix<T>(); } template<int Size> -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<Deg>::ret + Deg_1=decrement_if_fixed_size<Deg>::ret }; typedef _Scalar Scalar; @@ -92,7 +94,7 @@ class ei_companion } template<typename VectorType> - 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<Scalar>(); + rowB = rowNorm / radix<Scalar>(); colB = Scalar(1); const Scalar s = colNorm + rowNorm; while (colNorm < rowB) { - colB *= ei_radix<Scalar>(); - colNorm *= ei_radix2<Scalar>(); + colB *= radix<Scalar>(); + colNorm *= radix2<Scalar>(); } - rowB = rowNorm * ei_radix<Scalar>(); + rowB = rowNorm * radix<Scalar>(); while (colNorm >= rowB) { - colB /= ei_radix<Scalar>(); - colNorm /= ei_radix2<Scalar>(); + colB /= radix<Scalar>(); + colNorm /= radix2<Scalar>(); } //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<deg_1; ++i ) { // column norm, excluding the diagonal - colNorm = ei_abs(m_bl_diag[i]); + colNorm = abs(m_bl_diag[i]); // row norm, excluding the diagonal - rowNorm = ei_abs(m_bl_diag[i-1]) + ei_abs(m_monic[i]); + rowNorm = abs(m_bl_diag[i-1]) + abs(m_monic[i]); //Compute balancing of the row and the column if( !balanced( colNorm, rowNorm, hasConverged, colB, rowB ) ) @@ -268,7 +270,7 @@ void ei_companion<_Scalar,_Deg>::balance() const Index ebl = m_bl_diag.size()-1; VectorBlock<RightColumn,Deg_1> 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<m_roots.size(); ++i ) { - if( ei_abs( m_roots[i].imag() ) < absImaginaryThreshold ){ + if( internal::abs( m_roots[i].imag() ) < absImaginaryThreshold ){ bi_seq.push_back( m_roots[i].real() ); } } } @@ -95,10 +95,10 @@ class PolynomialSolverBase inline const RootType& selectComplexRoot_withRespectToNorm( squaredNormBinaryPredicate& pred ) const { Index res=0; - RealScalar norm2 = ei_abs2( m_roots[0] ); + RealScalar norm2 = internal::abs2( m_roots[0] ); for( Index i=1; i<m_roots.size(); ++i ) { - const RealScalar currNorm2 = ei_abs2( m_roots[i] ); + const RealScalar currNorm2 = internal::abs2( m_roots[i] ); if( pred( currNorm2, norm2 ) ){ res=i; norm2=currNorm2; } } @@ -137,7 +137,7 @@ class PolynomialSolverBase for( Index i=0; i<m_roots.size(); ++i ) { - if( ei_abs( m_roots[i].imag() ) < absImaginaryThreshold ) + if( internal::abs( m_roots[i].imag() ) < absImaginaryThreshold ) { if( !hasArealRoot ) { @@ -157,11 +157,11 @@ class PolynomialSolverBase } else { - if( ei_abs( m_roots[i].imag() ) < ei_abs( m_roots[res].imag() ) ){ + if( internal::abs( m_roots[i].imag() ) < internal::abs( m_roots[res].imag() ) ){ res = i; } } } - return ei_real_ref(m_roots[res]); + return internal::real_ref(m_roots[res]); } @@ -177,7 +177,7 @@ class PolynomialSolverBase for( Index i=0; i<m_roots.size(); ++i ) { - if( ei_abs( m_roots[i].imag() ) < absImaginaryThreshold ) + if( internal::abs( m_roots[i].imag() ) < absImaginaryThreshold ) { if( !hasArealRoot ) { @@ -197,11 +197,11 @@ class PolynomialSolverBase } else { - if( ei_abs( m_roots[i].imag() ) < ei_abs( m_roots[res].imag() ) ){ + if( internal::abs( m_roots[i].imag() ) < internal::abs( m_roots[res].imag() ) ){ res = i; } } } - return ei_real_ref(m_roots[res]); + return internal::real_ref(m_roots[res]); } public: @@ -355,7 +355,7 @@ class PolynomialSolver : public PolynomialSolverBase<_Scalar,_Deg> void compute( const OtherPolynomial& poly ) { assert( Scalar(0) != poly[poly.size()-1] ); - ei_companion<Scalar,_Deg> companion( poly ); + internal::companion<Scalar,_Deg> 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<T>::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<typename Polynomial::Scalar>::Real cauchy_max_bound( const Po Real cb(0); for( DenseIndex i=0; i<poly.size()-1; ++i ){ - cb += ei_abs(poly[i]*inv_leading_coeff); } + cb += internal::abs(poly[i]*inv_leading_coeff); } return cb + Real(1); } @@ -120,7 +120,7 @@ typename NumTraits<typename Polynomial::Scalar>::Real cauchy_min_bound( const Po const Scalar inv_min_coeff = Scalar(1)/poly[i]; Real cb(1); for( DenseIndex j=i+1; j<poly.size(); ++j ){ - cb += ei_abs(poly[j]*inv_min_coeff); } + cb += internal::abs(poly[j]*inv_min_coeff); } return Real(1)/cb; } diff --git a/unsupported/Eigen/src/Skyline/SkylineInplaceLU.h b/unsupported/Eigen/src/Skyline/SkylineInplaceLU.h index fa8f81908..51537402e 100644 --- a/unsupported/Eigen/src/Skyline/SkylineInplaceLU.h +++ b/unsupported/Eigen/src/Skyline/SkylineInplaceLU.h @@ -134,8 +134,8 @@ void SkylineInplaceLU<MatrixType>::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<MatrixType>::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<typename _Scalar, int _Options> -struct ei_traits<SkylineMatrix<_Scalar, _Options> > { +struct traits<SkylineMatrix<_Scalar, _Options> > { typedef _Scalar Scalar; typedef Sparse StorageKind; @@ -57,6 +58,7 @@ struct ei_traits<SkylineMatrix<_Scalar, _Options> > { CoeffReadCost = NumTraits<Scalar>::ReadCost, }; }; +} template<typename _Scalar, int _Options> 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<typename Derived> class SkylineMatrixBase : public EigenBase<Derived> { public: - typedef typename ei_traits<Derived>::Scalar Scalar; - typedef typename ei_traits<Derived>::StorageKind StorageKind; - typedef typename ei_index<StorageKind>::type Index; + typedef typename internal::traits<Derived>::Scalar Scalar; + typedef typename internal::traits<Derived>::StorageKind StorageKind; + typedef typename internal::index<StorageKind>::type Index; enum { - RowsAtCompileTime = ei_traits<Derived>::RowsAtCompileTime, + RowsAtCompileTime = internal::traits<Derived>::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<Derived>::ColsAtCompileTime, + ColsAtCompileTime = internal::traits<Derived>::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<ei_traits<Derived>::RowsAtCompileTime, - ei_traits<Derived>::ColsAtCompileTime>::ret), + SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime, + internal::traits<Derived>::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<MaxRowsAtCompileTime, + MaxSizeAtCompileTime = (internal::size_at_compile_time<MaxRowsAtCompileTime, MaxColsAtCompileTime>::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<Derived>::Flags, + Flags = internal::traits<Derived>::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<Derived>::CoeffReadCost, + CoeffReadCost = internal::traits<Derived>::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<Derived, IsSkyline>::type eval() const { - return typename ei_eval<Derived>::type(derived()); + EIGEN_STRONG_INLINE const typename internal::eval<Derived, IsSkyline>::type eval() const { + return typename internal::eval<Derived>::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<typename Lhs, typename Rhs, int ProductMode> struct SkylineProductReturnType { - typedef const typename ei_nested<Lhs, Rhs::RowsAtCompileTime>::type LhsNested; - typedef const typename ei_nested<Rhs, Lhs::RowsAtCompileTime>::type RhsNested; + typedef const typename internal::nested<Lhs, Rhs::RowsAtCompileTime>::type LhsNested; + typedef const typename internal::nested<Rhs, Lhs::RowsAtCompileTime>::type RhsNested; typedef SkylineProduct<LhsNested, RhsNested, ProductMode> Type; }; template<typename LhsNested, typename RhsNested, int ProductMode> -struct ei_traits<SkylineProduct<LhsNested, RhsNested, ProductMode> > { +struct internal::traits<SkylineProduct<LhsNested, RhsNested, ProductMode> > { // clean the nested types: - typedef typename ei_cleantype<LhsNested>::type _LhsNested; - typedef typename ei_cleantype<RhsNested>::type _RhsNested; + typedef typename internal::cleantype<LhsNested>::type _LhsNested; + typedef typename internal::cleantype<RhsNested>::type _RhsNested; typedef typename _LhsNested::Scalar Scalar; enum { @@ -65,29 +65,30 @@ struct ei_traits<SkylineProduct<LhsNested, RhsNested, ProductMode> > { CoeffReadCost = Dynamic }; - typedef typename ei_meta_if<ResultIsSkyline, + typedef typename internal::meta_if<ResultIsSkyline, SkylineMatrixBase<SkylineProduct<LhsNested, RhsNested, ProductMode> >, MatrixBase<SkylineProduct<LhsNested, RhsNested, ProductMode> > >::ret Base; }; +namespace internal { template<typename LhsNested, typename RhsNested, int ProductMode> -class SkylineProduct : ei_no_assignment_operator, -public ei_traits<SkylineProduct<LhsNested, RhsNested, ProductMode> >::Base { +class SkylineProduct : no_assignment_operator, +public traits<SkylineProduct<LhsNested, RhsNested, ProductMode> >::Base { public: EIGEN_GENERIC_PUBLIC_INTERFACE(SkylineProduct) private: - typedef typename ei_traits<SkylineProduct>::_LhsNested _LhsNested; - typedef typename ei_traits<SkylineProduct>::_RhsNested _RhsNested; + typedef typename traits<SkylineProduct>::_LhsNested _LhsNested; + typedef typename traits<SkylineProduct>::_RhsNested _RhsNested; public: template<typename Lhs, typename Rhs> 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<typename Lhs, typename Rhs, typename Dest> -EIGEN_DONT_INLINE void ei_skyline_row_major_time_dense_product(const Lhs& lhs, const Rhs& rhs, Dest& dst) { - typedef typename ei_cleantype<Lhs>::type _Lhs; - typedef typename ei_cleantype<Rhs>::type _Rhs; - typedef typename ei_traits<Lhs>::Scalar Scalar; +EIGEN_DONT_INLINE void skyline_row_major_time_dense_product(const Lhs& lhs, const Rhs& rhs, Dest& dst) { + typedef typename cleantype<Lhs>::type _Lhs; + typedef typename cleantype<Rhs>::type _Rhs; + typedef typename traits<Lhs>::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<typename Lhs, typename Rhs, typename Dest> -EIGEN_DONT_INLINE void ei_skyline_col_major_time_dense_product(const Lhs& lhs, const Rhs& rhs, Dest& dst) { - typedef typename ei_cleantype<Lhs>::type _Lhs; - typedef typename ei_cleantype<Rhs>::type _Rhs; - typedef typename ei_traits<Lhs>::Scalar Scalar; +EIGEN_DONT_INLINE void skyline_col_major_time_dense_product(const Lhs& lhs, const Rhs& rhs, Dest& dst) { + typedef typename cleantype<Lhs>::type _Lhs; + typedef typename cleantype<Rhs>::type _Rhs; + typedef typename traits<Lhs>::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<typename Lhs, typename Rhs, typename ResultType, - int LhsStorageOrder = ei_traits<Lhs>::Flags&RowMajorBit> - struct ei_skyline_product_selector; + int LhsStorageOrder = traits<Lhs>::Flags&RowMajorBit> + struct skyline_product_selector; template<typename Lhs, typename Rhs, typename ResultType> -struct ei_skyline_product_selector<Lhs, Rhs, ResultType, RowMajor> { - typedef typename ei_traits<typename ei_cleantype<Lhs>::type>::Scalar Scalar; +struct skyline_product_selector<Lhs, Rhs, ResultType, RowMajor> { + typedef typename traits<typename cleantype<Lhs>::type>::Scalar Scalar; static void run(const Lhs& lhs, const Rhs& rhs, ResultType & res) { - ei_skyline_row_major_time_dense_product<Lhs, Rhs, ResultType > (lhs, rhs, res); + skyline_row_major_time_dense_product<Lhs, Rhs, ResultType > (lhs, rhs, res); } }; template<typename Lhs, typename Rhs, typename ResultType> -struct ei_skyline_product_selector<Lhs, Rhs, ResultType, ColMajor> { - typedef typename ei_traits<typename ei_cleantype<Lhs>::type>::Scalar Scalar; +struct skyline_product_selector<Lhs, Rhs, ResultType, ColMajor> { + typedef typename traits<typename cleantype<Lhs>::type>::Scalar Scalar; static void run(const Lhs& lhs, const Rhs& rhs, ResultType & res) { - ei_skyline_col_major_time_dense_product<Lhs, Rhs, ResultType > (lhs, rhs, res); + skyline_col_major_time_dense_product<Lhs, Rhs, ResultType > (lhs, rhs, res); } }; +} // end namespace internal + // template<typename Derived> // template<typename Lhs, typename Rhs > // Derived & MatrixBase<Derived>::lazyAssign(const SkylineProduct<Lhs, Rhs, SkylineTimeDenseProduct>& product) { -// typedef typename ei_cleantype<Lhs>::type _Lhs; -// ei_skyline_product_selector<typename ei_cleantype<Lhs>::type, -// typename ei_cleantype<Rhs>::type, +// typedef typename internal::cleantype<Lhs>::type _Lhs; +// internal::skyline_product_selector<typename internal::cleantype<Lhs>::type, +// typename internal::cleantype<Rhs>::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<Derived>::Scalar Scalar; \ + typedef typename Eigen::internal::traits<Derived>::Scalar Scalar; \ typedef typename Eigen::NumTraits<Scalar>::Real RealScalar; \ - typedef typename Eigen::ei_traits<Derived>::StorageKind StorageKind; \ - typedef typename Eigen::ei_index<StorageKind>::type Index; \ - enum { Flags = Eigen::ei_traits<Derived>::Flags, }; + typedef typename Eigen::internal::traits<Derived>::StorageKind StorageKind; \ + typedef typename Eigen::internal::index<StorageKind>::type Index; \ + enum { Flags = Eigen::internal::traits<Derived>::Flags, }; #define EIGEN_SKYLINE_GENERIC_PUBLIC_INTERFACE(Derived) \ _EIGEN_SKYLINE_GENERIC_PUBLIC_INTERFACE(Derived, Eigen::SkylineMatrixBase<Derived>) @@ -79,20 +79,23 @@ template<typename _Scalar, int _Flags = 0> class DynamicSkylineMatrix; template<typename _Scalar, int _Flags = 0> class SkylineVector; template<typename _Scalar, int _Flags = 0> class MappedSkylineMatrix; -template<typename Lhs, typename Rhs> struct ei_skyline_product_mode; -template<typename Lhs, typename Rhs, int ProductMode = ei_skyline_product_mode<Lhs,Rhs>::value> struct SkylineProductReturnType; +namespace internal { +template<typename Lhs, typename Rhs> struct skyline_product_mode; +template<typename Lhs, typename Rhs, int ProductMode = skyline_product_mode<Lhs,Rhs>::value> struct SkylineProductReturnType; -template<typename T> class ei_eval<T,IsSkyline> +template<typename T> class eval<T,IsSkyline> { - typedef typename ei_traits<T>::Scalar _Scalar; + typedef typename traits<T>::Scalar _Scalar; enum { - _Flags = ei_traits<T>::Flags + _Flags = traits<T>::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<typename Scalar, typename CholmodType> -void ei_cholmod_configure_matrix(CholmodType& mat) +void cholmod_configure_matrix(CholmodType& mat) { - if (ei_is_same_type<Scalar,float>::ret) + if (is_same_type<Scalar,float>::ret) { mat.xtype = CHOLMOD_REAL; mat.dtype = CHOLMOD_SINGLE; } - else if (ei_is_same_type<Scalar,double>::ret) + else if (is_same_type<Scalar,double>::ret) { mat.xtype = CHOLMOD_REAL; mat.dtype = CHOLMOD_DOUBLE; } - else if (ei_is_same_type<Scalar,std::complex<float> >::ret) + else if (is_same_type<Scalar,std::complex<float> >::ret) { mat.xtype = CHOLMOD_COMPLEX; mat.dtype = CHOLMOD_SINGLE; } - else if (ei_is_same_type<Scalar,std::complex<double> >::ret) + else if (is_same_type<Scalar,std::complex<double> >::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<typename _MatrixType> -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<Scalar>(res); + cholmod_configure_matrix<Scalar>(res); if (_MatrixType::Flags & SelfAdjoint) @@ -92,9 +93,9 @@ cholmod_sparse ei_cholmod_map_eigen_to_sparse(_MatrixType& mat) } template<typename Derived> -cholmod_dense ei_cholmod_map_eigen_to_dense(MatrixBase<Derived>& mat) +cholmod_dense cholmod_map_eigen_to_dense(MatrixBase<Derived>& mat) { - EIGEN_STATIC_ASSERT((ei_traits<Derived>::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES); + EIGEN_STATIC_ASSERT((traits<Derived>::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<Derived>& mat) res.x = mat.derived().data(); res.z = 0; - ei_cholmod_configure_matrix<Scalar>(res); + cholmod_configure_matrix<Scalar>(res); return res; } template<typename Scalar, int Flags, typename Index> -MappedSparseMatrix<Scalar,Flags,Index> ei_map_cholmod_sparse_to_eigen(cholmod_sparse& cm) +MappedSparseMatrix<Scalar,Flags,Index> map_cholmod_sparse_to_eigen(cholmod_sparse& cm) { return MappedSparseMatrix<Scalar,Flags,Index> (cm.nrow, cm.ncol, reinterpret_cast<Index*>(cm.p)[cm.ncol], reinterpret_cast<Index*>(cm.p), reinterpret_cast<Index*>(cm.i),reinterpret_cast<Scalar*>(cm.x) ); } - +} // end namespace internal template<typename _MatrixType> class SparseLLT<_MatrixType, Cholmod> : public SparseLLT<_MatrixType> @@ -164,11 +165,11 @@ class SparseLLT<_MatrixType, Cholmod> : public SparseLLT<_MatrixType> bool solveInPlace(MatrixBase<Derived> &b) const; template<typename Rhs> - inline const ei_solve_retval<SparseLLT<MatrixType, Cholmod>, Rhs> + inline const internal::solve_retval<SparseLLT<MatrixType, Cholmod>, Rhs> solve(const MatrixBase<Rhs>& b) const { - ei_assert(true && "SparseLLT is not initialized."); - return ei_solve_retval<SparseLLT<MatrixType, Cholmod>, Rhs>(*this, b.derived()); + eigen_assert(true && "SparseLLT is not initialized."); + return internal::solve_retval<SparseLLT<MatrixType, Cholmod>, Rhs>(*this, b.derived()); } void compute(const MatrixType& matrix); @@ -192,8 +193,8 @@ class SparseLLT<_MatrixType, Cholmod> : public SparseLLT<_MatrixType> template<typename _MatrixType, typename Rhs> - struct ei_solve_retval<SparseLLT<_MatrixType, Cholmod>, Rhs> - : ei_solve_retval_base<SparseLLT<_MatrixType, Cholmod>, Rhs> + struct internal::solve_retval<SparseLLT<_MatrixType, Cholmod>, Rhs> + : internal::solve_retval_base<SparseLLT<_MatrixType, Cholmod>, Rhs> { typedef SparseLLT<_MatrixType, Cholmod> SpLLTDecType; EIGEN_MAKE_SOLVE_HELPERS(SpLLTDecType,Rhs) @@ -201,7 +202,7 @@ template<typename _MatrixType, typename Rhs> template<typename Dest> 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<cholmod_factor*>(dec().cholmodFactor()); cholmod_common* cholmodCommon = const_cast<cholmod_common*>(dec().cholmodCommon()); @@ -211,7 +212,7 @@ template<typename _MatrixType, typename Rhs> // 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<typename Base::Scalar,Dynamic,1>::Map(reinterpret_cast<typename Base::Scalar*>(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<typename Base::CholMatrixType&>(m_matrix) = - ei_map_cholmod_sparse_to_eigen<Scalar,ColMajor,Index>(*cmRes); + internal::map_cholmod_sparse_to_eigen<Scalar,ColMajor,Index>(*cmRes); free(cmRes); m_status = (m_status & ~MatrixLIsDirty); @@ -291,7 +292,7 @@ template<typename Derived> bool SparseLLT<_MatrixType,Cholmod>::solveInPlace(MatrixBase<Derived> &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<Derived> &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<typename Base::Scalar,Dynamic,1>::Map(reinterpret_cast<typename Base::Scalar*>(x->x),b.rows()); cholmod_free_dense(&x, &m_cholmod); @@ -362,11 +363,11 @@ class SparseLDLT<_MatrixType,Cholmod> : public SparseLDLT<_MatrixType> void solveInPlace(MatrixBase<Derived> &b) const; template<typename Rhs> - inline const ei_solve_retval<SparseLDLT<MatrixType, Cholmod>, Rhs> + inline const internal::solve_retval<SparseLDLT<MatrixType, Cholmod>, Rhs> solve(const MatrixBase<Rhs>& b) const { - ei_assert(true && "SparseLDLT is not initialized."); - return ei_solve_retval<SparseLDLT<MatrixType, Cholmod>, Rhs>(*this, b.derived()); + eigen_assert(true && "SparseLDLT is not initialized."); + return internal::solve_retval<SparseLDLT<MatrixType, Cholmod>, Rhs>(*this, b.derived()); } void compute(const _MatrixType& matrix); @@ -392,8 +393,8 @@ class SparseLDLT<_MatrixType,Cholmod> : public SparseLDLT<_MatrixType> template<typename _MatrixType, typename Rhs> - struct ei_solve_retval<SparseLDLT<_MatrixType, Cholmod>, Rhs> - : ei_solve_retval_base<SparseLDLT<_MatrixType, Cholmod>, Rhs> + struct internal::solve_retval<SparseLDLT<_MatrixType, Cholmod>, Rhs> + : internal::solve_retval_base<SparseLDLT<_MatrixType, Cholmod>, Rhs> { typedef SparseLDLT<_MatrixType, Cholmod> SpLDLTDecType; EIGEN_MAKE_SOLVE_HELPERS(SpLDLTDecType,Rhs) @@ -401,7 +402,7 @@ template<typename _MatrixType, typename Rhs> template<typename Dest> 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<cholmod_factor*>(dec().cholmodFactor()); cholmod_common* cholmodCommon = const_cast<cholmod_common*>(dec().cholmodCommon()); @@ -411,7 +412,7 @@ template<typename _MatrixType, typename Rhs> // 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<typename Base::Scalar,Dynamic,1>::Map(reinterpret_cast<typename Base::Scalar*>(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<typename Base::CholMatrixType&>(m_matrix) = MappedSparseMatrix<Scalar>(*cmRes); @@ -494,7 +495,7 @@ template<typename Derived> void SparseLDLT<_MatrixType,Cholmod>::solveInPlace(MatrixBase<Derived> &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<Derived> &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<typename Base::Scalar,Dynamic,1>::Map(reinterpret_cast<typename Base::Scalar*>(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<RealScalar>::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<RealScalar>::dummy_precision(); compute(matrix); } @@ -166,11 +166,11 @@ class SparseLDLT bool solveInPlace(MatrixBase<Derived> &b) const; template<typename Rhs> - inline const ei_solve_retval<SparseLDLT<MatrixType>, Rhs> + inline const internal::solve_retval<SparseLDLT<MatrixType>, Rhs> solve(const MatrixBase<Rhs>& b) const { - ei_assert(true && "SparseLDLT is not initialized."); - return ei_solve_retval<SparseLDLT<MatrixType>, Rhs>(*this, b.derived()); + eigen_assert(true && "SparseLDLT is not initialized."); + return internal::solve_retval<SparseLDLT<MatrixType>, Rhs>(*this, b.derived()); } inline Index cols() const { return m_matrix.cols(); } @@ -193,13 +193,11 @@ class SparseLDLT bool m_succeeded; }; - - - +namespace internal { template<typename _MatrixType, typename Rhs> -struct ei_solve_retval<SparseLDLT<_MatrixType>, Rhs> - : ei_solve_retval_base<SparseLDLT<_MatrixType>, Rhs> +struct solve_retval<SparseLDLT<_MatrixType>, Rhs> + : solve_retval_base<SparseLDLT<_MatrixType>, Rhs> { typedef SparseLDLT<_MatrixType> SpLDLTDecType; EIGEN_MAKE_SOLVE_HELPERS(SpLDLTDecType,Rhs) @@ -207,7 +205,7 @@ struct ei_solve_retval<SparseLDLT<_MatrixType>, Rhs> template<typename Dest> 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<SparseLDLT<_MatrixType>, 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<typename Derived> bool SparseLDLT<_MatrixType, Backend>::solveInPlace(MatrixBase<Derived> &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<Derived> &b) const; template<typename Rhs> - inline const ei_solve_retval<SparseLLT<MatrixType>, Rhs> + inline const internal::solve_retval<SparseLLT<MatrixType>, Rhs> solve(const MatrixBase<Rhs>& b) const { - ei_assert(true && "SparseLLT is not initialized."); - return ei_solve_retval<SparseLLT<MatrixType>, Rhs>(*this, b.derived()); + eigen_assert(true && "SparseLLT is not initialized."); + return internal::solve_retval<SparseLLT<MatrixType>, Rhs>(*this, b.derived()); } inline Index cols() const { return m_matrix.cols(); } @@ -134,13 +134,11 @@ class SparseLLT }; - - - +namespace internal { template<typename _MatrixType, typename Rhs> -struct ei_solve_retval<SparseLLT<_MatrixType>, Rhs> - : ei_solve_retval_base<SparseLLT<_MatrixType>, Rhs> +struct solve_retval<SparseLLT<_MatrixType>, Rhs> + : solve_retval_base<SparseLLT<_MatrixType>, Rhs> { typedef SparseLLT<_MatrixType> SpLLTDecType; EIGEN_MAKE_SOLVE_HELPERS(SpLLTDecType,Rhs) @@ -148,7 +146,7 @@ struct ei_solve_retval<SparseLLT<_MatrixType>, Rhs> template<typename Dest> 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<SparseLLT<_MatrixType>, 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<Scalar,Index>::Iterator it(tempVector, m_precision*rx); it; ++it) @@ -236,7 +234,7 @@ template<typename Derived> bool SparseLLT<_MatrixType, Backend>::solveInPlace(MatrixBase<Derived> &b) const { const Index size = m_matrix.rows(); - ei_assert(size==b.rows()); + eigen_assert(size==b.rows()); m_matrix.template triangularView<Lower>().solveInPlace(b); m_matrix.adjoint().template triangularView<Upper>().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<typename _MatrixType, typename Backend> 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<typename _MatrixType, typename Backend> template<typename BDerived, typename XDerived> bool SparseLU<_MatrixType,Backend>::solve(const MatrixBase<BDerived> &, MatrixBase<XDerived>* , 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<typename Scalar> void setScalarType() { - if (ei_is_same_type<Scalar,float>::ret) + if (internal::is_same_type<Scalar,float>::ret) Dtype = SLU_S; - else if (ei_is_same_type<Scalar,double>::ret) + else if (internal::is_same_type<Scalar,double>::ret) Dtype = SLU_D; - else if (ei_is_same_type<Scalar,std::complex<float> >::ret) + else if (internal::is_same_type<Scalar,std::complex<float> >::ret) Dtype = SLU_C; - else if (ei_is_same_type<Scalar,std::complex<double> >::ret) + else if (internal::is_same_type<Scalar,std::complex<double> >::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<Scalar,Rows,Cols,Options,MRows,MCols>& mat) { typedef Matrix<Scalar,Rows,Cols,Options,MRows,MCols> 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<Scalar>(); @@ -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<Matrix<Scalar,Rows,Cols,Options,MRows,MCols> > typedef Matrix<Scalar,Rows,Cols,Options,MRows,MCols> 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<Scalar>(); res.Mtype = SLU_GE; @@ -256,21 +256,23 @@ struct SluMatrixMapHelper<SparseMatrixBase<Derived> > 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<typename MatrixType> -SluMatrix ei_asSluMatrix(MatrixType& mat) +SluMatrix asSluMatrix(MatrixType& mat) { return SluMatrix::Map(mat); } /** View a Super LU matrix as an Eigen expression */ template<typename Scalar, int Flags, typename Index> -MappedSparseMatrix<Scalar,Flags,Index> ei_map_superlu(SluMatrix& sluMat) +MappedSparseMatrix<Scalar,Flags,Index> 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<Scalar,Flags,Index> ei_map_superlu(SluMatrix& sluMat) sluMat.storage.outerInd, sluMat.storage.innerInd, reinterpret_cast<Scalar*>(sluMat.storage.values) ); } +} // end namespace internal + template<typename MatrixType> class SparseLU<MatrixType,SuperLU> : public SparseLU<MatrixType> { @@ -393,7 +397,7 @@ void SparseLU<MatrixType,SuperLU>::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<MatrixType,SuperLU>::solve(const MatrixBase<BDerived> &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<MatrixType,SuperLU>::Scalar SparseLU<MatrixType,SuperLU>::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<BDerived> &b, MatrixBase<XDerived>* x) const; template<typename Rhs> - inline const ei_solve_retval<SparseLU<MatrixType, UmfPack>, Rhs> + inline const internal::solve_retval<SparseLU<MatrixType, UmfPack>, Rhs> solve(const MatrixBase<Rhs>& b) const { - ei_assert(true && "SparseLU is not initialized."); - return ei_solve_retval<SparseLU<MatrixType, UmfPack>, Rhs>(*this, b.derived()); + eigen_assert(true && "SparseLU is not initialized."); + return internal::solve_retval<SparseLU<MatrixType, UmfPack>, 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<typename _MatrixType, typename Rhs> - struct ei_solve_retval<SparseLU<_MatrixType, UmfPack>, Rhs> - : ei_solve_retval_base<SparseLU<_MatrixType, UmfPack>, Rhs> + struct solve_retval<SparseLU<_MatrixType, UmfPack>, Rhs> + : solve_retval_base<SparseLU<_MatrixType, UmfPack>, Rhs> { typedef SparseLU<_MatrixType, UmfPack> SpLUDecType; EIGEN_MAKE_SOLVE_HELPERS(SpLUDecType,Rhs) @@ -233,8 +234,8 @@ template<typename _MatrixType, typename Rhs> { 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<void*>(dec().numeric()); @@ -244,13 +245,13 @@ template<typename _MatrixType, typename Rhs> 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<typename MatrixType> void SparseLU<MatrixType,UmfPack>::compute(const MatrixType& a) @@ -258,7 +259,7 @@ void SparseLU<MatrixType,UmfPack>::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<MatrixType,UmfPack>::solve(const MatrixBase<BDerived> &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<rhsCols; ++j) diff --git a/unsupported/doc/examples/BVH_Example.cpp b/unsupported/doc/examples/BVH_Example.cpp index d135fd990..9e9959a32 100644 --- a/unsupported/doc/examples/BVH_Example.cpp +++ b/unsupported/doc/examples/BVH_Example.cpp @@ -5,7 +5,7 @@ using namespace Eigen; typedef AlignedBox<double, 2> 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<float> 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<typename Scalar, int Dim> AlignedBox<Scalar, Dim> ei_bounding_box(const Matrix<Scalar, Dim, 1> &v) { return AlignedBox<Scalar, Dim>(v); } -template<int Dim> AlignedBox<double, Dim> ei_bounding_box(const Ball<Dim> &b) +template<typename Scalar, int Dim> AlignedBox<Scalar, Dim> bounding_box(const Matrix<Scalar, Dim, 1> &v) { return AlignedBox<Scalar, Dim>(v); } +template<int Dim> AlignedBox<double, Dim> bounding_box(const Ball<Dim> &b) { return AlignedBox<double, Dim>(b.center.array() - b.radius, b.center.array() + b.radius); } +} // end namespace internal +} template<int Dim> 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<double, Dim, BallType> 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<double, Dim, BallType> 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<typename Scalar> void alignedvector3() { - Scalar s1 = ei_random<Scalar>(); - Scalar s2 = ei_random<Scalar>(); + Scalar s1 = internal::random<Scalar>(); + Scalar s2 = internal::random<Scalar>(); typedef Matrix<Scalar,3,1> RefType; typedef Matrix<Scalar,3,3> Mat33; typedef AlignedVector3<Scalar> 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<typename ei_traits<MatrixType>::Scalar>::Real RealScalar; + typedef typename NumTraits<typename internal::traits<MatrixType>::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<int>(0,2))) - + ei_random<Scalar>() * Scalar(RealScalar(0.01)); + diag(i, i) = Scalar(RealScalar(internal::random<int>(0,2))) + + internal::random<Scalar>() * Scalar(RealScalar(0.01)); } MatrixType A = MatrixType::Random(size, size); HouseholderQR<MatrixType> QRofA(A); return QRofA.householderQ().inverse() * diag * QRofA.householderQ(); } -template <typename MatrixType, int IsComplex = NumTraits<typename ei_traits<MatrixType>::Scalar>::IsComplex> +template <typename MatrixType, int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex> struct randomMatrixWithImagEivals { // Returns a matrix with eigenvalues clustered around 0 and +/- i. @@ -71,12 +71,12 @@ struct randomMatrixWithImagEivals<MatrixType, 0> MatrixType diag = MatrixType::Zero(size, size); Index i = 0; while (i < size) { - Index randomInt = ei_random<Index>(-1, 1); + Index randomInt = internal::random<Index>(-1, 1); if (randomInt == 0 || i == size-1) { - diag(i, i) = ei_random<Scalar>() * Scalar(0.01); + diag(i, i) = internal::random<Scalar>() * Scalar(0.01); ++i; } else { - Scalar alpha = Scalar(randomInt) + ei_random<Scalar>() * Scalar(0.01); + Scalar alpha = Scalar(randomInt) + internal::random<Scalar>() * Scalar(0.01); diag(i, i+1) = alpha; diag(i+1, i) = -alpha; i += 2; @@ -100,8 +100,8 @@ struct randomMatrixWithImagEivals<MatrixType, 1> 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<Index>(-1, 1))) * imagUnit - + ei_random<Scalar>() * Scalar(RealScalar(0.01)); + diag(i, i) = Scalar(RealScalar(internal::random<Index>(-1, 1))) * imagUnit + + internal::random<Scalar>() * Scalar(RealScalar(0.01)); } MatrixType A = MatrixType::Random(size, size); HouseholderQR<MatrixType> QRofA(A); @@ -113,7 +113,7 @@ struct randomMatrixWithImagEivals<MatrixType, 1> template<typename MatrixType> void testMatrixExponential(const MatrixType& A) { - typedef typename ei_traits<MatrixType>::Scalar Scalar; + typedef typename internal::traits<MatrixType>::Scalar Scalar; typedef typename NumTraits<Scalar>::Real RealScalar; typedef std::complex<RealScalar> 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<mpreal>::lowest() << "\n"; for(int i = 0; i < g_repeat; i++) { - int s = ei_random<int>(1,100); + int s = Eigen::internal::random<int>(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<double>(), Vector3d::Random())); + Quaterniond qd(AngleAxisd(internal::random<double>(), Vector3d::Random())); VERIFY_MATRIX(glRotate(qd), Projective3d(qd).matrix()); - Quaternionf qf(AngleAxisf(ei_random<double>(), Vector3f::Random())); + Quaternionf qf(AngleAxisf(internal::random<double>(), 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<float> usf(ei_random<float>()); + UniformScaling<float> usf(internal::random<float>()); VERIFY_MATRIX(glScale(usf), Projective3f(usf).matrix()); - UniformScaling<double> usd(ei_random<double>()); + UniformScaling<double> usd(internal::random<double>()); 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<int Size> -struct ei_increment_if_fixed_size +struct increment_if_fixed_size { enum { ret = (Size == Dynamic) ? Dynamic : Size+1 }; }; - - +} +} template<int Deg, typename POLYNOMIAL, typename SOLVER> @@ -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<Scalar> 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<rootModuli.size() && distinctModuli; ++i ) { - if( ei_isApprox( rootModuli[i], rootModuli[i-1] ) ){ + if( internal::isApprox( rootModuli[i], rootModuli[i-1] ) ){ distinctModuli = false; } } VERIFY( evalToZero || !distinctModuli ); @@ -158,51 +160,51 @@ void evalSolverSugarFunction( const POLYNOMIAL& pols, const ROOTS& roots, const psolve.realRoots( calc_realRoots ); VERIFY( calc_realRoots.size() == (size_t)real_roots.size() ); - const Scalar psPrec = ei_sqrt( test_precision<Scalar>() ); + const Scalar psPrec = internal::sqrt( test_precision<Scalar>() ); for( size_t i=0; i<calc_realRoots.size(); ++i ) { bool found = false; for( size_t j=0; j<calc_realRoots.size()&& !found; ++j ) { - if( ei_isApprox( calc_realRoots[i], real_roots[j] ), psPrec ){ + if( internal::isApprox( calc_realRoots[i], real_roots[j] ), psPrec ){ found = true; } } VERIFY( found ); } //Test greatestRoot - VERIFY( ei_isApprox( roots.array().abs().maxCoeff(), - ei_abs( psolve.greatestRoot() ), psPrec ) ); + VERIFY( internal::isApprox( roots.array().abs().maxCoeff(), + internal::abs( psolve.greatestRoot() ), psPrec ) ); //Test smallestRoot - VERIFY( ei_isApprox( roots.array().abs().minCoeff(), - ei_abs( psolve.smallestRoot() ), psPrec ) ); + VERIFY( internal::isApprox( roots.array().abs().minCoeff(), + internal::abs( psolve.smallestRoot() ), psPrec ) ); bool hasRealRoot; //Test absGreatestRealRoot Real r = psolve.absGreatestRealRoot( hasRealRoot ); VERIFY( hasRealRoot == (real_roots.size() > 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<typename _Scalar, int _Deg> 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<typename _Scalar> void polynomialsolver_scalar() CALL_SUBTEST_8( (polynomialsolver<_Scalar,8>(8)) ); CALL_SUBTEST_9( (polynomialsolver<_Scalar,Dynamic>( - ei_random<int>(9,45) + internal::random<int>(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<int Size> -struct ei_increment_if_fixed_size +struct increment_if_fixed_size { enum { ret = (Size == Dynamic) ? Dynamic : Size+1 }; }; +} +} template<typename _Scalar, int _Deg> 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<typename _Scalar> 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<int>(18,26) )) ); + internal::random<int>(18,26) )) ); } @@ -77,7 +81,7 @@ template<typename _Scalar> void realRoots_to_monicPolynomial_scalar() template<typename _Scalar, int _Deg> 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<typename _Scalar> void CauchyBounds_scalar() CALL_SUBTEST_8( (CauchyBounds<_Scalar,17>(17)) ); CALL_SUBTEST_9( (CauchyBounds<_Scalar,Dynamic>( - ei_random<int>(18,26) )) ); + internal::random<int>(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<Scalar,Options>& sm, const DenseType& ref, std::vector<Vector2i> remaining = nonzeroCoords; while(!remaining.empty()) { - int i = ei_random<int>(0,static_cast<int>(remaining.size())-1); + int i = internal::random<int>(0,static_cast<int>(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<T>& sm, const DenseType& ref, const std::vector<Vector2i> remaining = nonzeroCoords; while(!remaining.empty()) { - int i = ei_random<int>(0,static_cast<int>(remaining.size())-1); + int i = internal::random<int>(0,static_cast<int>(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<typename SparseMatrixType> 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<SparseMatrixType,SparseMatrix<Scalar,Flags> >::ret) + if(internal::is_same_type<SparseMatrixType,SparseMatrix<Scalar,Flags> >::ret) VERIFY_RAISES_ASSERT( m.coeffRef(zeroCoords[0].x(),zeroCoords[0].y()) = 5 ); } VERIFY_IS_APPROX(m, refMat); @@ -105,7 +105,7 @@ template<typename SparseMatrixType> void sparse_extra(const SparseMatrixType& re // std::vector<Vector2i> remaining = nonzeroCoords; // while(!remaining.empty()) // { -// int i = ei_random<int>(0,remaining.size()-1); +// int i = internal::random<int>(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<typename Scalar> void sparse_ldlt(int rows, int cols) initSparse<Scalar>(density, refMat2, m2, ForceNonZeroDiag|MakeUpperTriangular, 0, 0); for(int i=0; i<rows; ++i) - m2.coeffRef(i,i) = refMat2(i,i) = ei_abs(ei_real(refMat2(i,i))); + m2.coeffRef(i,i) = refMat2(i,i) = internal::abs(internal::real(refMat2(i,i))); refX = refMat2.template selfadjointView<Upper>().ldlt().solve(b); typedef SparseMatrix<Scalar,Upper|SelfAdjoint> SparseSelfAdjointMatrix; @@ -85,7 +85,7 @@ void test_sparse_ldlt() { for(int i = 0; i < g_repeat; i++) { CALL_SUBTEST_1(sparse_ldlt<double>(8, 8) ); - int s = ei_random<int>(1,300); + int s = internal::random<int>(1,300); CALL_SUBTEST_2(sparse_ldlt<std::complex<double> >(s,s) ); CALL_SUBTEST_1(sparse_ldlt<double>(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<typename Scalar> void sparse_llt(int rows, int cols) initSparse<Scalar>(density, refMat2, m2, ForceNonZeroDiag|MakeLowerTriangular, 0, 0); for(int i=0; i<rows; ++i) - m2.coeffRef(i,i) = refMat2(i,i) = ei_abs(ei_real(refMat2(i,i))); + m2.coeffRef(i,i) = refMat2(i,i) = internal::abs(internal::real(refMat2(i,i))); refX = refMat2.template selfadjointView<Lower>().llt().solve(b); if (!NumTraits<Scalar>::IsComplex) @@ -78,7 +78,7 @@ void test_sparse_llt() { for(int i = 0; i < g_repeat; i++) { CALL_SUBTEST_1(sparse_llt<double>(8, 8) ); - int s = ei_random<int>(1,300); + int s = internal::random<int>(1,300); CALL_SUBTEST_2(sparse_llt<std::complex<double> >(s,s) ); CALL_SUBTEST_1(sparse_llt<double>(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<double>(8, 8) ); - int s = ei_random<int>(1,300); + int s = internal::random<int>(1,300); CALL_SUBTEST_2(sparse_lu<std::complex<double> >(s,s) ); CALL_SUBTEST_1(sparse_lu<double>(s,s) ); } |