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 /Eigen/src/Sparse | |
| parent | ca85a1f6c5fc33ac382aa2d7ba2da63d55d3223e (diff) | |
bug #86 : use internal:: namespace instead of ei_ prefix
Diffstat (limited to 'Eigen/src/Sparse')
23 files changed, 439 insertions, 373 deletions
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; } |