Chemical Data Processing Library C++ API - Version 1.1.1
Public Types | Public Member Functions | Static Public Attributes | Friends | List of all members
CDPL::Math::BoundedMatrix< T, M, N > Class Template Reference

#include <Matrix.hpp>

+ Inheritance diagram for CDPL::Math::BoundedMatrix< T, M, N >:

Public Types

typedef T ValueType
 
typedef T & Reference
 
typedef const T & ConstReference
 
typedef std::size_t SizeType
 
typedef std::ptrdiff_t DifferenceType
 
typedef ValueType ArrayType[M][N]
 
typedef T(* ArrayPointer)[N]
 
typedef const T(* ConstArrayPointer)[N]
 
typedef T * Pointer
 
typedef const T * ConstPointer
 
typedef MatrixReference< SelfTypeClosureType
 
typedef const MatrixReference< const SelfTypeConstClosureType
 
typedef SelfType MatrixTemporaryType
 
typedef BoundedVector< T, M *N > VectorTemporaryType
 
typedef std::shared_ptr< SelfTypeSharedPointer
 
typedef std::initializer_list< std::initializer_list< T > > InitializerListType
 
- Public Types inherited from CDPL::Math::MatrixContainer< BoundedMatrix< T, M, N > >
typedef BoundedMatrix< T, M, N > ContainerType
 
- Public Types inherited from CDPL::Math::MatrixExpression< BoundedMatrix< T, M, N > >
typedef BoundedMatrix< T, M, N > ExpressionType
 
- Public Types inherited from CDPL::Math::Expression< BoundedMatrix< T, M, N > >
typedef BoundedMatrix< T, M, N > ExpressionType
 

Public Member Functions

 BoundedMatrix ()
 
 BoundedMatrix (SizeType m, SizeType n)
 
 BoundedMatrix (SizeType m, SizeType n, const ValueType &v)
 
 BoundedMatrix (const BoundedMatrix &m)
 
 BoundedMatrix (InitializerListType l)
 
template<typename E >
 BoundedMatrix (const MatrixExpression< E > &e)
 
Reference operator() (SizeType i, SizeType j)
 
ConstReference operator() (SizeType i, SizeType j) const
 
bool isEmpty () const
 
SizeType getSize1 () const
 
SizeType getSize2 () const
 
SizeType getMaxSize1 () const
 
SizeType getMaxSize2 () const
 
ArrayPointer getData ()
 
ConstArrayPointer getData () const
 
BoundedMatrixoperator= (const BoundedMatrix &m)
 
template<typename C >
BoundedMatrixoperator= (const MatrixContainer< C > &c)
 
BoundedMatrixoperator= (InitializerListType l)
 
template<typename E >
BoundedMatrixoperator= (const MatrixExpression< E > &e)
 
template<typename C >
BoundedMatrixoperator+= (const MatrixContainer< C > &c)
 
BoundedMatrixoperator+= (InitializerListType l)
 
template<typename E >
BoundedMatrixoperator+= (const MatrixExpression< E > &e)
 
template<typename C >
BoundedMatrixoperator-= (const MatrixContainer< C > &c)
 
BoundedMatrixoperator-= (InitializerListType l)
 
template<typename E >
BoundedMatrixoperator-= (const MatrixExpression< E > &e)
 
template<typename T1 >
std::enable_if< IsScalar< T1 >::value, BoundedMatrix >::type & operator*= (const T1 &v)
 
template<typename T1 >
std::enable_if< IsScalar< T1 >::value, BoundedMatrix >::type & operator/= (const T1 &v)
 
template<typename E >
BoundedMatrixassign (const MatrixExpression< E > &e)
 
BoundedMatrixassign (InitializerListType l)
 
template<typename E >
BoundedMatrixplusAssign (const MatrixExpression< E > &e)
 
BoundedMatrixplusAssign (InitializerListType l)
 
template<typename E >
BoundedMatrixminusAssign (const MatrixExpression< E > &e)
 
BoundedMatrixminusAssign (InitializerListType l)
 
void swap (BoundedMatrix &m)
 
