Chemical Data Processing Library C++ API - Version 1.1.1
Public Types | Public Member Functions | Friends | List of all members
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< SelfTypeReference
 
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< SelfTypeClosureType
 
typedef const MatrixReference< const SelfTypeConstClosureType
 
typedef SelfType MatrixTemporaryType
 
typedef Vector< T, std::vector< T > > VectorTemporaryType
 
typedef std::shared_ptr< SelfTypeSharedPointer
 
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< SparseMatrix< T, std::unordered_map< std::uint64_t, T > > >
typedef SparseMatrix< T, std::unordered_map< std::uint64_t, T > > ExpressionType
 
- Public Types inherited from CDPL::Math::Expression< SparseMatrix< T, std::unordered_map< std::uint64_t, T > > >
typedef SparseMatrix< T, std::unordered_map< std::uint64_t, T > > 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
 
ArrayTypegetData ()
 
const ArrayTypegetData () const
 
SparseMatrixoperator= (const SparseMatrix &m)
 
SparseMatrixoperator= (SparseMatrix &&m)
 
template<typename C >
SparseMatrixoperator= (const MatrixContainer< C > &c)
 
SparseMatrixoperator= (InitializerListType l)
 
template<typename E >
SparseMatrixoperator= (const MatrixExpression< E > &e)
 
template<typename C >
SparseMatrixoperator+= (const MatrixContainer< C > &c)
 
SparseMatrixoperator+= (InitializerListType l)
 
template<typename E >
SparseMatrixoperator+= (const MatrixExpression< E > &e)
 
template<typename C >
SparseMatrixoperator-= (const MatrixContainer< C > &c)
 
SparseMatrixoperator-= (InitializerListType l)
 
template<typename E >
SparseMatrixoperator-= (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 >
SparseMatrixassign (const MatrixExpression< E > &e)
 
SparseMatrixassign (InitializerListType l)
 
template<typename E >
SparseMatrixplusAssign (const MatrixExpression< E > &e)
 
SparseMatrixplusAssign (InitializerListType l)
 
template<typename E >
SparseMatrixminusAssign (const MatrixExpression< E > &e)
 
SparseMatrixminusAssign (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 ContainerTypeoperator() () const
 
ContainerTypeoperator() ()
 
- Public Member Functions inherited from CDPL::Math::MatrixExpression< SparseMatrix< T, std::unordered_map< std::uint64_t, T > > >
const ExpressionTypeoperator() () const
 
ExpressionTypeoperator() ()
 

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< SparseMatrix< T, std::unordered_map< std::uint64_t, T > > >
 MatrixExpression ()
 
 ~MatrixExpression ()
 
- Protected Member Functions inherited from CDPL::Math::Expression< SparseMatrix< T, std::unordered_map< std::uint64_t, T > > >
 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: