A versatible sparse matrix representation. More...

#include <SparseMatrix.h>

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

Classes
struct	IndexPosPair

class	SingletonVector

Public Types
enum	{ Options = Options_ }

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

typedef Diagonal< SparseMatrix >	DiagonalReturnType

typedef Diagonal< const SparseMatrix >	ConstDiagonalReturnType

typedef Base::InnerIterator	InnerIterator

typedef Base::ReverseInnerIterator	ReverseInnerIterator

typedef internal::CompressedStorage< Scalar, StorageIndex >	Storage

typedef Base::IndexVector	IndexVector

typedef Base::ScalarVector	ScalarVector

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 internal::traits< SparseMatrix< Scalar_, Options_, StorageIndex_ > >::Scalar	Scalar

typedef Scalar	value_type

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

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

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

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

typedef SparseMatrixBase	StorageBaseType

typedef Matrix< StorageIndex, Dynamic, 1 >	IndexVector

typedef Matrix< Scalar, Dynamic, 1 >	ScalarVector

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< SparseMatrix< Scalar_, Options_, StorageIndex_ > >	TransposeReturnType

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

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

typedef NumTraits< Scalar >::Real	RealScalar

typedef std::conditional_t< HasDirectAccess_, const Scalar &, Scalar >	CoeffReturnType

typedef CwiseNullaryOp< internal::scalar_constant_op< Scalar >, Matrix< Scalar, Dynamic, Dynamic > >	ConstantReturnType

typedef Matrix< Scalar, RowsAtCompileTime, ColsAtCompileTime >	DenseMatrixType

typedef Matrix< Scalar, internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime), internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime)>	SquareMatrixType

typedef EigenBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >	Base

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
Index	rows () const

Index	cols () const

Index	innerSize () const

Index	outerSize () const

const Scalar *	valuePtr () const

Scalar *	valuePtr ()

const StorageIndex *	innerIndexPtr () const

StorageIndex *	innerIndexPtr ()

const StorageIndex *	outerIndexPtr () const

StorageIndex *	outerIndexPtr ()

const StorageIndex *	innerNonZeroPtr () const

StorageIndex *	innerNonZeroPtr ()

constexpr Storage &	data ()

constexpr const Storage &	data () const

Scalar	coeff (Index row, Index col) const

Scalar &	findOrInsertCoeff (Index row, Index col, bool *inserted)

Scalar &	coeffRef (Index row, Index col)

Scalar &	insert (Index row, Index col)

void	setZero ()

void	reserve (Index reserveSize)

template<class SizesType >
void	reserve (const SizesType &reserveSizes, const typename SizesType::value_type &enableif=typename SizesType::value_type())

Scalar &	insertBack (Index row, Index col)

Scalar &	insertBackByOuterInner (Index outer, Index inner)

Scalar &	insertBackByOuterInnerUnordered (Index outer, Index inner)

void	startVec (Index outer)

void	finalize ()

void	removeOuterVectors (Index j, Index num=1)

void	insertEmptyOuterVectors (Index j, Index num=1)

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)

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

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	insertFromTriplets (const InputIterators &begin, const InputIterators &end)

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

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)

Scalar &	insertByOuterInner (Index j, Index i)

void	makeCompressed ()

void	uncompress ()

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

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

void	conservativeResize (Index rows, Index cols)

void	resize (Index rows, Index cols)

void	resizeNonZeros (Index size)

const ConstDiagonalReturnType	diagonal () const

DiagonalReturnType	diagonal ()

	SparseMatrix ()

	SparseMatrix (Index rows, Index cols)

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

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

	SparseMatrix (SparseMatrix &&other)

template<typename OtherDerived >
	SparseMatrix (SparseCompressedBase< OtherDerived > &&other)

	SparseMatrix (const SparseMatrix &other)

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

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

void	swap (SparseMatrix &other)

void	setIdentity ()

SparseMatrix &	operator= (const SparseMatrix &other)

SparseMatrix &	operator= (SparseMatrix &&other)

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

template<typename Lhs , typename Rhs >
SparseMatrix &	operator= (const Product< Lhs, Rhs, AliasFreeProduct > &other)

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

template<typename OtherDerived >
SparseMatrix &	operator= (SparseCompressedBase< OtherDerived > &&other)

	~SparseMatrix ()

Scalar	sum () const

EIGEN_STRONG_INLINE Scalar &	insertBackUncompressed (Index row, Index col)

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

template<typename Lhs , typename Rhs >
SparseMatrix< Scalar, Options_, StorageIndex_ > &	operator= (const Product< Lhs, Rhs, AliasFreeProduct > &src)

bool	isCompressed () const

Index	nonZeros () const

Public Member Functions inherited from Eigen::SparseCompressedBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >
Index	nonZeros () const

const Scalar *	valuePtr () const

Scalar *	valuePtr ()

const StorageIndex *	innerIndexPtr () const

StorageIndex *	innerIndexPtr ()

const StorageIndex *	outerIndexPtr () const

StorageIndex *	outerIndexPtr ()

const StorageIndex *	innerNonZeroPtr () const

StorageIndex *	innerNonZeroPtr ()

bool	isCompressed () const

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

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

void	sortInnerIndices (Index begin, Index end)

void	sortInnerIndices ()

Index	innerIndicesAreSorted (Index begin, Index end) const

Index	innerIndicesAreSorted () 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 SparseMatrixBase< OtherDerived > &other)

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

Public Member Functions inherited from Eigen::SparseMatrixBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >
SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator= (const EigenBase< OtherDerived > &other)

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

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

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

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

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

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

Index	rows () const

Index	cols () const

Index	size () const

bool	isVector () const

Index	outerSize () const

Index	innerSize () const

bool	isRValue () const

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

	SparseMatrixBase ()

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)

EIGEN_STRONG_INLINE SparseMatrix< Scalar_, Options_, StorageIndex_ > &	operator+= (const SparseMatrixBase< 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)

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

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

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

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

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

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

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

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

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

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

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

ConstSelfAdjointViewReturnType< UpLo >::Type	selfadjointView () const

SelfAdjointViewReturnType< UpLo >::Type	selfadjointView ()

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

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

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

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

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

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

RealScalar	squaredNorm () const

RealScalar	norm () const

RealScalar	blueNorm () const

TransposeReturnType	transpose ()

const ConstTransposeReturnType	transpose () const

const AdjointReturnType	adjoint () const

DenseMatrixType	toDense () const

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

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

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

Scalar	sum () const

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

Public Member Functions inherited from Eigen::EigenBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >
constexpr EIGEN_DEVICE_FUNC SparseMatrix< Scalar_, Options_, StorageIndex_ > &	derived ()

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

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

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

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	rows () const EIGEN_NOEXCEPT

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	cols () const EIGEN_NOEXCEPT

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	size () const EIGEN_NOEXCEPT

EIGEN_DEVICE_FUNC void	evalTo (Dest &dst) const

EIGEN_DEVICE_FUNC void	addTo (Dest &dst) const

EIGEN_DEVICE_FUNC void	subTo (Dest &dst) const

EIGEN_DEVICE_FUNC void	applyThisOnTheRight (Dest &dst) const

EIGEN_DEVICE_FUNC void	applyThisOnTheLeft (Dest &dst) const

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DeviceWrapper< SparseMatrix< Scalar_, Options_, StorageIndex_ >, Device >	device (Device &device)

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DeviceWrapper< const SparseMatrix< Scalar_, Options_, StorageIndex_ >, Device >	device (Device &device) 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<class SizesType >
void	reserveInnerVectors (const SizesType &reserveSizes)

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

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

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

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

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

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

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

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

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

	SparseCompressedBase ()

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

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
Index	m_outerSize

Index	m_innerSize

StorageIndex *	m_outerIndex

StorageIndex *	m_innerNonZeros

Storage	m_data

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

Friends
class	SparseVector< Scalar_, 0, StorageIndex_ >

template<typename , typename , typename , typename , typename >
struct	internal::Assignment

EIGEN_DEVICE_FUNC void	swap (SparseMatrix &a, SparseMatrix &b)

std::ostream &	operator<< (std::ostream &s, const SparseMatrix &m)

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.

Member Typedef Documentation

◆ Base

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

private

◆ ConstDiagonalReturnType

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

◆ DiagonalReturnType

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

◆ IndexVector

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

◆ InnerIterator

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

◆ Map

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

◆ ReverseInnerIterator

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

◆ ScalarVector

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

◆ Storage

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

◆ TransposedSparseMatrix

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

protected

Member Enumeration Documentation

◆ anonymous enum

template<typename Scalar_ , int Options_, typename StorageIndex_ >

anonymous enum

Enumerator
Options

143 { Options = Options_ };

Eigen::SparseMatrix::Options

@ Options

Definition: SparseMatrix.h:143

Constructor & Destructor Documentation

◆ SparseMatrix() [1/9]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

Default constructor yielding an empty 0 x 0 matrix

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

Eigen::SparseMatrix::m_outerIndex

StorageIndex * m_outerIndex

Definition: SparseMatrix.h:153

Eigen::SparseMatrix::m_outerSize

Index m_outerSize

Definition: SparseMatrix.h:151

Eigen::SparseMatrix::resize

void resize(Index rows, Index cols)

Definition: SparseMatrix.h:734

Eigen::SparseMatrix::m_innerNonZeros

StorageIndex * m_innerNonZeros

Definition: SparseMatrix.h:154

Eigen::SparseMatrix::m_innerSize

Index m_innerSize

Definition: SparseMatrix.h:152

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::resize().

◆ SparseMatrix() [2/9]

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

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

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::resize(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows().

◆ SparseMatrix() [3/9]

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

       : 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());
     }
   }

References Eigen::internal::call_assignment_no_alias(), Eigen::SparseMatrixBase< Derived >::derived(), EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::EIGEN_STATIC_ASSERT(), and Eigen::RowMajorBit.

◆ SparseMatrix() [4/9]

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

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

