A versatible sparse matrix representation. More...

Inheritance diagram for Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >:

Classes
struct	IndexPosPair

class	SingletonVector

Public Types
enum	{ Options }

typedef Diagonal< const SparseMatrix >	ConstDiagonalReturnType

typedef Diagonal< SparseMatrix >	DiagonalReturnType

typedef Base::IndexVector	IndexVector

typedef Eigen::Map< SparseMatrix< Scalar, Options_, StorageIndex > >	Map

typedef Base::ScalarVector	ScalarVector

typedef internal::CompressedStorage< Scalar, StorageIndex >	Storage

Public Types inherited from Eigen::SparseCompressedBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >
typedef SparseMatrixBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >	Base

Public Types inherited from Eigen::SparseMatrixBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >
enum

typedef std::conditional_t< NumTraits< Scalar >::IsComplex, CwiseUnaryOp< internal::scalar_conjugate_op< Scalar >, Eigen::Transpose< const SparseMatrix< Scalar_, Options_, StorageIndex_ > > >, Transpose< const SparseMatrix< Scalar_, Options_, StorageIndex_ > > >	AdjointReturnType

typedef Transpose< const SparseMatrix< Scalar_, Options_, StorageIndex_ > >	ConstTransposeReturnType

typedef Matrix< StorageIndex, Dynamic, 1 >	IndexVector

typedef internal::add_const_on_value_type_if_arithmetic< typename internal::packet_traits< Scalar >::type >::type	PacketReturnType

typedef internal::packet_traits< Scalar >::type	PacketScalar

typedef SparseMatrix< Scalar, Flags &RowMajorBit ? RowMajor :ColMajor, StorageIndex >	PlainObject

typedef internal::traits< SparseMatrix< Scalar_, Options_, StorageIndex_ > >::Scalar	Scalar

typedef Matrix< Scalar, Dynamic, 1 >	ScalarVector

typedef SparseMatrixBase	StorageBaseType

typedef internal::traits< SparseMatrix< Scalar_, Options_, StorageIndex_ > >::StorageIndex	StorageIndex

typedef internal::traits< SparseMatrix< Scalar_, Options_, StorageIndex_ > >::StorageKind	StorageKind

typedef Transpose< SparseMatrix< Scalar_, Options_, StorageIndex_ > >	TransposeReturnType

typedef Scalar	value_type

Public Types inherited from Eigen::EigenBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >
typedef Eigen::Index	Index
	The interface type of indices. More...

typedef internal::traits< SparseMatrix< Scalar_, Options_, StorageIndex_ > >::StorageKind	StorageKind

Public Member Functions
Scalar	coeff (Index row, Index col) const

Scalar &	coeffRef (Index row, Index col)

template<typename Derived , typename DupFunctor >
void	collapseDuplicates (DenseBase< Derived > &wi, DupFunctor dup_func=DupFunctor())

Index	cols () const

void	conservativeResize (Index rows, Index cols)

Storage &	data ()

const Storage &	data () const

DiagonalReturnType	diagonal ()

const ConstDiagonalReturnType	diagonal () const

void	finalize ()

StorageIndex *	innerIndexPtr ()

const StorageIndex *	innerIndexPtr () const

StorageIndex *	innerNonZeroPtr ()

const StorageIndex *	innerNonZeroPtr () const

Index	innerSize () const

Scalar &	insert (Index row, Index col)

Scalar &	insertBack (Index row, Index col)

Scalar &	insertBackByOuterInner (Index outer, Index inner)

Scalar &	insertBackByOuterInnerUnordered (Index outer, Index inner)

Scalar &	insertBackUncompressed (Index row, Index col)

Scalar &	insertByOuterInner (Index j, Index i)

void	insertEmptyOuterVectors (Index j, Index num=1)

template<typename InputIterators >
void	insertFromSortedTriplets (const InputIterators &begin, const InputIterators &end)

template<typename InputIterators , typename DupFunctor >
void	insertFromSortedTriplets (const InputIterators &begin, const InputIterators &end, DupFunctor dup_func)

template<typename InputIterators >
void	insertFromTriplets (const InputIterators &begin, const InputIterators &end)

template<typename InputIterators , typename DupFunctor >
void	insertFromTriplets (const InputIterators &begin, const InputIterators &end, DupFunctor dup_func)

bool	isCompressed () const

void	makeCompressed ()

Index	nonZeros () const

SparseMatrix &	operator= (const SparseMatrix &other)

template<typename OtherDerived >
EIGEN_DONT_INLINE SparseMatrix &	operator= (const SparseMatrixBase< OtherDerived > &other)

template<typename OtherDerived >
EIGEN_DONT_INLINE SparseMatrix< Scalar, Options_, StorageIndex_ > &	operator= (const SparseMatrixBase< OtherDerived > &other)

SparseMatrix &	operator= (SparseMatrix &&other)

StorageIndex *	outerIndexPtr ()

const StorageIndex *	outerIndexPtr () const

Index	outerSize () const

template<typename KeepFunc >
void	prune (const KeepFunc &keep=KeepFunc())

void	prune (const Scalar &reference, const RealScalar &epsilon=NumTraits< RealScalar >::dummy_precision())

void	removeOuterVectors (Index j, Index num=1)

template<class SizesType >
void	reserve (const SizesType &reserveSizes)

void	reserve (Index reserveSize)

void	resize (Index rows, Index cols)

void	resizeNonZeros (Index size)

Index	rows () const

template<typename InputIterators >
void	setFromSortedTriplets (const InputIterators &begin, const InputIterators &end)

template<typename InputIterators , typename DupFunctor >
void	setFromSortedTriplets (const InputIterators &begin, const InputIterators &end, DupFunctor dup_func)

template<typename InputIterators >
void	setFromTriplets (const InputIterators &begin, const InputIterators &end)

template<typename InputIterators , typename DupFunctor >
void	setFromTriplets (const InputIterators &begin, const InputIterators &end, DupFunctor dup_func)

void	setIdentity ()

void	setZero ()

	SparseMatrix ()

template<typename OtherDerived >
	SparseMatrix (const DiagonalBase< OtherDerived > &other)
	Copy constructor with in-place evaluation. More...

template<typename OtherDerived >
	SparseMatrix (const ReturnByValue< OtherDerived > &other)
	Copy constructor with in-place evaluation. More...

	SparseMatrix (const SparseMatrix &other)

template<typename OtherDerived >
	SparseMatrix (const SparseMatrixBase< OtherDerived > &other)

template<typename OtherDerived , unsigned int UpLo>
	SparseMatrix (const SparseSelfAdjointView< OtherDerived, UpLo > &other)

	SparseMatrix (Index rows, Index cols)

	SparseMatrix (SparseMatrix &&other)

void	startVec (Index outer)

Scalar	sum () const

void	swap (SparseMatrix &other)

void	uncompress ()

Scalar *	valuePtr ()

const Scalar *	valuePtr () const

	~SparseMatrix ()

Public Member Functions inherited from Eigen::SparseCompressedBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >
Map< Array< Scalar, Dynamic, 1 > >	coeffs ()

const Map< const Array< Scalar, Dynamic, 1 > >	coeffs () const

StorageIndex *	innerIndexPtr ()

const StorageIndex *	innerIndexPtr () const

Index	innerIndicesAreSorted () const

Index	innerIndicesAreSorted (Index begin, Index end) const

StorageIndex *	innerNonZeroPtr ()

const StorageIndex *	innerNonZeroPtr () const

bool	isCompressed () const

