A versatile sparse matrix representation where each element is a block. More...

#include <src/eigen/unsupported/Eigen/src/SparseExtra/BlockSparseMatrix.h>

Inheritance diagram for Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >:

Collaboration diagram for Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >:

Classes
class	BlockInnerIterator

class	InnerIterator

Public Types
enum	{ Options = _Options , Flags = Options , BlockSize =_BlockAtCompileTime , RowsAtCompileTime = Dynamic , ColsAtCompileTime = Dynamic , MaxRowsAtCompileTime = Dynamic , MaxColsAtCompileTime = Dynamic , IsVectorAtCompileTime = 0 , IsColMajor = Flags&RowMajorBit ? 0 : 1 }

typedef _Scalar	Scalar

typedef NumTraits< Scalar >::Real	RealScalar

typedef _StorageIndex	StorageIndex

typedef internal::ref_selector< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::type	Nested

typedef Matrix< Scalar, _BlockAtCompileTime, _BlockAtCompileTime, IsColMajor ? ColMajor :RowMajor >	BlockScalar

typedef Matrix< RealScalar, _BlockAtCompileTime, _BlockAtCompileTime, IsColMajor ? ColMajor :RowMajor >	BlockRealScalar

typedef internal::conditional< _BlockAtCompileTime==Dynamic, Scalar, BlockScalar >::type	BlockScalarReturnType

typedef BlockSparseMatrix< Scalar, BlockSize, IsColMajor ? ColMajor :RowMajor, StorageIndex >	PlainObject

enum

typedef Scalar	value_type

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

typedef internal::traits< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::StorageKind	StorageKind

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

typedef SparseMatrixBase	StorageBaseType

typedef Matrix< StorageIndex, Dynamic, 1 >	IndexVector

typedef Matrix< Scalar, Dynamic, 1 >	ScalarVector

typedef internal::conditional< NumTraits< Scalar >::IsComplex, CwiseUnaryOp< internal::scalar_conjugate_op< Scalar >, Eigen::Transpose< constDerived > >, Transpose< constDerived > >::type	AdjointReturnType

typedef Transpose< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >	TransposeReturnType

typedef internal::add_const< Transpose< constDerived > >::type	ConstTransposeReturnType

typedef internal::conditional< _HasDirectAccess, constScalar &, Scalar >::type	CoeffReturnType

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

typedef Matrix< Scalar, RowsAtCompileTime, ColsAtCompileTime >	DenseMatrixType

typedef Matrix< Scalar, EIGEN_SIZE_MAX(RowsAtCompileTime, ColsAtCompileTime), EIGEN_SIZE_MAX(RowsAtCompileTime, ColsAtCompileTime)>	SquareMatrixType

typedef EigenBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >	Base

typedef Block< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >, IsRowMajor?1:Dynamic, IsRowMajor?Dynamic:1, true >	InnerVectorReturnType

typedef Block< const BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >, IsRowMajor?1:Dynamic, IsRowMajor?Dynamic:1, true >	ConstInnerVectorReturnType

typedef Block< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >, Dynamic, Dynamic, true >	InnerVectorsReturnType

typedef Block< const BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >, Dynamic, Dynamic, true >	ConstInnerVectorsReturnType

typedef Eigen::Index	Index
	The interface type of indices.

Public Member Functions
	BlockSparseMatrix ()

	BlockSparseMatrix (Index brow, Index bcol)
	Construct and resize.

	BlockSparseMatrix (const BlockSparseMatrix &other)
	Copy-constructor.

BlockSparseMatrix &	operator= (BlockSparseMatrix other)

	~BlockSparseMatrix ()

template<typename MatrixType >
	BlockSparseMatrix (const MatrixType &spmat)
	Constructor from a sparse matrix.

template<typename MatrixType >
BlockSparseMatrix &	operator= (const MatrixType &spmat)
	Assignment from a sparse matrix with the same storage order.

template<typename MatrixType >
void	setBlockStructure (const MatrixType &blockPattern)
	Set the nonzero block pattern of the matrix.

void	resize (Index brow, Index bcol)
	Set the number of rows and columns blocks.

void	setBlockSize (Index blockSize)
	set the block size at runtime for fixed-size block layout

void	setBlockLayout (const VectorXi &rowBlocks, const VectorXi &colBlocks)
	Set the row and column block layouts,.

void	reserve (const Index nonzerosblocks)
	Allocate the internal array of pointers to blocks and their inner indices.

template<typename InputIterator >
void	setFromTriplets (const InputIterator &begin, const InputIterator &end)
	Fill values in a matrix from a triplet list.

Index	rows () const

Index	cols () const

Index	innerSize () const

Index	outerSize () const

Index	blockRows () const

Index	blockCols () const

Index	outerBlocks () const

Index	innerBlocks () const

Index	outerToBlock (Index outer) const

Index	innerToBlock (Index inner) const

Ref< BlockScalar >	coeffRef (Index brow, Index bcol)

Map< const BlockScalar >	coeff (Index brow, Index bcol) const

template<typename VecType >
BlockSparseTimeDenseProduct< BlockSparseMatrix, VecType >	operator* (const VecType &lhs) const

Index	nonZerosBlocks () const

Index	nonZeros () const

BlockScalarReturnType *	valuePtr ()

StorageIndex *	innerIndexPtr ()

const StorageIndex *	innerIndexPtr () const

StorageIndex *	outerIndexPtr ()

const StorageIndex *	outerIndexPtr () const

bool	isCompressed () const
	for compatibility purposes with the SparseMatrix class

Index	blockRowsIndex (Index bi) const

Index	blockColsIndex (Index bj) const

Index	blockOuterIndex (Index bj) const

Index	blockInnerIndex (Index bi) const

Index	blockInnerSize (Index bi) const

Index	blockOuterSize (Index bj) const

Index	blockPtr (Index id) const

const BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	derived () const

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	derived ()

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	const_cast_derived () const

Index	size () const

bool	isVector () const

bool	isRValue () const

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	markAsRValue ()

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	operator+= (const SparseMatrixBase< OtherDerived > &other)

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	operator+= (const DiagonalBase< OtherDerived > &other)

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	operator+= (const EigenBase< OtherDerived > &other)

EIGEN_STRONG_INLINE BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	operator+= (const SparseMatrixBase< OtherDerived > &other)

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	operator-= (const SparseMatrixBase< OtherDerived > &other)

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	operator-= (const DiagonalBase< OtherDerived > &other)

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	operator-= (const EigenBase< OtherDerived > &other)

EIGEN_STRONG_INLINE BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	operator-= (const SparseMatrixBase< OtherDerived > &other)

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	operator*= (const Scalar &other)

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	operator*= (const SparseMatrixBase< OtherDerived > &other)

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	operator/= (const Scalar &other)

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

EIGEN_STRONG_INLINE const SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::template CwiseProductDenseReturnType< OtherDerived >::Type	cwiseProduct (const MatrixBase< OtherDerived > &other) const

const Product< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >, OtherDerived >	operator* (const DiagonalBase< OtherDerived > &other) const

const Product< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >, OtherDerived, AliasFreeProduct >	operator* (const SparseMatrixBase< OtherDerived > &other) const

const Product< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >, OtherDerived >	operator* (const MatrixBase< OtherDerived > &other) const

SparseSymmetricPermutationProduct< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >, Upper\|Lower >	twistedBy (const PermutationMatrix< Dynamic, Dynamic, StorageIndex > &perm) const

const TriangularView< const BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >, Mode >	triangularView () const

ConstSelfAdjointViewReturnType< UpLo >::Type	selfadjointView () const

SelfAdjointViewReturnType< UpLo >::Type	selfadjointView ()

SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::template ConstSelfAdjointViewReturnType< UpLo >::Type	selfadjointView () const

SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::template SelfAdjointViewReturnType< UpLo >::Type	selfadjointView ()

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

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

internal::traits< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::Scalar	dot (const MatrixBase< OtherDerived > &other) const

internal::traits< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _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

InnerVectorReturnType	innerVector (Index outer)

const ConstInnerVectorReturnType	innerVector (Index outer) const

InnerVectorsReturnType	innerVectors (Index outerStart, Index outerSize)

const ConstInnerVectorsReturnType	innerVectors (Index outerStart, Index outerSize) 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< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::type	eval () const

Scalar	sum () const

const SparseView< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >	pruned (const Scalar &reference=Scalar(0), const RealScalar &epsilon=NumTraits< Scalar >::dummy_precision()) const

EIGEN_DEVICE_FUNC const Derived &	const_derived () const

template<typename Dest >
EIGEN_DEVICE_FUNC void	addTo (Dest &dst) const

template<typename Dest >
EIGEN_DEVICE_FUNC void	subTo (Dest &dst) const

template<typename Dest >
EIGEN_DEVICE_FUNC void	applyThisOnTheRight (Dest &dst) const

template<typename Dest >
EIGEN_DEVICE_FUNC void	applyThisOnTheLeft (Dest &dst) const

Protected Member Functions
Map< BlockScalar >	insert (Index brow, Index bcol)

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	assign (const OtherDerived &other)

void	assignGeneric (const OtherDerived &other)

Static Protected Member Functions
static StorageIndex	convert_index (const Index idx)

Protected Attributes
Index	m_innerBSize

Index	m_outerBSize

StorageIndex *	m_innerOffset

StorageIndex *	m_outerOffset

Index	m_nonzerosblocks

Index	m_nonzeros

Scalar *	m_values

StorageIndex *	m_blockPtr

StorageIndex *	m_indices

StorageIndex *	m_outerIndex

Index	m_blockSize

bool	m_isRValue

Private Member Functions
void	evalTo (Dest &) const

Friends
void	swap (BlockSparseMatrix &first, BlockSparseMatrix &second)

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

Detailed Description

template<typename _Scalar, int _BlockAtCompileTime, int _Options, typename _StorageIndex>
class Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >

A versatile sparse matrix representation where each element is a block.

This class provides routines to manipulate block sparse matrices stored in a BSR-like representation. There are two main types :

All blocks have the same number of rows and columns, called block size in the following. In this case, if this block size is known at compile time, it can be given as a template parameter like
BlockSparseMatrix<Scalar, 3, ColMajor> bmat(b_rows, b_cols);

Eigen::BlockSparseMatrix
A versatile sparse matrix representation where each element is a block.
Definition BlockSparseMatrix.h:285

Here, bmat is a b_rows x b_cols block sparse matrix where each coefficient is a 3x3 dense matrix. If the block size is fixed but will be given at runtime,
BlockSparseMatrix<Scalar, Dynamic, ColMajor> bmat(b_rows, b_cols);

bmat.setBlockSize(block_size);
The second case is for variable-block sparse matrices. Here each block has its own dimensions. The only restriction is that all the blocks in a row (resp. a column) should have the same number of rows (resp. of columns). It is thus required in this case to describe the layout of the matrix by calling setBlockLayout(rowBlocks, colBlocks).

In any of the previous case, the matrix can be filled by calling setFromTriplets(). A regular sparse matrix can be converted to a block sparse matrix and vice versa. It is obviously required to describe the block layout beforehand by calling either setBlockSize() for fixed-size blocks or setBlockLayout for variable-size blocks.

Template Parameters

_Scalar	The Scalar type
_BlockAtCompileTime	The block layout option. It takes the following values Dynamic : block size known at runtime a numeric number : fixed-size block known at compile time

Member Typedef Documentation

◆ AdjointReturnType

typedef internal::conditional<NumTraits<Scalar>::IsComplex,CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>,Eigen::Transpose<constDerived>>,Transpose<constDerived>>::type Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::AdjointReturnType

inherited

◆ Base

typedef EigenBase<BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > > Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::Base

inherited

◆ BlockRealScalar

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

typedef Matrix<RealScalar, _BlockAtCompileTime, _BlockAtCompileTime,IsColMajor ? ColMajor : RowMajor> Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockRealScalar

◆ BlockScalar

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

typedef Matrix<Scalar, _BlockAtCompileTime, _BlockAtCompileTime,IsColMajor ? ColMajor : RowMajor> Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockScalar

◆ BlockScalarReturnType

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

typedef internal::conditional<_BlockAtCompileTime==Dynamic,Scalar,BlockScalar>::type Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockScalarReturnType

◆ CoeffReturnType

typedef internal::conditional<_HasDirectAccess,constScalar&,Scalar>::type Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::CoeffReturnType

inherited

◆ ConstantReturnType

typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,Matrix<Scalar,Dynamic,Dynamic> > Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::ConstantReturnType

inherited

◆ ConstInnerVectorReturnType

typedef Block<const BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > ,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true> Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::ConstInnerVectorReturnType

inherited

◆ ConstInnerVectorsReturnType

typedef Block<const BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > ,Dynamic,Dynamic,true> Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::ConstInnerVectorsReturnType

inherited

◆ ConstTransposeReturnType

typedef internal::add_const<Transpose<constDerived>>::type Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::ConstTransposeReturnType

inherited

◆ DenseMatrixType

typedef Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime> Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::DenseMatrixType

inherited

type of the equivalent dense matrix

◆ Index

template<typename Derived >

typedef Eigen::Index Eigen::EigenBase< Derived >::Index

inherited

The interface type of indices.

To change this, #define the preprocessor symbol EIGEN_DEFAULT_DENSE_INDEX_TYPE.

See also: StorageIndex, TopicPreprocessorDirectives.

◆ IndexVector

typedef Matrix<StorageIndex,Dynamic,1> Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::IndexVector

inherited

◆ InnerVectorReturnType

typedef Block<BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > ,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true> Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::InnerVectorReturnType

inherited

◆ InnerVectorsReturnType

typedef Block<BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > ,Dynamic,Dynamic,true> Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::InnerVectorsReturnType

inherited

◆ Nested

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

typedef internal::ref_selector<BlockSparseMatrix<_Scalar,_BlockAtCompileTime,_Options,_StorageIndex>>::type Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::Nested

◆ PacketReturnType

typedef internal::add_const_on_value_type_if_arithmetic<typenameinternal::packet_traits<Scalar>::type>::type Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::PacketReturnType

inherited

◆ PacketScalar

typedef internal::packet_traits<Scalar>::type Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::PacketScalar

inherited

◆ PlainObject

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

typedef BlockSparseMatrix<Scalar, BlockSize, IsColMajor ? ColMajor : RowMajor, StorageIndex> Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::PlainObject

◆ RealScalar

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

typedef NumTraits<Scalar>::Real Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::RealScalar

◆ Scalar

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

typedef _Scalar Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::Scalar

◆ ScalarVector

typedef Matrix<Scalar,Dynamic,1> Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::ScalarVector

inherited

◆ SquareMatrixType

typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime), EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime)> Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::SquareMatrixType

inherited

type of the equivalent square matrix

◆ StorageBaseType

typedef SparseMatrixBase Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::StorageBaseType

inherited

◆ StorageIndex

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

typedef _StorageIndex Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::StorageIndex

◆ StorageKind

typedef internal::traits<BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::StorageKind Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::StorageKind

inherited

◆ TransposeReturnType

typedef Transpose<BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > > Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::TransposeReturnType

inherited

◆ value_type

typedef Scalar Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::value_type

inherited

The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc.

It is an alias for the Scalar type

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

inherited

         {
 
      RowsAtCompileTime = internal::traits<Derived>::RowsAtCompileTime,
      ColsAtCompileTime = internal::traits<Derived>::ColsAtCompileTime,
      SizeAtCompileTime = (internal::size_at_compile_time<internal::traits<Derived>::RowsAtCompileTime,
                                                   internal::traits<Derived>::ColsAtCompileTime>::ret),
      MaxRowsAtCompileTime = RowsAtCompileTime,
      MaxColsAtCompileTime = ColsAtCompileTime,
 
      MaxSizeAtCompileTime = (internal::size_at_compile_time<MaxRowsAtCompileTime,
                                                      MaxColsAtCompileTime>::ret),
 
      IsVectorAtCompileTime = RowsAtCompileTime == 1 || ColsAtCompileTime == 1,
      Flags = internal::traits<Derived>::Flags,
      IsRowMajor = Flags&RowMajorBit ? 1 : 0,
      
      InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? int(SizeAtCompileTime)
                             : int(IsRowMajor) ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
 
      #ifndef EIGEN_PARSED_BY_DOXYGEN
      _HasDirectAccess = (int(Flags)&DirectAccessBit) ? 1 : 0 // workaround sunCC
      #endif
    };

◆ anonymous enum

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

anonymous enum

Enumerator
Options
Flags
BlockSize
RowsAtCompileTime
ColsAtCompileTime
MaxRowsAtCompileTime
MaxColsAtCompileTime
IsVectorAtCompileTime
IsColMajor

         {
      Options = _Options,
      Flags = Options,
      BlockSize=_BlockAtCompileTime,
      RowsAtCompileTime = Dynamic,
      ColsAtCompileTime = Dynamic,
      MaxRowsAtCompileTime = Dynamic,
      MaxColsAtCompileTime = Dynamic,
      IsVectorAtCompileTime = 0,
      IsColMajor = Flags&RowMajorBit ? 0 : 1
    };

Constructor & Destructor Documentation

◆ BlockSparseMatrix() [1/4]

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockSparseMatrix ( )

inline

    : m_innerBSize(0),m_outerBSize(0),m_innerOffset(0),m_outerOffset(0),
      m_nonzerosblocks(0),m_values(0),m_blockPtr(0),m_indices(0),
      m_outerIndex(0),m_blockSize(BlockSize)
    { }

◆ BlockSparseMatrix() [2/4]

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockSparseMatrix	(	Index	brow,
		Index	bcol
	)

inline

Construct and resize.

      : m_innerBSize(IsColMajor ? brow : bcol),
        m_outerBSize(IsColMajor ? bcol : brow),
        m_innerOffset(0),m_outerOffset(0),m_nonzerosblocks(0),
        m_values(0),m_blockPtr(0),m_indices(0),
        m_outerIndex(0),m_blockSize(BlockSize)
    { }

◆ BlockSparseMatrix() [3/4]

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockSparseMatrix ( const BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & other )

inline

Copy-constructor.

      : m_innerBSize(other.m_innerBSize),m_outerBSize(other.m_outerBSize),
        m_nonzerosblocks(other.m_nonzerosblocks),m_nonzeros(other.m_nonzeros),
        m_blockPtr(0),m_blockSize(other.m_blockSize)
    {
      // should we allow copying between variable-size blocks and fixed-size blocks ??
      eigen_assert(m_blockSize == BlockSize && " CAN NOT COPY BETWEEN FIXED-SIZE AND VARIABLE-SIZE BLOCKS");
 
      std::copy(other.m_innerOffset, other.m_innerOffset+m_innerBSize+1, m_innerOffset);
      std::copy(other.m_outerOffset, other.m_outerOffset+m_outerBSize+1, m_outerOffset);
      std::copy(other.m_values, other.m_values+m_nonzeros, m_values);
 
      if(m_blockSize != Dynamic)
        std::copy(other.m_blockPtr, other.m_blockPtr+m_nonzerosblocks, m_blockPtr);
 
      std::copy(other.m_indices, other.m_indices+m_nonzerosblocks, m_indices);
      std::copy(other.m_outerIndex, other.m_outerIndex+m_outerBSize, m_outerIndex);
    }

◆ ~BlockSparseMatrix()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::~BlockSparseMatrix ( )

inline

    {
      delete[] m_outerIndex;
      delete[] m_innerOffset;
      delete[] m_outerOffset;
      delete[] m_indices;
      delete[] m_blockPtr;
      delete[] m_values;
    }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockPtr, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_indices, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_innerOffset, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerIndex, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerOffset, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_values.

◆ BlockSparseMatrix() [4/4]

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

template<typename MatrixType >

Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockSparseMatrix ( const MatrixType & spmat )

inline

Constructor from a sparse matrix.

                                                      : m_blockSize(BlockSize)
    {
      EIGEN_STATIC_ASSERT((m_blockSize != Dynamic), THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE);
 
      *this = spmat;
    }

References Eigen::Dynamic, EIGEN_STATIC_ASSERT, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockSize.

Member Function Documentation

◆ addTo()

template<typename Derived >

template<typename Dest >

EIGEN_DEVICE_FUNC void Eigen::EigenBase< Derived >::addTo ( Dest & dst ) const

inlineinherited

  {
    // This is the default implementation,
    // derived class can reimplement it in a more optimized way.
    typename Dest::PlainObject res(rows(),cols());
    evalTo(res);
    dst += res;
  }

◆ adjoint()

const AdjointReturnType Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::adjoint ( ) const

inlineinherited

351{ return AdjointReturnType(transpose()); }

Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::AdjointReturnType

internal::conditional< NumTraits< Scalar >::IsComplex, CwiseUnaryOp< internal::scalar_conjugate_op< Scalar >, Eigen::Transpose< constDerived > >, Transpose< constDerived > >::type AdjointReturnType

Definition SparseMatrixBase.h:109

Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::transpose

TransposeReturnType transpose()

Definition SparseMatrixBase.h:349

◆ applyThisOnTheLeft()

template<typename Derived >

template<typename Dest >

EIGEN_DEVICE_FUNC void Eigen::EigenBase< Derived >::applyThisOnTheLeft ( Dest & dst ) const

inlineinherited

  {
    // This is the default implementation,
    // derived class can reimplement it in a more optimized way.
    dst = this->derived() * dst;
  }

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

Here is the call graph for this function:

◆ applyThisOnTheRight()

template<typename Derived >

template<typename Dest >

EIGEN_DEVICE_FUNC void Eigen::EigenBase< Derived >::applyThisOnTheRight ( Dest & dst ) const

inlineinherited

  {
    // This is the default implementation,
    // derived class can reimplement it in a more optimized way.
    dst = dst * this->derived();
  }

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

Here is the call graph for this function:

◆ assign()

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::assign ( const OtherDerived & other )

inlineprotectedinherited

◆ assignGeneric()

void Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::assignGeneric ( const OtherDerived & other )

inlineprotectedinherited

◆ blockCols()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockCols ( ) const

inline

Returns: the number of columns grouped by blocks

    {
      return (IsColMajor ? m_outerBSize : m_innerBSize);
    }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::IsColMajor, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_innerBSize, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerBSize.

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::coeff(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::coeffRef(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::operator=().

Here is the caller graph for this function:

◆ blockColsIndex()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockColsIndex ( Index bj ) const

inline

Returns: the starting index of the bj col block

    {
      return IsColMajor ? blockOuterIndex(bj) : blockInnerIndex(bj);
    }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockInnerIndex(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockOuterIndex(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::IsColMajor.

Here is the call graph for this function:

◆ blockInnerIndex()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockInnerIndex ( Index bi ) const

inline

    {
      return (m_blockSize == Dynamic) ? m_innerOffset[bi] : (bi * m_blockSize);
    }

References Eigen::Dynamic, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockSize, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_innerOffset.

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockColsIndex(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockRowsIndex().

Here is the caller graph for this function:

◆ blockInnerSize()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockInnerSize ( Index bi ) const

inline

    {
      return (m_blockSize == Dynamic) ? (m_innerOffset[bi+1] - m_innerOffset[bi]) : m_blockSize;
    }

References Eigen::Dynamic, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockSize, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_innerOffset.

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::coeff(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::coeffRef(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::operator=(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setBlockStructure().

Here is the caller graph for this function:

◆ blockOuterIndex()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockOuterIndex ( Index bj ) const

inline

    {
      return (m_blockSize == Dynamic) ? m_outerOffset[bj] : (bj * m_blockSize);
    }

References Eigen::Dynamic, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockSize, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerOffset.

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockColsIndex(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockRowsIndex(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::operator=().

Here is the caller graph for this function:

◆ blockOuterSize()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockOuterSize ( Index bj ) const

inline

    {
      return (m_blockSize == Dynamic) ? (m_outerOffset[bj+1]- m_outerOffset[bj]) : m_blockSize;
    }

References Eigen::Dynamic, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockSize, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerOffset.

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::coeff(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::coeffRef(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::operator=(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setBlockStructure().

Here is the caller graph for this function:

◆ blockPtr()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockPtr ( Index id ) const

inline

Returns: the starting position of the block id in the array of values

    {
      if(m_blockSize == Dynamic) return m_blockPtr[id];
      else return id * m_blockSize * m_blockSize;
      //return blockDynIdx(id, typename internal::conditional<(BlockSize==Dynamic), internal::true_type, internal::false_type>::type());
    }

References Eigen::Dynamic, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockPtr, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockSize.

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::coeff(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::coeffRef(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setFromTriplets().

Here is the caller graph for this function:

◆ blockRows()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockRows ( ) const

inline

Returns: the number of rows grouped by blocks

    {
      return (IsColMajor ? m_innerBSize : m_outerBSize);
    }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::IsColMajor, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_innerBSize, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerBSize.

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::coeff(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::coeffRef(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::operator=().

Here is the caller graph for this function:

◆ blockRowsIndex()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockRowsIndex ( Index bi ) const

inline

Returns: the starting index of the bi row block

    {
      return IsColMajor ? blockInnerIndex(bi) : blockOuterIndex(bi);
    }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockInnerIndex(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockOuterIndex(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::IsColMajor.

Here is the call graph for this function:

◆ blueNorm()

NumTraits< typenameinternal::traits< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::Scalar >::Real Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::blueNorm

inlineinherited

{
  return internal::blueNorm_impl(*this);
}

◆ coeff()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Map< const BlockScalar > Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::coeff	(	Index	brow,
		Index	bcol
	)		const

inline

Returns: the value of the (i,j) block as an Eigen Dense Matrix

    {
      eigen_assert(brow < blockRows() && "BLOCK ROW INDEX OUT OF BOUNDS");
      eigen_assert(bcol < blockCols() && "BLOCK COLUMN OUT OF BOUNDS");
 
      StorageIndex rsize = IsColMajor ? blockInnerSize(brow): blockOuterSize(bcol);
      StorageIndex csize = IsColMajor ? blockOuterSize(bcol) : blockInnerSize(brow);
      StorageIndex inner = IsColMajor ? brow : bcol;
      StorageIndex outer = IsColMajor ? bcol : brow;
      StorageIndex offset = m_outerIndex[outer];
      while(offset < m_outerIndex[outer+1] && m_indices[offset] != inner) offset++;
      if(m_indices[offset] == inner)
      {
        return Map<const BlockScalar> (&(m_values[blockPtr(offset)]), rsize, csize);
      }
      else
//        return BlockScalar::Zero(rsize, csize);
        eigen_assert("NOT YET SUPPORTED");
    }

Here is the call graph for this function:

◆ coeffRef()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Ref< BlockScalar > Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::coeffRef	(	Index	brow,
		Index	bcol
	)

inline

Returns: a reference to the (i,j) block as an Eigen Dense Matrix

    {
      eigen_assert(brow < blockRows() && "BLOCK ROW INDEX OUT OF BOUNDS");
      eigen_assert(bcol < blockCols() && "BLOCK nzblocksFlagCOLUMN OUT OF BOUNDS");
 
      StorageIndex rsize = IsColMajor ? blockInnerSize(brow): blockOuterSize(bcol);
      StorageIndex csize = IsColMajor ? blockOuterSize(bcol) : blockInnerSize(brow);
      StorageIndex inner = IsColMajor ? brow : bcol;
      StorageIndex outer = IsColMajor ? bcol : brow;
      StorageIndex offset = m_outerIndex[outer];
      while(offset < m_outerIndex[outer+1] && m_indices[offset] != inner)
        offset++;
      if(m_indices[offset] == inner)
      {
        return Map<BlockScalar>(&(m_values[blockPtr(offset)]), rsize, csize);
      }
      else
      {
        //FIXME the block does not exist, Insert it !!!!!!!!!
        eigen_assert("DYNAMIC INSERTION IS NOT YET SUPPORTED");
      }
    }

Here is the call graph for this function:

◆ cols()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::cols ( ) const

inline

Returns: the number of cols

    {
//      return blockCols();
      return (IsColMajor ? outerSize() : innerSize());
    }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::innerSize(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::IsColMajor, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::outerSize().

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockInnerIterator::value(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockInnerIterator::valueRef().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ const_cast_derived()

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::const_cast_derived ( ) const

inlineinherited

141 { return *static_cast<Derived*>(const_cast<SparseMatrixBase*>(this)); }

Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::SparseMatrixBase

SparseMatrixBase()

Definition SparseMatrixBase.h:192

◆ const_derived()

template<typename Derived >

EIGEN_DEVICE_FUNC const Derived & Eigen::EigenBase< Derived >::const_derived ( ) const

inlineinherited

55 { return *static_cast<const Derived*>(this); }

◆ convert_index()

static StorageIndex Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::convert_index ( const Index idx )

inlinestaticprotectedinherited

                                                              {
      return internal::convert_index<StorageIndex>(idx);
    }

◆ cwiseProduct() [1/2]

EIGEN_STRONG_INLINE const SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::template CwiseProductDenseReturnType< OtherDerived >::Type Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::cwiseProduct ( const MatrixBase< OtherDerived > & other ) const

inherited

{
  return typename CwiseProductDenseReturnType<OtherDerived>::Type(derived(), other.derived());
}

◆ cwiseProduct() [2/2]

EIGEN_STRONG_INLINE const CwiseProductDenseReturnType< OtherDerived >::Type Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::cwiseProduct ( const MatrixBase< OtherDerived > & other ) const

inherited

◆ derived() [1/2]

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::derived ( )

inlineinherited

139{ return *static_cast<Derived*>(this); }

◆ derived() [2/2]

const BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::derived ( ) const

inlineinherited

138{ return *static_cast<const Derived*>(this); }

◆ dot() [1/4]

internal::traits< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::Scalar Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::dot ( const MatrixBase< OtherDerived > & other ) const

inherited

{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
  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)
 
  eigen_assert(size() == other.size());
  eigen_assert(other.size()>0 && "you are using a non initialized vector");
 
  internal::evaluator<Derived> thisEval(derived());
  typename internal::evaluator<Derived>::InnerIterator i(thisEval, 0);
  Scalar res(0);
  while (i)
  {
    res += numext::conj(i.value()) * other.coeff(i.index());
    ++i;
  }
  return res;
}

◆ dot() [2/4]

Scalar Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::dot ( const MatrixBase< OtherDerived > & other ) const

inherited

◆ dot() [3/4]

internal::traits< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::Scalar Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::dot ( const SparseMatrixBase< OtherDerived > & other ) const

inherited

{
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
  EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived,OtherDerived)
  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)
 
  eigen_assert(size() == other.size());
 
  internal::evaluator<Derived> thisEval(derived());
  typename internal::evaluator<Derived>::InnerIterator i(thisEval, 0);
  
  internal::evaluator<OtherDerived>  otherEval(other.derived());
  typename internal::evaluator<OtherDerived>::InnerIterator j(otherEval, 0);
 
  Scalar res(0);
  while (i && j)
  {
    if (i.index()==j.index())
    {
      res += numext::conj(i.value()) * j.value();
      ++i; ++j;
    }
    else if (i.index()<j.index())
      ++i;
    else
      ++j;
  }
  return res;
}

◆ dot() [4/4]

Scalar Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::dot ( const SparseMatrixBase< OtherDerived > & other ) const

inherited

◆ eval()

const internal::eval< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::type Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::eval ( ) const

inlineinherited

Returns: the matrix or vector obtained by evaluating this expression.

Notice that in the case of a plain matrix or vector (not an expression) this function just returns a const reference, in order to avoid a useless copy.

385 { return typename internal::eval<Derived>::type(derived()); }

◆ evalTo()

void Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::evalTo ( Dest & ) const

privateinherited

◆ innerBlocks()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::innerBlocks ( ) const

inline

776{ return m_innerBSize; }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_innerBSize.

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setBlockLayout().

Here is the caller graph for this function:

◆ innerIndexPtr() [1/2]

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

StorageIndex * Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::innerIndexPtr ( )

inline

866{return m_indices; }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_indices.

◆ innerIndexPtr() [2/2]

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

const StorageIndex * Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::innerIndexPtr ( ) const

inline

867{return m_indices; }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_indices.

◆ innerSize()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::innerSize ( ) const

inline

    {
      if(m_blockSize == Dynamic) return m_innerOffset[m_innerBSize];
      else return  (m_innerBSize * m_blockSize) ;
    }

References Eigen::Dynamic, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockSize, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_innerBSize, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_innerOffset.

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::cols(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::innerToBlock(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::rows().

Here is the caller graph for this function:

◆ innerToBlock()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::innerToBlock ( Index inner ) const

inline

Returns: the block index where inner belongs to

    {
      eigen_assert(inner < innerSize() && "OUTER INDEX OUT OF BOUNDS");
 
      if(m_blockSize != Dynamic)
        return (inner / m_blockSize); // Integer division
 
      StorageIndex b_inner = 0;
      while(m_innerOffset[b_inner] <= inner) ++b_inner;
      return b_inner - 1;
    }

References Eigen::Dynamic, eigen_assert, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::innerSize(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockSize, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_innerOffset.

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ innerVector() [1/2]

SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::InnerVectorReturnType Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::innerVector ( Index outer )

inherited

Returns: the outer -th column (resp. row) of the matrix *this if *this is col-major (resp. row-major).

334{ return InnerVectorReturnType(derived(), outer); }

Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::InnerVectorReturnType

Block< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >, IsRowMajor?1:Dynamic, IsRowMajor?Dynamic:1, true > InnerVectorReturnType

Definition SparseMatrixBase.h:354

◆ innerVector() [2/2]

const SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::ConstInnerVectorReturnType Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::innerVector ( Index outer ) const

inherited

Returns: the outer -th column (resp. row) of the matrix *this if *this is col-major (resp. row-major). Read-only.

341{ return ConstInnerVectorReturnType(derived(), outer); }

Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::ConstInnerVectorReturnType

Block< const BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >, IsRowMajor?1:Dynamic, IsRowMajor?Dynamic:1, true > ConstInnerVectorReturnType

Definition SparseMatrixBase.h:355

◆ innerVectors() [1/2]

SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::InnerVectorsReturnType Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::innerVectors	(	Index	outerStart,
		Index	outerSize
	)

inherited

Returns: the outer -th column (resp. row) of the matrix *this if *this is col-major (resp. row-major).

{
  return Block<Derived,Dynamic,Dynamic,true>(derived(),
                                             IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,
                                             IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);
 
}

◆ innerVectors() [2/2]

const SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::ConstInnerVectorsReturnType Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::innerVectors	(	Index	outerStart,
		Index	outerSize
	)		const

inherited

Returns: the outer -th column (resp. row) of the matrix *this if *this is col-major (resp. row-major). Read-only.

{
  return Block<const Derived,Dynamic,Dynamic,true>(derived(),
                                                  IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,
                                                  IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);
 
}

◆ insert()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Map< BlockScalar > Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::insert	(	Index	brow,
		Index	bcol
	)

protected

◆ isApprox() [1/2]

bool Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::isApprox	(	const MatrixBase< OtherDerived > &	other,
		const RealScalar &	prec = `NumTraits<Scalar>::dummy_precision()`
	)		const

inlineinherited

377 { return toDense().isApprox(other,prec); }

Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::toDense

DenseMatrixType toDense() const

Definition SparseMatrixBase.h:365

◆ isApprox() [2/2]

bool Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::isApprox	(	const SparseMatrixBase< OtherDerived > &	other,
		const RealScalar &	prec = `NumTraits<Scalar>::dummy_precision()`
	)		const

inherited

{
  const typename internal::nested_eval<Derived,2,PlainObject>::type actualA(derived());
  typename internal::conditional<bool(IsRowMajor)==bool(OtherDerived::IsRowMajor),
    const typename internal::nested_eval<OtherDerived,2,PlainObject>::type,
    const PlainObject>::type actualB(other.derived());
 
  return (actualA - actualB).squaredNorm() <= prec * prec * numext::mini(actualA.squaredNorm(), actualB.squaredNorm());
}

◆ isCompressed()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

bool Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::isCompressed ( ) const

inline

for compatibility purposes with the SparseMatrix class

872{return true;}

◆ isRValue()

bool Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::isRValue ( ) const

inlineinherited

189{ return m_isRValue; }

Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::m_isRValue

bool m_isRValue

Definition SparseMatrixBase.h:394

◆ isVector()

bool Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::isVector ( ) const

inlineinherited

Returns: true if either the number of rows or the number of columns is equal to 1. In other words, this function returns
rows()==1 || cols()==1

Eigen::BlockSparseMatrix::rows
Index rows() const
Definition BlockSparseMatrix.h:738

Eigen::BlockSparseMatrix::cols
Index cols() const
Definition BlockSparseMatrix.h:747

See also: rows(), cols(), IsVectorAtCompileTime.

181{ return rows()==1 || cols()==1; }

◆ markAsRValue()

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::markAsRValue ( )

inlineinherited

190{ m_isRValue = true; return derived(); }

◆ nonZeros()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::nonZeros ( ) const

inline

Returns: the total number of nonzero elements, including eventual explicit zeros in blocks

862{ return m_nonzeros; }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_nonzeros.

◆ nonZerosBlocks()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::nonZerosBlocks ( ) const

inline

Returns: the number of nonzero blocks

860{ return m_nonzerosblocks; }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_nonzerosblocks.

◆ norm()

NumTraits< typenameinternal::traits< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::Scalar >::Real Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::norm

inlineinherited

{
  using std::sqrt;
  return sqrt(squaredNorm());
}

◆ operator*() [1/4]

const Product< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > , OtherDerived > Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::operator* ( const DiagonalBase< OtherDerived > & other ) const

inlineinherited

298 { return Product<Derived,OtherDerived>(derived(), other.derived()); }

◆ operator*() [2/4]

const Product< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > , OtherDerived > Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::operator* ( const MatrixBase< OtherDerived > & other ) const

inlineinherited

315 { return Product<Derived,OtherDerived>(derived(), other.derived()); }

◆ operator*() [3/4]

const Product< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > , OtherDerived, AliasFreeProduct > Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::operator* ( const SparseMatrixBase< OtherDerived > & other ) const

inlineinherited

Returns: an expression of the product of two sparse matrices. By default a conservative product preserving the symbolic non zeros is performed. The automatic pruning of the small values can be achieved by calling the pruned() function in which case a totally different product algorithm is employed:
C = (A*B).pruned(); // supress numerical zeros (exact)

C = (A*B).pruned(ref);

C = (A*B).pruned(ref,epsilon);

Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::pruned
const SparseView< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > > pruned(const Scalar &reference=Scalar(0), const RealScalar &epsilon=NumTraits< Scalar >::dummy_precision()) const
Definition SparseView.h:245

where ref is a meaningful non zero reference value.

{
  return Product<Derived,OtherDerived,AliasFreeProduct>(derived(), other.derived());
}

◆ operator*() [4/4]

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

template<typename VecType >

BlockSparseTimeDenseProduct< BlockSparseMatrix, VecType > Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::operator* ( const VecType & lhs ) const

inline

    {
      return BlockSparseTimeDenseProduct<BlockSparseMatrix, VecType>(*this, lhs);
    }

◆ operator*=() [1/2]

EIGEN_STRONG_INLINE BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::operator*= ( const Scalar & other )

inherited

{
  typedef typename internal::evaluator<Derived>::InnerIterator EvalIterator;
  internal::evaluator<Derived> thisEval(derived());
  for (Index j=0; j<outerSize(); ++j)
    for (EvalIterator i(thisEval,j); i; ++i)
      i.valueRef() *= other;
  return derived();
}

◆ operator*=() [2/2]

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::operator*= ( const SparseMatrixBase< OtherDerived > & other )

inherited

◆ operator+=() [1/4]

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::operator+= ( const DiagonalBase< OtherDerived > & other )

inherited

{
  call_assignment_no_alias(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
  return derived();
}

◆ operator+=() [2/4]

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::operator+= ( const EigenBase< OtherDerived > & other )

inherited

{
  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
  return derived();
}

◆ operator+=() [3/4]

EIGEN_STRONG_INLINE BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::operator+= ( const SparseMatrixBase< OtherDerived > & other )

inherited

{
  return derived() = derived() + other.derived();
}

◆ operator+=() [4/4]

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::operator+= ( const SparseMatrixBase< OtherDerived > & other )

inherited

◆ operator-=() [1/4]

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::operator-= ( const DiagonalBase< OtherDerived > & other )

inherited

{
  call_assignment_no_alias(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
  return derived();
}

◆ operator-=() [2/4]

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::operator-= ( const EigenBase< OtherDerived > & other )

inherited

{
  call_assignment(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
  return derived();
}

◆ operator-=() [3/4]

EIGEN_STRONG_INLINE BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::operator-= ( const SparseMatrixBase< OtherDerived > & other )

inherited

{
  return derived() = derived() - other.derived();
}

◆ operator-=() [4/4]

BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::operator-= ( const SparseMatrixBase< OtherDerived > & other )

inherited

◆ operator/=()

EIGEN_STRONG_INLINE BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > & Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::operator/= ( const Scalar & other )

inherited

{
  typedef typename internal::evaluator<Derived>::InnerIterator EvalIterator;
  internal::evaluator<Derived> thisEval(derived());
  for (Index j=0; j<outerSize(); ++j)
    for (EvalIterator i(thisEval,j); i; ++i)
      i.valueRef() /= other;
  return derived();
}

◆ operator=() [1/2]

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

BlockSparseMatrix & Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::operator= ( BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > other )

inline

    {
      //Copy-and-swap paradigm ... avoid leaked data if thrown
      swap(*this, other);
      return *this;
    }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::swap.

◆ operator=() [2/2]

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

template<typename MatrixType >

BlockSparseMatrix & Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::operator= ( const MatrixType & spmat )

inline

Assignment from a sparse matrix with the same storage order.

Convert from a sparse matrix to block sparse matrix.

Warning: Before calling this function, tt is necessary to call either setBlockLayout() (matrices with variable-size blocks) or setBlockSize() (for fixed-size blocks).

    {
      eigen_assert((m_innerBSize != 0 && m_outerBSize != 0)
                   && "Trying to assign to a zero-size matrix, call resize() first");
      eigen_assert(((MatrixType::Options&RowMajorBit) != IsColMajor) && "Wrong storage order");
      typedef SparseMatrix<bool,MatrixType::Options,typename MatrixType::Index> MatrixPatternType;
      MatrixPatternType  blockPattern(blockRows(), blockCols());
      m_nonzeros = 0;
 
      // First, compute the number of nonzero blocks and their locations
      for(StorageIndex bj = 0; bj < m_outerBSize; ++bj)
      {
        // Browse each outer block and compute the structure
        std::vector<bool> nzblocksFlag(m_innerBSize,false);  // Record the existing blocks
        blockPattern.startVec(bj);
        for(StorageIndex j = blockOuterIndex(bj); j < blockOuterIndex(bj+1); ++j)
        {
          typename MatrixType::InnerIterator it_spmat(spmat, j);
          for(; it_spmat; ++it_spmat)
          {
            StorageIndex bi = innerToBlock(it_spmat.index()); // Index of the current nonzero block
            if(!nzblocksFlag[bi])
            {
              // Save the index of this nonzero block
              nzblocksFlag[bi] = true;
              blockPattern.insertBackByOuterInnerUnordered(bj, bi) = true;
              // Compute the total number of nonzeros (including explicit zeros in blocks)
              m_nonzeros += blockOuterSize(bj) * blockInnerSize(bi);
            }
          }
        } // end current outer block
      }
      blockPattern.finalize();
 
      // Allocate the internal arrays
      setBlockStructure(blockPattern);
 
      for(StorageIndex nz = 0; nz < m_nonzeros; ++nz) m_values[nz] = Scalar(0);
      for(StorageIndex bj = 0; bj < m_outerBSize; ++bj)
      {
        // Now copy the values
        for(StorageIndex j = blockOuterIndex(bj); j < blockOuterIndex(bj+1); ++j)
        {
          // Browse the outer block column by column (for column-major matrices)
          typename MatrixType::InnerIterator it_spmat(spmat, j);
          for(; it_spmat; ++it_spmat)
          {
            StorageIndex idx = 0; // Position of this block in the column block
            StorageIndex bi = innerToBlock(it_spmat.index()); // Index of the current nonzero block
            // Go to the inner block where this element belongs to
            while(bi > m_indices[m_outerIndex[bj]+idx]) ++idx; // Not expensive for ordered blocks
            StorageIndex idxVal;// Get the right position in the array of values for this element
            if(m_blockSize == Dynamic)
            {
              // Offset from all blocks before ...
              idxVal =  m_blockPtr[m_outerIndex[bj]+idx];
              // ... and offset inside the block
              idxVal += (j - blockOuterIndex(bj)) * blockOuterSize(bj) + it_spmat.index() - m_innerOffset[bi];
            }
            else
            {
              // All blocks before
              idxVal = (m_outerIndex[bj] + idx) * m_blockSize * m_blockSize;
              // inside the block
              idxVal += (j - blockOuterIndex(bj)) * m_blockSize + (it_spmat.index()%m_blockSize);
            }
            // Insert the value
            m_values[idxVal] = it_spmat.value();
          } // end of this column
        } // end of this block
      } // end of this outer block
 
      return *this;
    }

Here is the call graph for this function:

◆ outerBlocks()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::outerBlocks ( ) const

inline

775{ return m_outerBSize; }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerBSize.

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setBlockLayout().

Here is the caller graph for this function:

◆ outerIndexPtr() [1/2]

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

StorageIndex * Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::outerIndexPtr ( )

inline

868{return m_outerIndex; }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerIndex.

◆ outerIndexPtr() [2/2]

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

const StorageIndex * Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::outerIndexPtr ( ) const

inline

869{return m_outerIndex; }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerIndex.

◆ outerSize()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::outerSize ( ) const

inline

    {
      if(m_blockSize == Dynamic) return m_outerOffset[m_outerBSize];
      else return  (m_outerBSize * m_blockSize) ;
    }

References Eigen::Dynamic, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockSize, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerBSize, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerOffset.

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::cols(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::outerToBlock(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::rows().

Here is the caller graph for this function:

◆ outerToBlock()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::outerToBlock ( Index outer ) const

inline

Returns: the block index where outer belongs to

    {
      eigen_assert(outer < outerSize() && "OUTER INDEX OUT OF BOUNDS");
 
      if(m_blockSize != Dynamic)
        return (outer / m_blockSize); // Integer division
 
      StorageIndex b_outer = 0;
      while(m_outerOffset[b_outer] <= outer) ++b_outer;
      return b_outer - 1;
    }

References Eigen::Dynamic, eigen_assert, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockSize, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerOffset, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::outerSize().

Here is the call graph for this function:

◆ pruned()

const SparseView< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > > Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::pruned	(	const Scalar &	reference = `Scalar(0)`,
		const RealScalar &	epsilon = `NumTraits<Scalar>::dummy_precision()`
	)		const

inlineinherited

Returns: an expression of *this with values smaller than reference * epsilon removed.

This method is typically used in conjunction with the product of two sparse matrices to automatically prune the smallest values as follows:

C = (A*B).pruned();             // suppress numerical zeros (exact)
C = (A*B).pruned(ref);
C = (A*B).pruned(ref,epsilon);

where ref is a meaningful non zero reference value.

{
  return SparseView<Derived>(derived(), reference, epsilon);
}

◆ reserve()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

void Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::reserve ( const Index nonzerosblocks )

inline

Allocate the internal array of pointers to blocks and their inner indices.

Note: For fixed-size blocks, call setBlockSize() to set the block. And For variable-size blocks, call setBlockLayout() before using this function

Parameters

nonzerosblocks Number of nonzero blocks. The total number of nonzeros is is computed in setBlockLayout() for variable-size blocks

See also: setBlockSize()

    {
      eigen_assert((m_innerBSize != 0 && m_outerBSize != 0) &&
          "TRYING TO RESERVE ZERO-SIZE MATRICES, CALL resize() first");
 
      //FIXME Should free if already allocated
      m_outerIndex = new StorageIndex[m_outerBSize+1];
 
      m_nonzerosblocks = nonzerosblocks;
      if(m_blockSize != Dynamic)
      {
        m_nonzeros = nonzerosblocks * (m_blockSize * m_blockSize);
        m_blockPtr = 0;
      }
      else
      {
        // m_nonzeros  is already computed in setBlockLayout()
        m_blockPtr = new StorageIndex[m_nonzerosblocks+1];
      }
      m_indices = new StorageIndex[m_nonzerosblocks+1];
      m_values = new Scalar[m_nonzeros];
    }

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setBlockStructure(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setFromTriplets().

Here is the caller graph for this function:

◆ resize()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

void Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::resize	(	Index	brow,
		Index	bcol
	)

inline

Set the number of rows and columns blocks.

    {
      m_innerBSize = IsColMajor ? brow : bcol;
      m_outerBSize = IsColMajor ? bcol : brow;
    }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::IsColMajor, Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_innerBSize, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerBSize.

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setBlockStructure().

Here is the caller graph for this function:

◆ rows()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::rows ( ) const

inline

Returns: the number of rows

    {
//      return blockRows();
      return (IsColMajor ? innerSize() : outerSize());
    }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::innerSize(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::IsColMajor, and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::outerSize().

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockInnerIterator::value(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockInnerIterator::valueRef().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ selfadjointView() [1/4]

SelfAdjointViewReturnType< UpLo >::Type Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::selfadjointView ( )

inlineinherited

◆ selfadjointView() [2/4]

SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::template SelfAdjointViewReturnType< UpLo >::Type Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::selfadjointView ( )

inherited

{
  return SparseSelfAdjointView<Derived, UpLo>(derived());
}

◆ selfadjointView() [3/4]

ConstSelfAdjointViewReturnType< UpLo >::Type Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::selfadjointView ( ) const

inlineinherited

◆ selfadjointView() [4/4]

SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::template ConstSelfAdjointViewReturnType< UpLo >::Type Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::selfadjointView ( ) const

inherited

{
  return SparseSelfAdjointView<const Derived, UpLo>(derived());
}

◆ setBlockLayout()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

void Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setBlockLayout	(	const VectorXi &	rowBlocks,
		const VectorXi &	colBlocks
	)

inline

Set the row and column block layouts,.

This function set the size of each row and column block. So this function should be used only for blocks with variable size.

Parameters

rowBlocks	: Number of rows per row block
colBlocks	: Number of columns per column block

See also: resize(), setBlockSize()

    {
      const VectorXi& innerBlocks = IsColMajor ? rowBlocks : colBlocks;
      const VectorXi& outerBlocks = IsColMajor ? colBlocks : rowBlocks;
      eigen_assert(m_innerBSize == innerBlocks.size() && "CHECK THE NUMBER OF ROW OR COLUMN BLOCKS");
      eigen_assert(m_outerBSize == outerBlocks.size() && "CHECK THE NUMBER OF ROW OR COLUMN BLOCKS");
      m_outerBSize = outerBlocks.size();
      //  starting index of blocks... cumulative sums
      m_innerOffset = new StorageIndex[m_innerBSize+1];
      m_outerOffset = new StorageIndex[m_outerBSize+1];
      m_innerOffset[0] = 0;
      m_outerOffset[0] = 0;
      std::partial_sum(&innerBlocks[0], &innerBlocks[m_innerBSize-1]+1, &m_innerOffset[1]);
      std::partial_sum(&outerBlocks[0], &outerBlocks[m_outerBSize-1]+1, &m_outerOffset[1]);
 
      // Compute the total number of nonzeros
      m_nonzeros = 0;
      for(StorageIndex bj = 0; bj < m_outerBSize; ++bj)
        for(StorageIndex bi = 0; bi < m_innerBSize; ++bi)
          m_nonzeros += outerBlocks[bj] * innerBlocks[bi];
 
    }

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setFromTriplets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setBlockSize()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

void Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setBlockSize ( Index blockSize )

inline

set the block size at runtime for fixed-size block layout

Call this only for fixed-size blocks

    {
      m_blockSize = blockSize;
    }

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockSize.

◆ setBlockStructure()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

template<typename MatrixType >

void Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setBlockStructure ( const MatrixType & blockPattern )

inline

Set the nonzero block pattern of the matrix.

Given a sparse matrix describing the nonzero block pattern, this function prepares the internal pointers for values. After calling this function, any nonzero block (bi, bj) can be set with a simple call to coeffRef(bi,bj).

Warning: Before calling this function, tt is necessary to call either setBlockLayout() (matrices with variable-size blocks) or setBlockSize() (for fixed-size blocks).

Parameters

blockPattern Sparse matrix of boolean elements describing the block structure

See also: setBlockLayout(); setBlockSize()

    {
      resize(blockPattern.rows(), blockPattern.cols());
      reserve(blockPattern.nonZeros());
 
      // Browse the block pattern and set up the various pointers
      m_outerIndex[0] = 0;
      if(m_blockSize == Dynamic) m_blockPtr[0] = 0;
      for(StorageIndex nz = 0; nz < m_nonzeros; ++nz) m_values[nz] = Scalar(0);
      for(StorageIndex bj = 0; bj < m_outerBSize; ++bj)
      {
        //Browse each outer block
 
        //First, copy and save the indices of nonzero blocks
        //FIXME : find a way to avoid this ...
        std::vector<int> nzBlockIdx;
        typename MatrixType::InnerIterator it(blockPattern, bj);
        for(; it; ++it)
        {
          nzBlockIdx.push_back(it.index());
        }
        std::sort(nzBlockIdx.begin(), nzBlockIdx.end());
 
        // Now, fill block indices and (eventually) pointers to blocks
        for(StorageIndex idx = 0; idx < nzBlockIdx.size(); ++idx)
        {
          StorageIndex offset = m_outerIndex[bj]+idx; // offset in m_indices
          m_indices[offset] = nzBlockIdx[idx];
          if(m_blockSize == Dynamic)
            m_blockPtr[offset] = m_blockPtr[offset-1] + blockInnerSize(nzBlockIdx[idx]) * blockOuterSize(bj);
          // There is no blockPtr for fixed-size blocks... not needed !???
        }
        // Save the pointer to the next outer block
        m_outerIndex[bj+1] = m_outerIndex[bj] + nzBlockIdx.size();
      }
    }

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setFromTriplets()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

template<typename InputIterator >

void Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setFromTriplets	(	const InputIterator &	begin,
		const InputIterator &	end
	)

inline

Fill values in a matrix from a triplet list.

Each triplet item has a block stored in an Eigen dense matrix. The InputIterator class should provide the functions row(), col() and value()

Note: For fixed-size blocks, call setBlockSize() before this function.

FIXME Do not accept duplicates

    {
      eigen_assert((m_innerBSize!=0 && m_outerBSize !=0) && "ZERO BLOCKS, PLEASE CALL resize() before");
 
      /* First, sort the triplet list
        * FIXME This can be unnecessarily expensive since only the inner indices have to be sorted
        * The best approach is like in SparseMatrix::setFromTriplets()
        */
      internal::TripletComp<InputIterator, IsColMajor> tripletcomp;
      std::sort(begin, end, tripletcomp);
 
      /* Count the number of rows and column blocks,
       * and the number of nonzero blocks per outer dimension
       */
      VectorXi rowBlocks(m_innerBSize); // Size of each block row
      VectorXi colBlocks(m_outerBSize); // Size of each block column
      rowBlocks.setZero(); colBlocks.setZero();
      VectorXi nzblock_outer(m_outerBSize); // Number of nz blocks per outer vector
      VectorXi nz_outer(m_outerBSize); // Number of nz per outer vector...for variable-size blocks
      nzblock_outer.setZero();
      nz_outer.setZero();
      for(InputIterator it(begin); it !=end; ++it)
      {
        eigen_assert(it->row() >= 0 && it->row() < this->blockRows() && it->col() >= 0 && it->col() < this->blockCols());
        eigen_assert((it->value().rows() == it->value().cols() && (it->value().rows() == m_blockSize))
                     || (m_blockSize == Dynamic));
 
        if(m_blockSize == Dynamic)
        {
          eigen_assert((rowBlocks[it->row()] == 0 || rowBlocks[it->row()] == it->value().rows()) &&
              "NON CORRESPONDING SIZES FOR ROW BLOCKS");
          eigen_assert((colBlocks[it->col()] == 0 || colBlocks[it->col()] == it->value().cols()) &&
              "NON CORRESPONDING SIZES FOR COLUMN BLOCKS");
          rowBlocks[it->row()] =it->value().rows();
          colBlocks[it->col()] = it->value().cols();
        }
        nz_outer(IsColMajor ? it->col() : it->row()) += it->value().rows() * it->value().cols();
        nzblock_outer(IsColMajor ? it->col() : it->row())++;
      }
      // Allocate member arrays
      if(m_blockSize == Dynamic) setBlockLayout(rowBlocks, colBlocks);
      StorageIndex nzblocks = nzblock_outer.sum();
      reserve(nzblocks);
 
       // Temporary markers
      VectorXi block_id(m_outerBSize); // To be used as a block marker during insertion
 
      // Setup outer index pointers and markers
      m_outerIndex[0] = 0;
      if (m_blockSize == Dynamic)  m_blockPtr[0] =  0;
      for(StorageIndex bj = 0; bj < m_outerBSize; ++bj)
      {
        m_outerIndex[bj+1] = m_outerIndex[bj] + nzblock_outer(bj);
        block_id(bj) = m_outerIndex[bj];
        if(m_blockSize==Dynamic)
        {
          m_blockPtr[m_outerIndex[bj+1]] = m_blockPtr[m_outerIndex[bj]] + nz_outer(bj);
        }
      }
 
      // Fill the matrix
      for(InputIterator it(begin); it!=end; ++it)
      {
        StorageIndex outer = IsColMajor ? it->col() : it->row();
        StorageIndex inner = IsColMajor ? it->row() : it->col();
        m_indices[block_id(outer)] = inner;
        StorageIndex block_size = it->value().rows()*it->value().cols();
        StorageIndex nz_marker = blockPtr(block_id[outer]);
        memcpy(&(m_values[nz_marker]), it->value().data(), block_size * sizeof(Scalar));
        if(m_blockSize == Dynamic)
        {
          m_blockPtr[block_id(outer)+1] = m_blockPtr[block_id(outer)] + block_size;
        }
        block_id(outer)++;
      }
 
      // An alternative when the outer indices are sorted...no need to use an array of markers
//      for(Index bcol = 0; bcol < m_outerBSize; ++bcol)
//      {
//      Index id = 0, id_nz = 0, id_nzblock = 0;
//      for(InputIterator it(begin); it!=end; ++it)
//      {
//        while (id<bcol) // one pass should do the job unless there are empty columns
//        {
//          id++;
//          m_outerIndex[id+1]=m_outerIndex[id];
//        }
//        m_outerIndex[id+1] += 1;
//        m_indices[id_nzblock]=brow;
//        Index block_size = it->value().rows()*it->value().cols();
//        m_blockPtr[id_nzblock+1] = m_blockPtr[id_nzblock] + block_size;
//        id_nzblock++;
//        memcpy(&(m_values[id_nz]),it->value().data(), block_size*sizeof(Scalar));
//        id_nz += block_size;
//      }
//      while(id < m_outerBSize-1) // Empty columns at the end
//      {
//        id++;
//        m_outerIndex[id+1]=m_outerIndex[id];
//      }
//      }
    }

Here is the call graph for this function:

◆ size()

Index Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::size ( ) const

inlineinherited

Returns: the number of coefficients, which is rows()*cols().

See also: rows(), cols().

176{ return rows() * cols(); }

◆ squaredNorm()

NumTraits< typenameinternal::traits< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::Scalar >::Real Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::squaredNorm

inlineinherited

{
  return numext::real((*this).cwiseAbs2().sum());
}

◆ subTo()

template<typename Derived >

template<typename Dest >

EIGEN_DEVICE_FUNC void Eigen::EigenBase< Derived >::subTo ( Dest & dst ) const

inlineinherited

  {
    // This is the default implementation,
    // derived class can reimplement it in a more optimized way.
    typename Dest::PlainObject res(rows(),cols());
    evalTo(res);
    dst -= res;
  }

References Eigen::EigenBase< Derived >::cols(), Eigen::EigenBase< Derived >::evalTo(), and Eigen::EigenBase< Derived >::rows().

Here is the call graph for this function:

◆ sum()

internal::traits< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::Scalar Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::sum

inherited

{
  eigen_assert(rows()>0 && cols()>0 && "you are using a non initialized matrix");
  Scalar res(0);
  internal::evaluator<Derived> thisEval(derived());
  for (Index j=0; j<outerSize(); ++j)
    for (typename internal::evaluator<Derived>::InnerIterator iter(thisEval,j); iter; ++iter)
      res += iter.value();
  return res;
}

◆ toDense()

DenseMatrixType Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::toDense ( ) const

inlineinherited

    {
      return DenseMatrixType(derived());
    }

◆ transpose() [1/2]

TransposeReturnType Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::transpose ( )

inlineinherited

349{ return TransposeReturnType(derived()); }

Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::TransposeReturnType

Transpose< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > > TransposeReturnType

Definition SparseMatrixBase.h:110

◆ transpose() [2/2]

const ConstTransposeReturnType Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::transpose ( ) const

inlineinherited

350{ return ConstTransposeReturnType(derived()); }

Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::ConstTransposeReturnType

internal::add_const< Transpose< constDerived > >::type ConstTransposeReturnType

Definition SparseMatrixBase.h:111

◆ triangularView()

const TriangularView< const BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > , Mode > Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::triangularView

inlineinherited

{
  return TriangularView<const Derived, Mode>(derived());
}

◆ twistedBy()

SparseSymmetricPermutationProduct< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > , Upper|Lower > Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::twistedBy ( const PermutationMatrix< Dynamic, Dynamic, StorageIndex > & perm ) const

inlineinherited

Returns: an expression of P H P^-1 where H is the matrix represented by *this

    {
      return SparseSymmetricPermutationProduct<Derived,Upper|Lower>(derived(), perm);
    }

◆ valuePtr()

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

BlockScalarReturnType * Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::valuePtr ( )

inline

864{return static_cast<BlockScalarReturnType *>(m_values);}

Eigen::BlockSparseMatrix::BlockScalarReturnType

internal::conditional< _BlockAtCompileTime==Dynamic, Scalar, BlockScalar >::type BlockScalarReturnType

Definition BlockSparseMatrix.h:305

References Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_values.

Friends And Related Symbol Documentation

◆ operator<<

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

std::ostream & operator<<	(	std::ostream &	s,
		const BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	m
	)

friend

    {
      for (StorageIndex j = 0; j < m.outerBlocks(); ++j)
      {
        BlockInnerIterator itb(m, j);
        for(; itb; ++itb)
        {
          s << "("<<itb.row() << ", " << itb.col() << ")\n";
          s << itb.value() <<"\n";
        }
      }
      s << std::endl;
      return s;
    }

◆ swap

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

void swap	(	BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	first,
		BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > &	second
	)

friend

    {
      std::swap(first.m_innerBSize, second.m_innerBSize);
      std::swap(first.m_outerBSize, second.m_outerBSize);
      std::swap(first.m_innerOffset, second.m_innerOffset);
      std::swap(first.m_outerOffset, second.m_outerOffset);
      std::swap(first.m_nonzerosblocks, second.m_nonzerosblocks);
      std::swap(first.m_nonzeros, second.m_nonzeros);
      std::swap(first.m_values, second.m_values);
      std::swap(first.m_blockPtr, second.m_blockPtr);
      std::swap(first.m_indices, second.m_indices);
      std::swap(first.m_outerIndex, second.m_outerIndex);
      std::swap(first.m_BlockSize, second.m_blockSize);
    }

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::operator=().

Member Data Documentation

◆ m_blockPtr

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

StorageIndex* Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockPtr

protected

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockSparseMatrix(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::~BlockSparseMatrix(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockPtr(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::operator=(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::reserve(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setBlockStructure(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setFromTriplets().

◆ m_blockSize

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_blockSize

protected

◆ m_indices

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

StorageIndex* Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_indices

protected

◆ m_innerBSize

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_innerBSize

protected

◆ m_innerOffset

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

StorageIndex* Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_innerOffset

protected

◆ m_isRValue

bool Eigen::SparseMatrixBase< BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex > >::m_isRValue

protectedinherited

◆ m_nonzeros

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_nonzeros

protected

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockSparseMatrix(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::nonZeros(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::operator=(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::reserve(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setBlockLayout(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setBlockStructure().

◆ m_nonzerosblocks

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_nonzerosblocks

protected

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockSparseMatrix(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::nonZerosBlocks(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::reserve().

◆ m_outerBSize

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Index Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerBSize

protected

◆ m_outerIndex

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

StorageIndex* Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerIndex

protected

◆ m_outerOffset

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

StorageIndex* Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_outerOffset

protected

Referenced by Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::BlockSparseMatrix(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::~BlockSparseMatrix(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockOuterIndex(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::blockOuterSize(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::outerSize(), Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::outerToBlock(), and Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::setBlockLayout().

◆ m_values

template<typename _Scalar , int _BlockAtCompileTime, int _Options, typename _StorageIndex >

Scalar* Eigen::BlockSparseMatrix< _Scalar, _BlockAtCompileTime, _Options, _StorageIndex >::m_values

protected

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

src/eigen/unsupported/Eigen/src/SparseExtra/BlockSparseMatrix.h

Classes

Public Types

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ AdjointReturnType

◆ Base

◆ BlockRealScalar

◆ BlockScalar

◆ BlockScalarReturnType

◆ CoeffReturnType

◆ ConstantReturnType

◆ ConstInnerVectorReturnType

◆ ConstInnerVectorsReturnType

◆ ConstTransposeReturnType

◆ DenseMatrixType

◆ Index

◆ IndexVector

◆ InnerVectorReturnType

◆ InnerVectorsReturnType

◆ Nested

◆ PacketReturnType

◆ PacketScalar

◆ PlainObject

◆ RealScalar

◆ Scalar

◆ ScalarVector

◆ SquareMatrixType

◆ StorageBaseType

◆ StorageIndex

◆ StorageKind

◆ TransposeReturnType

◆ value_type

Member Enumeration Documentation

◆ anonymous enum

◆ anonymous enum

Constructor & Destructor Documentation

◆ BlockSparseMatrix() [1/4]

◆ BlockSparseMatrix() [2/4]

◆ BlockSparseMatrix() [3/4]

◆ ~BlockSparseMatrix()

◆ BlockSparseMatrix() [4/4]

Member Function Documentation

◆ addTo()

◆ adjoint()

◆ applyThisOnTheLeft()

◆ applyThisOnTheRight()

◆ assign()

◆ assignGeneric()

◆ blockCols()

◆ blockColsIndex()

◆ blockInnerIndex()

◆ blockInnerSize()

◆ blockOuterIndex()

◆ blockOuterSize()

◆ blockPtr()

◆ blockRows()

◆ blockRowsIndex()

◆ blueNorm()

◆ coeff()

◆ coeffRef()

◆ cols()

◆ const_cast_derived()

◆ const_derived()

◆ convert_index()

◆ cwiseProduct() [1/2]

◆ cwiseProduct() [2/2]

◆ derived() [1/2]

◆ derived() [2/2]

◆ dot() [1/4]

◆ dot() [2/4]

◆ dot() [3/4]

◆ dot() [4/4]

◆ eval()

◆ evalTo()