References Eigen::SparseCompressedBase< Derived >::operator=().

◆ SparseMatrix() [5/9]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

Move constructor

799 : SparseMatrix() { this->swap(other); }

Eigen::SparseMatrix::swap

void swap(SparseMatrix &other)

Definition: SparseMatrix.h:829

Eigen::SparseMatrix::SparseMatrix

SparseMatrix()

Definition: SparseMatrix.h:766

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::swap().

◆ SparseMatrix() [6/9]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename OtherDerived >

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

inline

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

References Eigen::SparseMatrixBase< Derived >::derived().

◆ SparseMatrix() [7/9]

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)

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

References Eigen::SparseMatrixBase< Derived >::derived().

◆ SparseMatrix() [8/9]

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.

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

References Eigen::ReturnByValue< Derived >::evalTo(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::initAssignment().

◆ SparseMatrix() [9/9]

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.

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

References Eigen::DiagonalBase< Derived >::derived().

◆ ~SparseMatrix()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

Destructor

                          {
     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

assign diagXpr to the diagonal of *this There are different strategies: 1 - if *this is overwritten (Func==assign_op) or *this is empty, then we can work treat *this as a dense vector expression. 2 - otherwise, for each diagonal coeff, 2.a - if it already exists, then we update it, 2.b - if the correct position is at the end of the vector, and there is capacity, push to back 2.b - otherwise, the insertion requires a data move, record insertion locations and handle in a second pass 3 - at the end, if some entries failed to be updated in-place, then we alloc a new buffer, copy each chunk at the right position, and insert the new elements.

                                                                      {
     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));
     }
   }

