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

#include <Grid.hpp>

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

Public Types
typedef T	ValueType
typedef T &	Reference
typedef const T &	ConstReference
typedef A::size_type	SizeType
typedef A::difference_type	DifferenceType
typedef A	ArrayType
typedef T *	Pointer
typedef const T *	ConstPointer
typedef GridReference< SelfType >	ClosureType
typedef const GridReference< const SelfType >	ConstClosureType
typedef SelfType	GridTemporaryType
typedef std::shared_ptr< SelfType >	SharedPointer
Public Types inherited from CDPL::Math::GridContainer< Grid< T, std::vector< T > > >
typedef Grid< T, std::vector< T > >	ContainerType
Public Types inherited from CDPL::Math::GridExpression< E >
typedef E	ExpressionType
Public Types inherited from CDPL::Math::Expression< E >
typedef E	ExpressionType

Public Member Functions
	Grid ()
	Grid (SizeType m, SizeType n, SizeType o)
	Grid (SizeType m, SizeType n, SizeType o, const ValueType &v)
	Grid (const Grid &g)
	Grid (Grid &&g)
template<typename E >
	Grid (const GridExpression< E > &e)
Reference	operator() (SizeType i)
ConstReference	operator() (SizeType i) const
Reference	operator() (SizeType i, SizeType j, SizeType k)
ConstReference	operator() (SizeType i, SizeType j, SizeType k) const
bool	isEmpty () const
SizeType	getSize () const
SizeType	getSize1 () const
SizeType	getSize2 () const
SizeType	getSize3 () const
SizeType	getMaxSize () const
ArrayType &	getData ()
const ArrayType &	getData () const
Grid &	operator= (const Grid &g)
Grid &	operator= (Grid &&g)
template<typename C >
Grid &	operator= (const GridContainer< C > &c)
template<typename E >
Grid &	operator= (const GridExpression< E > &e)
template<typename C >
Grid &	operator+= (const GridContainer< C > &c)
template<typename E >
Grid &	operator+= (const GridExpression< E > &e)
template<typename C >
Grid &	operator-= (const GridContainer< C > &c)
template<typename E >
Grid &	operator-= (const GridExpression< E > &e)
template<typename T1 >
std::enable_if< IsScalar< T1 >::value, Grid >::type &	operator*= (const T1 &t)
template<typename T1 >
std::enable_if< IsScalar< T1 >::value, Grid >::type &	operator/= (const T1 &t)
template<typename E >
Grid &	assign (const GridExpression< E > &e)
template<typename E >
Grid &	plusAssign (const GridExpression< E > &e)
template<typename E >
Grid &	minusAssign (const GridExpression< E > &e)
void	swap (Grid &g)
void	clear (const ValueType &v=ValueType())
void	resize (SizeType m, SizeType n, SizeType o, bool preserve=true, const ValueType &v=ValueType())
Public Member Functions inherited from CDPL::Math::GridContainer< Grid< T, std::vector< T > > >
const ContainerType &	operator() () const
ContainerType &	operator() ()
Public Member Functions inherited from CDPL::Math::GridExpression< E >
const ExpressionType &	operator() () const
ExpressionType &	operator() ()

Friends
void	swap (Grid &g1, Grid &g2)

Additional Inherited Members
Protected Member Functions inherited from CDPL::Math::GridContainer< Grid< T, std::vector< T > > >
	GridContainer ()
	~GridContainer ()
Protected Member Functions inherited from CDPL::Math::GridExpression< E >
	GridExpression ()
	~GridExpression ()
Protected Member Functions inherited from CDPL::Math::Expression< E >
	Expression ()
	~Expression ()

Member Typedef Documentation

ValueType

template<typename T , typename A = std::vector<T>>

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

Reference

template<typename T , typename A = std::vector<T>>

typedef T& CDPL::Math::Grid< T, A >::Reference

ConstReference

template<typename T , typename A = std::vector<T>>

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

SizeType

template<typename T , typename A = std::vector<T>>

typedef A::size_type CDPL::Math::Grid< T, A >::SizeType

DifferenceType

template<typename T , typename A = std::vector<T>>

typedef A::difference_type CDPL::Math::Grid< T, A >::DifferenceType

ArrayType

template<typename T , typename A = std::vector<T>>

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

Pointer

template<typename T , typename A = std::vector<T>>

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

ConstPointer

template<typename T , typename A = std::vector<T>>

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

ClosureType

template<typename T , typename A = std::vector<T>>

typedef GridReference<SelfType> CDPL::Math::Grid< T, A >::ClosureType

ConstClosureType

template<typename T , typename A = std::vector<T>>

typedef const GridReference<const SelfType> CDPL::Math::Grid< T, A >::ConstClosureType

GridTemporaryType

template<typename T , typename A = std::vector<T>>

typedef SelfType CDPL::Math::Grid< T, A >::GridTemporaryType

SharedPointer

template<typename T , typename A = std::vector<T>>

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

Constructor & Destructor Documentation

Grid() [1/6]

template<typename T , typename A = std::vector<T>>

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

inline

Grid() [2/6]

template<typename T , typename A = std::vector<T>>

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

inline

Grid() [3/6]

template<typename T , typename A = std::vector<T>>

CDPL::Math::Grid< T, A >::Grid ( SizeType  m, SizeType  n, SizeType  o, const ValueType &  v  )

inline

Grid() [4/6]

template<typename T , typename A = std::vector<T>>

CDPL::Math::Grid< T, A >::Grid ( const Grid< T, A > &  g )

inline

Grid() [5/6]

template<typename T , typename A = std::vector<T>>

CDPL::Math::Grid< T, A >::Grid ( Grid< T, A > &&  g )

inline

Grid() [6/6]

template<typename T , typename A = std::vector<T>>

template<typename E >

CDPL::Math::Grid< T, A >::Grid ( const GridExpression< E > &  e )

inline

Member Function Documentation

operator()() [1/4]

template<typename T , typename A = std::vector<T>>

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

inline

operator()() [2/4]

template<typename T , typename A = std::vector<T>>

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

inline

operator()() [3/4]

template<typename T , typename A = std::vector<T>>

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

inline

operator()() [4/4]

template<typename T , typename A = std::vector<T>>

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

inline

isEmpty()

template<typename T , typename A = std::vector<T>>

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

inline

getSize()

template<typename T , typename A = std::vector<T>>

SizeType CDPL::Math::Grid< T, A >::getSize ( ) const

inline

getSize1()

template<typename T , typename A = std::vector<T>>

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

inline

getSize2()

template<typename T , typename A = std::vector<T>>

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

inline

getSize3()

template<typename T , typename A = std::vector<T>>

SizeType CDPL::Math::Grid< T, A >::getSize3 ( ) const

inline

getMaxSize()

template<typename T , typename A = std::vector<T>>

SizeType CDPL::Math::Grid< T, A >::getMaxSize ( ) const

inline

getData() [1/2]

template<typename T , typename A = std::vector<T>>

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

inline

getData() [2/2]

template<typename T , typename A = std::vector<T>>

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

inline

operator=() [1/4]

template<typename T , typename A = std::vector<T>>

Grid& CDPL::Math::Grid< T, A >::operator= ( const Grid< T, A > &  g )

inline

operator=() [2/4]

template<typename T , typename A = std::vector<T>>

Grid& CDPL::Math::Grid< T, A >::operator= ( Grid< T, A > &&  g )

inline

operator=() [3/4]

template<typename T , typename A = std::vector<T>>

template<typename C >

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

inline

operator=() [4/4]

template<typename T , typename A = std::vector<T>>

template<typename E >

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

inline

operator+=() [1/2]

template<typename T , typename A = std::vector<T>>

template<typename C >

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

inline

operator+=() [2/2]

template<typename T , typename A = std::vector<T>>

template<typename E >

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

inline

operator-=() [1/2]

template<typename T , typename A = std::vector<T>>

template<typename C >

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

inline

operator-=() [2/2]

template<typename T , typename A = std::vector<T>>

template<typename E >

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

inline

operator*=()

template<typename T , typename A = std::vector<T>>

template<typename T1 >

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

inline

operator/=()

template<typename T , typename A = std::vector<T>>

template<typename T1 >

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

inline

assign()

template<typename T , typename A = std::vector<T>>

template<typename E >

Grid& CDPL::Math::Grid< T, A >::assign ( const GridExpression< E > &  e )

inline

plusAssign()

template<typename T , typename A = std::vector<T>>

template<typename E >

Grid& CDPL::Math::Grid< T, A >::plusAssign ( const GridExpression< E > &  e )

inline

minusAssign()

template<typename T , typename A = std::vector<T>>

template<typename E >

Grid& CDPL::Math::Grid< T, A >::minusAssign ( const GridExpression< E > &  e )

inline

swap()

template<typename T , typename A = std::vector<T>>

void CDPL::Math::Grid< T, A >::swap ( Grid< T, A > &  g )

inline

clear()

template<typename T , typename A = std::vector<T>>

void CDPL::Math::Grid< T, A >::clear ( const ValueType &  v = ValueType() )

inline

resize()

template<typename T , typename A = std::vector<T>>

void CDPL::Math::Grid< T, A >::resize ( SizeType  m, SizeType  n, SizeType  o, bool  preserve = true, const ValueType &  v = ValueType()  )

inline

Friends And Related Function Documentation

swap

template<typename T , typename A = std::vector<T>>

void swap ( Grid< T, A > &  g1, Grid< T, A > &  g2  )

friend

---

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

• Math/Grid.hpp