Chemical Data Processing Library C++ API - Version 1.1.1
Public Types | Public Member Functions | Friends | List of all members
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< Grid< T, std::vector< T > > >
typedef Grid< T, std::vector< T > > ExpressionType
 
- Public Types inherited from CDPL::Math::Expression< Grid< T, std::vector< T > > >
typedef Grid< T, std::vector< T > > 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< Grid< T, std::vector< T > > >
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< Grid< T, std::vector< T > > >
 GridExpression ()
 
 ~GridExpression ()
 
- Protected Member Functions inherited from CDPL::Math::Expression< Grid< T, std::vector< T > > >
 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:
Generated by doxygen 1.8.20