References Eigen::internal::call_assignment_no_alias(), ei_declare_aligned_stack_constructed_variable, eigen_assert, Eigen::placeholders::end, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::index(), j, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::moveChunk(), n, resize(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::resize(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::searchLowerIndex(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::size(), tmp, Eigen::value, and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::value().

Referenced by Eigen::internal::Assignment< DstXprType, SrcXprType, Functor, Diagonal2Sparse >::run().

◆ 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

                                                   {
     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);
   }

References Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::atInRange(), col(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), eigen_assert, Eigen::placeholders::end, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::IsRowMajor, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerNonZeros, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, row(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows().

◆ 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.

275 { return findOrInsertCoeff(row, col, nullptr); }

Eigen::SparseMatrix::findOrInsertCoeff

Scalar & findOrInsertCoeff(Index row, Index col, bool *inserted)

Definition: SparseMatrix.h:231

References col(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::findOrInsertCoeff(), and row().

Referenced by bug1105(), Eigen::SparseInverse< Scalar >::computeInverse(), sparseGaussianTest< Scalar >::df(), Eigen::internal::householder_qr_inplace_update(), Eigen::internal::llt_rank_update_lower(), Eigen::internal::transform_make_affine< Mode >::run(), Eigen::internal::direct_selfadjoint_eigenvalues< SolverType, 2, false >::run(), setrand_eigen_compact(), setrand_eigen_dynamic(), setrand_eigen_gnu_hash(), setrand_eigen_google_dense(), setrand_eigen_google_sparse(), setrand_eigen_sumeq(), setrand_scipy(), Eigen::internal::llt_inplace< Scalar, Lower >::unblocked(), Eigen::internal::ldlt_inplace< Lower >::unblocked(), Eigen::internal::ldlt_inplace< Lower >::updateInPlace(), and Eigen::internal::upperbidiagonalization_inplace_unblocked().

◆ 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()`
	)

                                                                                                                    {
   // 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;
 }

References eigen_assert, Eigen::placeholders::end, i, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::index(), j, k, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::resize(), Eigen::DenseBase< Derived >::setConstant(), and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::value().

◆ cols()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

Returns: the number of columns of the matrix

161 { return IsRowMajor ? m_innerSize : m_outerSize; }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::IsRowMajor, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerSize, and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::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()

                                                   {
     // 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];
         using std::fill_n;
         fill_n(m_outerIndex + m_outerSize, outerChange + 1, lastIdx);
  
         if (!isCompressed()) 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);
   }

Referenced by Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertEmptyOuterVectors(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::removeOuterVectors().

◆ data() [1/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inlineconstexpr

205 { return m_data; }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data.

Referenced by bug1105(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenQuaternionPrinter::children(), GlMatrixHelper< false, Flags_ >::loadMatrix(), Eigen::SluMatrix::Map(), GlMatrixHelper< false, Flags_ >::multMatrix(), operator*(), Eigen::internal::lapacke_helpers::lapacke_hqr< MatrixQR, HCoeffs >::run(), Eigen::selfadjoint_product_selector< MatrixType, OtherType, UpLo, true >::run(), Eigen::selfadjoint_product_selector< MatrixType, OtherType, UpLo, false >::run(), Eigen::general_product_to_triangular_selector< MatrixType, ProductType, UpLo, true >::run(), Eigen::general_product_to_triangular_selector< MatrixType, ProductType, UpLo, false >::run(), Eigen::SluMatrixMapHelper< Matrix< Scalar, Rows, Cols, Options, MRows, MCols > >::run(), Eigen::internal::set_from_triplets_sorted(), gdb.printers.EigenMatrixPrinter::to_string(), gdb.printers.EigenSparseMatrixPrinter::to_string(), and gdb.printers.EigenQuaternionPrinter::to_string().

◆ data() [2/2]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inlineconstexpr

207 { return m_data; }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data.

Referenced by gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenQuaternionPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), gdb.printers.EigenSparseMatrixPrinter::to_string(), and gdb.printers.EigenQuaternionPrinter::to_string().

◆ 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.

763 { return DiagonalReturnType(*this); }

Eigen::SparseMatrix::DiagonalReturnType

Diagonal< SparseMatrix > DiagonalReturnType

Definition: SparseMatrix.h:136

◆ 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.

757 { return ConstDiagonalReturnType(*this); }

Eigen::SparseMatrix::ConstDiagonalReturnType

Diagonal< const SparseMatrix > ConstDiagonalReturnType

Definition: SparseMatrix.h:137

Referenced by Eigen::SparseInverse< Scalar >::computeInverse(), Eigen::SimplicialLLT< MatrixType_, UpLo_, Ordering_ >::determinant(), Eigen::SimplicialNonHermitianLLT< MatrixType_, UpLo_, Ordering_ >::determinant(), Eigen::internal::direct_selfadjoint_eigenvalues< SolverType, 3, false >::extract_kernel(), Eigen::MatrixMarketIterator< Scalar >::matrix(), Eigen::internal::tridiagonalization_inplace_selector< MatrixType, Size, IsComplex >::run(), and Eigen::internal::ldlt_inplace< Lower >::unblocked().

◆ 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

                                {
     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;
   };

References CRBond_Bessel::eps, oomph::SarahBL::epsilon, Eigen::internal::isMuchSmallerThan(), and Eigen::value.

Referenced by Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::SparseMatrix().

◆ finalize()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

Must be called after inserting a set of non zero entries using the low level compressed API.

                          {
     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;
       }
     }
   }

References i, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::isCompressed(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerSize, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::size(), and Eigen::SparseMatrixBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >::size().

Referenced by fillMatrix(), fillMatrix2(), initSPD(), setinnerrand_eigen(), and setrand_eigen_dynamic().

◆ findOrInsertCoeff()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Scalar& Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::findOrInsertCoeff	(	Index	row,
		Index	col,
		bool *	inserted
	)

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. The output parameter inserted is set to true.

Otherwise, if the element does exist, inserted will be set to false.

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.

                                                                          {
     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);
         if (inserted != nullptr) {
           *inserted = true;
         }
         return m_data.value(end);
       }
     }
     if ((dst < end) && (m_data.index(dst) == inner)) {
       // this coefficient exists, return a reference to it
       if (inserted != nullptr) {
         *inserted = false;
       }
       return m_data.value(dst);
     } else {
       if (inserted != nullptr) {
         *inserted = true;
       }
       // insertion will require reconfiguring the buffer
       return insertAtByOuterInner(outer, inner, dst);
     }
   }

Referenced by Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::coeffRef().

◆ initAssignment()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename Other >

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

inlineprotected

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

References resize().

Referenced by Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::operator=(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::SparseMatrix().

◆ 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()

184 { return m_data.indexPtr(); }

Eigen::internal::CompressedStorage::indexPtr

const StorageIndex * indexPtr() const

Definition: CompressedStorage.h:100

References Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::indexPtr(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data.

◆ 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()

180 { return m_data.indexPtr(); }

References Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::indexPtr(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data.

Referenced by Eigen::PastixBase< Derived >::analyzePattern(), Eigen::internal::c_to_fortran_numbering(), Eigen::PastixBase< Derived >::factorize(), Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::factorize(), Eigen::internal::fortran_to_c_numbering(), Eigen::SluMatrix::Map(), Eigen::COLAMDOrdering< StorageIndex >::operator()(), Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >::permute_inner(), Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >::permute_outer(), Eigen::internal::permute_symm_to_symm(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::reserveInnerVectors(), Eigen::SluMatrixMapHelper< SparseMatrixBase< Derived > >::run(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::setIdentity(), sparse_solvers(), and Eigen::viewAsCholmod().

◆ 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

202 { return m_innerNonZeros; }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::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

198 { return m_innerNonZeros; }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerNonZeros.

Referenced by Eigen::SparseCompressedBase< Derived >::InnerIterator::InnerIterator(), Eigen::SparseCompressedBase< Derived >::ReverseInnerIterator::ReverseInnerIterator(), and Eigen::viewAsCholmod().

◆ 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)

164 { return m_innerSize; }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerSize.

Referenced by initSparse(), and Eigen::internal::set_from_triplets().

◆ 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.

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

References col(), and row().

Referenced by fillMatrix(), fillMatrix2(), initSPD(), setinnerrand_eigen(), Eigen::SparseLUMatrixUReturnType< MatrixLType, MatrixUType >::toSparse(), and Eigen::SparseLUMatrixLReturnType< MappedSupernodalType >::toSparse().

◆ insertAtByOuterInner()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

protected

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

Referenced by Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::findOrInsertCoeff(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertByOuterInner().

◆ insertBack()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

Returns

a reference to the non zero coefficient at position row, col assuming that:

the nonzero does not already exist
the new coefficient is the last one according to the storage order

Before filling a given inner vector you must call the statVec(Index) function.

After an insertion session, you should call the finalize() function.

See also: insert, insertBackByOuterInner, startVec

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

References col(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertBackByOuterInner(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::IsRowMajor, and row().

◆ insertBackByOuterInner()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

See also: insertBack, startVec

                                                                   {
     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);
   }

References Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::append(), eigen_assert, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::index(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, p, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::size(), and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::value().

Referenced by Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertBack().

◆ insertBackByOuterInnerUnordered()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

Warning: use it only if you know what you are doing

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

References Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::append(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, p, and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::value().

◆ insertBackUncompressed()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

See also: insert(Index,Index)

                                                                            {
     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);
   }

References col(), eigen_assert, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::index(), p, row(), and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::value().

◆ insertByOuterInner()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

same as insert(Index,Index) except that the indices are given relative to the storage order

                                                {
     eigen_assert(j >= 0 && j < m_outerSize && "invalid outer index");
     eigen_assert(i >= 0 && i < m_innerSize && "invalid inner index");
     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);
   }

References eigen_assert, Eigen::placeholders::end, i, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::index(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::insertAtByOuterInner(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::isCompressed(), j, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerNonZeros, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerSize, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerSize, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::searchLowerIndex(), oomph::CumulativeTimings::start(), and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::value().

Referenced by initSparse().

◆ 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

See also: insert(Index,Index)

                                                                                      {
   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);
 }

References col(), eigen_assert, Eigen::placeholders::end, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::index(), row(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::searchLowerIndex(), and oomph::CumulativeTimings::start().

◆ 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

                                                                                                                   {
   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 minimum 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);
 }

References Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::allocatedSize(), eigen_assert, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::index(), j, Eigen::numext::maxi(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::moveChunk(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::reserve(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::resize(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::size(), and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::value().

◆ insertEmptyOuterVectors()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

                                                        {
     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())

b

Scalar * b

Definition: benchVecAdd.cpp:17

Eigen::ColMajor

@ ColMajor

Definition: Constants.h:318

Eigen::RowMajor

@ RowMajor

Definition: Constants.h:320

a

const Scalar * a

Definition: level2_cplx_impl.h:32

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

References Eigen::placeholders::end.

◆ 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; });

Eigen::SparseMatrix< double >

Eigen::SparseMatrix::insertFromSortedTriplets

void insertFromSortedTriplets(const InputIterators &begin, const InputIterators &end)

Definition: SparseMatrix.h:1450

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

References Eigen::placeholders::end.

◆ 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.

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

References Eigen::placeholders::end.

◆ 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; });

Eigen::SparseMatrix::insertFromTriplets

void insertFromTriplets(const InputIterators &begin, const InputIterators &end)

Definition: SparseMatrix.h:1421

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

References Eigen::placeholders::end.

◆ 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

See also: insert(Index,Index)

                                                                                        {
   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);
 }

References col(), eigen_assert, Eigen::placeholders::end, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::index(), row(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::searchLowerIndex(), oomph::CumulativeTimings::start(), and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::value().

◆ 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

                                                                                                                     {
   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);
 }

References Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::allocatedSize(), eigen_assert, Eigen::placeholders::end, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::index(), j, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::moveChunk(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::resize(), oomph::CumulativeTimings::start(), and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::value().

◆ isCompressed()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

bool Eigen::SparseCompressedBase< Derived >::isCompressed

inline

Returns: whether *this is in compressed form.

114 { return innerNonZeroPtr() == 0; }

Eigen::SparseMatrix::innerNonZeroPtr

const StorageIndex * innerNonZeroPtr() const

Definition: SparseMatrix.h:198

◆ makeCompressed()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

Turns the matrix into the compressed format.

                         {
     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();
   }

References eigen_internal_assert, Eigen::placeholders::end, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::isCompressed(), j, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerNonZeros, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerSize, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::moveChunk(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::resize(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::squeeze(), and oomph::CumulativeTimings::start().

Referenced by Eigen::PardisoLU< MatrixType >::getMatrix(), Eigen::PardisoLLT< MatrixType, UpLo_ >::getMatrix(), Eigen::PardisoLDLT< MatrixType, Options >::getMatrix(), Eigen::SparseLUMatrixUReturnType< MatrixLType, MatrixUType >::toSparse(), and Eigen::SparseLUMatrixLReturnType< MappedSupernodalType >::toSparse().

◆ nonZeros()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

Index Eigen::SparseCompressedBase< Derived >::nonZeros

inline

Returns: the number of non zero coefficients

                                 {
     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();
   }

Referenced by Eigen::SimplicialCholeskyBase< Derived >::_solve_impl(), Eigen::SparseQR< MatrixType_, OrderingType_ >::analyzePattern(), Browse_Matrices(), Eigen::internal::c_to_fortran_numbering(), doEigen(), Eigen::SimplicialCholeskyBase< Derived >::dumpMemory(), Eigen::internal::fortran_to_c_numbering(), Eigen::SparseCompressedBase< Derived >::InnerIterator::InnerIterator(), main(), Eigen::SluMatrix::Map(), Eigen::COLAMDOrdering< StorageIndex >::operator()(), Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >::permute_inner(), Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >::permute_outer(), Eigen::SparseCompressedBase< Derived >::ReverseInnerIterator::ReverseInnerIterator(), Eigen::SluMatrixMapHelper< SparseMatrixBase< Derived > >::run(), Eigen::saveMarket(), sparse_solvers(), and Eigen::viewAsCholmod().

◆ operator=() [1/8]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename OtherDerived >

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

inline

                                                                        {
     return Base::operator=(other.derived());
   }

References Eigen::EigenBase< Derived >::derived(), and Eigen::SparseCompressedBase< Derived >::operator=().

◆ operator=() [2/8]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename Lhs , typename Rhs >

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

inline

◆ operator=() [3/8]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename Lhs , typename Rhs >

SparseMatrix<Scalar, Options_, StorageIndex_>& Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::operator= ( const Product< Lhs, Rhs, AliasFreeProduct > & src )

                                                     {
   // std::cout << "in Assignment : " << DstOptions << "\n";
   SparseMatrix dst(src.rows(), src.cols());
   internal::generic_product_impl<Lhs, Rhs>::evalTo(dst, src.lhs(), src.rhs());
   this->swap(dst);
   return *this;
 }

References Eigen::Product< Lhs_, Rhs_, Option >::cols(), Eigen::Product< Lhs_, Rhs_, Option >::lhs(), Eigen::Product< Lhs_, Rhs_, Option >::rhs(), Eigen::Product< Lhs_, Rhs_, Option >::rows(), and Eigen::swap().

◆ operator=() [4/8]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

                                                             {
     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;
   }

References Eigen::SparseMatrixBase< Derived >::const_cast_derived(), EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::initAssignment(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::isCompressed(), Eigen::SparseMatrixBase< Derived >::isRValue(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerSize, Eigen::SparseCompressedBase< Derived >::operator=(), Eigen::internal::smart_copy(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::swap().

◆ operator=() [5/8]

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=() [6/8]

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 )

                                                                                                     {
   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());
   }
 }

References Eigen::SparseMatrixBase< Derived >::cols(), Eigen::SparseMatrixBase< Derived >::derived(), EIGEN_SPARSE_CREATE_TEMPORARY_PLUGIN, EIGEN_SPARSE_TRANSPOSED_COPY_PLUGIN, EIGEN_STATIC_ASSERT, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::index(), Eigen::SparseMatrixBase< Derived >::isRValue(), j, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::outerSize(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::resize(), Eigen::RowMajorBit, Eigen::SparseMatrixBase< Derived >::rows(), swap(), tmp, compute_granudrum_aor::type, and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::value().

◆ operator=() [7/8]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename OtherDerived >

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

inline

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

References Eigen::SparseMatrixBase< Derived >::derived().

◆ operator=() [8/8]

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

                                                        {
     this->swap(other);
     return *this;
   }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::swap().

◆ 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()

193 { return m_outerIndex; }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::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()

189 { return m_outerIndex; }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex.

Referenced by Eigen::PastixBase< Derived >::analyzePattern(), Eigen::SparseLU< MatrixType_, OrderingType_ >::analyzePattern(), Eigen::internal::c_to_fortran_numbering(), Eigen::PastixBase< Derived >::factorize(), Eigen::SparseQR< MatrixType_, OrderingType_ >::factorize(), Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::factorize(), Eigen::internal::fortran_to_c_numbering(), Eigen::SparseCompressedBase< Derived >::InnerIterator::InnerIterator(), Eigen::SluMatrix::Map(), Eigen::COLAMDOrdering< StorageIndex >::operator()(), Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >::permute_inner(), Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >::permute_outer(), Eigen::internal::permute_symm_to_symm(), Eigen::SparseCompressedBase< Derived >::ReverseInnerIterator::ReverseInnerIterator(), Eigen::SluMatrixMapHelper< SparseMatrixBase< Derived > >::run(), Eigen::internal::set_from_triplets_sorted(), sparse_solvers(), and Eigen::viewAsCholmod().

◆ 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)

166 { return m_outerSize; }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerSize.

Referenced by Eigen::DiagonalPreconditioner< Scalar_ >::factorize(), Eigen::LeastSquareDiagonalPreconditioner< Scalar_ >::factorize(), Eigen::PastixLU< MatrixType_, IsStrSym >::grabMatrix(), initSparse(), is_sorted(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::operator=(), Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >::permute_inner(), Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >::permute_outer(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::resize(), Eigen::saveMarket(), Eigen::internal::set_from_triplets(), Eigen::internal::set_from_triplets_sorted(), Eigen::internal::stable_norm_impl(), and Eigen::SparseVector< Scalar_, Options_, StorageIndex_ >::swap().

◆ 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)

                                                 {
     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);
     }
   }

References col(), Eigen::placeholders::end, i, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::index(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::isCompressed(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::IsRowMajor, j, k, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerNonZeros, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerSize, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::resize(), row(), and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::value().

◆ 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

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

References oomph::SarahBL::epsilon.

◆ removeOuterVectors()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

                                                   {
     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,
		const typename SizesType::value_type &	enableif = `typename SizesType::value_type()`
	)

inline

                                                                                                      {
     EIGEN_UNUSED_VARIABLE(enableif);
     reserveInnerVectors(reserveSizes);
   }

References EIGEN_UNUSED_VARIABLE, and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::reserveInnerVectors().

◆ 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.

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

References eigen_assert, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::isCompressed(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::reserve().

Referenced by fillMatrix(), fillMatrix2(), initSparse(), Eigen::loadMarket(), setrand_eigen_dynamic(), setrand_eigen_sumeq(), Eigen::SparseLUMatrixUReturnType< MatrixLType, MatrixUType >::toSparse(), and Eigen::SparseLUMatrixLReturnType< MappedSupernodalType >::toSparse().

◆ reserveInnerVectors()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<class SizesType >

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

inlineprotected

                                                                  {
     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);
     }
   }

References Eigen::placeholders::end, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::innerIndexPtr(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::isCompressed(), j, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerNonZeros, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerSize, Eigen::numext::maxi(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::moveChunk(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::reserve(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::resize(), Eigen::internal::smart_memmove(), swap(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::valuePtr().

Referenced by Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::reserve().

◆ 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();

Eigen::SparseMatrix::data

constexpr Storage & data()

Definition: SparseMatrix.h:205

after resizing it.

See also: reserve(), setZero()

                                       {
     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;
  
     using std::fill_n;
     fill_n(m_outerIndex, m_outerSize + 1, StorageIndex(0));
   }

Referenced by Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::analyzePattern(), cholesky_faillure_cases(), Eigen::IterScaling< MatrixType_ >::compute(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::conservativeResize(), Eigen::PardisoLLT< MatrixType, UpLo_ >::getMatrix(), Eigen::PardisoLDLT< MatrixType, Options >::getMatrix(), Eigen::loadMarket(), Eigen::loadMarketDense(), Eigen::internal::permute_symm_to_symm(), Eigen::internal::set_from_triplets_sorted(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::SparseMatrix().

◆ resizeNonZeros()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

Resize the nonzero vector to size

754 { m_data.resize(size); }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::resize(), and Eigen::SparseMatrixBase< SparseMatrix< Scalar_, Options_, StorageIndex_ > >::size().

Referenced by Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >::permute_inner(), Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >::permute_outer(), Eigen::internal::permute_symm_to_symm(), Eigen::internal::set_from_triplets_sorted(), and setrand_scipy().

◆ rows()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

Returns: the number of rows of the matrix

159 { return IsRowMajor ? m_outerSize : m_innerSize; }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::IsRowMajor, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerSize, and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerSize.

◆ 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())

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

References Eigen::placeholders::end.

◆ 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; });

Eigen::SparseMatrix::setFromSortedTriplets

void setFromSortedTriplets(const InputIterators &begin, const InputIterators &end)

Definition: SparseMatrix.h:1357

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

References Eigen::placeholders::end.

◆ 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.

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

References Eigen::placeholders::end.

Referenced by Eigen::loadMarket().

◆ 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; });

Eigen::SparseMatrix::setFromTriplets

void setFromTriplets(const InputIterators &begin, const InputIterators &end)

Definition: SparseMatrix.h:1328

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

References Eigen::placeholders::end.

◆ 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.

                             {
     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));
     using std::fill_n;
     fill_n(valuePtr(), m_outerSize, Scalar(1));
   }

References eigen_assert, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::innerIndexPtr(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerNonZeros, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerSize, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerSize, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::resize(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::squeeze(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::valuePtr().

Referenced by initMatrix_identity(), and Eigen::internal::tridiagonalization_inplace_selector< MatrixType, 3, false >::run().

◆ 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()

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

References Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::clear(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerNonZeros, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerSize.

Referenced by dostuff(), initSparse(), initSPD(), main(), Eigen::internal::transform_make_affine< Mode >::run(), Eigen::general_product_to_triangular_selector< MatrixType, ProductType, UpLo, true >::run(), Eigen::general_product_to_triangular_selector< MatrixType, ProductType, UpLo, false >::run(), and test_random_setter().

◆ startVec()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

See also: insertBack, insertBackByOuterInner

                                     {
     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];
   }

References eigen_assert, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::size().

◆ sum()

template<typename Scalar_ , int Options_, typename Index_ >

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

Overloaded for performance

                                                    {
   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();
 }

References cols, eigen_assert, Eigen::PlainObjectBase< Matrix< Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_ > >::Map(), and rows.

Referenced by main().

◆ 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.

                                         {
     // 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);
   }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerNonZeros, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerSize, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerSize, Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::swap(), and swap().

Referenced by Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::operator=(), Eigen::internal::transposition_matrix_product< ExpressionType, Side, Transposed, ExpressionShape >::run(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::SparseMatrix(), and Eigen::internal::ldlt_inplace< Lower >::unblocked().

◆ uncompress()

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

inline

Turns the matrix into the uncompressed mode

                     {
     if (!isCompressed()) return;
     m_innerNonZeros = internal::conditional_aligned_new_auto<StorageIndex, true>(m_outerSize);
     if (m_outerIndex[m_outerSize] == 0) {
       using std::fill_n;
       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];
     }
   }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::isCompressed(), j, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_innerNonZeros, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerIndex, and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_outerSize.

Referenced by Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::conservativeResize(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::removeOuterVectors().

◆ 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()

175 { return m_data.valuePtr(); }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::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()

171 { return m_data.valuePtr(); }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::m_data, and Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::valuePtr().

Referenced by Eigen::PastixBase< Derived >::analyzePattern(), Eigen::PastixBase< Derived >::factorize(), Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::factorize(), Eigen::SluMatrix::Map(), Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >::permute_inner(), Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >::permute_outer(), Eigen::internal::permute_symm_to_symm(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::reserveInnerVectors(), Eigen::SluMatrixMapHelper< SparseMatrixBase< Derived > >::run(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::setIdentity(), sparse_solvers(), and Eigen::viewAsCholmod().

Friends And Related Function Documentation

◆ internal::Assignment

template<typename Scalar_ , int Options_, typename StorageIndex_ >

template<typename , typename , typename , typename , typename >

friend struct internal::Assignment

friend

◆ operator<<

template<typename Scalar_ , int Options_, typename StorageIndex_ >

std::ostream& operator<<	(	std::ostream &	s,
		const SparseMatrix< Scalar_, Options_, StorageIndex_ > &	m
	)

friend

                                                                       {
     EIGEN_DBG_SPARSE(
         s << "Nonzero entries:\n"; if (m.isCompressed()) {
           for (Index i = 0; i < m.nonZeros(); ++i) s << "(" << m.m_data.value(i) << "," << m.m_data.index(i) << ") ";
         } else {
           for (Index i = 0; i < m.outerSize(); ++i) {
             Index p = m.m_outerIndex[i];
             Index pe = m.m_outerIndex[i] + m.m_innerNonZeros[i];
             Index k = p;
             for (; k < pe; ++k) {
               s << "(" << m.m_data.value(k) << "," << m.m_data.index(k) << ") ";
             }
             for (; k < m.m_outerIndex[i + 1]; ++k) {
               s << "(_,_) ";
             }
           }
         } s << std::endl;
         s << std::endl; s << "Outer pointers:\n";
         for (Index i = 0; i < m.outerSize(); ++i) { s << m.m_outerIndex[i] << " "; } s << " $" << std::endl;
         if (!m.isCompressed()) {
           s << "Inner non zeros:\n";
           for (Index i = 0; i < m.outerSize(); ++i) {
             s << m.m_innerNonZeros[i] << " ";
           }
           s << " $" << std::endl;
         } s
         << std::endl;);
     s << static_cast<const SparseMatrixBase<SparseMatrix>&>(m);
     return s;
   }

◆ SparseVector< Scalar_, 0, StorageIndex_ >

template<typename Scalar_ , int Options_, typename StorageIndex_ >

friend class SparseVector< Scalar_, 0, StorageIndex_ >

friend

◆ swap

template<typename Scalar_ , int Options_, typename StorageIndex_ >

EIGEN_DEVICE_FUNC void swap	(	SparseMatrix< Scalar_, Options_, StorageIndex_ > &	a,
		SparseMatrix< Scalar_, Options_, StorageIndex_ > &	b
	)

friend

Free-function swap.

838 { a.swap(b); }

Member Data Documentation

◆ m_data

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

protected

◆ m_innerNonZeros

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

protected

◆ m_innerSize

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

protected

◆ m_outerIndex

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

protected

◆ m_outerSize

template<typename Scalar_ , int Options_, typename StorageIndex_ >

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

protected

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

Friends

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

◆ InnerIterator

◆ Map

◆ ReverseInnerIterator

◆ ScalarVector

◆ Storage

◆ TransposedSparseMatrix

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ SparseMatrix() [1/9]

◆ SparseMatrix() [2/9]

◆ SparseMatrix() [3/9]

◆ SparseMatrix() [4/9]

◆ SparseMatrix() [5/9]

◆ SparseMatrix() [6/9]

◆ SparseMatrix() [7/9]

◆ SparseMatrix() [8/9]

◆ SparseMatrix() [9/9]

◆ ~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()

◆ findOrInsertCoeff()

◆ 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/8]

◆ operator=() [2/8]

◆ operator=() [3/8]

◆ operator=() [4/8]

◆ operator=() [5/8]

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