void clear (const ValueType &v=ValueType())
 
void resize (SizeType m, SizeType n)
 
void resize (SizeType m, SizeType n, const ValueType &v)
 
- Public Member Functions inherited from CDPL::Math::MatrixContainer< BoundedMatrix< T, M, N > >
const ContainerTypeoperator() () const
 
ContainerTypeoperator() ()
 
- Public Member Functions inherited from CDPL::Math::MatrixExpression< BoundedMatrix< T, M, N > >
const ExpressionTypeoperator() () const
 
ExpressionTypeoperator() ()
 

Static Public Attributes

static const SizeType MaxSize1 = M
 
static const SizeType MaxSize2 = N
 

Friends

void swap (BoundedMatrix &m1, BoundedMatrix &m2)
 

Additional Inherited Members

- Protected Member Functions inherited from CDPL::Math::MatrixContainer< BoundedMatrix< T, M, N > >
 MatrixContainer ()
 
 ~MatrixContainer ()
 
- Protected Member Functions inherited from CDPL::Math::MatrixExpression< BoundedMatrix< T, M, N > >
 MatrixExpression ()
 
 ~MatrixExpression ()
 
- Protected Member Functions inherited from CDPL::Math::Expression< BoundedMatrix< T, M, N > >
 Expression ()
 
 ~Expression ()
 

Member Typedef Documentation

◆ ValueType

template<typename T , std::size_t M, std::size_t N>
typedef T CDPL::Math::BoundedMatrix< T, M, N >::ValueType

◆ Reference

template<typename T , std::size_t M, std::size_t N>
typedef T& CDPL::Math::BoundedMatrix< T, M, N >::Reference

◆ ConstReference

template<typename T , std::size_t M, std::size_t N>
typedef const T& CDPL::Math::BoundedMatrix< T, M, N >::ConstReference

◆ SizeType

template<typename T , std::size_t M, std::size_t N>
typedef std::size_t CDPL::Math::BoundedMatrix< T, M, N >::SizeType

◆ DifferenceType

template<typename T , std::size_t M, std::size_t N>
typedef std::ptrdiff_t CDPL::Math::BoundedMatrix< T, M, N >::DifferenceType

◆ ArrayType

template<typename T , std::size_t M, std::size_t N>
typedef ValueType CDPL::Math::BoundedMatrix< T, M, N >::ArrayType[M][N]

◆ ArrayPointer

template<typename T , std::size_t M, std::size_t N>
typedef T(* CDPL::Math::BoundedMatrix< T, M, N >::ArrayPointer)[N]

◆ ConstArrayPointer

template<typename T , std::size_t M, std::size_t N>
typedef const T(* CDPL::Math::BoundedMatrix< T, M, N >::ConstArrayPointer)[N]

◆ Pointer

template<typename T , std::size_t M, std::size_t N>
typedef T* CDPL::Math::BoundedMatrix< T, M, N >::Pointer

◆ ConstPointer

template<typename T , std::size_t M, std::size_t N>
typedef const T* CDPL::Math::BoundedMatrix< T, M, N >::ConstPointer

◆ ClosureType

template<typename T , std::size_t M, std::size_t N>
typedef MatrixReference<SelfType> CDPL::Math::BoundedMatrix< T, M, N >::ClosureType

◆ ConstClosureType

template<typename T , std::size_t M, std::size_t N>
typedef const MatrixReference<const SelfType> CDPL::Math::BoundedMatrix< T, M, N >::ConstClosureType

◆ MatrixTemporaryType

template<typename T , std::size_t M, std::size_t N>
typedef SelfType CDPL::Math::BoundedMatrix< T, M, N >::MatrixTemporaryType

◆ VectorTemporaryType

template<typename T , std::size_t M, std::size_t N>
typedef BoundedVector<T, M * N> CDPL::Math::BoundedMatrix< T, M, N >::VectorTemporaryType

◆ SharedPointer

template<typename T , std::size_t M, std::size_t N>
typedef std::shared_ptr<SelfType> CDPL::Math::BoundedMatrix< T, M, N >::SharedPointer

