| // This file is part of Eigen, a lightweight C++ template library |
| // for linear algebra. |
| // |
| // Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inria.fr> |
| // |
| // This Source Code Form is subject to the terms of the Mozilla |
| // Public License v. 2.0. If a copy of the MPL was not distributed |
| // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. |
| |
| #ifndef EIGEN_SPARSE_REF_H |
| #define EIGEN_SPARSE_REF_H |
| |
| namespace Eigen { |
| |
| enum { |
| StandardCompressedFormat = 2 /**< used by Ref<SparseMatrix> to specify whether the input storage must be in standard compressed form */ |
| }; |
| |
| namespace internal { |
| |
| template<typename Derived> class SparseRefBase; |
| |
| template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType> |
| struct traits<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> > |
| : public traits<SparseMatrix<MatScalar,MatOptions,MatIndex> > |
| { |
| typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType; |
| enum { |
| Options = _Options, |
| Flags = traits<PlainObjectType>::Flags | CompressedAccessBit | NestByRefBit |
| }; |
| |
| template<typename Derived> struct match { |
| enum { |
| StorageOrderMatch = PlainObjectType::IsVectorAtCompileTime || Derived::IsVectorAtCompileTime || ((PlainObjectType::Flags&RowMajorBit)==(Derived::Flags&RowMajorBit)), |
| MatchAtCompileTime = (Derived::Flags&CompressedAccessBit) && StorageOrderMatch |
| }; |
| typedef typename internal::conditional<MatchAtCompileTime,internal::true_type,internal::false_type>::type type; |
| }; |
| |
| }; |
| |
| template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType> |
| struct traits<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> > |
| : public traits<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> > |
| { |
| enum { |
| Flags = (traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >::Flags | CompressedAccessBit | NestByRefBit) & ~LvalueBit |
| }; |
| }; |
| |
| template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType> |
| struct traits<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> > |
| : public traits<SparseVector<MatScalar,MatOptions,MatIndex> > |
| { |
| typedef SparseVector<MatScalar,MatOptions,MatIndex> PlainObjectType; |
| enum { |
| Options = _Options, |
| Flags = traits<PlainObjectType>::Flags | CompressedAccessBit | NestByRefBit |
| }; |
| |
| template<typename Derived> struct match { |
| enum { |
| MatchAtCompileTime = (Derived::Flags&CompressedAccessBit) && Derived::IsVectorAtCompileTime |
| }; |
| typedef typename internal::conditional<MatchAtCompileTime,internal::true_type,internal::false_type>::type type; |
| }; |
| |
| }; |
| |
| template<typename MatScalar, int MatOptions, typename MatIndex, int _Options, typename _StrideType> |
| struct traits<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> > |
| : public traits<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, _Options, _StrideType> > |
| { |
| enum { |
| Flags = (traits<SparseVector<MatScalar,MatOptions,MatIndex> >::Flags | CompressedAccessBit | NestByRefBit) & ~LvalueBit |
| }; |
| }; |
| |
| template<typename Derived> |
| struct traits<SparseRefBase<Derived> > : public traits<Derived> {}; |
| |
| template<typename Derived> class SparseRefBase |
| : public SparseMapBase<Derived> |
| { |
| public: |
| |
| typedef SparseMapBase<Derived> Base; |
| EIGEN_SPARSE_PUBLIC_INTERFACE(SparseRefBase) |
| |
| SparseRefBase() |
| : Base(RowsAtCompileTime==Dynamic?0:RowsAtCompileTime,ColsAtCompileTime==Dynamic?0:ColsAtCompileTime, 0, 0, 0, 0, 0) |
| {} |
| |
| protected: |
| |
| template<typename Expression> |
| void construct(Expression& expr) |
| { |
| if(expr.outerIndexPtr()==0) |
| ::new (static_cast<Base*>(this)) Base(expr.size(), expr.nonZeros(), expr.innerIndexPtr(), expr.valuePtr()); |
| else |
| ::new (static_cast<Base*>(this)) Base(expr.rows(), expr.cols(), expr.nonZeros(), expr.outerIndexPtr(), expr.innerIndexPtr(), expr.valuePtr(), expr.innerNonZeroPtr()); |
| } |
| }; |
| |
| } // namespace internal |
| |
| |
| /** |
| * \ingroup SparseCore_Module |
| * |
| * \brief A sparse matrix expression referencing an existing sparse expression |
| * |
| * \tparam SparseMatrixType the equivalent sparse matrix type of the referenced data, it must be a template instance of class SparseMatrix. |
| * \tparam Options specifies whether the a standard compressed format is required \c Options is \c #StandardCompressedFormat, or \c 0. |
| * The default is \c 0. |
| * |
| * \sa class Ref |
| */ |
| #ifndef EIGEN_PARSED_BY_DOXYGEN |
| template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType> |
| class Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType > |
| : public internal::SparseRefBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType > > |
| #else |
| template<typename SparseMatrixType, int Options> |
| class Ref<SparseMatrixType, Options> |
| : public SparseMapBase<Derived,WriteAccessors> // yes, that's weird to use Derived here, but that works! |
| #endif |
| { |
| typedef SparseMatrix<MatScalar,MatOptions,MatIndex> PlainObjectType; |
| typedef internal::traits<Ref> Traits; |
| template<int OtherOptions> |
| inline Ref(const SparseMatrix<MatScalar,OtherOptions,MatIndex>& expr); |
| template<int OtherOptions> |
| inline Ref(const MappedSparseMatrix<MatScalar,OtherOptions,MatIndex>& expr); |
| public: |
| |
| typedef internal::SparseRefBase<Ref> Base; |
| EIGEN_SPARSE_PUBLIC_INTERFACE(Ref) |
| |
| |
| #ifndef EIGEN_PARSED_BY_DOXYGEN |
| template<int OtherOptions> |
| inline Ref(SparseMatrix<MatScalar,OtherOptions,MatIndex>& expr) |
| { |
| EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseMatrix<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH); |
| eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) ); |
| Base::construct(expr.derived()); |
| } |
| |
| template<int OtherOptions> |
| inline Ref(MappedSparseMatrix<MatScalar,OtherOptions,MatIndex>& expr) |
| { |
| EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseMatrix<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH); |
| eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) ); |
| Base::construct(expr.derived()); |
| } |
| |
| template<typename Derived> |
| inline Ref(const SparseCompressedBase<Derived>& expr) |
| #else |
| /** Implicit constructor from any sparse expression (2D matrix or 1D vector) */ |
| template<typename Derived> |
| inline Ref(SparseCompressedBase<Derived>& expr) |
| #endif |
| { |
| EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY); |
| EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH); |
| eigen_assert( ((Options & int(StandardCompressedFormat))==0) || (expr.isCompressed()) ); |
| Base::construct(expr.const_cast_derived()); |
| } |
| }; |
| |
| // this is the const ref version |
| template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType> |
| class Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> |
| : public internal::SparseRefBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > |
| { |
| typedef SparseMatrix<MatScalar,MatOptions,MatIndex> TPlainObjectType; |
| typedef internal::traits<Ref> Traits; |
| public: |
| |
| typedef internal::SparseRefBase<Ref> Base; |
| EIGEN_SPARSE_PUBLIC_INTERFACE(Ref) |
| |
| template<typename Derived> |
| inline Ref(const SparseMatrixBase<Derived>& expr) : m_hasCopy(false) |
| { |
| construct(expr.derived(), typename Traits::template match<Derived>::type()); |
| } |
| |
| inline Ref(const Ref& other) : Base(other), m_hasCopy(false) { |
| // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy |
| } |
| |
| template<typename OtherRef> |
| inline Ref(const RefBase<OtherRef>& other) : m_hasCopy(false) { |
| construct(other.derived(), typename Traits::template match<OtherRef>::type()); |
| } |
| |
| ~Ref() { |
| if(m_hasCopy) { |
| TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage); |
| obj->~TPlainObjectType(); |
| } |
| } |
| |
| protected: |
| |
| template<typename Expression> |
| void construct(const Expression& expr,internal::true_type) |
| { |
| if((Options & int(StandardCompressedFormat)) && (!expr.isCompressed())) |
| { |
| TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage); |
| ::new (obj) TPlainObjectType(expr); |
| m_hasCopy = true; |
| Base::construct(*obj); |
| } |
| else |
| { |
| Base::construct(expr); |
| } |
| } |
| |
| template<typename Expression> |
| void construct(const Expression& expr, internal::false_type) |
| { |
| TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage); |
| ::new (obj) TPlainObjectType(expr); |
| m_hasCopy = true; |
| Base::construct(*obj); |
| } |
| |
| protected: |
| typename internal::aligned_storage<sizeof(TPlainObjectType), EIGEN_ALIGNOF(TPlainObjectType)>::type m_storage; |
| bool m_hasCopy; |
| }; |
| |
| |
| |
| /** |
| * \ingroup SparseCore_Module |
| * |
| * \brief A sparse vector expression referencing an existing sparse vector expression |
| * |
| * \tparam SparseVectorType the equivalent sparse vector type of the referenced data, it must be a template instance of class SparseVector. |
| * |
| * \sa class Ref |
| */ |
| #ifndef EIGEN_PARSED_BY_DOXYGEN |
| template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType> |
| class Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType > |
| : public internal::SparseRefBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType > > |
| #else |
| template<typename SparseVectorType> |
| class Ref<SparseVectorType> |
| : public SparseMapBase<Derived,WriteAccessors> |
| #endif |
| { |
| typedef SparseVector<MatScalar,MatOptions,MatIndex> PlainObjectType; |
| typedef internal::traits<Ref> Traits; |
| template<int OtherOptions> |
| inline Ref(const SparseVector<MatScalar,OtherOptions,MatIndex>& expr); |
| public: |
| |
| typedef internal::SparseRefBase<Ref> Base; |
| EIGEN_SPARSE_PUBLIC_INTERFACE(Ref) |
| |
| #ifndef EIGEN_PARSED_BY_DOXYGEN |
| template<int OtherOptions> |
| inline Ref(SparseVector<MatScalar,OtherOptions,MatIndex>& expr) |
| { |
| EIGEN_STATIC_ASSERT(bool(Traits::template match<SparseVector<MatScalar,OtherOptions,MatIndex> >::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH); |
| Base::construct(expr.derived()); |
| } |
| |
| template<typename Derived> |
| inline Ref(const SparseCompressedBase<Derived>& expr) |
| #else |
| /** Implicit constructor from any 1D sparse vector expression */ |
| template<typename Derived> |
| inline Ref(SparseCompressedBase<Derived>& expr) |
| #endif |
| { |
| EIGEN_STATIC_ASSERT(bool(internal::is_lvalue<Derived>::value), THIS_EXPRESSION_IS_NOT_A_LVALUE__IT_IS_READ_ONLY); |
| EIGEN_STATIC_ASSERT(bool(Traits::template match<Derived>::MatchAtCompileTime), STORAGE_LAYOUT_DOES_NOT_MATCH); |
| Base::construct(expr.const_cast_derived()); |
| } |
| }; |
| |
| // this is the const ref version |
| template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType> |
| class Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> |
| : public internal::SparseRefBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > |
| { |
| typedef SparseVector<MatScalar,MatOptions,MatIndex> TPlainObjectType; |
| typedef internal::traits<Ref> Traits; |
| public: |
| |
| typedef internal::SparseRefBase<Ref> Base; |
| EIGEN_SPARSE_PUBLIC_INTERFACE(Ref) |
| |
| template<typename Derived> |
| inline Ref(const SparseMatrixBase<Derived>& expr) : m_hasCopy(false) |
| { |
| construct(expr.derived(), typename Traits::template match<Derived>::type()); |
| } |
| |
| inline Ref(const Ref& other) : Base(other), m_hasCopy(false) { |
| // copy constructor shall not copy the m_object, to avoid unnecessary malloc and copy |
| } |
| |
| template<typename OtherRef> |
| inline Ref(const RefBase<OtherRef>& other) : m_hasCopy(false) { |
| construct(other.derived(), typename Traits::template match<OtherRef>::type()); |
| } |
| |
| ~Ref() { |
| if(m_hasCopy) { |
| TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage); |
| obj->~TPlainObjectType(); |
| } |
| } |
| |
| protected: |
| |
| template<typename Expression> |
| void construct(const Expression& expr,internal::true_type) |
| { |
| Base::construct(expr); |
| } |
| |
| template<typename Expression> |
| void construct(const Expression& expr, internal::false_type) |
| { |
| TPlainObjectType* obj = reinterpret_cast<TPlainObjectType*>(&m_storage); |
| ::new (obj) TPlainObjectType(expr); |
| m_hasCopy = true; |
| Base::construct(*obj); |
| } |
| |
| protected: |
| typename internal::aligned_storage<sizeof(TPlainObjectType), EIGEN_ALIGNOF(TPlainObjectType)>::type m_storage; |
| bool m_hasCopy; |
| }; |
| |
| namespace internal { |
| |
| // FIXME shall we introduce a general evaluatior_ref that we can specialize for any sparse object once, and thus remove this copy-pasta thing... |
| |
| template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType> |
| struct evaluator<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > |
| : evaluator<SparseCompressedBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > |
| { |
| typedef evaluator<SparseCompressedBase<Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base; |
| typedef Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType; |
| evaluator() : Base() {} |
| explicit evaluator(const XprType &mat) : Base(mat) {} |
| }; |
| |
| template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType> |
| struct evaluator<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > |
| : evaluator<SparseCompressedBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > |
| { |
| typedef evaluator<SparseCompressedBase<Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base; |
| typedef Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType; |
| evaluator() : Base() {} |
| explicit evaluator(const XprType &mat) : Base(mat) {} |
| }; |
| |
| template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType> |
| struct evaluator<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > |
| : evaluator<SparseCompressedBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > |
| { |
| typedef evaluator<SparseCompressedBase<Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base; |
| typedef Ref<SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType; |
| evaluator() : Base() {} |
| explicit evaluator(const XprType &mat) : Base(mat) {} |
| }; |
| |
| template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType> |
| struct evaluator<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > |
| : evaluator<SparseCompressedBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > |
| { |
| typedef evaluator<SparseCompressedBase<Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> > > Base; |
| typedef Ref<const SparseVector<MatScalar,MatOptions,MatIndex>, Options, StrideType> XprType; |
| evaluator() : Base() {} |
| explicit evaluator(const XprType &mat) : Base(mat) {} |
| }; |
| |
| } |
| |
| } // end namespace Eigen |
| |
| #endif // EIGEN_SPARSE_REF_H |