mirror/eigen
2
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-01-30 17:40:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

bug #910: add a StandardCompressedFormat option to Ref<SparseMatrix> to enforce standard compressed storage format.

Browse Source 
If the input is not compressed, then this trigger a copy for a const Ref, and a runtime assert for non-const Ref.
This commit is contained in:
Gael Guennebaud 2015-06-09 23:11:24 +02:00
parent f899aeb301
commit feaf76c001
3 changed files with 50 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Eigen/src/SparseCore/SparseMatrix.h
View File

@ -725,6 +725,9 @@ class SparseMatrix
}
else if(this!=&other)
{
#ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
#endif
initAssignment(other);
if(other.isCompressed())
{

30
Eigen/src/SparseCore/SparseRef.h
View File

@ -12,6 +12,10 @@
namespace Eigen {
enum {
StandardCompressedFormat = 2
};
namespace internal {
template<typename Derived> class SparseRefBase;
@ -72,6 +76,19 @@ protected:
} // namespace internal
/**
* \ingroup Sparse_Module
*
* \brief A sparse matrix expression referencing an existing sparse expression
*
* \tparam PlainObjectType the equivalent sparse matrix type of the referenced data
* \tparam Options specifies whether the a standard compressed format is required \c Options is \c #StandardCompressedFormat, or \c 0.
* The default is \c 0.
* \tparam StrideType Only used for dense Ref
*
* \sa class Ref
*/
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 > >
@ -93,6 +110,7 @@ class Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType >
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());
}
@ -100,6 +118,7 @@ class Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType >
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());
}
@ -112,6 +131,7 @@ class Ref<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType >
{
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());
}
};
@ -148,7 +168,15 @@ class Ref<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType
template<typename Expression>
void construct(const Expression& expr,internal::true_type)
{
Base::construct(expr);
if((Options & int(StandardCompressedFormat)) && (!expr.isCompressed()))
{
m_object = expr;
Base::construct(m_object);
}
else
{
Base::construct(expr);
}
}
template<typename Expression>

18
test/sparse_ref.cpp
View File

@ -47,12 +47,20 @@ EIGEN_DONT_INLINE void call_ref_1(Ref<SparseMatrix<float> > a, const B &b) { VER
template<typename B>
EIGEN_DONT_INLINE void call_ref_2(const Ref<const SparseMatrix<float> >& a, const B &b) { VERIFY_IS_EQUAL(a.toDense(),b.toDense()); }
template<typename B>
EIGEN_DONT_INLINE void call_ref_3(const Ref<const SparseMatrix<float>, StandardCompressedFormat>& a, const B &b) {
VERIFY(a.isCompressed());
VERIFY_IS_EQUAL(a.toDense(),b.toDense());
}
void call_ref()
{
// SparseVector<std::complex<float> > ca = VectorXcf::Random(10).sparseView();
// SparseVector<float> a = VectorXf::Random(10).sparseView();
SparseMatrix<float> A = MatrixXf::Random(10,10).sparseView(0.5,1);
SparseMatrix<float,RowMajor> B = MatrixXf::Random(10,10).sparseView(0.5,1);
SparseMatrix<float> C = MatrixXf::Random(10,10).sparseView(0.5,1);
C.reserve(VectorXi::Constant(C.outerSize(), 2));
const SparseMatrix<float>& Ac(A);
Block<SparseMatrix<float> > Ab(A,0,1, 3,3);
const Block<SparseMatrix<float> > Abc(A,0,1,3,3);
@ -61,12 +69,22 @@ void call_ref()
VERIFY_EVALUATION_COUNT( call_ref_1(A, A), 0);
// VERIFY_EVALUATION_COUNT( call_ref_1(Ac, Ac), 0); // does not compile on purpose
VERIFY_EVALUATION_COUNT( call_ref_2(A, A), 0);
VERIFY_EVALUATION_COUNT( call_ref_3(A, A), 0);
VERIFY_EVALUATION_COUNT( call_ref_2(A.transpose(), A.transpose()), 1);
VERIFY_EVALUATION_COUNT( call_ref_3(A.transpose(), A.transpose()), 1);
VERIFY_EVALUATION_COUNT( call_ref_2(Ac,Ac), 0);
VERIFY_EVALUATION_COUNT( call_ref_3(Ac,Ac), 0);
VERIFY_EVALUATION_COUNT( call_ref_2(A+A,2*Ac), 1);
VERIFY_EVALUATION_COUNT( call_ref_3(A+A,2*Ac), 1);
VERIFY_EVALUATION_COUNT( call_ref_2(B, B), 1);
VERIFY_EVALUATION_COUNT( call_ref_3(B, B), 1);
VERIFY_EVALUATION_COUNT( call_ref_2(B.transpose(), B.transpose()), 0);
VERIFY_EVALUATION_COUNT( call_ref_3(B.transpose(), B.transpose()), 0);
VERIFY_EVALUATION_COUNT( call_ref_2(A*A, A*A), 1);
VERIFY_EVALUATION_COUNT( call_ref_3(A*A, A*A), 1);
VERIFY(!C.isCompressed());
VERIFY_EVALUATION_COUNT( call_ref_3(C, C), 1);
Ref<SparseMatrix<float> > Ar(A);
VERIFY_IS_APPROX(Ar+Ar, A+A);