◆ InitializerListType

template<typename T , std::size_t M, std::size_t N>
typedef std::initializer_list<std::initializer_list<T> > CDPL::Math::BoundedMatrix< T, M, N >::InitializerListType

Constructor & Destructor Documentation

◆ BoundedMatrix() [1/6]

template<typename T , std::size_t M, std::size_t N>
CDPL::Math::BoundedMatrix< T, M, N >::BoundedMatrix ( )
inline

◆ BoundedMatrix() [2/6]

template<typename T , std::size_t M, std::size_t N>
CDPL::Math::BoundedMatrix< T, M, N >::BoundedMatrix ( SizeType  m,
SizeType  n 
)
inline

◆ BoundedMatrix() [3/6]

template<typename T , std::size_t M, std::size_t N>
CDPL::Math::BoundedMatrix< T, M, N >::BoundedMatrix ( SizeType  m,
SizeType  n,
const ValueType v 
)
inline

◆ BoundedMatrix() [4/6]

template<typename T , std::size_t M, std::size_t N>
CDPL::Math::BoundedMatrix< T, M, N >::BoundedMatrix ( const BoundedMatrix< T, M, N > &  m)
inline

◆ BoundedMatrix() [5/6]

template<typename T , std::size_t M, std::size_t N>
CDPL::Math::BoundedMatrix< T, M, N >::BoundedMatrix ( InitializerListType  l)
inline

◆ BoundedMatrix() [6/6]

template<typename T , std::size_t M, std::size_t N>
template<typename E >
CDPL::Math::BoundedMatrix< T, M, N >::BoundedMatrix ( const MatrixExpression< E > &  e)
inline

Member Function Documentation

◆ operator()() [1/2]

template<typename T , std::size_t M, std::size_t N>
Reference CDPL::Math::BoundedMatrix< T, M, N >::operator() ( SizeType  i,
SizeType  j 
)
inline

◆ operator()() [2/2]

template<typename T , std::size_t M, std::size_t N>
ConstReference CDPL::Math::BoundedMatrix< T, M, N >::operator() ( SizeType  i,
SizeType  j 
) const
inline

◆ isEmpty()

template<typename T , std::size_t M, std::size_t N>
bool CDPL::Math::BoundedMatrix< T, M, N >::isEmpty ( ) const
inline

◆ getSize1()

template<typename T , std::size_t M, std::size_t N>
SizeType CDPL::Math::BoundedMatrix< T, M, N >::getSize1 ( ) const
inline

◆ getSize2()

template<typename T , std::size_t M, std::size_t N>
SizeType CDPL::Math::BoundedMatrix< T, M, N >::getSize2 ( ) const
inline

◆ getMaxSize1()

template<typename T , std::size_t M, std::size_t N>
SizeType CDPL::Math::BoundedMatrix< T, M, N >::getMaxSize1 ( ) const
inline

◆ getMaxSize2()

template<typename T , std::size_t M, std::size_t N>
SizeType CDPL::Math::BoundedMatrix< T, M, N >::getMaxSize2 ( ) const
inline

◆ getData() [1/2]

template<typename T , std::size_t M, std::size_t N>
ArrayPointer CDPL::Math::BoundedMatrix< T, M, N >::getData ( )
inline

◆ getData() [2/2]

template<typename T , std::size_t M, std::size_t N>
ConstArrayPointer CDPL::Math::BoundedMatrix< T, M, N >::getData ( ) const
inline

◆ operator=() [1/4]

template<typename T , std::size_t M, std::size_t N>
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::operator= ( const BoundedMatrix< T, M, N > &  m)
inline

◆ operator=() [2/4]

template<typename T , std::size_t M, std::size_t N>
template<typename C >
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::operator= ( const MatrixContainer< C > &  c)
inline

◆ operator=() [3/4]

template<typename T , std::size_t M, std::size_t N>
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::operator= ( InitializerListType  l)
inline

◆ operator=() [4/4]

template<typename T , std::size_t M, std::size_t N>
template<typename E >
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::operator= ( const MatrixExpression< E > &  e)
inline

