CDPL::Math::CMatrix< T, M, N > Class Template Reference

#include <Matrix.hpp>

Inheritance diagram for CDPL::Math::CMatrix< 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< SelfType >	ClosureType
typedef const MatrixReference< const SelfType >	ConstClosureType
typedef BoundedMatrix< T, M, N >	MatrixTemporaryType
typedef BoundedVector< T, M *N >	VectorTemporaryType
typedef std::shared_ptr< SelfType >	SharedPointer
typedef std::initializer_list< std::initializer_list< T > >	InitializerListType
Public Types inherited from CDPL::Math::MatrixContainer< CMatrix< T, M, N > >
typedef CMatrix< T, M, N >	ContainerType
Public Types inherited from CDPL::Math::MatrixExpression< CMatrix< T, M, N > >
typedef CMatrix< T, M, N >	ExpressionType
Public Types inherited from CDPL::Math::Expression< CMatrix< T, M, N > >
typedef CMatrix< T, M, N >	ExpressionType

Public Member Functions
	CMatrix ()
	CMatrix (const ValueType &v)
	CMatrix (const CMatrix &m)
	CMatrix (InitializerListType l)
template<typename E >
	CMatrix (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
CMatrix &	operator= (const CMatrix &m)
template<typename C >
CMatrix &	operator= (const MatrixContainer< C > &c)
template<typename T1 >
CMatrix &	operator= (InitializerListType l)
template<typename E >
CMatrix &	operator= (const MatrixExpression< E > &e)
template<typename C >
CMatrix &	operator+= (const MatrixContainer< C > &c)
CMatrix &	operator+= (InitializerListType l)
template<typename E >
CMatrix &	operator+= (const MatrixExpression< E > &e)
template<typename C >
CMatrix &	operator-= (const MatrixContainer< C > &c)
CMatrix &	operator-= (InitializerListType l)
template<typename E >
CMatrix &	operator-= (const MatrixExpression< E > &e)
template<typename T1 >
std::enable_if< IsScalar< T1 >::value, CMatrix >::type &	operator*= (const T1 &t)
template<typename T1 >
std::enable_if< IsScalar< T1 >::value, CMatrix >::type &	operator/= (const T1 &t)
template<typename E >
CMatrix &	assign (const MatrixExpression< E > &e)
CMatrix &	assign (InitializerListType l)
template<typename E >
CMatrix &	plusAssign (const MatrixExpression< E > &e)
CMatrix &	plusAssign (InitializerListType l)
template<typename E >
CMatrix &	minusAssign (const MatrixExpression< E > &e)
CMatrix &	minusAssign (InitializerListType l)
void	swap (CMatrix &m)
void	clear (const ValueType &v=ValueType())
Public Member Functions inherited from CDPL::Math::MatrixContainer< CMatrix< T, M, N > >
const ContainerType &	operator() () const
ContainerType &	operator() ()
Public Member Functions inherited from CDPL::Math::MatrixExpression< CMatrix< T, M, N > >
const ExpressionType &	operator() () const
ExpressionType &	operator() ()

Static Public Attributes
static const SizeType	Size1 = M
static const SizeType	Size2 = N

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

Additional Inherited Members
Protected Member Functions inherited from CDPL::Math::MatrixContainer< CMatrix< T, M, N > >
	MatrixContainer ()
	~MatrixContainer ()
Protected Member Functions inherited from CDPL::Math::MatrixExpression< CMatrix< T, M, N > >
	MatrixExpression ()
	~MatrixExpression ()
Protected Member Functions inherited from CDPL::Math::Expression< CMatrix< T, M, N > >
	Expression ()
	~Expression ()

Member Typedef Documentation

ValueType

template<typename T , std::size_t M, std::size_t N>

typedef T CDPL::Math::CMatrix< T, M, N >::ValueType

Reference

template<typename T , std::size_t M, std::size_t N>

typedef T& CDPL::Math::CMatrix< T, M, N >::Reference

ConstReference

template<typename T , std::size_t M, std::size_t N>

typedef const T& CDPL::Math::CMatrix< T, M, N >::ConstReference

SizeType

template<typename T , std::size_t M, std::size_t N>

typedef std::size_t CDPL::Math::CMatrix< T, M, N >::SizeType

DifferenceType

template<typename T , std::size_t M, std::size_t N>

typedef std::ptrdiff_t CDPL::Math::CMatrix< T, M, N >::DifferenceType

ArrayType

template<typename T , std::size_t M, std::size_t N>

typedef ValueType CDPL::Math::CMatrix< T, M, N >::ArrayType[M][N]

ArrayPointer

template<typename T , std::size_t M, std::size_t N>

typedef T(* CDPL::Math::CMatrix< T, M, N >::ArrayPointer)[N]

ConstArrayPointer

template<typename T , std::size_t M, std::size_t N>

typedef const T(* CDPL::Math::CMatrix< T, M, N >::ConstArrayPointer)[N]

Pointer

template<typename T , std::size_t M, std::size_t N>

typedef T* CDPL::Math::CMatrix< T, M, N >::Pointer

ConstPointer

template<typename T , std::size_t M, std::size_t N>

typedef const T* CDPL::Math::CMatrix< T, M, N >::ConstPointer

ClosureType

template<typename T , std::size_t M, std::size_t N>

typedef MatrixReference<SelfType> CDPL::Math::CMatrix< T, M, N >::ClosureType

ConstClosureType

template<typename T , std::size_t M, std::size_t N>

typedef const MatrixReference<const SelfType> CDPL::Math::CMatrix< T, M, N >::ConstClosureType

MatrixTemporaryType

template<typename T , std::size_t M, std::size_t N>

typedef BoundedMatrix<T, M, N> CDPL::Math::CMatrix< T, M, N >::MatrixTemporaryType

VectorTemporaryType

template<typename T , std::size_t M, std::size_t N>

typedef BoundedVector<T, M * N> CDPL::Math::CMatrix< T, M, N >::VectorTemporaryType

SharedPointer

template<typename T , std::size_t M, std::size_t N>

typedef std::shared_ptr<SelfType> CDPL::Math::CMatrix< 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::CMatrix< T, M, N >::InitializerListType

Constructor & Destructor Documentation

CMatrix() [1/5]

template<typename T , std::size_t M, std::size_t N>

CDPL::Math::CMatrix< T, M, N >::CMatrix ( )

inline

CMatrix() [2/5]

template<typename T , std::size_t M, std::size_t N>

CDPL::Math::CMatrix< T, M, N >::CMatrix ( const ValueType &  v )

inlineexplicit

CMatrix() [3/5]

template<typename T , std::size_t M, std::size_t N>

CDPL::Math::CMatrix< T, M, N >::CMatrix ( const CMatrix< T, M, N > &  m )

inline

CMatrix() [4/5]

template<typename T , std::size_t M, std::size_t N>

CDPL::Math::CMatrix< T, M, N >::CMatrix ( InitializerListType  l )

inline

CMatrix() [5/5]

template<typename T , std::size_t M, std::size_t N>

template<typename E >

CDPL::Math::CMatrix< T, M, N >::CMatrix ( 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::CMatrix< 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::CMatrix< 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::CMatrix< T, M, N >::isEmpty ( ) const

inline

getSize1()

template<typename T , std::size_t M, std::size_t N>

SizeType CDPL::Math::CMatrix< T, M, N >::getSize1 ( ) const

inline

getSize2()

template<typename T , std::size_t M, std::size_t N>

SizeType CDPL::Math::CMatrix< T, M, N >::getSize2 ( ) const

inline

getMaxSize1()

template<typename T , std::size_t M, std::size_t N>

SizeType CDPL::Math::CMatrix< T, M, N >::getMaxSize1 ( ) const

inline

getMaxSize2()

template<typename T , std::size_t M, std::size_t N>

SizeType CDPL::Math::CMatrix< T, M, N >::getMaxSize2 ( ) const

inline

getData() [1/2]

template<typename T , std::size_t M, std::size_t N>

ArrayPointer CDPL::Math::CMatrix< T, M, N >::getData ( )

inline

getData() [2/2]

template<typename T , std::size_t M, std::size_t N>

ConstArrayPointer CDPL::Math::CMatrix< T, M, N >::getData ( ) const

inline

operator=() [1/4]

template<typename T , std::size_t M, std::size_t N>

CMatrix& CDPL::Math::CMatrix< T, M, N >::operator= ( const CMatrix< T, M, N > &  m )

inline

operator=() [2/4]

template<typename T , std::size_t M, std::size_t N>

template<typename C >

CMatrix& CDPL::Math::CMatrix< T, M, N >::operator= ( const MatrixContainer< C > &  c )

inline

operator=() [3/4]

template<typename T , std::size_t M, std::size_t N>

template<typename T1 >

CMatrix& CDPL::Math::CMatrix< T, M, N >::operator= ( InitializerListType  l )

inline

operator=() [4/4]

template<typename T , std::size_t M, std::size_t N>

template<typename E >

CMatrix& CDPL::Math::CMatrix< 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 >

CMatrix& CDPL::Math::CMatrix< T, M, N >::operator+= ( const MatrixContainer< C > &  c )

inline

operator+=() [2/3]

template<typename T , std::size_t M, std::size_t N>

CMatrix& CDPL::Math::CMatrix< T, M, N >::operator+= ( InitializerListType  l )

inline

operator+=() [3/3]

template<typename T , std::size_t M, std::size_t N>

template<typename E >

CMatrix& CDPL::Math::CMatrix< 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 >

CMatrix& CDPL::Math::CMatrix< T, M, N >::operator-= ( const MatrixContainer< C > &  c )

inline

operator-=() [2/3]

template<typename T , std::size_t M, std::size_t N>

CMatrix& CDPL::Math::CMatrix< T, M, N >::operator-= ( InitializerListType  l )

inline

operator-=() [3/3]

template<typename T , std::size_t M, std::size_t N>

template<typename E >

CMatrix& CDPL::Math::CMatrix< 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, CMatrix>::type& CDPL::Math::CMatrix< T, M, N >::operator*= ( const T1 &  t )

inline

operator/=()

template<typename T , std::size_t M, std::size_t N>

template<typename T1 >

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

inline

assign() [1/2]

template<typename T , std::size_t M, std::size_t N>

template<typename E >

CMatrix& CDPL::Math::CMatrix< T, M, N >::assign ( const MatrixExpression< E > &  e )

inline

assign() [2/2]

template<typename T , std::size_t M, std::size_t N>

CMatrix& CDPL::Math::CMatrix< T, M, N >::assign ( InitializerListType  l )

inline

plusAssign() [1/2]

template<typename T , std::size_t M, std::size_t N>

template<typename E >

CMatrix& CDPL::Math::CMatrix< T, M, N >::plusAssign ( const MatrixExpression< E > &  e )

inline

plusAssign() [2/2]

template<typename T , std::size_t M, std::size_t N>

CMatrix& CDPL::Math::CMatrix< T, M, N >::plusAssign ( InitializerListType  l )

inline

minusAssign() [1/2]

template<typename T , std::size_t M, std::size_t N>

template<typename E >

CMatrix& CDPL::Math::CMatrix< T, M, N >::minusAssign ( const MatrixExpression< E > &  e )

inline

minusAssign() [2/2]

template<typename T , std::size_t M, std::size_t N>

CMatrix& CDPL::Math::CMatrix< T, M, N >::minusAssign ( InitializerListType  l )

inline

swap()

template<typename T , std::size_t M, std::size_t N>

void CDPL::Math::CMatrix< T, M, N >::swap ( CMatrix< T, M, N > &  m )

inline

clear()

template<typename T , std::size_t M, std::size_t N>

void CDPL::Math::CMatrix< T, M, N >::clear ( const ValueType &  v = ValueType() )

inline

Friends And Related Function Documentation

swap

template<typename T , std::size_t M, std::size_t N>

void swap ( CMatrix< T, M, N > &  m1, CMatrix< T, M, N > &  m2  )

friend

Member Data Documentation

Size1

template<typename T , std::size_t M, std::size_t N>

const CMatrix< T, M, N >::SizeType CDPL::Math::CMatrix< T, M, N >::Size1 = M

static

Size2

template<typename T , std::size_t M, std::size_t N>

const CMatrix< T, M, N >::SizeType CDPL::Math::CMatrix< T, M, N >::Size2 = N

static

---

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

• Matrix.hpp