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::CVector< T, N > Class Template Reference

#include <Vector.hpp>

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[N]
 
typedef T * Pointer
 
typedef const T * ConstPointer
 
typedef VectorReference< SelfTypeClosureType
 
typedef const VectorReference< const SelfTypeConstClosureType
 
typedef BoundedVector< T, N+1 > VectorTemporaryType
 
typedef std::shared_ptr< SelfTypeSharedPointer
 
typedef std::initializer_list< T > InitializerListType
 

Public Member Functions

 CVector ()
 
 CVector (const ValueType &v)
 
 CVector (const CVector &v)
 
 CVector (InitializerListType l)
 
template<typename E >
 CVector (const VectorExpression< E > &e)
 
Reference operator[] (SizeType i)
 
ConstReference operator[] (SizeType i) const
 
Reference operator() (SizeType i)
 
ConstReference operator() (SizeType i) const
 
bool isEmpty () const
 
SizeType getSize () const
 
SizeType getMaxSize () const
 
Pointer getData ()
 
ConstPointer getData () const
 
CVectoroperator= (const CVector &v)
 
CVectoroperator= (InitializerListType l)
 
template<typename C >
CVectoroperator= (const VectorContainer< C > &c)
 
template<typename E >
CVectoroperator= (const VectorExpression< E > &e)
 
template<typename C >
CVectoroperator+= (const VectorContainer< C > &c)
 
CVectoroperator+= (InitializerListType l)
 
template<typename E >
CVectoroperator+= (const VectorExpression< E > &e)
 
template<typename C >
CVectoroperator-= (const VectorContainer< C > &c)
 
CVectoroperator-= (InitializerListType l)
 
template<typename E >
CVectoroperator-= (const VectorExpression< E > &e)
 
template<typename T1 >
std::enable_if< IsScalar< T1 >::value, CVector >::type & operator*= (const T1 &t)
 
template<typename T1 >
std::enable_if< IsScalar< T1 >::value, CVector >::type & operator/= (const T1 &t)
 
template<typename E >
CVectorassign (const VectorExpression< E > &e)
 
CVectorassign (InitializerListType l)
 
template<typename E >
CVectorplusAssign (const VectorExpression< E > &e)
 
CVectorplusAssign (InitializerListType l)
 
template<typename E >
CVectorminusAssign (const VectorExpression< E > &e)
 
CVectorminusAssign (InitializerListType l)
 
void swap (CVector &v)
 
void clear (const ValueType &v=ValueType())
 

Static Public Attributes

static const SizeType Size = N
 

Friends

void swap (CVector &v1, CVector &v2)
 

Member Typedef Documentation

◆ ValueType

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

◆ Reference

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

◆ ConstReference

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

◆ SizeType

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

◆ DifferenceType

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

◆ ArrayType

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

◆ Pointer

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

◆ ConstPointer

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

◆ ClosureType

template<typename T , std::size_t N>
typedef VectorReference<SelfType> CDPL::Math::CVector< T, N >::ClosureType

◆ ConstClosureType

template<typename T , std::size_t N>
typedef const VectorReference<const SelfType> CDPL::Math::CVector< T, N >::ConstClosureType

◆ VectorTemporaryType

template<typename T , std::size_t N>
typedef BoundedVector<T, N + 1> CDPL::Math::CVector< T, N >::VectorTemporaryType

◆ SharedPointer

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

◆ InitializerListType

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

Constructor & Destructor Documentation

◆ CVector() [1/5]

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

◆ CVector() [2/5]

template<typename T , std::size_t N>
CDPL::Math::CVector< T, N >::CVector ( const ValueType v)
inlineexplicit

◆ CVector() [3/5]

template<typename T , std::size_t N>
CDPL::Math::CVector< T, N >::CVector ( const CVector< T, N > &  v)
inline

◆ CVector() [4/5]

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

◆ CVector() [5/5]

template<typename T , std::size_t N>
template<typename E >
CDPL::Math::CVector< T, N >::CVector ( const VectorExpression< E > &  e)
inline

Member Function Documentation

◆ operator[]() [1/2]

template<typename T , std::size_t N>
Reference CDPL::Math::CVector< T, N >::operator[] ( SizeType  i)
inline

◆ operator[]() [2/2]

template<typename T , std::size_t N>
ConstReference CDPL::Math::CVector< T, N >::operator[] ( SizeType  i) const
inline

◆ operator()() [1/2]

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

◆ operator()() [2/2]

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

◆ isEmpty()

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

◆ getSize()

template<typename T , std::size_t N>
SizeType CDPL::Math::CVector< T, N >::getSize ( ) const
inline

◆ getMaxSize()

template<typename T , std::size_t N>
SizeType CDPL::Math::CVector< T, N >::getMaxSize ( ) const
inline

◆ getData() [1/2]

template<typename T , std::size_t N>
Pointer CDPL::Math::CVector< T, N >::getData ( )
inline

◆ getData() [2/2]

template<typename T , std::size_t N>
ConstPointer CDPL::Math::CVector< T, N >::getData ( ) const
inline

◆ operator=() [1/4]

template<typename T , std::size_t N>
CVector& CDPL::Math::CVector< T, N >::operator= ( const CVector< T, N > &  v)
inline

◆ operator=() [2/4]

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

◆ operator=() [3/4]

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

◆ operator=() [4/4]

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

◆ operator+=() [1/3]

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

◆ operator+=() [2/3]

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

◆ operator+=() [3/3]

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

◆ operator-=() [1/3]

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

◆ operator-=() [2/3]

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

◆ operator-=() [3/3]

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

◆ operator*=()

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

◆ operator/=()

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

◆ assign() [1/2]

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

◆ assign() [2/2]

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

◆ plusAssign() [1/2]

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

◆ plusAssign() [2/2]

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

◆ minusAssign() [1/2]

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

◆ minusAssign() [2/2]

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

◆ swap()

template<typename T , std::size_t N>
void CDPL::Math::CVector< T, N >::swap ( CVector< T, N > &  v)
inline

◆ clear()

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

Friends And Related Function Documentation

◆ swap

template<typename T , std::size_t N>
void swap ( CVector< T, N > &  v1,
CVector< T, N > &  v2 
)
friend

Member Data Documentation

◆ Size

template<typename T , std::size_t N>
const CVector< T, N >::SizeType CDPL::Math::CVector< T, N >::Size = N
static

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