◆ operator+=() [1/3]

template<typename T , std::size_t M, std::size_t N>
template<typename C >
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::operator+= ( const MatrixContainer< C > &  c)
inline

◆ operator+=() [2/3]

template<typename T , std::size_t M, std::size_t N>
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::operator+= ( InitializerListType  l)
inline

◆ operator+=() [3/3]

template<typename T , std::size_t M, std::size_t N>
template<typename E >
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::operator+= ( const MatrixExpression< E > &  e)
inline

◆ operator-=() [1/3]

template<typename T , std::size_t M, std::size_t N>
template<typename C >
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::operator-= ( const MatrixContainer< C > &  c)
inline

◆ operator-=() [2/3]

template<typename T , std::size_t M, std::size_t N>
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::operator-= ( InitializerListType  l)
inline

◆ operator-=() [3/3]

template<typename T , std::size_t M, std::size_t N>
template<typename E >
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::operator-= ( const MatrixExpression< E > &  e)
inline

◆ operator*=()

template<typename T , std::size_t M, std::size_t N>
template<typename T1 >
std::enable_if<IsScalar<T1>::value, BoundedMatrix>::type& CDPL::Math::BoundedMatrix< T, M, N >::operator*= ( const T1 &  v)
inline

◆ operator/=()

template<typename T , std::size_t M, std::size_t N>
template<typename T1 >
std::enable_if<IsScalar<T1>::value, BoundedMatrix>::type& CDPL::Math::BoundedMatrix< T, M, N >::operator/= ( const T1 &  v)
inline

◆ assign() [1/2]

template<typename T , std::size_t M, std::size_t N>
template<typename E >
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::assign ( const MatrixExpression< E > &  e)
inline

◆ assign() [2/2]

template<typename T , std::size_t M, std::size_t N>
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::assign ( InitializerListType  l)
inline

◆ plusAssign() [1/2]

template<typename T , std::size_t M, std::size_t N>
template<typename E >
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::plusAssign ( const MatrixExpression< E > &  e)
inline

◆ plusAssign() [2/2]

template<typename T , std::size_t M, std::size_t N>
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::plusAssign ( InitializerListType  l)
inline

◆ minusAssign() [1/2]

template<typename T , std::size_t M, std::size_t N>
template<typename E >
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::minusAssign ( const MatrixExpression< E > &  e)
inline

◆ minusAssign() [2/2]

template<typename T , std::size_t M, std::size_t N>
BoundedMatrix& CDPL::Math::BoundedMatrix< T, M, N >::minusAssign ( InitializerListType  l)
inline

◆ swap()

template<typename T , std::size_t M, std::size_t N>
void CDPL::Math::BoundedMatrix< T, M, N >::swap ( BoundedMatrix< T, M, N > &  m)
inline

◆ clear()

template<typename T , std::size_t M, std::size_t N>
void CDPL::Math::BoundedMatrix< T, M, N >::clear ( const ValueType v = ValueType())
inline

◆ resize() [1/2]

template<typename T , std::size_t M, std::size_t N>
void CDPL::Math::BoundedMatrix< T, M, N >::resize ( SizeType  m,
SizeType  n 
)
inline

◆ resize() [2/2]

template<typename T , std::size_t M, std::size_t N>
void CDPL::Math::BoundedMatrix< T, M, N >::resize ( SizeType  m,
SizeType  n,
const ValueType v 
)
inline

Friends And Related Function Documentation

◆ swap

template<typename T , std::size_t M, std::size_t N>
void swap ( BoundedMatrix< T, M, N > &  m1,
BoundedMatrix< T, M, N > &  m2 
)
friend

Member Data Documentation

◆ MaxSize1

template<typename T , std::size_t M, std::size_t N>
const BoundedMatrix< T, M, N >::SizeType CDPL::Math::BoundedMatrix< T, M, N >::MaxSize1 = M
static

◆ MaxSize2

template<typename T , std::size_t M, std::size_t N>
const BoundedMatrix< T, M, N >::SizeType CDPL::Math::BoundedMatrix< T, M, N >::MaxSize2 = N
static

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