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< SelfType >	ClosureType
typedef const MatrixReference< const SelfType >	ConstClosureType
typedef SelfType	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< 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
BoundedMatrix &	operator= (const BoundedMatrix &m)
template<typename C >
BoundedMatrix &	operator= (const MatrixContainer< C > &c)
BoundedMatrix &	operator= (InitializerListType l)
template<typename E >
BoundedMatrix &	operator= (const MatrixExpression< E > &e)
template<typename C >
BoundedMatrix &	operator+= (const MatrixContainer< C > &c)
BoundedMatrix &	operator+= (InitializerListType l)
template<typename E >
BoundedMatrix &	operator+= (const MatrixExpression< E > &e)
template<typename C >
BoundedMatrix &	operator-= (const MatrixContainer< C > &c)
BoundedMatrix &	operator-= (InitializerListType l)
template<typename E >
BoundedMatrix &	operator-= (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 >
BoundedMatrix &	assign (const MatrixExpression< E > &e)
BoundedMatrix &	assign (InitializerListType l)
template<typename E >
BoundedMatrix &	plusAssign (const MatrixExpression< E > &e)
BoundedMatrix &	plusAssign (InitializerListType l)
template<typename E >
BoundedMatrix &	minusAssign (const MatrixExpression< E > &e)
BoundedMatrix &	minusAssign (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 ContainerType &	operator() () const
ContainerType &	operator() ()
Public Member Functions inherited from CDPL::Math::MatrixExpression< BoundedMatrix< T, M, N > >
const ExpressionType &	operator() () const
ExpressionType &	operator() ()

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:

• Matrix.hpp