Chemical Data Processing Library C++ API - Version 1.1.1: CDPL::Math::CVector< T, N > Class Template Reference

Chemical Data Processing Library C++ API - Version 1.1.1

#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< SelfType >	ClosureType

typedef const VectorReference< const SelfType >	ConstClosureType

typedef BoundedVector< T, N+1 >	VectorTemporaryType

typedef std::shared_ptr< SelfType >	SharedPointer

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

CVector &	operator= (const CVector &v)

CVector &	operator= (InitializerListType l)

template<typename C >
CVector &	operator= (const VectorContainer< C > &c)

template<typename E >
CVector &	operator= (const VectorExpression< E > &e)

template<typename C >
CVector &	operator+= (const VectorContainer< C > &c)

CVector &	operator+= (InitializerListType l)

template<typename E >
CVector &	operator+= (const VectorExpression< E > &e)

template<typename C >
CVector &	operator-= (const VectorContainer< C > &c)

CVector &	operator-= (InitializerListType l)

template<typename E >
CVector &	operator-= (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 >
CVector &	assign (const VectorExpression< E > &e)

CVector &	assign (InitializerListType l)

template<typename E >
CVector &	plusAssign (const VectorExpression< E > &e)

CVector &	plusAssign (InitializerListType l)

template<typename E >
CVector &	minusAssign (const VectorExpression< E > &e)

CVector &	minusAssign (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: