Eigen::BlockSparseMatrixView< BlockSparseMatrixT > Class Template Reference

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

Inheritance diagram for Eigen::BlockSparseMatrixView< BlockSparseMatrixT >:

Collaboration diagram for Eigen::BlockSparseMatrixView< BlockSparseMatrixT >:

Classes
class	InnerIterator

Public Types
enum	{   Flags = BlockSparseMatrixT::Options , Options = BlockSparseMatrixT::Options , RowsAtCompileTime = BlockSparseMatrixT::RowsAtCompileTime , ColsAtCompileTime = BlockSparseMatrixT::ColsAtCompileTime ,   MaxColsAtCompileTime = BlockSparseMatrixT::MaxColsAtCompileTime , MaxRowsAtCompileTime = BlockSparseMatrixT::MaxRowsAtCompileTime }
typedef Ref< typename BlockSparseMatrixT::BlockScalar >	Scalar
typedef Ref< typename BlockSparseMatrixT::BlockRealScalar >	RealScalar
typedef BlockSparseMatrixT::Index	Index
typedef BlockSparseMatrixT	Nested
enum
typedef Scalar	value_type
typedef internal::packet_traits< Scalar >::type	PacketScalar
typedef internal::traits< BlockSparseMatrixT >::StorageKind	StorageKind
typedef internal::traits< BlockSparseMatrixT >::StorageIndex	StorageIndex
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< BlockSparseMatrixT >	TransposeReturnType
typedef internal::add_const< Transpose< constDerived > >::type	ConstTransposeReturnType
typedef SparseMatrix< Scalar, Flags &RowMajorBit ? RowMajor :ColMajor, StorageIndex >	PlainObject
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< BlockSparseMatrixT >	Base
typedef Block< BlockSparseMatrixT, IsRowMajor?1:Dynamic, IsRowMajor?Dynamic:1, true >	InnerVectorReturnType
typedef Block< const BlockSparseMatrixT, IsRowMajor?1:Dynamic, IsRowMajor?Dynamic:1, true >	ConstInnerVectorReturnType
typedef Block< BlockSparseMatrixT, Dynamic, Dynamic, true >	InnerVectorsReturnType
typedef Block< const BlockSparseMatrixT, Dynamic, Dynamic, true >	ConstInnerVectorsReturnType

Public Member Functions
	BlockSparseMatrixView (const BlockSparseMatrixT &spblockmat)
Index	outerSize () const
Index	cols () const
Index	rows () const
Scalar	coeff (Index row, Index col)
Scalar	coeffRef (Index row, Index col)
const BlockSparseMatrixT &	derived () const
BlockSparseMatrixT &	derived ()
BlockSparseMatrixT &	const_cast_derived () const
Index	size () const
bool	isVector () const
Index	innerSize () const
bool	isRValue () const
BlockSparseMatrixT &	markAsRValue ()
BlockSparseMatrixT &	operator+= (const SparseMatrixBase< OtherDerived > &other)
BlockSparseMatrixT &	operator+= (const DiagonalBase< OtherDerived > &other)
BlockSparseMatrixT &	operator+= (const EigenBase< OtherDerived > &other)
EIGEN_STRONG_INLINE BlockSparseMatrixT &	operator+= (const SparseMatrixBase< OtherDerived > &other)
BlockSparseMatrixT &	operator-= (const SparseMatrixBase< OtherDerived > &other)
BlockSparseMatrixT &	operator-= (const DiagonalBase< OtherDerived > &other)
BlockSparseMatrixT &	operator-= (const EigenBase< OtherDerived > &other)
EIGEN_STRONG_INLINE BlockSparseMatrixT &	operator-= (const SparseMatrixBase< OtherDerived > &other)
BlockSparseMatrixT &	operator*= (const Scalar &other)
BlockSparseMatrixT &	operator*= (const SparseMatrixBase< OtherDerived > &other)
BlockSparseMatrixT &	operator/= (const Scalar &other)
EIGEN_STRONG_INLINE const CwiseProductDenseReturnType< OtherDerived >::Type	cwiseProduct (const MatrixBase< OtherDerived > &other) const
EIGEN_STRONG_INLINE const SparseMatrixBase< BlockSparseMatrixT >::template CwiseProductDenseReturnType< OtherDerived >::Type	cwiseProduct (const MatrixBase< OtherDerived > &other) const
const Product< BlockSparseMatrixT, OtherDerived >	operator* (const DiagonalBase< OtherDerived > &other) const
const Product< BlockSparseMatrixT, OtherDerived, AliasFreeProduct >	operator* (const SparseMatrixBase< OtherDerived > &other) const
const Product< BlockSparseMatrixT, OtherDerived >	operator* (const MatrixBase< OtherDerived > &other) const
SparseSymmetricPermutationProduct< BlockSparseMatrixT, Upper|Lower >	twistedBy (const PermutationMatrix< Dynamic, Dynamic, StorageIndex > &perm) const
const TriangularView< const BlockSparseMatrixT, Mode >	triangularView () const
ConstSelfAdjointViewReturnType< UpLo >::Type	selfadjointView () const
SelfAdjointViewReturnType< UpLo >::Type	selfadjointView ()
SparseMatrixBase< BlockSparseMatrixT >::template ConstSelfAdjointViewReturnType< UpLo >::Type	selfadjointView () const
SparseMatrixBase< BlockSparseMatrixT >::template SelfAdjointViewReturnType< UpLo >::Type	selfadjointView ()
Scalar	dot (const MatrixBase< OtherDerived > &other) const
Scalar	dot (const SparseMatrixBase< OtherDerived > &other) const
internal::traits< BlockSparseMatrixT >::Scalar	dot (const MatrixBase< OtherDerived > &other) const
internal::traits< BlockSparseMatrixT >::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< BlockSparseMatrixT >::type	eval () const
Scalar	sum () const
const SparseView< BlockSparseMatrixT >	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
BlockSparseMatrixT &	assign (const OtherDerived &other)
void	assignGeneric (const OtherDerived &other)

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

Protected Attributes
const BlockSparseMatrixT &	m_spblockmat
bool	m_isRValue

Private Member Functions
void	evalTo (Dest &) const

Detailed Description

template<typename BlockSparseMatrixT>
class Eigen::BlockSparseMatrixView< BlockSparseMatrixT >

Member Typedef Documentation

AdjointReturnType

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

inherited

Base

typedef EigenBase<BlockSparseMatrixT > Eigen::SparseMatrixBase< BlockSparseMatrixT >::Base

inherited

CoeffReturnType

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

inherited

ConstantReturnType

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

inherited

ConstInnerVectorReturnType

typedef Block<const BlockSparseMatrixT ,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true> Eigen::SparseMatrixBase< BlockSparseMatrixT >::ConstInnerVectorReturnType

inherited

ConstInnerVectorsReturnType

typedef Block<const BlockSparseMatrixT ,Dynamic,Dynamic,true> Eigen::SparseMatrixBase< BlockSparseMatrixT >::ConstInnerVectorsReturnType

inherited

ConstTransposeReturnType

typedef internal::add_const<Transpose<constDerived>>::type Eigen::SparseMatrixBase< BlockSparseMatrixT >::ConstTransposeReturnType

inherited

DenseMatrixType

typedef Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime> Eigen::SparseMatrixBase< BlockSparseMatrixT >::DenseMatrixType

inherited

type of the equivalent dense matrix

Index

template<typename BlockSparseMatrixT >

typedef BlockSparseMatrixT::Index Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::Index

IndexVector

typedef Matrix<StorageIndex,Dynamic,1> Eigen::SparseMatrixBase< BlockSparseMatrixT >::IndexVector

inherited

InnerVectorReturnType

typedef Block<BlockSparseMatrixT ,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true> Eigen::SparseMatrixBase< BlockSparseMatrixT >::InnerVectorReturnType

inherited

InnerVectorsReturnType

typedef Block<BlockSparseMatrixT ,Dynamic,Dynamic,true> Eigen::SparseMatrixBase< BlockSparseMatrixT >::InnerVectorsReturnType

inherited

Nested

template<typename BlockSparseMatrixT >

typedef BlockSparseMatrixT Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::Nested

PacketReturnType

typedef internal::add_const_on_value_type_if_arithmetic<typenameinternal::packet_traits<Scalar>::type>::type Eigen::SparseMatrixBase< BlockSparseMatrixT >::PacketReturnType

inherited

PacketScalar

typedef internal::packet_traits<Scalar>::type Eigen::SparseMatrixBase< BlockSparseMatrixT >::PacketScalar

inherited

PlainObject

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

inherited

RealScalar

template<typename BlockSparseMatrixT >

typedef Ref<typename BlockSparseMatrixT::BlockRealScalar> Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::RealScalar

Scalar

template<typename BlockSparseMatrixT >

typedef Ref<typename BlockSparseMatrixT::BlockScalar> Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::Scalar

ScalarVector

typedef Matrix<Scalar,Dynamic,1> Eigen::SparseMatrixBase< BlockSparseMatrixT >::ScalarVector

inherited

SquareMatrixType

typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime), EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime)> Eigen::SparseMatrixBase< BlockSparseMatrixT >::SquareMatrixType

inherited

type of the equivalent square matrix

StorageBaseType

typedef SparseMatrixBase Eigen::SparseMatrixBase< BlockSparseMatrixT >::StorageBaseType

inherited

StorageIndex

typedef internal::traits<BlockSparseMatrixT >::StorageIndex Eigen::SparseMatrixBase< BlockSparseMatrixT >::StorageIndex

inherited

The integer type used to store indices within a SparseMatrix. For a SparseMatrix<Scalar,Options,IndexType> it an alias of the third template parameter IndexType.

StorageKind

typedef internal::traits<BlockSparseMatrixT >::StorageKind Eigen::SparseMatrixBase< BlockSparseMatrixT >::StorageKind

inherited

TransposeReturnType

typedef Transpose<BlockSparseMatrixT > Eigen::SparseMatrixBase< BlockSparseMatrixT >::TransposeReturnType

inherited

value_type

typedef Scalar Eigen::SparseMatrixBase< BlockSparseMatrixT >::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 BlockSparseMatrixT >

anonymous enum

Enumerator
Flags
Options
RowsAtCompileTime
ColsAtCompileTime
MaxColsAtCompileTime
MaxRowsAtCompileTime

         {
      Flags = BlockSparseMatrixT::Options,
      Options = BlockSparseMatrixT::Options,
      RowsAtCompileTime = BlockSparseMatrixT::RowsAtCompileTime,
      ColsAtCompileTime = BlockSparseMatrixT::ColsAtCompileTime,
      MaxColsAtCompileTime = BlockSparseMatrixT::MaxColsAtCompileTime,
      MaxRowsAtCompileTime = BlockSparseMatrixT::MaxRowsAtCompileTime
    };

Constructor & Destructor Documentation

BlockSparseMatrixView()

template<typename BlockSparseMatrixT >

Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::BlockSparseMatrixView ( const BlockSparseMatrixT &  spblockmat )

inline

     : m_spblockmat(spblockmat)
    {}

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< BlockSparseMatrixT >::adjoint ( ) const

inlineinherited

{ return AdjointReturnType(transpose()); }

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

BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::assign ( const OtherDerived &  other )

inlineprotectedinherited

assignGeneric()

void Eigen::SparseMatrixBase< BlockSparseMatrixT >::assignGeneric ( const OtherDerived &  other )

inlineprotectedinherited

blueNorm()

NumTraits< typenameinternal::traits< BlockSparseMatrixT >::Scalar >::Real Eigen::SparseMatrixBase< BlockSparseMatrixT >::blueNorm

inlineinherited

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

coeff()

template<typename BlockSparseMatrixT >

Scalar Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::coeff ( Index  row, Index  col  )

inline

    {
      return m_spblockmat.coeff(row, col);
    }

References col(), Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::m_spblockmat, and row().

Here is the call graph for this function:

coeffRef()

template<typename BlockSparseMatrixT >

Scalar Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::coeffRef ( Index  row, Index  col  )

inline

    {
      return m_spblockmat.coeffRef(row, col);
    }

References col(), Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::m_spblockmat, and row().

Here is the call graph for this function:

cols()

template<typename BlockSparseMatrixT >

Index Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::cols ( ) const

inline

    {
      return m_spblockmat.blockCols();
    }

References Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::m_spblockmat.

Referenced by Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::outerSize().

Here is the caller graph for this function:

const_cast_derived()

BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::const_cast_derived ( ) const

inlineinherited

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

const_derived()

template<typename Derived >

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

inlineinherited

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

convert_index()

static StorageIndex Eigen::SparseMatrixBase< BlockSparseMatrixT >::convert_index ( const Index  idx )

inlinestaticprotectedinherited

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

cwiseProduct() [1/2]

EIGEN_STRONG_INLINE const SparseMatrixBase< BlockSparseMatrixT >::template CwiseProductDenseReturnType< OtherDerived >::Type Eigen::SparseMatrixBase< BlockSparseMatrixT >::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< BlockSparseMatrixT >::cwiseProduct ( const MatrixBase< OtherDerived > &  other ) const

inherited

derived() [1/2]

BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::derived ( )

inlineinherited

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

derived() [2/2]

const BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::derived ( ) const

inlineinherited

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

dot() [1/4]

internal::traits< BlockSparseMatrixT >::Scalar Eigen::SparseMatrixBase< BlockSparseMatrixT >::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< BlockSparseMatrixT >::dot ( const MatrixBase< OtherDerived > &  other ) const

inherited

dot() [3/4]

internal::traits< BlockSparseMatrixT >::Scalar Eigen::SparseMatrixBase< BlockSparseMatrixT >::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< BlockSparseMatrixT >::dot ( const SparseMatrixBase< OtherDerived > &  other ) const

inherited

eval()

const internal::eval< BlockSparseMatrixT >::type Eigen::SparseMatrixBase< BlockSparseMatrixT >::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.

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

evalTo()

void Eigen::SparseMatrixBase< BlockSparseMatrixT >::evalTo ( Dest &  ) const

privateinherited

innerSize()

Index Eigen::SparseMatrixBase< BlockSparseMatrixT >::innerSize ( ) const

inlineinherited

Returns

the size of the inner dimension according to the storage order, i.e., the number of rows for a columns major matrix, and the number of cols otherwise

{ return (int(Flags)&RowMajorBit) ? this->cols() : this->rows(); }

innerVector() [1/2]

SparseMatrixBase< BlockSparseMatrixT >::InnerVectorReturnType Eigen::SparseMatrixBase< BlockSparseMatrixT >::innerVector ( Index  outer )

inherited

Returns

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

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

innerVector() [2/2]

const SparseMatrixBase< BlockSparseMatrixT >::ConstInnerVectorReturnType Eigen::SparseMatrixBase< BlockSparseMatrixT >::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.

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

innerVectors() [1/2]

SparseMatrixBase< BlockSparseMatrixT >::InnerVectorsReturnType Eigen::SparseMatrixBase< BlockSparseMatrixT >::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< BlockSparseMatrixT >::ConstInnerVectorsReturnType Eigen::SparseMatrixBase< BlockSparseMatrixT >::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);
 
}

isApprox() [1/2]

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

inlineinherited

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

isApprox() [2/2]

bool Eigen::SparseMatrixBase< BlockSparseMatrixT >::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());
}

isRValue()

bool Eigen::SparseMatrixBase< BlockSparseMatrixT >::isRValue ( ) const

inlineinherited

{ return m_isRValue; }

isVector()

bool Eigen::SparseMatrixBase< BlockSparseMatrixT >::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 

See also

rows(), cols(), IsVectorAtCompileTime.

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

markAsRValue()

BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::markAsRValue ( )

inlineinherited

{ m_isRValue = true; return derived(); }

norm()

NumTraits< typenameinternal::traits< BlockSparseMatrixT >::Scalar >::Real Eigen::SparseMatrixBase< BlockSparseMatrixT >::norm

inlineinherited

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

operator*() [1/3]

const Product< BlockSparseMatrixT , OtherDerived > Eigen::SparseMatrixBase< BlockSparseMatrixT >::operator* ( const DiagonalBase< OtherDerived > &  other ) const

inlineinherited

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

operator*() [2/3]

const Product< BlockSparseMatrixT , OtherDerived > Eigen::SparseMatrixBase< BlockSparseMatrixT >::operator* ( const MatrixBase< OtherDerived > &  other ) const

inlineinherited

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

operator*() [3/3]

const Product< BlockSparseMatrixT , OtherDerived, AliasFreeProduct > Eigen::SparseMatrixBase< BlockSparseMatrixT >::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);

where ref is a meaningful non zero reference value.

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

operator*=() [1/2]

EIGEN_STRONG_INLINE BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::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]

BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::operator*= ( const SparseMatrixBase< OtherDerived > &  other )

inherited

operator+=() [1/4]

BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::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]

BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::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 BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::operator+= ( const SparseMatrixBase< OtherDerived > &  other )

inherited

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

operator+=() [4/4]

BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::operator+= ( const SparseMatrixBase< OtherDerived > &  other )

inherited

operator-=() [1/4]

BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::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]

BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::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 BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::operator-= ( const SparseMatrixBase< OtherDerived > &  other )

inherited

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

operator-=() [4/4]

BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::operator-= ( const SparseMatrixBase< OtherDerived > &  other )

inherited

operator/=()

EIGEN_STRONG_INLINE BlockSparseMatrixT & Eigen::SparseMatrixBase< BlockSparseMatrixT >::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();
}

outerSize()

template<typename BlockSparseMatrixT >

Index Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::outerSize ( ) const

inline

    {
      return (Flags&RowMajorBit) == 1 ? this->rows() : this->cols();
    }

References Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::cols(), Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::Flags, Eigen::RowMajorBit, and Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::rows().

Here is the call graph for this function:

pruned()

const SparseView< BlockSparseMatrixT > Eigen::SparseMatrixBase< BlockSparseMatrixT >::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);
}

rows()

template<typename BlockSparseMatrixT >

Index Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::rows ( ) const

inline

    {
      return m_spblockmat.blockRows();
    }

References Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::m_spblockmat.

Referenced by Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::outerSize().

Here is the caller graph for this function:

selfadjointView() [1/4]

SelfAdjointViewReturnType< UpLo >::Type Eigen::SparseMatrixBase< BlockSparseMatrixT >::selfadjointView ( )

inlineinherited

selfadjointView() [2/4]

SparseMatrixBase< BlockSparseMatrixT >::template SelfAdjointViewReturnType< UpLo >::Type Eigen::SparseMatrixBase< BlockSparseMatrixT >::selfadjointView ( )

inherited

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

selfadjointView() [3/4]

ConstSelfAdjointViewReturnType< UpLo >::Type Eigen::SparseMatrixBase< BlockSparseMatrixT >::selfadjointView ( ) const

inlineinherited

selfadjointView() [4/4]

SparseMatrixBase< BlockSparseMatrixT >::template ConstSelfAdjointViewReturnType< UpLo >::Type Eigen::SparseMatrixBase< BlockSparseMatrixT >::selfadjointView ( ) const

inherited

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

size()

Index Eigen::SparseMatrixBase< BlockSparseMatrixT >::size ( ) const

inlineinherited

Returns

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

See also

rows(), cols().

{ return rows() * cols(); }

squaredNorm()

NumTraits< typenameinternal::traits< BlockSparseMatrixT >::Scalar >::Real Eigen::SparseMatrixBase< BlockSparseMatrixT >::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< BlockSparseMatrixT >::Scalar Eigen::SparseMatrixBase< BlockSparseMatrixT >::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< BlockSparseMatrixT >::toDense ( ) const

inlineinherited

    {
      return DenseMatrixType(derived());
    }

transpose() [1/2]

TransposeReturnType Eigen::SparseMatrixBase< BlockSparseMatrixT >::transpose ( )

inlineinherited

{ return TransposeReturnType(derived()); }

transpose() [2/2]

const ConstTransposeReturnType Eigen::SparseMatrixBase< BlockSparseMatrixT >::transpose ( ) const

inlineinherited

{ return ConstTransposeReturnType(derived()); }

triangularView()

const TriangularView< const BlockSparseMatrixT , Mode > Eigen::SparseMatrixBase< BlockSparseMatrixT >::triangularView

inlineinherited

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

twistedBy()

SparseSymmetricPermutationProduct< BlockSparseMatrixT , Upper|Lower > Eigen::SparseMatrixBase< BlockSparseMatrixT >::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);
    }

Member Data Documentation

m_isRValue

bool Eigen::SparseMatrixBase< BlockSparseMatrixT >::m_isRValue

protectedinherited

m_spblockmat

template<typename BlockSparseMatrixT >

const BlockSparseMatrixT& Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::m_spblockmat

protected

Referenced by Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::coeff(), Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::coeffRef(), Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::cols(), and Eigen::BlockSparseMatrixView< BlockSparseMatrixT >::rows().

---

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

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