You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
397 lines
15 KiB
397 lines
15 KiB
// 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 the mozilla.org home page |
|
|
|
#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
|
|
|