Index	nonZeros () const

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator= (const EigenBase< OtherDerived > &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator= (const ReturnByValue< OtherDerived > &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator= (const SparseMatrix< Scalar_, Options_, StorageIndex_ > &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator= (const SparseMatrixBase< OtherDerived > &other)

StorageIndex *	outerIndexPtr ()

const StorageIndex *	outerIndexPtr () const

void	sortInnerIndices ()

void	sortInnerIndices (Index begin, Index end)

Scalar *	valuePtr ()

const Scalar *	valuePtr () const

Public Member Functions inherited from Eigen::SparseMatrixBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >
const AdjointReturnType	adjoint () const

RealScalar	blueNorm () const

Index	cols () const

const SparseMatrixBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >::template CwiseProductDenseReturnType< OtherDerived >::Type	cwiseProduct (const MatrixBase< OtherDerived > &other) const

const CwiseProductDenseReturnType< OtherDerived >::Type	cwiseProduct (const MatrixBase< OtherDerived > &other) const

internal::traits< SparseMatrix< Scalar_, Options_, StorageIndex_ > >::Scalar	dot (const MatrixBase< OtherDerived > &other) const

Scalar	dot (const MatrixBase< OtherDerived > &other) const

internal::traits< SparseMatrix< Scalar_, Options_, StorageIndex_ > >::Scalar	dot (const SparseMatrixBase< OtherDerived > &other) const

Scalar	dot (const SparseMatrixBase< OtherDerived > &other) const

const internal::eval< SparseMatrix< Scalar_, Options_, StorageIndex_ > >::type	eval () const

Index	innerSize () const

bool	isApprox (const MatrixBase< OtherDerived > &other, const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const

bool	isApprox (const SparseMatrixBase< OtherDerived > &other, const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const

bool	isRValue () const

bool	isVector () const

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	markAsRValue ()

RealScalar	norm () const

const Product< SparseMatrix< Scalar_, Options_, StorageIndex_ >, OtherDerived >	operator* (const DiagonalBase< OtherDerived > &other) const

const Product< SparseMatrix< Scalar_, Options_, StorageIndex_ >, OtherDerived >	operator* (const MatrixBase< OtherDerived > &other) const

const Product< SparseMatrix< Scalar_, Options_, StorageIndex_ >, OtherDerived, AliasFreeProduct >	operator* (const SparseMatrixBase< OtherDerived > &other) const

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator*= (const Scalar &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator*= (const SparseMatrixBase< OtherDerived > &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator+= (const DiagonalBase< OtherDerived > &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator+= (const EigenBase< OtherDerived > &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator+= (const SparseMatrixBase< OtherDerived > &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator-= (const DiagonalBase< OtherDerived > &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator-= (const EigenBase< OtherDerived > &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator-= (const SparseMatrixBase< OtherDerived > &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator/= (const Scalar &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator= (const EigenBase< OtherDerived > &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator= (const ReturnByValue< OtherDerived > &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator= (const SparseMatrix< Scalar_, Options_, StorageIndex_ > &other)

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator= (const SparseMatrixBase< OtherDerived > &other)

Index	outerSize () const

const SparseView< SparseMatrix< Scalar_, Options_, StorageIndex_ > >	pruned (const Scalar &reference=Scalar(0), const RealScalar &epsilon=NumTraits< Scalar >::dummy_precision()) const

Index	rows () const

SelfAdjointViewReturnType< UpLo >::Type	selfadjointView ()

SparseMatrixBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >::template SelfAdjointViewReturnType< UpLo >::Type	selfadjointView ()

ConstSelfAdjointViewReturnType< UpLo >::Type	selfadjointView () const

SparseMatrixBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >::template ConstSelfAdjointViewReturnType< UpLo >::Type	selfadjointView () const

Index	size () const

	SparseMatrixBase ()

RealScalar	squaredNorm () const

Scalar	sum () const

DenseMatrixType	toDense () const

TransposeReturnType	transpose ()

const ConstTransposeReturnType	transpose () const

const TriangularView< const SparseMatrix< Scalar_, Options_, StorageIndex_ >, Mode >	triangularView () const

SparseSymmetricPermutationProduct< SparseMatrix< Scalar_, Options_, StorageIndex_ >, Upper\|Lower >	twistedBy (const PermutationMatrix< Dynamic, Dynamic, StorageIndex > &perm) const

Public Member Functions inherited from Eigen::EigenBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >
void	addTo (Dest &dst) const

void	applyThisOnTheLeft (Dest &dst) const

void	applyThisOnTheRight (Dest &dst) const

EIGEN_CONSTEXPR Index	cols () const EIGEN_NOEXCEPT

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	const_cast_derived () const

const SparseMatrix< Scalar_, Options_, StorageIndex_ > &	const_derived () const

SparseMatrix< Scalar_, Options_, StorageIndex_ > &	derived ()

const SparseMatrix< Scalar_, Options_, StorageIndex_ > &	derived () const

void	evalTo (Dest &dst) const

EIGEN_CONSTEXPR Index	rows () const EIGEN_NOEXCEPT

EIGEN_CONSTEXPR Index	size () const EIGEN_NOEXCEPT

void	subTo (Dest &dst) const

Protected Types
typedef SparseMatrix< Scalar, IsRowMajor ? ColMajor :RowMajor, StorageIndex >	TransposedSparseMatrix

Protected Types inherited from Eigen::SparseCompressedBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >
typedef Base::IndexVector	IndexVector

Protected Member Functions
template<typename DiagXpr , typename Func >
void	assignDiagonal (const DiagXpr diagXpr, const Func &assignFunc)

template<typename Other >
void	initAssignment (const Other &other)

Scalar &	insertAtByOuterInner (Index outer, Index inner, Index dst)

EIGEN_DEPRECATED EIGEN_DONT_INLINE Scalar &	insertCompressed (Index row, Index col)

Scalar &	insertCompressedAtByOuterInner (Index outer, Index inner, Index dst)

EIGEN_DEPRECATED EIGEN_DONT_INLINE Scalar &	insertUncompressed (Index row, Index col)

Scalar &	insertUncompressedAtByOuterInner (Index outer, Index inner, Index dst)

template<class SizesType >
void	reserveInnerVectors (const SizesType &reserveSizes)

Protected Member Functions inherited from Eigen::SparseCompressedBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >
Eigen::Map< IndexVector >	innerNonZeros ()

const Eigen::Map< const IndexVector >	innerNonZeros () const

internal::LowerBoundIndex	lower_bound (Index row, Index col) const

	SparseCompressedBase ()

Protected Member Functions inherited from Eigen::SparseMatrixBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >
SparseMatrix< Scalar_, Options_, StorageIndex_ > &	assign (const OtherDerived &other)

void	assignGeneric (const OtherDerived &other)

Protected Attributes
Storage	m_data

StorageIndex *	m_innerNonZeros

Index	m_innerSize

StorageIndex *	m_outerIndex

Index	m_outerSize

Protected Attributes inherited from Eigen::SparseMatrixBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >
bool	m_isRValue

Private Types
typedef SparseCompressedBase< SparseMatrix >	Base

Private Member Functions
	EIGEN_STATIC_ASSERT ((Options &(ColMajor\|RowMajor))==Options, INVALID_MATRIX_TEMPLATE_PARAMETERS) struct default_prunning_func

Additional Inherited Members
Static Protected Member Functions inherited from Eigen::SparseMatrixBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >
static StorageIndex	convert_index (const Index idx)

Detailed Description

template<typename Scalar_, int Options_, typename StorageIndex_>
class Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >

A versatible sparse matrix representation.

This class implements a more versatile variants of the common compressed row/column storage format. Each colmun's (resp. row) non zeros are stored as a pair of value with associated row (resp. colmiun) index. All the non zeros are stored in a single large buffer. Unlike the compressed format, there might be extra space in between the nonzeros of two successive colmuns (resp. rows) such that insertion of new non-zero can be done with limited memory reallocation and copies.

A call to the function makeCompressed() turns the matrix into the standard compressed format compatible with many library.

More details on this storage sceheme are given in the manual pages.

Template Parameters

Scalar_	the scalar type, i.e. the type of the coefficients
Options_	Union of bit flags controlling the storage scheme. Currently the only possibility is ColMajor or RowMajor. The default is 0 which means column-major.
StorageIndex_	the type of the indices. It has to be a signed type (e.g., short, int, std::ptrdiff_t). Default is `int`.

Warning: In Eigen 3.2, the undocumented type SparseMatrix::Index was improperly defined as the storage index type (e.g., int), whereas it is now (starting from Eigen 3.3) deprecated and always defined as Eigen::Index. Codes making use of SparseMatrix::Index, might thus likely have to be changed to use SparseMatrix::StorageIndex instead.

This class can be extended with the help of the plugin mechanism described on the page Extending MatrixBase (and other classes) by defining the preprocessor symbol EIGEN_SPARSEMATRIX_PLUGIN.

Definition at line 123 of file SparseMatrix.h.

Member Typedef Documentation

◆ Base

template<typename Scalar_ , int Options_, typename StorageIndex_ >

typedef SparseCompressedBase<SparseMatrix> Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::Base

private

Definition at line 126 of file SparseMatrix.h.

◆ ConstDiagonalReturnType

template<typename Scalar_ , int Options_, typename StorageIndex_ >

typedef Diagonal<const SparseMatrix> Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::ConstDiagonalReturnType

Definition at line 140 of file SparseMatrix.h.

◆ DiagonalReturnType

template<typename Scalar_ , int Options_, typename StorageIndex_ >

typedef Diagonal<SparseMatrix> Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::DiagonalReturnType

Definition at line 139 of file SparseMatrix.h.

◆ IndexVector

template<typename Scalar_ , int Options_, typename StorageIndex_ >

typedef Base::IndexVector Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::IndexVector

Definition at line 151 of file SparseMatrix.h.

◆ Map

template<typename Scalar_ , int Options_, typename StorageIndex_ >

typedef Eigen::Map<SparseMatrix<Scalar,Options_,StorageIndex> > Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::Map

Definition at line 138 of file SparseMatrix.h.

◆ ScalarVector

template<typename Scalar_ , int Options_, typename StorageIndex_ >

typedef Base::ScalarVector Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::ScalarVector

Definition at line 152 of file SparseMatrix.h.

◆ Storage

template<typename Scalar_ , int Options_, typename StorageIndex_ >

typedef internal::CompressedStorage<Scalar,StorageIndex> Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::Storage

Definition at line 146 of file SparseMatrix.h.

◆ TransposedSparseMatrix

template<typename Scalar_ , int Options_, typename StorageIndex_ >

typedef SparseMatrix<Scalar, IsRowMajor ? ColMajor : RowMajor, StorageIndex> Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::TransposedSparseMatrix

protected

Definition at line 154 of file SparseMatrix.h.

Member Enumeration Documentation

◆ anonymous enum

template<typename Scalar_ , int Options_, typename StorageIndex_ >

anonymous enum

Enumerator
Options

Definition at line 147 of file SparseMatrix.h.

          {
       Options = Options_
     };

Constructor & Destructor Documentation

◆ SparseMatrix() [1/8]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::SparseMatrix ( )

inline

Default constructor yielding an empty 0 x 0 matrix

Definition at line 773 of file SparseMatrix.h.

       : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
     {
       resize(0, 0);
     }

◆ SparseMatrix() [2/8]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::SparseMatrix	(	Index	rows,
		Index	cols
	)

inline

Constructs a rows x cols empty matrix

Definition at line 780 of file SparseMatrix.h.

       : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
     {
       resize(rows, cols);
     }

◆ SparseMatrix() [3/8]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename OtherDerived >

Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::SparseMatrix ( const SparseMatrixBase< OtherDerived > & other )

inline

Constructs a sparse matrix from the sparse expression other

Definition at line 788 of file SparseMatrix.h.

       : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
     {
       EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
         YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
       const bool needToTranspose = (Flags & RowMajorBit) != (internal::evaluator<OtherDerived>::Flags & RowMajorBit);
       if (needToTranspose)
         *this = other.derived();
       else
       {
         #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
           EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
         #endif
         internal::call_assignment_no_alias(*this, other.derived());
       }
     }

◆ SparseMatrix() [4/8]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename OtherDerived , unsigned int UpLo>

Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::SparseMatrix ( const SparseSelfAdjointView< OtherDerived, UpLo > & other )

inline

Constructs a sparse matrix from the sparse selfadjoint view other

Definition at line 807 of file SparseMatrix.h.

       : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
     {
       Base::operator=(other);
     }

◆ SparseMatrix() [5/8]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::SparseMatrix ( SparseMatrix< Scalar_, Options_, StorageIndex_ > && other )

inline

Definition at line 813 of file SparseMatrix.h.

                                               : Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
     {
       *this = other.derived().markAsRValue();
     }

◆ SparseMatrix() [6/8]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::SparseMatrix ( const SparseMatrix< Scalar_, Options_, StorageIndex_ > & other )

inline

Copy constructor (it performs a deep copy)

Definition at line 819 of file SparseMatrix.h.

       : Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
     {
       *this = other.derived();
     }

◆ SparseMatrix() [7/8]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename OtherDerived >

Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::SparseMatrix ( const ReturnByValue< OtherDerived > & other )

inline

Copy constructor with in-place evaluation.

Definition at line 827 of file SparseMatrix.h.

       : Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
     {
       initAssignment(other);
       other.evalTo(*this);
     }

◆ SparseMatrix() [8/8]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename OtherDerived >

Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::SparseMatrix ( const DiagonalBase< OtherDerived > & other )

inlineexplicit

Copy constructor with in-place evaluation.

Definition at line 836 of file SparseMatrix.h.

       : Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
     {
       *this = other.derived();
     }

◆ ~SparseMatrix()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::~SparseMatrix ( )

inline

Destructor

Definition at line 958 of file SparseMatrix.h.

     {
       internal::conditional_aligned_delete_auto<StorageIndex, true>(m_outerIndex, m_outerSize + 1);
       internal::conditional_aligned_delete_auto<StorageIndex, true>(m_innerNonZeros, m_outerSize);
     }

Member Function Documentation

◆ assignDiagonal()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename DiagXpr , typename Func >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::assignDiagonal	(	const DiagXpr	diagXpr,
		const Func &	assignFunc
	)

inlineprotected

Definition at line 1037 of file SparseMatrix.h.

     {
       
       constexpr StorageIndex kEmptyIndexVal(-1);
       typedef typename ScalarVector::AlignedMapType ValueMap;
  
       Index n = diagXpr.size();
  
       const bool overwrite = internal::is_same<Func, internal::assign_op<Scalar,Scalar> >::value;
       if(overwrite)
       {
         if((m_outerSize != n) || (m_innerSize != n))
           resize(n, n);
       }
  
       if(m_data.size()==0 || overwrite)
       {
         internal::conditional_aligned_delete_auto<StorageIndex, true>(m_innerNonZeros, m_outerSize);
         m_innerNonZeros = 0;
         resizeNonZeros(n);
         ValueMap valueMap(valuePtr(), n);
         std::iota(m_outerIndex, m_outerIndex + n + 1, StorageIndex(0));
         std::iota(innerIndexPtr(), innerIndexPtr() + n, StorageIndex(0));
         valueMap.setZero();
         internal::call_assignment_no_alias(valueMap, diagXpr, assignFunc);
       }
       else
       {
           internal::evaluator<DiagXpr> diaEval(diagXpr);
  
           ei_declare_aligned_stack_constructed_variable(StorageIndex, tmp, n, 0);
           typename IndexVector::AlignedMapType insertionLocations(tmp, n);
           insertionLocations.setConstant(kEmptyIndexVal);
  
           Index deferredInsertions = 0;
           Index shift = 0;
  
           for (Index j = 0; j < n; j++) {
             Index begin = m_outerIndex[j];
             Index end = isCompressed() ? m_outerIndex[j + 1] : begin + m_innerNonZeros[j];
             Index capacity = m_outerIndex[j + 1] - end;
             Index dst = m_data.searchLowerIndex(begin, end, j);
             // the entry exists: update it now
             if (dst != end && m_data.index(dst) == StorageIndex(j)) assignFunc.assignCoeff(m_data.value(dst), diaEval.coeff(j));
             // the entry belongs at the back of the vector: push to back
             else if (dst == end && capacity > 0)
               assignFunc.assignCoeff(insertBackUncompressed(j, j), diaEval.coeff(j));
             // the insertion requires a data move, record insertion location and handle in second pass
             else {
               insertionLocations.coeffRef(j) = StorageIndex(dst);
               deferredInsertions++;
               // if there is no capacity, all vectors to the right of this are shifted
               if (capacity == 0) shift++;
             }
           }
           
           if (deferredInsertions > 0) {
  
             m_data.resize(m_data.size() + shift);
             Index copyEnd = isCompressed() ? m_outerIndex[m_outerSize]
                                            : m_outerIndex[m_outerSize - 1] + m_innerNonZeros[m_outerSize - 1];
             for (Index j = m_outerSize - 1; deferredInsertions > 0; j--) {
               Index begin = m_outerIndex[j];
               Index end = isCompressed() ? m_outerIndex[j + 1] : begin + m_innerNonZeros[j];
               Index capacity = m_outerIndex[j + 1] - end;
  
               bool doInsertion = insertionLocations(j) >= 0;
               bool breakUpCopy = doInsertion && (capacity > 0);
               // break up copy for sorted insertion into inactive nonzeros
               // optionally, add another criterium, i.e. 'breakUpCopy || (capacity > threhsold)'
               // where `threshold >= 0` to skip inactive nonzeros in each vector
               // this reduces the total number of copied elements, but requires more moveChunk calls
               if (breakUpCopy) {
                 Index copyBegin = m_outerIndex[j + 1];
                 Index to = copyBegin + shift;
                 Index chunkSize = copyEnd - copyBegin;
                 m_data.moveChunk(copyBegin, to, chunkSize);
                 copyEnd = end;
               }
  
               m_outerIndex[j + 1] += shift;
               
               if (doInsertion) {
                 // if there is capacity, shift into the inactive nonzeros
                 if (capacity > 0) shift++;
                 Index copyBegin = insertionLocations(j);
                 Index to = copyBegin + shift;
                 Index chunkSize = copyEnd - copyBegin;
                 m_data.moveChunk(copyBegin, to, chunkSize);
                 Index dst = to - 1;
                 m_data.index(dst) = StorageIndex(j);
                 m_data.value(dst) = Scalar(0);
                 assignFunc.assignCoeff(m_data.value(dst), diaEval.coeff(j));
                 if (!isCompressed()) m_innerNonZeros[j]++;
                 shift--;
                 deferredInsertions--;
                 copyEnd = copyBegin;
               }
             }
           }     
           eigen_assert((shift == 0) && (deferredInsertions == 0));
       }
     }

◆ coeff()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Scalar Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::coeff	(	Index	row,
		Index	col
	)		const

inline

Returns: the value of the matrix at position i, j This function returns Scalar(0) if the element is an explicit zero

Definition at line 217 of file SparseMatrix.h.

     {
       eigen_assert(row>=0 && row<rows() && col>=0 && col<cols());
       
       const Index outer = IsRowMajor ? row : col;
       const Index inner = IsRowMajor ? col : row;
       Index end = m_innerNonZeros ? m_outerIndex[outer] + m_innerNonZeros[outer] : m_outerIndex[outer+1];
       return m_data.atInRange(m_outerIndex[outer], end, inner);
     }

◆ coeffRef()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Scalar& Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::coeffRef	(	Index	row,
		Index	col
	)

inline

Returns: a non-const reference to the value of the matrix at position i, j

If the element does not exist then it is inserted via the insert(Index,Index) function which itself turns the matrix into a non compressed form if that was not the case.

This is a O(log(nnz_j)) operation (binary search) plus the cost of insert(Index,Index) function if the element does not already exist.

Definition at line 235 of file SparseMatrix.h.

     {
       eigen_assert(row>=0 && row<rows() && col>=0 && col<cols());
       const Index outer = IsRowMajor ? row : col;
       const Index inner = IsRowMajor ? col : row;
       Index start = m_outerIndex[outer];
       Index end = isCompressed() ? m_outerIndex[outer + 1] : m_outerIndex[outer] + m_innerNonZeros[outer];
       eigen_assert(end >= start && "you probably called coeffRef on a non finalized matrix");
       Index dst = start == end ? end : m_data.searchLowerIndex(start, end, inner);
       if (dst == end) {
         Index capacity = m_outerIndex[outer + 1] - end;
         if (capacity > 0) {
           // implies uncompressed: push to back of vector
           m_innerNonZeros[outer]++;
           m_data.index(end) = StorageIndex(inner);
           m_data.value(end) = Scalar(0);
           return m_data.value(end);
         }
       }
       if ((dst < end) && (m_data.index(dst) == inner))
         // this coefficient exists, return a refernece to it
         return m_data.value(dst);
       else
         // insertion will require reconfiguring the buffer
         return insertAtByOuterInner(outer, inner, dst);
     }

◆ collapseDuplicates()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename Derived , typename DupFunctor >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::collapseDuplicates	(	DenseBase< Derived > &	wi,
		DupFunctor	dup_func = `DupFunctor()`
	)

Definition at line 1506 of file SparseMatrix.h.

                                                                                                                    {
   // removes duplicate entries and compresses the matrix
   // the excess allocated memory is not released
   // the inner indices do not need to be sorted, nor is the matrix returned in a sorted state
   eigen_assert(wi.size() == m_innerSize);
   constexpr StorageIndex kEmptyIndexValue(-1);
   wi.setConstant(kEmptyIndexValue);
   StorageIndex count = 0;
   const bool is_compressed = isCompressed();
   // for each inner-vector, wi[inner_index] will hold the position of first element into the index/value buffers
   for (Index j = 0; j < m_outerSize; ++j) {
     const StorageIndex newBegin = count;
     const StorageIndex end = is_compressed ? m_outerIndex[j + 1] : m_outerIndex[j] + m_innerNonZeros[j];
     for (StorageIndex k = m_outerIndex[j]; k < end; ++k) {
       StorageIndex i = m_data.index(k);
       if (wi(i) >= newBegin) {
         // entry at k is a duplicate
         // accumulate it into the primary entry located at wi(i)
         m_data.value(wi(i)) = dup_func(m_data.value(wi(i)), m_data.value(k));
       } else {
         // k is the primary entry in j with inner index i
         // shift it to the left and record its location at wi(i)
         m_data.index(count) = i;
         m_data.value(count) = m_data.value(k);
         wi(i) = count;
         ++count;
       }
     }
     m_outerIndex[j] = newBegin;
   }
   m_outerIndex[m_outerSize] = count;
   m_data.resize(count);
  
   // turn the matrix into compressed form (if it is not already)
   internal::conditional_aligned_delete_auto<StorageIndex, true>(m_innerNonZeros, m_outerSize);
   m_innerNonZeros = 0;
 }

◆ cols()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Index Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols ( void ) const

inline

Returns: the number of columns of the matrix

Definition at line 167 of file SparseMatrix.h.

167 { return IsRowMajor ? m_innerSize : m_outerSize; }

◆ conservativeResize()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::conservativeResize	(	Index	rows,
		Index	cols
	)

inline

Resizes the matrix to a rows x cols matrix leaving old values untouched.

If the sizes of the matrix are decreased, then the matrix is turned to uncompressed-mode and the storage of the out of bounds coefficients is kept and reserved. Call makeCompressed() to pack the entries and squeeze extra memory.

See also: reserve(), setZero(), makeCompressed()

Definition at line 686 of file SparseMatrix.h.

                                                     {
  
       // If one dimension is null, then there is nothing to be preserved
       if (rows == 0 || cols == 0) return resize(rows, cols);
  
       Index newOuterSize = IsRowMajor ? rows : cols;
       Index newInnerSize = IsRowMajor ? cols : rows;
  
       Index innerChange = newInnerSize - m_innerSize;
       Index outerChange = newOuterSize - m_outerSize;
  
       if (outerChange != 0) {
         m_outerIndex = internal::conditional_aligned_realloc_new_auto<StorageIndex, true>(
             m_outerIndex, newOuterSize + 1, m_outerSize + 1);
  
         if (!isCompressed())
           m_innerNonZeros = internal::conditional_aligned_realloc_new_auto<StorageIndex, true>(
               m_innerNonZeros, newOuterSize, m_outerSize);
  
         if (outerChange > 0) {
           StorageIndex lastIdx = m_outerSize == 0 ? StorageIndex(0) : m_outerIndex[m_outerSize];
           std::fill_n(m_outerIndex + m_outerSize, outerChange + 1, lastIdx);
  
           if (!isCompressed()) std::fill_n(m_innerNonZeros + m_outerSize, outerChange, StorageIndex(0));
         }
       }
       m_outerSize = newOuterSize;
  
       if (innerChange < 0) {
         for (Index j = 0; j < m_outerSize; j++) {
           Index start = m_outerIndex[j];
           Index end = isCompressed() ? m_outerIndex[j + 1] : start + m_innerNonZeros[j];
           Index lb = m_data.searchLowerIndex(start, end, newInnerSize);
           if (lb != end) {
             uncompress();
             m_innerNonZeros[j] = StorageIndex(lb - start);
           }
         }
       }
       m_innerSize = newInnerSize;
  
       Index newSize = m_outerIndex[m_outerSize];
       eigen_assert(newSize <= m_data.size());
       m_data.resize(newSize);
     }

◆ data() [1/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Storage& Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::data ( )

inline

Definition at line 211 of file SparseMatrix.h.

211 { return m_data; }

◆ data() [2/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

const Storage& Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::data ( ) const

inline

Definition at line 213 of file SparseMatrix.h.

213 { return m_data; }

◆ diagonal() [1/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

DiagonalReturnType Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::diagonal ( )

inline

Returns: a read-write expression of the diagonal coefficients.

Warning: If the diagonal entries are written, then all diagonal entries must already exist, otherwise an assertion will be raised.

Definition at line 770 of file SparseMatrix.h.

770 { return DiagonalReturnType(*this); }

Eigen::SparseMatrix::DiagonalReturnType

Diagonal< SparseMatrix > DiagonalReturnType

Definition: SparseMatrix.h:139

◆ diagonal() [2/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

const ConstDiagonalReturnType Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::diagonal ( ) const

inline

Returns: a const expression of the diagonal coefficients.

Definition at line 764 of file SparseMatrix.h.

764 { return ConstDiagonalReturnType(*this); }

Eigen::SparseMatrix::ConstDiagonalReturnType

Diagonal< const SparseMatrix > ConstDiagonalReturnType

Definition: SparseMatrix.h:140

◆ EIGEN_STATIC_ASSERT()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::EIGEN_STATIC_ASSERT	(	(Options &(ColMajor\|RowMajor))	= `=Options`,
		INVALID_MATRIX_TEMPLATE_PARAMETERS
	)

inlineprivate

Definition at line 1148 of file SparseMatrix.h.

                                {
     default_prunning_func(const Scalar& ref, const RealScalar& eps) : reference(ref), epsilon(eps) {}
     inline bool operator() (const Index&, const Index&, const Scalar& value) const
     {
       return !internal::isMuchSmallerThan(value, reference, epsilon);
     }
     Scalar reference;
     RealScalar epsilon;
   };

◆ finalize()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::finalize ( )

inline

Definition at line 457 of file SparseMatrix.h.

     {
       if(isCompressed())
       {
         StorageIndex size = internal::convert_index<StorageIndex>(m_data.size());
         Index i = m_outerSize;
         // find the last filled column
         while (i>=0 && m_outerIndex[i]==0)
           --i;
         ++i;
         while (i<=m_outerSize)
         {
           m_outerIndex[i] = size;
           ++i;
         }
       }
     }

◆ initAssignment()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename Other >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::initAssignment ( const Other & other )

inlineprotected

Definition at line 974 of file SparseMatrix.h.

     {
       resize(other.rows(), other.cols());
       internal::conditional_aligned_delete_auto<StorageIndex, true>(m_innerNonZeros, m_outerSize);
       m_innerNonZeros = 0;
     }

◆ innerIndexPtr() [1/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

StorageIndex* Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::innerIndexPtr ( )

inline

Returns: a non-const pointer to the array of inner indices. This function is aimed at interoperability with other libraries.

See also: valuePtr(), outerIndexPtr()

Definition at line 190 of file SparseMatrix.h.

190 { return m_data.indexPtr(); }

◆ innerIndexPtr() [2/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

const StorageIndex* Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::innerIndexPtr ( ) const

inline

Returns: a const pointer to the array of inner indices. This function is aimed at interoperability with other libraries.

See also: valuePtr(), outerIndexPtr()

Definition at line 186 of file SparseMatrix.h.

186 { return m_data.indexPtr(); }

◆ innerNonZeroPtr() [1/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

StorageIndex* Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::innerNonZeroPtr ( )

inline

Returns: a non-const pointer to the array of the number of non zeros of the inner vectors. This function is aimed at interoperability with other libraries.

Warning: it returns the null pointer 0 in compressed mode

Definition at line 208 of file SparseMatrix.h.

208 { return m_innerNonZeros; }

◆ innerNonZeroPtr() [2/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

const StorageIndex* Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::innerNonZeroPtr ( ) const

inline

Returns: a const pointer to the array of the number of non zeros of the inner vectors. This function is aimed at interoperability with other libraries.

Warning: it returns the null pointer 0 in compressed mode

Definition at line 204 of file SparseMatrix.h.

204 { return m_innerNonZeros; }

◆ innerSize()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Index Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::innerSize ( ) const

inline

Returns: the number of rows (resp. columns) of the matrix if the storage order column major (resp. row major)

Definition at line 170 of file SparseMatrix.h.

170 { return m_innerSize; }

◆ insert()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

SparseMatrix< Scalar_, Options_, StorageIndex_ >::Scalar & Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insert	(	Index	row,
		Index	col
	)

inline

Returns: a reference to a novel non zero coefficient with coordinates row x col. The non zero coefficient must not already exist.

If the matrix *this is in compressed mode, then *this is turned into uncompressed mode while reserving room for 2 x this->innerSize() non zeros if reserve(Index) has not been called earlier. In this case, the insertion procedure is optimized for a sequential insertion mode where elements are assumed to be inserted by increasing outer-indices.

If that's not the case, then it is strongly recommended to either use a triplet-list to assemble the matrix, or to first call reserve(const SizesType &) to reserve the appropriate number of non-zero elements per inner vector.

Assuming memory has been appropriately reserved, this function performs a sorted insertion in O(1) if the elements of each inner vector are inserted in increasing inner index order, and in O(nnz_j) for a random insertion.

Definition at line 1620 of file SparseMatrix.h.

                                                                            {
   return insertByOuterInner(IsRowMajor ? row : col, IsRowMajor ? col : row);
 }

◆ insertAtByOuterInner()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

SparseMatrix< Scalar_, Options_, StorageIndex_ >::Scalar & Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertAtByOuterInner	(	Index	outer,
		Index	inner,
		Index	dst
	)

inlineprotected

Definition at line 1626 of file SparseMatrix.h.

                                                                                                         {
   // random insertion into compressed matrix is very slow
   uncompress();
   return insertUncompressedAtByOuterInner(outer, inner, dst);
 }

◆ insertBack()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Scalar& Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertBack	(	Index	row,
		Index	col
	)

inline

Definition at line 418 of file SparseMatrix.h.

     {
       return insertBackByOuterInner(IsRowMajor?row:col, IsRowMajor?col:row);
     }

◆ insertBackByOuterInner()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Scalar& Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertBackByOuterInner	(	Index	outer,
		Index	inner
	)

inline

Definition at line 425 of file SparseMatrix.h.

     {
       eigen_assert(Index(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)");
       StorageIndex p = m_outerIndex[outer+1];
       ++m_outerIndex[outer+1];
       m_data.append(Scalar(0), inner);
       return m_data.value(p);
     }

◆ insertBackByOuterInnerUnordered()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Scalar& Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertBackByOuterInnerUnordered	(	Index	outer,
		Index	inner
	)

inline

Definition at line 437 of file SparseMatrix.h.

     {
       StorageIndex p = m_outerIndex[outer+1];
       ++m_outerIndex[outer+1];
       m_data.append(Scalar(0), inner);
       return m_data.value(p);
     }

◆ insertBackUncompressed()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Scalar& Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertBackUncompressed	(	Index	row,
		Index	col
	)

inline

Definition at line 1007 of file SparseMatrix.h.

     {
       const Index outer = IsRowMajor ? row : col;
       const Index inner = IsRowMajor ? col : row;
  
       eigen_assert(!isCompressed());
       eigen_assert(m_innerNonZeros[outer]<=(m_outerIndex[outer+1] - m_outerIndex[outer]));
  
       Index p = m_outerIndex[outer] + m_innerNonZeros[outer]++;
       m_data.index(p) = StorageIndex(inner);
       m_data.value(p) = Scalar(0);
       return m_data.value(p);
     }

◆ insertByOuterInner()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Scalar& Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertByOuterInner	(	Index	j,
		Index	i
	)

inline

Definition at line 566 of file SparseMatrix.h.

     {
       Index start = m_outerIndex[j];
       Index end = isCompressed() ? m_outerIndex[j + 1] : start + m_innerNonZeros[j];
       Index dst = start == end ? end : m_data.searchLowerIndex(start, end, i);
       if (dst == end) {
         Index capacity = m_outerIndex[j + 1] - end;
         if (capacity > 0) {
           // implies uncompressed: push to back of vector
           m_innerNonZeros[j]++;
           m_data.index(end) = StorageIndex(i);
           m_data.value(end) = Scalar(0);
           return m_data.value(end);
         }
       }
       eigen_assert((dst == end || m_data.index(dst) != i) &&
           "you cannot insert an element that already exists, you must call coeffRef to this end");
       return insertAtByOuterInner(j, i, dst);
     }

◆ insertCompressed()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

EIGEN_DEPRECATED EIGEN_DONT_INLINE SparseMatrix< Scalar_, Options_, StorageIndex_ >::Scalar & Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertCompressed	(	Index	row,
		Index	col
	)

protected

Definition at line 1658 of file SparseMatrix.h.

                                                                                      {
   eigen_assert(isCompressed());
   Index outer = IsRowMajor ? row : col;
   Index inner = IsRowMajor ? col : row;
   Index start = m_outerIndex[outer];
   Index end = m_outerIndex[outer + 1];
   Index dst = start == end ? end : m_data.searchLowerIndex(start, end, inner);
   eigen_assert((dst == end || m_data.index(dst) != inner) &&
                "you cannot insert an element that already exists, you must call coeffRef to this end");
   return insertCompressedAtByOuterInner(outer, inner, dst);
 }

◆ insertCompressedAtByOuterInner()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

SparseMatrix< Scalar_, Options_, StorageIndex_ >::Scalar & Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertCompressedAtByOuterInner	(	Index	outer,
		Index	inner,
		Index	dst
	)

protected

Definition at line 1672 of file SparseMatrix.h.

                                                                                                                   {
   eigen_assert(isCompressed());
   // compressed insertion always requires expanding the buffer
   // first, check if there is adequate allocated memory
   if (m_data.allocatedSize() <= m_data.size()) {
     // if there is no capacity for a single insertion, double the capacity
     // increase capacity by a mininum of 32
     Index minReserve = 32;
     Index reserveSize = numext::maxi(minReserve, m_data.allocatedSize());
     m_data.reserve(reserveSize);
   }
   m_data.resize(m_data.size() + 1);
   Index chunkSize = m_outerIndex[m_outerSize] - dst;
   // shift the existing data to the right if necessary
   m_data.moveChunk(dst, dst + 1, chunkSize);
   // update nonzero counts
   // potentially O(outerSize) bottleneck!
   for (Index j = outer; j < m_outerSize; j++) m_outerIndex[j + 1]++;
   // initialize the coefficient
   m_data.index(dst) = StorageIndex(inner);
   m_data.value(dst) = Scalar(0);
   // return a reference to the coefficient
   return m_data.value(dst);
 }

◆ insertEmptyOuterVectors()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertEmptyOuterVectors	(	Index	j,
		Index	num = `1`
	)

inline

Definition at line 509 of file SparseMatrix.h.

                                                          {
       EIGEN_USING_STD(fill_n);
       eigen_assert(num >= 0 && j >= 0 && j < m_outerSize && "Invalid parameters");
  
       const Index newRows = IsRowMajor ? m_outerSize + num : rows();
       const Index newCols = IsRowMajor ? cols() : m_outerSize + num;
  
       const Index begin = j;
       const Index end = m_outerSize;
       const Index target = j + num;
  
       // expand the matrix to the larger size
       conservativeResize(newRows, newCols);
  
       // shift m_outerIndex and m_innerNonZeros [num] to the right
       internal::smart_memmove(m_outerIndex + begin, m_outerIndex + end + 1, m_outerIndex + target);
       // m_outerIndex[begin] == m_outerIndex[target], set all indices in this range to same value
       fill_n(m_outerIndex + begin, num, m_outerIndex[begin]);
  
       if (!isCompressed()) {
         internal::smart_memmove(m_innerNonZeros + begin, m_innerNonZeros + end, m_innerNonZeros + target);
         // set the nonzeros of the newly inserted vectors to 0
         fill_n(m_innerNonZeros + begin, num, StorageIndex(0));
       }
     }

◆ insertFromSortedTriplets() [1/2]

template<typename Scalar , int Options_, typename StorageIndex_ >

template<typename InputIterators >

void Eigen::SparseMatrix< Scalar, Options_, StorageIndex_ >::insertFromSortedTriplets	(	const InputIterators &	begin,
		const InputIterators &	end
	)

The same as insertFromTriplets but triplets are assumed to be pre-sorted. This is faster and requires less temporary storage. Two triplets a and b are appropriately ordered if:

ColMajor: ((a.col() != b.col()) ? (a.col() < b.col()) : (a.row() < b.row())

RowMajor: ((a.row() != b.row()) ? (a.row() < b.row()) : (a.col() < b.col())

a

ArrayXXi a

Definition: Array_initializer_list_23_cxx11.cpp:1

b

Array< int, 3, 1 > b

Definition: Array_variadic_ctor_cxx11.cpp:2

Eigen::ColMajor

@ ColMajor

Definition: Constants.h:321

Eigen::RowMajor

@ RowMajor

Definition: Constants.h:323

Definition at line 1482 of file SparseMatrix.h.

 {
   internal::insert_from_triplets_sorted<InputIterators, SparseMatrix<Scalar, Options_, StorageIndex_> >(begin, end, *this, internal::scalar_sum_op<Scalar, Scalar>());
 }

◆ insertFromSortedTriplets() [2/2]

template<typename Scalar , int Options_, typename StorageIndex_ >

template<typename InputIterators , typename DupFunctor >

void Eigen::SparseMatrix< Scalar, Options_, StorageIndex_ >::insertFromSortedTriplets	(	const InputIterators &	begin,
		const InputIterators &	end,
		DupFunctor	dup_func
	)

The same as insertFromSortedTriplets but when duplicates are met the functor dup_func is applied:

value = dup_func(OldValue, NewValue)

Here is a C++11 example keeping the latest entry only:

mat.insertFromSortedTriplets(triplets.begin(), triplets.end(), [] (const Scalar&,const Scalar &b) { return b; });

mat

MatrixXf mat

Definition: Tutorial_AdvancedInitialization_CommaTemporary.cpp:1

Definition at line 1498 of file SparseMatrix.h.

 {
   internal::insert_from_triplets_sorted<InputIterators, SparseMatrix<Scalar, Options_, StorageIndex_>, DupFunctor>(begin, end, *this, dup_func);
 }

◆ insertFromTriplets() [1/2]

template<typename Scalar , int Options_, typename StorageIndex_ >

template<typename InputIterators >

void Eigen::SparseMatrix< Scalar, Options_, StorageIndex_ >::insertFromTriplets	(	const InputIterators &	begin,
		const InputIterators &	end
	)

Insert a batch of elements into the matrix *this with the list of triplets defined in the half-open range from begin to end.

A triplet is a tuple (i,j,value) defining a non-zero element. The input list of triplets does not have to be sorted, and may contain duplicated elements. In any case, the result is a sorted and compressed sparse matrix where the duplicates have been summed up. This is a O(n) operation, with n the number of triplet elements. The initial contents of *this are preserved (except for the summation of duplicate elements). The matrix *this must be properly sized beforehand. The sizes are not extracted from the triplet list.

The InputIterators value_type must provide the following interface:

Scalar value() const; // the value
IndexType row() const;   // the row index i
IndexType col() const;   // the column index j

See for instance the Eigen::Triplet template class.

Here is a typical usage example:

SparseMatrixType m(rows,cols); // m contains nonzero entries
typedef Triplet<double> T;
std::vector<T> tripletList;
tripletList.reserve(estimation_of_entries);
for(...)
{
  // ...
  tripletList.push_back(T(i,j,v_ij));
}
 
m.insertFromTriplets(tripletList.begin(), tripletList.end());
// m is ready to go!

Warning: The list of triplets is read multiple times (at least twice). Therefore, it is not recommended to define an abstract iterator over a complex data-structure that would be expensive to evaluate. The triplets should rather be explicitly stored into a std::vector for instance.

Definition at line 1452 of file SparseMatrix.h.

 {
   internal::insert_from_triplets<InputIterators, SparseMatrix<Scalar, Options_, StorageIndex_> >(begin, end, *this, internal::scalar_sum_op<Scalar, Scalar>());
 }

◆ insertFromTriplets() [2/2]

template<typename Scalar , int Options_, typename StorageIndex_ >

template<typename InputIterators , typename DupFunctor >

void Eigen::SparseMatrix< Scalar, Options_, StorageIndex_ >::insertFromTriplets	(	const InputIterators &	begin,
		const InputIterators &	end,
		DupFunctor	dup_func
	)

The same as insertFromTriplets but when duplicates are met the functor dup_func is applied:

value = dup_func(OldValue, NewValue)

Here is a C++11 example keeping the latest entry only:

mat.insertFromTriplets(triplets.begin(), triplets.end(), [] (const Scalar&,const Scalar &b) { return b; });

Definition at line 1468 of file SparseMatrix.h.

 {
   internal::insert_from_triplets<InputIterators, SparseMatrix<Scalar, Options_, StorageIndex_>, DupFunctor>(begin, end, *this, dup_func);
 }

◆ insertUncompressed()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

EIGEN_DEPRECATED EIGEN_DONT_INLINE SparseMatrix< Scalar_, Options_, StorageIndex_ >::Scalar & Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertUncompressed	(	Index	row,
		Index	col
	)

protected

Definition at line 1634 of file SparseMatrix.h.

                                                                                        {
   eigen_assert(!isCompressed());
   Index outer = IsRowMajor ? row : col;
   Index inner = IsRowMajor ? col : row;
   Index start = m_outerIndex[outer];
   Index end = start + m_innerNonZeros[outer];
   Index dst = start == end ? end : m_data.searchLowerIndex(start, end, inner);
   if (dst == end) {
     Index capacity = m_outerIndex[outer + 1] - end;
     if (capacity > 0) {
       // implies uncompressed: push to back of vector
       m_innerNonZeros[outer]++;
       m_data.index(end) = StorageIndex(inner);
       m_data.value(end) = Scalar(0);
       return m_data.value(end);
     }
   }
   eigen_assert((dst == end || m_data.index(dst) != inner) &&
                "you cannot insert an element that already exists, you must call coeffRef to this end");
   return insertUncompressedAtByOuterInner(outer, inner, dst);
 }

◆ insertUncompressedAtByOuterInner()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

SparseMatrix< Scalar_, Options_, StorageIndex_ >::Scalar & Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertUncompressedAtByOuterInner	(	Index	outer,
		Index	inner,
		Index	dst
	)

protected

Definition at line 1699 of file SparseMatrix.h.

                                                                                                                     {
   eigen_assert(!isCompressed());
   // find a vector with capacity, starting at `outer` and searching to the left and right
   for (Index leftTarget = outer - 1, rightTarget = outer; (leftTarget >= 0) || (rightTarget < m_outerSize);) {
     if (rightTarget < m_outerSize) {
       Index start = m_outerIndex[rightTarget];
       Index end = start + m_innerNonZeros[rightTarget];
       Index nextStart = m_outerIndex[rightTarget + 1];
       Index capacity = nextStart - end;
       if (capacity > 0) {
         // move [dst, end) to dst+1 and insert at dst
         Index chunkSize = end - dst;
         if (chunkSize > 0) m_data.moveChunk(dst, dst + 1, chunkSize);
         m_innerNonZeros[outer]++;
         for (Index j = outer; j < rightTarget; j++) m_outerIndex[j + 1]++;
         m_data.index(dst) = StorageIndex(inner);
         m_data.value(dst) = Scalar(0);
         return m_data.value(dst);
       }
       rightTarget++;
     }
     if (leftTarget >= 0) {
       Index start = m_outerIndex[leftTarget];
       Index end = start + m_innerNonZeros[leftTarget];
       Index nextStart = m_outerIndex[leftTarget + 1];
       Index capacity = nextStart - end;
       if (capacity > 0) {
         // tricky: dst is a lower bound, so we must insert at dst-1 when shifting left
         // move [nextStart, dst) to nextStart-1 and insert at dst-1
         Index chunkSize = dst - nextStart;
         if (chunkSize > 0) m_data.moveChunk(nextStart, nextStart - 1, chunkSize);
         m_innerNonZeros[outer]++;
         for (Index j = leftTarget; j < outer; j++) m_outerIndex[j + 1]--;
         m_data.index(dst - 1) = StorageIndex(inner);
         m_data.value(dst - 1) = Scalar(0);
         return m_data.value(dst - 1);
       }
       leftTarget--;
     }
   }
  
   // no room for interior insertion
   // nonZeros() == m_data.size()
   // record offset as outerIndxPtr will change
   Index dst_offset = dst - m_outerIndex[outer];
   // allocate space for random insertion
   if (m_data.allocatedSize() == 0) {
     // fast method to allocate space for one element per vector in empty matrix
     m_data.resize(m_outerSize);
     std::iota(m_outerIndex, m_outerIndex + m_outerSize + 1, StorageIndex(0));
   } else {
     // check for integer overflow: if maxReserveSize == 0, insertion is not possible
     Index maxReserveSize = static_cast<Index>(NumTraits<StorageIndex>::highest()) - m_data.allocatedSize();
     eigen_assert(maxReserveSize > 0);
     if (m_outerSize <= maxReserveSize) {
       // allocate space for one additional element per vector
       reserveInnerVectors(IndexVector::Constant(m_outerSize, 1));
     } else {
       // handle the edge case where StorageIndex is insufficient to reserve outerSize additional elements
       // allocate space for one additional element in the interval [outer,maxReserveSize)
       typedef internal::sparse_reserve_op<StorageIndex> ReserveSizesOp;
       typedef CwiseNullaryOp<ReserveSizesOp, IndexVector> ReserveSizesXpr;
       ReserveSizesXpr reserveSizesXpr(m_outerSize, 1, ReserveSizesOp(outer, m_outerSize, maxReserveSize));
       reserveInnerVectors(reserveSizesXpr);
     }
   }
   // insert element at `dst` with new outer indices
   Index start = m_outerIndex[outer];
   Index end = start + m_innerNonZeros[outer];
   Index new_dst = start + dst_offset;
   Index chunkSize = end - new_dst;
   if (chunkSize > 0) m_data.moveChunk(new_dst, new_dst + 1, chunkSize);
   m_innerNonZeros[outer]++;
   m_data.index(new_dst) = StorageIndex(inner);
   m_data.value(new_dst) = Scalar(0);
   return m_data.value(new_dst);
 }

◆ isCompressed()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

bool Eigen::SparseCompressedBase< Derived >::isCompressed

inline

Returns: whether *this is in compressed form.

Definition at line 112 of file SparseCompressedBase.h.

112 { return innerNonZeroPtr()==0; }

Eigen::SparseMatrix::innerNonZeroPtr

const StorageIndex * innerNonZeroPtr() const

Definition: SparseMatrix.h:204

◆ makeCompressed()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::makeCompressed ( )

inline

Turns the matrix into the compressed format.

Definition at line 588 of file SparseMatrix.h.

     {
       if (isCompressed()) return;
       
       eigen_internal_assert(m_outerIndex!=0 && m_outerSize>0);
  
       StorageIndex start = m_outerIndex[1];
       m_outerIndex[1] = m_innerNonZeros[0];
       // try to move fewer, larger contiguous chunks
       Index copyStart = start;
       Index copyTarget = m_innerNonZeros[0];
       for (Index j = 1; j < m_outerSize; j++)
       {
         StorageIndex end = start + m_innerNonZeros[j];
         StorageIndex nextStart = m_outerIndex[j + 1];
         // dont forget to move the last chunk!
         bool breakUpCopy = (end != nextStart) || (j == m_outerSize - 1);
         if (breakUpCopy)
         {
           Index chunkSize = end - copyStart;
           if(chunkSize > 0) m_data.moveChunk(copyStart, copyTarget, chunkSize);
           copyStart = nextStart;
           copyTarget += chunkSize;
         }
         start = nextStart;
         m_outerIndex[j + 1] = m_outerIndex[j] + m_innerNonZeros[j];
       }
       m_data.resize(m_outerIndex[m_outerSize]);
  
       // release as much memory as possible
       internal::conditional_aligned_delete_auto<StorageIndex, true>(m_innerNonZeros, m_outerSize);
       m_innerNonZeros = 0;
       m_data.squeeze();
     }

◆ nonZeros()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Index Eigen::SparseCompressedBase< Derived >::nonZeros

inline

Returns: the number of non zero coefficients

Definition at line 61 of file SparseCompressedBase.h.

     {
      if (Derived::IsVectorAtCompileTime && outerIndexPtr() == 0)
        return derived().nonZeros();
      else if (derived().outerSize() == 0)
        return 0;
      else if (isCompressed())
        return outerIndexPtr()[derived().outerSize()] - outerIndexPtr()[0];
      else
        return innerNonZeros().sum();
     }

◆ operator=() [1/4]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

SparseMatrix& Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::operator= ( const SparseMatrix< Scalar_, Options_, StorageIndex_ > & other )

inline

Definition at line 869 of file SparseMatrix.h.

     {
       if (other.isRValue())
       {
         swap(other.const_cast_derived());
       }
       else if(this!=&other)
       {
         #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
           EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
         #endif
         initAssignment(other);
         if(other.isCompressed())
         {
           internal::smart_copy(other.m_outerIndex, other.m_outerIndex + m_outerSize + 1, m_outerIndex);
           m_data = other.m_data;
         }
         else
         {
           Base::operator=(other);
         }
       }
       return *this;
     }

◆ operator=() [2/4]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename OtherDerived >

EIGEN_DONT_INLINE SparseMatrix& Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::operator= ( const SparseMatrixBase< OtherDerived > & other )

◆ operator=() [3/4]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename OtherDerived >

EIGEN_DONT_INLINE SparseMatrix<Scalar,Options_,StorageIndex_>& Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::operator= ( const SparseMatrixBase< OtherDerived > & other )

Definition at line 1547 of file SparseMatrix.h.

 {
   EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
         YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
  
   #ifdef EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
     EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN
   #endif
       
   const bool needToTranspose = (Flags & RowMajorBit) != (internal::evaluator<OtherDerived>::Flags & RowMajorBit);
   if (needToTranspose)
   {
     #ifdef EIGEN_SPARSE_TRANSPOSED_COPY_PLUGIN
       EIGEN_SPARSE_TRANSPOSED_COPY_PLUGIN
     #endif
     // two passes algorithm:
     //  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 internal::nested_eval<OtherDerived,2,typename internal::plain_matrix_type<OtherDerived>::type >::type OtherCopy;
     typedef internal::remove_all_t<OtherCopy> OtherCopy_;
     typedef internal::evaluator<OtherCopy_> OtherCopyEval;
     OtherCopy otherCopy(other.derived());
     OtherCopyEval otherCopyEval(otherCopy);
  
     SparseMatrix dest(other.rows(),other.cols());
     Eigen::Map<IndexVector> (dest.m_outerIndex,dest.outerSize()).setZero();
  
     // pass 1
     // FIXME the above copy could be merged with that pass
     for (Index j=0; j<otherCopy.outerSize(); ++j)
       for (typename OtherCopyEval::InnerIterator it(otherCopyEval, j); it; ++it)
         ++dest.m_outerIndex[it.index()];
  
     // prefix sum
     StorageIndex count = 0;
     IndexVector positions(dest.outerSize());
     for (Index j=0; j<dest.outerSize(); ++j)
     {
       StorageIndex tmp = dest.m_outerIndex[j];
       dest.m_outerIndex[j] = count;
       positions[j] = count;
       count += tmp;
     }
     dest.m_outerIndex[dest.outerSize()] = count;
     // alloc
     dest.m_data.resize(count);
     // pass 2
     for (StorageIndex j=0; j<otherCopy.outerSize(); ++j)
     {
       for (typename OtherCopyEval::InnerIterator it(otherCopyEval, j); it; ++it)
       {
         Index pos = positions[it.index()]++;
         dest.m_data.index(pos) = j;
         dest.m_data.value(pos) = it.value();
       }
     }
     this->swap(dest);
     return *this;
   }
   else
   {
     if(other.isRValue())
     {
       initAssignment(other.derived());
     }
     // there is no special optimization
     return Base::operator=(other.derived());
   }
 }

◆ operator=() [4/4]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

SparseMatrix& Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::operator= ( SparseMatrix< Scalar_, Options_, StorageIndex_ > && other )

inline

Definition at line 894 of file SparseMatrix.h.

                                                          {
       return *this = other.derived().markAsRValue();
     }

◆ outerIndexPtr() [1/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

StorageIndex* Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::outerIndexPtr ( )

inline

Returns: a non-const pointer to the array of the starting positions of the inner vectors. This function is aimed at interoperability with other libraries.

See also: valuePtr(), innerIndexPtr()

Definition at line 199 of file SparseMatrix.h.

199 { return m_outerIndex; }

◆ outerIndexPtr() [2/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

const StorageIndex* Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::outerIndexPtr ( ) const

inline

Returns: a const pointer to the array of the starting positions of the inner vectors. This function is aimed at interoperability with other libraries.

See also: valuePtr(), innerIndexPtr()

Definition at line 195 of file SparseMatrix.h.

195 { return m_outerIndex; }

◆ outerSize()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Index Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::outerSize ( ) const

inline

Returns: the number of columns (resp. rows) of the matrix if the storage order column major (resp. row major)

Definition at line 172 of file SparseMatrix.h.

172 { return m_outerSize; }

◆ prune() [1/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename KeepFunc >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::prune ( const KeepFunc & keep = KeepFunc() )

inline

Turns the matrix into compressed format, and suppresses all nonzeros which do not satisfy the predicate keep. The functor type KeepFunc must implement the following function:

bool operator() (const Index& row, const Index& col, const Scalar& value) const;

See also: prune(Scalar,RealScalar)

Definition at line 648 of file SparseMatrix.h.

     {
       StorageIndex k = 0;
       for(Index j=0; j<m_outerSize; ++j)
       {
         StorageIndex previousStart = m_outerIndex[j];
         if (isCompressed())
           m_outerIndex[j] = k;
         else
           k = m_outerIndex[j];
         StorageIndex end = isCompressed() ? m_outerIndex[j+1] : previousStart + m_innerNonZeros[j];
         for(StorageIndex i=previousStart; i<end; ++i)
         {
           StorageIndex row = IsRowMajor ? StorageIndex(j) : m_data.index(i);
           StorageIndex col = IsRowMajor ? m_data.index(i) : StorageIndex(j);
           bool keepEntry = keep(row, col, m_data.value(i));
           if (keepEntry) {
             m_data.value(k) = m_data.value(i);
             m_data.index(k) = m_data.index(i);
             ++k;
           } else if (!isCompressed())
             m_innerNonZeros[j]--;
         }
       }
       if (isCompressed()) {
         m_outerIndex[m_outerSize] = k;
         m_data.resize(k, 0);
       }
     }

◆ prune() [2/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::prune	(	const Scalar &	reference,
		const RealScalar &	epsilon = `NumTraits<RealScalar>::dummy_precision()`
	)

inline

Suppresses all nonzeros which are much smaller than reference under the tolerance epsilon

Definition at line 635 of file SparseMatrix.h.

     {
       prune(default_prunning_func(reference,epsilon));
     }

◆ removeOuterVectors()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::removeOuterVectors	(	Index	j,
		Index	num = `1`
	)

inline

Definition at line 476 of file SparseMatrix.h.

                                                     {
       eigen_assert(num >= 0 && j >= 0 && j + num <= m_outerSize && "Invalid parameters");
  
       const Index newRows = IsRowMajor ? m_outerSize - num : rows();
       const Index newCols = IsRowMajor ? cols() : m_outerSize - num;
  
       const Index begin = j + num;
       const Index end = m_outerSize;
       const Index target = j;
  
       // if the removed vectors are not empty, uncompress the matrix
       if (m_outerIndex[j + num] > m_outerIndex[j]) uncompress();
  
       // shift m_outerIndex and m_innerNonZeros [num] to the left
       internal::smart_memmove(m_outerIndex + begin, m_outerIndex + end + 1, m_outerIndex + target);
       if (!isCompressed())
         internal::smart_memmove(m_innerNonZeros + begin, m_innerNonZeros + end, m_innerNonZeros + target);
  
       // if m_outerIndex[0] > 0, shift the data within the first vector while it is easy to do so
       if (m_outerIndex[0] > StorageIndex(0)) {
         uncompress();
         const Index from = internal::convert_index<Index>(m_outerIndex[0]);
         const Index to = Index(0);
         const Index chunkSize = internal::convert_index<Index>(m_innerNonZeros[0]);
         m_data.moveChunk(from, to, chunkSize);
         m_outerIndex[0] = StorageIndex(0);
       }
  
       // truncate the matrix to the smaller size
       conservativeResize(newRows, newCols);
     }

◆ reserve() [1/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<class SizesType >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::reserve ( const SizesType & reserveSizes )

inline

Preallocates reserveSize[j] non zeros for each column (resp. row) j.

This function turns the matrix in non-compressed mode.

The type SizesType must expose the following interface:

typedef value_type;

const value_type& operator[](i) const;

Eigen::SparseMatrixBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >::value_type

Scalar value_type

Definition: SparseMatrixBase.h:38

for i in the [0,this->outerSize()[ range. Typical choices include std::vector<int>, Eigen::VectorXi, Eigen::VectorXi::Constant, etc.

◆ reserve() [2/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::reserve ( Index reserveSize )

inline

Preallocates reserveSize non zeros.

Precondition: the matrix must be in compressed mode.

Definition at line 300 of file SparseMatrix.h.

     {
       eigen_assert(isCompressed() && "This function does not make sense in non compressed mode.");
       m_data.reserve(reserveSize);
     }

◆ reserveInnerVectors()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<class SizesType >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::reserveInnerVectors ( const SizesType & reserveSizes )

inlineprotected

Definition at line 332 of file SparseMatrix.h.

     {
       if(isCompressed())
       {
         Index totalReserveSize = 0;
         for (Index j = 0; j < m_outerSize; ++j) totalReserveSize += internal::convert_index<Index>(reserveSizes[j]);
  
         // if reserveSizes is empty, don't do anything!
         if (totalReserveSize == 0) return;
  
         // turn the matrix into non-compressed mode
         m_innerNonZeros = internal::conditional_aligned_new_auto<StorageIndex, true>(m_outerSize);
         
         // temporarily use m_innerSizes to hold the new starting points.
         StorageIndex* newOuterIndex = m_innerNonZeros;
         
         Index count = 0;
         for(Index j=0; j<m_outerSize; ++j)
         {
           newOuterIndex[j] = internal::convert_index<StorageIndex>(count);
           Index reserveSize = internal::convert_index<Index>(reserveSizes[j]);
           count += reserveSize + internal::convert_index<Index>(m_outerIndex[j+1]-m_outerIndex[j]);
         }
  
         m_data.reserve(totalReserveSize);
         StorageIndex previousOuterIndex = m_outerIndex[m_outerSize];
         for(Index j=m_outerSize-1; j>=0; --j)
         {
           StorageIndex innerNNZ = previousOuterIndex - m_outerIndex[j];
           StorageIndex begin = m_outerIndex[j];
           StorageIndex end = begin + innerNNZ;
           StorageIndex target = newOuterIndex[j];
           internal::smart_memmove(innerIndexPtr() + begin, innerIndexPtr() + end, innerIndexPtr() + target);
           internal::smart_memmove(valuePtr() + begin, valuePtr() + end, valuePtr() + target);
           previousOuterIndex = m_outerIndex[j];
           m_outerIndex[j] = newOuterIndex[j];
           m_innerNonZeros[j] = innerNNZ;
         }
         if(m_outerSize>0)
           m_outerIndex[m_outerSize] = m_outerIndex[m_outerSize-1] + m_innerNonZeros[m_outerSize-1] + internal::convert_index<StorageIndex>(reserveSizes[m_outerSize-1]);
         
         m_data.resize(m_outerIndex[m_outerSize]);
       }
       else
       {
         StorageIndex* newOuterIndex = internal::conditional_aligned_new_auto<StorageIndex, true>(m_outerSize + 1);
         
         Index count = 0;
         for(Index j=0; j<m_outerSize; ++j)
         {
           newOuterIndex[j] = internal::convert_index<StorageIndex>(count);
           Index alreadyReserved = internal::convert_index<Index>(m_outerIndex[j+1] - m_outerIndex[j] - m_innerNonZeros[j]);
           Index reserveSize = internal::convert_index<Index>(reserveSizes[j]);
           Index toReserve = numext::maxi(reserveSize, alreadyReserved);
           count += toReserve + internal::convert_index<Index>(m_innerNonZeros[j]);
         }
         newOuterIndex[m_outerSize] = internal::convert_index<StorageIndex>(count);
  
         m_data.resize(count);
         for(Index j=m_outerSize-1; j>=0; --j)
         {
           StorageIndex innerNNZ = m_innerNonZeros[j];
           StorageIndex begin = m_outerIndex[j];
           StorageIndex target = newOuterIndex[j];
           m_data.moveChunk(begin, target, innerNNZ);
         }
         
         std::swap(m_outerIndex, newOuterIndex);
         internal::conditional_aligned_delete_auto<StorageIndex, true>(newOuterIndex, m_outerSize + 1);
       }
       
     }

◆ resize()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::resize	(	Index	rows,
		Index	cols
	)

inline

Resizes the matrix to a rows x cols matrix and initializes it to zero.

This function does not free the currently allocated memory. To release as much as memory as possible, call

mat.data().squeeze();

after resizing it.

See also: reserve(), setZero()

Definition at line 739 of file SparseMatrix.h.

     {
       const Index outerSize = IsRowMajor ? rows : cols;
       m_innerSize = IsRowMajor ? cols : rows;
       m_data.clear();
  
       if ((m_outerIndex == 0) || (m_outerSize != outerSize)) {
         m_outerIndex = internal::conditional_aligned_realloc_new_auto<StorageIndex, true>(m_outerIndex, outerSize + 1, m_outerSize + 1);
         m_outerSize = outerSize;
       }
  
       internal::conditional_aligned_delete_auto<StorageIndex, true>(m_innerNonZeros, m_outerSize);
       m_innerNonZeros = 0;
  
       std::fill_n(m_outerIndex, m_outerSize + 1, StorageIndex(0));
     }

◆ resizeNonZeros()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::resizeNonZeros ( Index size )

inline

Definition at line 758 of file SparseMatrix.h.

     {
       m_data.resize(size);
     }

◆ rows()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Index Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows ( void ) const

inline

Returns: the number of rows of the matrix

Definition at line 165 of file SparseMatrix.h.

165 { return IsRowMajor ? m_outerSize : m_innerSize; }

◆ setFromSortedTriplets() [1/2]

template<typename Scalar , int Options_, typename StorageIndex_ >

template<typename InputIterators >

void Eigen::SparseMatrix< Scalar, Options_, StorageIndex_ >::setFromSortedTriplets	(	const InputIterators &	begin,
		const InputIterators &	end
	)

The same as setFromTriplets but triplets are assumed to be pre-sorted. This is faster and requires less temporary storage. Two triplets a and b are appropriately ordered if:

ColMajor: ((a.col() != b.col()) ? (a.col() < b.col()) : (a.row() < b.row())

RowMajor: ((a.row() != b.row()) ? (a.row() < b.row()) : (a.col() < b.col())

Definition at line 1392 of file SparseMatrix.h.

 {
   internal::set_from_triplets_sorted<InputIterators, SparseMatrix<Scalar, Options_, StorageIndex_> >(begin, end, *this, internal::scalar_sum_op<Scalar, Scalar>());
 }

◆ setFromSortedTriplets() [2/2]

template<typename Scalar , int Options_, typename StorageIndex_ >

template<typename InputIterators , typename DupFunctor >

void Eigen::SparseMatrix< Scalar, Options_, StorageIndex_ >::setFromSortedTriplets	(	const InputIterators &	begin,
		const InputIterators &	end,
		DupFunctor	dup_func
	)

The same as setFromSortedTriplets but when duplicates are met the functor dup_func is applied:

value = dup_func(OldValue, NewValue)

Here is a C++11 example keeping the latest entry only:

mat.setFromSortedTriplets(triplets.begin(), triplets.end(), [] (const Scalar&,const Scalar &b) { return b; });

Definition at line 1408 of file SparseMatrix.h.

 {
   internal::set_from_triplets_sorted<InputIterators, SparseMatrix<Scalar, Options_, StorageIndex_>, DupFunctor>(begin, end, *this, dup_func);
 }

◆ setFromTriplets() [1/2]

template<typename Scalar , int Options_, typename StorageIndex_ >

template<typename InputIterators >

void Eigen::SparseMatrix< Scalar, Options_, StorageIndex_ >::setFromTriplets	(	const InputIterators &	begin,
		const InputIterators &	end
	)

Fill the matrix *this with the list of triplets defined in the half-open range from begin to end.

A triplet is a tuple (i,j,value) defining a non-zero element. The input list of triplets does not have to be sorted, and may contain duplicated elements. In any case, the result is a sorted and compressed sparse matrix where the duplicates have been summed up. This is a O(n) operation, with n the number of triplet elements. The initial contents of *this are destroyed. The matrix *this must be properly resized beforehand using the SparseMatrix(Index,Index) constructor, or the resize(Index,Index) method. The sizes are not extracted from the triplet list.

The InputIterators value_type must provide the following interface:

Scalar value() const; // the value
IndexType row() const;   // the row index i
IndexType col() const;   // the column index j

See for instance the Eigen::Triplet template class.

Here is a typical usage example:

typedef Triplet<double> T;
std::vector<T> tripletList;
tripletList.reserve(estimation_of_entries);
for(...)
{
  // ...
  tripletList.push_back(T(i,j,v_ij));
}
SparseMatrixType m(rows,cols);
m.setFromTriplets(tripletList.begin(), tripletList.end());
// m is ready to go!

Warning: The list of triplets is read multiple times (at least twice). Therefore, it is not recommended to define an abstract iterator over a complex data-structure that would be expensive to evaluate. The triplets should rather be explicitly stored into a std::vector for instance.

Definition at line 1362 of file SparseMatrix.h.

 {
   internal::set_from_triplets<InputIterators, SparseMatrix<Scalar,Options_,StorageIndex_> >(begin, end, *this, internal::scalar_sum_op<Scalar,Scalar>());
 }

◆ setFromTriplets() [2/2]

template<typename Scalar , int Options_, typename StorageIndex_ >

template<typename InputIterators , typename DupFunctor >

void Eigen::SparseMatrix< Scalar, Options_, StorageIndex_ >::setFromTriplets	(	const InputIterators &	begin,
		const InputIterators &	end,
		DupFunctor	dup_func
	)

The same as setFromTriplets but when duplicates are met the functor dup_func is applied:

value = dup_func(OldValue, NewValue)

Here is a C++11 example keeping the latest entry only:

mat.setFromTriplets(triplets.begin(), triplets.end(), [] (const Scalar&,const Scalar &b) { return b; });

Definition at line 1378 of file SparseMatrix.h.

 {
   internal::set_from_triplets<InputIterators, SparseMatrix<Scalar, Options_, StorageIndex_>, DupFunctor>(begin, end, *this, dup_func);
 }

◆ setIdentity()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::setIdentity ( )

inline

Sets *this to the identity matrix. This function also turns the matrix into compressed mode, and drop any reserved memory.

Definition at line 856 of file SparseMatrix.h.

     {
       eigen_assert(m_outerSize == m_innerSize && "ONLY FOR SQUARED MATRICES");
       internal::conditional_aligned_delete_auto<StorageIndex, true>(m_innerNonZeros, m_outerSize);
       m_innerNonZeros = 0;
       m_data.resize(m_outerSize);
       // is it necessary to squeeze?
       m_data.squeeze();
       std::iota(m_outerIndex, m_outerIndex + m_outerSize + 1, StorageIndex(0));
       std::iota(innerIndexPtr(), innerIndexPtr() + m_outerSize, StorageIndex(0));
       std::fill_n(valuePtr(), m_outerSize, Scalar(1));
     }

◆ setZero()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::setZero ( )

inline

Removes all non zeros but keep allocated memory

This function does not free the currently allocated memory. To release as much as memory as possible, call

mat.data().squeeze();

after resizing it.

See also: resize(Index,Index), data()

Definition at line 288 of file SparseMatrix.h.

     {
       m_data.clear();
       std::fill_n(m_outerIndex, m_outerSize + 1, StorageIndex(0));
       if(m_innerNonZeros) {
         std::fill_n(m_innerNonZeros, m_outerSize, StorageIndex(0));
       }
     }

◆ startVec()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::startVec ( Index outer )

inline

Definition at line 447 of file SparseMatrix.h.

     {
       eigen_assert(m_outerIndex[outer]==Index(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];
     }

◆ sum()

template<typename Scalar_ , int Options_, typename Index_ >

internal::traits< SparseMatrix< Scalar_, Options_, Index_ > >::Scalar Eigen::SparseMatrix< Scalar_, Options_, Index_ >::sum

Overloaded for performance

Definition at line 32 of file SparseRedux.h.

 {
   eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
   if(this->isCompressed())
     return Matrix<Scalar,1,Dynamic>::Map(m_data.valuePtr(), m_data.size()).sum();
   else
     return Base::sum();
 }

◆ swap()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::swap ( SparseMatrix< Scalar_, Options_, StorageIndex_ > & other )

inline

Swaps the content of two sparse matrices of the same type. This is a fast operation that simply swaps the underlying pointers and parameters.

Definition at line 844 of file SparseMatrix.h.

     {
       //EIGEN_DBG_SPARSE(std::cout << "SparseMatrix:: swap\n");
       std::swap(m_outerIndex, other.m_outerIndex);
       std::swap(m_innerSize, other.m_innerSize);
       std::swap(m_outerSize, other.m_outerSize);
       std::swap(m_innerNonZeros, other.m_innerNonZeros);
       m_data.swap(other.m_data);
     }

◆ uncompress()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

void Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::uncompress ( )

inline

Turns the matrix into the uncompressed mode

Definition at line 624 of file SparseMatrix.h.

     {
       if (!isCompressed()) return;
       m_innerNonZeros = internal::conditional_aligned_new_auto<StorageIndex, true>(m_outerSize);
       if (m_outerIndex[m_outerSize] == 0)
         std::fill_n(m_innerNonZeros, m_outerSize, StorageIndex(0));
       else
         for (Index j = 0; j < m_outerSize; j++) m_innerNonZeros[j] = m_outerIndex[j + 1] - m_outerIndex[j];
     }

◆ valuePtr() [1/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Scalar* Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::valuePtr ( )

inline

Returns: a non-const pointer to the array of values. This function is aimed at interoperability with other libraries.

See also: innerIndexPtr(), outerIndexPtr()

Definition at line 181 of file SparseMatrix.h.

181 { return m_data.valuePtr(); }

◆ valuePtr() [2/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

const Scalar* Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::valuePtr ( ) const

inline

Returns: a const pointer to the array of values. This function is aimed at interoperability with other libraries.

See also: innerIndexPtr(), outerIndexPtr()

Definition at line 177 of file SparseMatrix.h.

177 { return m_data.valuePtr(); }

Member Data Documentation

◆ m_data

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Storage Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data

protected

Definition at line 160 of file SparseMatrix.h.

◆ m_innerNonZeros

template<typename Scalar_ , int Options_, typename StorageIndex_ >

StorageIndex* Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerNonZeros

protected

Definition at line 159 of file SparseMatrix.h.

◆ m_innerSize

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Index Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerSize

protected

Definition at line 157 of file SparseMatrix.h.

◆ m_outerIndex

template<typename Scalar_ , int Options_, typename StorageIndex_ >

StorageIndex* Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex

protected

Definition at line 158 of file SparseMatrix.h.

◆ m_outerSize

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Index Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerSize

protected

Definition at line 156 of file SparseMatrix.h.

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Additional Inherited Members

Detailed Description

template<typename Scalar_, int Options_, typename StorageIndex_> class Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >

Member Typedef Documentation

◆ Base

◆ ConstDiagonalReturnType

◆ DiagonalReturnType

◆ IndexVector

◆ Map

◆ ScalarVector

◆ Storage

◆ TransposedSparseMatrix

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ SparseMatrix() [1/8]

◆ SparseMatrix() [2/8]

◆ SparseMatrix() [3/8]

◆ SparseMatrix() [4/8]

◆ SparseMatrix() [5/8]

◆ SparseMatrix() [6/8]

◆ SparseMatrix() [7/8]

◆ SparseMatrix() [8/8]

◆ ~SparseMatrix()

Member Function Documentation

◆ assignDiagonal()

◆ coeff()

◆ coeffRef()

◆ collapseDuplicates()

◆ cols()

◆ conservativeResize()

◆ data() [1/2]

◆ data() [2/2]

◆ diagonal() [1/2]

◆ diagonal() [2/2]

◆ EIGEN_STATIC_ASSERT()

◆ finalize()

◆ initAssignment()

◆ innerIndexPtr() [1/2]

◆ innerIndexPtr() [2/2]

◆ innerNonZeroPtr() [1/2]

◆ innerNonZeroPtr() [2/2]

◆ innerSize()

◆ insert()

◆ insertAtByOuterInner()

◆ insertBack()

◆ insertBackByOuterInner()

◆ insertBackByOuterInnerUnordered()

◆ insertBackUncompressed()

◆ insertByOuterInner()

◆ insertCompressed()

◆ insertCompressedAtByOuterInner()

◆ insertEmptyOuterVectors()

◆ insertFromSortedTriplets() [1/2]

◆ insertFromSortedTriplets() [2/2]

◆ insertFromTriplets() [1/2]

◆ insertFromTriplets() [2/2]

◆ insertUncompressed()

◆ insertUncompressedAtByOuterInner()

◆ isCompressed()

◆ makeCompressed()

◆ nonZeros()

◆ operator=() [1/4]

◆ operator=() [2/4]

◆ operator=() [3/4]

◆ operator=() [4/4]

◆ outerIndexPtr() [1/2]

◆ outerIndexPtr() [2/2]

◆ outerSize()

◆ prune() [1/2]

◆ prune() [2/2]

◆ removeOuterVectors()

template<typename Scalar_, int Options_, typename StorageIndex_>
class Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >