CDPL::Math::SparseMatrix< T, A > Class Template Reference

#include <Matrix.hpp>

Inheritance diagram for CDPL::Math::SparseMatrix< T, A >:

Public Types
typedef T	ValueType
typedef A::key_type	KeyType
typedef SparseContainerElement< SelfType >	Reference
typedef const T &	ConstReference
typedef std::uint32_t	SizeType
typedef std::ptrdiff_t	DifferenceType
typedef A	ArrayType
typedef T *	Pointer
typedef const T *	ConstPointer
typedef MatrixReference< SelfType >	ClosureType
typedef const MatrixReference< const SelfType >	ConstClosureType
typedef SelfType	MatrixTemporaryType
typedef Vector< T, std::vector< T > >	VectorTemporaryType
typedef std::shared_ptr< SelfType >	SharedPointer
typedef std::initializer_list< std::initializer_list< T > >	InitializerListType
Public Types inherited from CDPL::Math::MatrixContainer< SparseMatrix< T, std::unordered_map< std::uint64_t, T > > >
typedef SparseMatrix< T, std::unordered_map< std::uint64_t, T > >	ContainerType
Public Types inherited from CDPL::Math::MatrixExpression< E >
typedef E	ExpressionType
Public Types inherited from CDPL::Math::Expression< E >
typedef E	ExpressionType

Public Member Functions
	SparseMatrix ()
	SparseMatrix (SizeType m, SizeType n)
	SparseMatrix (const SparseMatrix &m)
	SparseMatrix (SparseMatrix &&m)
	SparseMatrix (InitializerListType l)
template<typename E >
	SparseMatrix (const MatrixExpression< E > &e)
Reference	operator() (SizeType i, SizeType j)
ConstReference	operator() (SizeType i, SizeType j) const
SizeType	getNumElements () const
bool	isEmpty () const
SizeType	getSize1 () const
SizeType	getSize2 () const
ArrayType::size_type	getMaxSize () const
ArrayType &	getData ()
const ArrayType &	getData () const
SparseMatrix &	operator= (const SparseMatrix &m)
SparseMatrix &	operator= (SparseMatrix &&m)
template<typename C >
SparseMatrix &	operator= (const MatrixContainer< C > &c)
SparseMatrix &	operator= (InitializerListType l)
template<typename E >
SparseMatrix &	operator= (const MatrixExpression< E > &e)
template<typename C >
SparseMatrix &	operator+= (const MatrixContainer< C > &c)
SparseMatrix &	operator+= (InitializerListType l)
template<typename E >
SparseMatrix &	operator+= (const MatrixExpression< E > &e)
template<typename C >
SparseMatrix &	operator-= (const MatrixContainer< C > &c)
SparseMatrix &	operator-= (InitializerListType l)
template<typename E >
SparseMatrix &	operator-= (const MatrixExpression< E > &e)
template<typename T1 >
std::enable_if< IsScalar< T1 >::value, SparseMatrix >::type &	operator*= (const T1 &t)
template<typename T1 >
std::enable_if< IsScalar< T1 >::value, SparseMatrix >::type &	operator/= (const T1 &t)
template<typename E >
SparseMatrix &	assign (const MatrixExpression< E > &e)
SparseMatrix &	assign (InitializerListType l)
template<typename E >
SparseMatrix &	plusAssign (const MatrixExpression< E > &e)
SparseMatrix &	plusAssign (InitializerListType l)
template<typename E >
SparseMatrix &	minusAssign (const MatrixExpression< E > &e)
SparseMatrix &	minusAssign (InitializerListType l)
void	swap (SparseMatrix &m)
void	clear ()
void	resize (SizeType m, SizeType n)
Public Member Functions inherited from CDPL::Math::MatrixContainer< SparseMatrix< T, std::unordered_map< std::uint64_t, T > > >
const ContainerType &	operator() () const
ContainerType &	operator() ()
Public Member Functions inherited from CDPL::Math::MatrixExpression< E >
const ExpressionType &	operator() () const
ExpressionType &	operator() ()

Friends
void	swap (SparseMatrix &m1, SparseMatrix &m2)

Additional Inherited Members
Protected Member Functions inherited from CDPL::Math::MatrixContainer< SparseMatrix< T, std::unordered_map< std::uint64_t, T > > >
	MatrixContainer ()
	~MatrixContainer ()
Protected Member Functions inherited from CDPL::Math::MatrixExpression< E >
	MatrixExpression ()
	~MatrixExpression ()
Protected Member Functions inherited from CDPL::Math::Expression< E >
	Expression ()
	~Expression ()

Member Typedef Documentation

ValueType

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef T CDPL::Math::SparseMatrix< T, A >::ValueType

KeyType

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef A::key_type CDPL::Math::SparseMatrix< T, A >::KeyType

Reference

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef SparseContainerElement<SelfType> CDPL::Math::SparseMatrix< T, A >::Reference

ConstReference

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef const T& CDPL::Math::SparseMatrix< T, A >::ConstReference

SizeType

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef std::uint32_t CDPL::Math::SparseMatrix< T, A >::SizeType

DifferenceType

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef std::ptrdiff_t CDPL::Math::SparseMatrix< T, A >::DifferenceType

ArrayType

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef A CDPL::Math::SparseMatrix< T, A >::ArrayType

Pointer

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef T* CDPL::Math::SparseMatrix< T, A >::Pointer

ConstPointer

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef const T* CDPL::Math::SparseMatrix< T, A >::ConstPointer

ClosureType

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef MatrixReference<SelfType> CDPL::Math::SparseMatrix< T, A >::ClosureType

ConstClosureType

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef const MatrixReference<const SelfType> CDPL::Math::SparseMatrix< T, A >::ConstClosureType

MatrixTemporaryType

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef SelfType CDPL::Math::SparseMatrix< T, A >::MatrixTemporaryType

VectorTemporaryType

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef Vector<T, std::vector<T> > CDPL::Math::SparseMatrix< T, A >::VectorTemporaryType

SharedPointer

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef std::shared_ptr<SelfType> CDPL::Math::SparseMatrix< T, A >::SharedPointer

InitializerListType

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

typedef std::initializer_list<std::initializer_list<T> > CDPL::Math::SparseMatrix< T, A >::InitializerListType

Constructor & Destructor Documentation

SparseMatrix() [1/6]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

CDPL::Math::SparseMatrix< T, A >::SparseMatrix ( )

inline

SparseMatrix() [2/6]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

CDPL::Math::SparseMatrix< T, A >::SparseMatrix ( SizeType  m, SizeType  n  )

inline

SparseMatrix() [3/6]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

CDPL::Math::SparseMatrix< T, A >::SparseMatrix ( const SparseMatrix< T, A > &  m )

inline

SparseMatrix() [4/6]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

CDPL::Math::SparseMatrix< T, A >::SparseMatrix ( SparseMatrix< T, A > &&  m )

inline

SparseMatrix() [5/6]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

CDPL::Math::SparseMatrix< T, A >::SparseMatrix ( InitializerListType  l )

inline

SparseMatrix() [6/6]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

template<typename E >

CDPL::Math::SparseMatrix< T, A >::SparseMatrix ( const MatrixExpression< E > &  e )

inline

Member Function Documentation

operator()() [1/2]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

Reference CDPL::Math::SparseMatrix< T, A >::operator() ( SizeType  i, SizeType  j  )

inline

operator()() [2/2]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

ConstReference CDPL::Math::SparseMatrix< T, A >::operator() ( SizeType  i, SizeType  j  ) const

inline

getNumElements()

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

SizeType CDPL::Math::SparseMatrix< T, A >::getNumElements ( ) const

inline

isEmpty()

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

bool CDPL::Math::SparseMatrix< T, A >::isEmpty ( ) const

inline

getSize1()

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

SizeType CDPL::Math::SparseMatrix< T, A >::getSize1 ( ) const

inline

getSize2()

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

SizeType CDPL::Math::SparseMatrix< T, A >::getSize2 ( ) const

inline

getMaxSize()

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

ArrayType::size_type CDPL::Math::SparseMatrix< T, A >::getMaxSize ( ) const

inline

getData() [1/2]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

ArrayType& CDPL::Math::SparseMatrix< T, A >::getData ( )

inline

getData() [2/2]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

const ArrayType& CDPL::Math::SparseMatrix< T, A >::getData ( ) const

inline

operator=() [1/5]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::operator= ( const SparseMatrix< T, A > &  m )

inline

operator=() [2/5]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::operator= ( SparseMatrix< T, A > &&  m )

inline

operator=() [3/5]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

template<typename C >

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::operator= ( const MatrixContainer< C > &  c )

inline

operator=() [4/5]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::operator= ( InitializerListType  l )

inline

operator=() [5/5]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

template<typename E >

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::operator= ( const MatrixExpression< E > &  e )

inline

operator+=() [1/3]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

template<typename C >

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::operator+= ( const MatrixContainer< C > &  c )

inline

operator+=() [2/3]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::operator+= ( InitializerListType  l )

inline

operator+=() [3/3]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

template<typename E >

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::operator+= ( const MatrixExpression< E > &  e )

inline

operator-=() [1/3]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

template<typename C >

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::operator-= ( const MatrixContainer< C > &  c )

inline

operator-=() [2/3]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::operator-= ( InitializerListType  l )

inline

operator-=() [3/3]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

template<typename E >

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::operator-= ( const MatrixExpression< E > &  e )

inline

operator*=()

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

template<typename T1 >

std::enable_if<IsScalar<T1>::value, SparseMatrix>::type& CDPL::Math::SparseMatrix< T, A >::operator*= ( const T1 &  t )

inline

operator/=()

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

template<typename T1 >

std::enable_if<IsScalar<T1>::value, SparseMatrix>::type& CDPL::Math::SparseMatrix< T, A >::operator/= ( const T1 &  t )

inline

assign() [1/2]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

template<typename E >

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::assign ( const MatrixExpression< E > &  e )

inline

assign() [2/2]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::assign ( InitializerListType  l )

inline

plusAssign() [1/2]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

template<typename E >

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::plusAssign ( const MatrixExpression< E > &  e )

inline

plusAssign() [2/2]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::plusAssign ( InitializerListType  l )

inline

minusAssign() [1/2]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

template<typename E >

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::minusAssign ( const MatrixExpression< E > &  e )

inline

minusAssign() [2/2]

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

SparseMatrix& CDPL::Math::SparseMatrix< T, A >::minusAssign ( InitializerListType  l )

inline

swap()

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

void CDPL::Math::SparseMatrix< T, A >::swap ( SparseMatrix< T, A > &  m )

inline

clear()

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

void CDPL::Math::SparseMatrix< T, A >::clear ( )

inline

resize()

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

void CDPL::Math::SparseMatrix< T, A >::resize ( SizeType  m, SizeType  n  )

inline

Friends And Related Function Documentation

swap

template<typename T , typename A = std::unordered_map<std::uint64_t, T>>

void swap ( SparseMatrix< T, A > &  m1, SparseMatrix< T, A > &  m2  )

friend

---

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

• Matrix.hpp