Chemical Data Processing Library C++ API - Version 1.1.1
Public Types | Public Member Functions | Friends | List of all members
CDPL::Math::Vector< T, A > Class Template Reference

#include <Vector.hpp>

+ Inheritance diagram for CDPL::Math::Vector< 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 VectorReference< SelfType > ClosureType
 
typedef const VectorReference< const SelfType > ConstClosureType
 
typedef SelfType VectorTemporaryType
 
typedef std::shared_ptr< SelfType > SharedPointer
 
typedef std::initializer_list< T > InitializerListType
 

Public Member Functions

 Vector ()
 
 Vector (SizeType n)
 
 Vector (SizeType n, const ValueType &v)
 
 Vector (const ArrayType &data)
 
 Vector (const Vector &v)
 
 Vector (Vector &&v)
 
 Vector (InitializerListType l)
 
template<typename E >
 Vector (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
 
ArrayType & getData ()
 
const ArrayType & getData () const
 
Vector & operator= (const Vector &v)
 
Vector & operator= (Vector &&v)
 
Vector & operator= (InitializerListType l)
 
template<typename C >
Vector & operator= (const VectorContainer< C > &c)
 
template<typename E >
Vector & operator= (const VectorExpression< E > &e)
 
template<typename C >
Vector & operator+= (const VectorContainer< C > &c)
 
Vector & operator+= (InitializerListType l)
 
template<typename E >
Vector & operator+= (const VectorExpression< E > &e)
 
template<typename C >
Vector & operator-= (const VectorContainer< C > &c)
 
Vector & operator-= (InitializerListType l)
 
template<typename E >
Vector & operator-= (const VectorExpression< E > &e)
 
template<typename T1 >
std::enable_if< IsScalar< T1 >::value, Vector >::type & operator*= (const T1 &t)
 
template<typename T1 >
std::enable_if< IsScalar< T1 >::value, Vector >::type & operator/= (const T1 &t)
 
template<typename E >
Vector & assign (const VectorExpression< E > &e)
 
Vector & assign (InitializerListType l)
 
template<typename E >
Vector & plusAssign (const VectorExpression< E > &e)
 
Vector & plusAssign (InitializerListType l)
 
template<typename E >
Vector & minusAssign (const VectorExpression< E > &e)
 
Vector & minusAssign (InitializerListType l)
 
void swap (Vector &v)
 
void clear (const ValueType &v=ValueType())
 
void resize (SizeType n, const ValueType &v=ValueType())
 

Friends

void swap (Vector &v1, Vector &v2)
 

Member Typedef Documentation

◆ ValueType

template<typename T , typename A = std::vector<T>>
typedef T CDPL::Math::Vector< T, A >::ValueType

◆ Reference

template<typename T , typename A = std::vector<T>>
typedef T& CDPL::Math::Vector< T, A >::Reference

◆ ConstReference

template<typename T , typename A = std::vector<T>>
typedef const T& CDPL::Math::Vector< T, A >::ConstReference

◆ SizeType

template<typename T , typename A = std::vector<T>>
typedef A::size_type CDPL::Math::Vector< T, A >::SizeType

◆ DifferenceType

template<typename T , typename A = std::vector<T>>
typedef A::difference_type CDPL::Math::Vector< T, A >::DifferenceType

◆ ArrayType

template<typename T , typename A = std::vector<T>>
typedef A CDPL::Math::Vector< T, A >::ArrayType

◆ Pointer

template<typename T , typename A = std::vector<T>>
typedef T* CDPL::Math::Vector< T, A >::Pointer

◆ ConstPointer

template<typename T , typename A = std::vector<T>>
typedef const T* CDPL::Math::Vector< T, A >::ConstPointer

◆ ClosureType

template<typename T , typename A = std::vector<T>>
typedef VectorReference<SelfType> CDPL::Math::Vector< T, A >::ClosureType

◆ ConstClosureType

template<typename T , typename A = std::vector<T>>
typedef const VectorReference<const SelfType> CDPL::Math::Vector< T, A >::ConstClosureType

◆ VectorTemporaryType

template<typename T , typename A = std::vector<T>>
typedef SelfType CDPL::Math::Vector< T, A >::VectorTemporaryType

◆ SharedPointer

template<typename T , typename A = std::vector<T>>
typedef std::shared_ptr<SelfType> CDPL::Math::Vector< T, A >::SharedPointer

◆ InitializerListType

template<typename T , typename A = std::vector<T>>
typedef std::initializer_list<T> CDPL::Math::Vector< T, A >::InitializerListType

Constructor & Destructor Documentation

◆ Vector() [1/8]

template<typename T , typename A = std::vector<T>>
CDPL::Math::Vector< T, A >::Vector ( )
inline

◆ Vector() [2/8]

template<typename T , typename A = std::vector<T>>
CDPL::Math::Vector< T, A >::Vector ( SizeType  n)
inlineexplicit

◆ Vector() [3/8]

template<typename T , typename A = std::vector<T>>
CDPL::Math::Vector< T, A >::Vector ( SizeType  n,
const ValueType &  v 
)
inline

◆ Vector() [4/8]

template<typename T , typename A = std::vector<T>>
CDPL::Math::Vector< T, A >::Vector ( const ArrayType &  data)
inline

◆ Vector() [5/8]

template<typename T , typename A = std::vector<T>>
CDPL::Math::Vector< T, A >::Vector ( const Vector< T, A > &  v)
inline

◆ Vector() [6/8]

template<typename T , typename A = std::vector<T>>
CDPL::Math::Vector< T, A >::Vector ( Vector< T, A > &&  v)
inline

◆ Vector() [7/8]

template<typename T , typename A = std::vector<T>>
CDPL::Math::Vector< T, A >::Vector ( InitializerListType  l)
inline

◆ Vector() [8/8]

template<typename T , typename A = std::vector<T>>
template<typename E >
CDPL::Math::Vector< T, A >::Vector ( const VectorExpression< E > &  e)
inline

Member Function Documentation

◆ operator[]() [1/2]

template<typename T , typename A = std::vector<T>>
Reference CDPL::Math::Vector< T, A >::operator[] ( SizeType  i)
inline

◆ operator[]() [2/2]

template<typename T , typename A = std::vector<T>>
ConstReference CDPL::Math::Vector< T, A >::operator[] ( SizeType  i) const
inline

◆ operator()() [1/2]

template<typename T , typename A = std::vector<T>>
Reference CDPL::Math::Vector< T, A >::operator() ( SizeType  i)
inline

◆ operator()() [2/2]

template<typename T , typename A = std::vector<T>>
ConstReference CDPL::Math::Vector< T, A >::operator() ( SizeType  i) const
inline

◆ isEmpty()

template<typename T , typename A = std::vector<T>>
bool CDPL::Math::Vector< T, A >::isEmpty ( ) const
inline

◆ getSize()

template<typename T , typename A = std::vector<T>>
SizeType CDPL::Math::Vector< T, A >::getSize ( ) const
inline

◆ getMaxSize()

template<typename T , typename A = std::vector<T>>
SizeType CDPL::Math::Vector< T, A >::getMaxSize ( ) const
inline

◆ getData() [1/2]

template<typename T , typename A = std::vector<T>>
ArrayType& CDPL::Math::Vector< T, A >::getData ( )
inline

◆ getData() [2/2]

template<typename T , typename A = std::vector<T>>
const ArrayType& CDPL::Math::Vector< T, A >::getData ( ) const
inline

◆ operator=() [1/5]

template<typename T , typename A = std::vector<T>>
Vector& CDPL::Math::Vector< T, A >::operator= ( const Vector< T, A > &  v)
inline

◆ operator=() [2/5]

template<typename T , typename A = std::vector<T>>
Vector& CDPL::Math::Vector< T, A >::operator= ( Vector< T, A > &&  v)
inline

◆ operator=() [3/5]

template<typename T , typename A = std::vector<T>>
Vector& CDPL::Math::Vector< T, A >::operator= ( InitializerListType  l)
inline

◆ operator=() [4/5]

template<typename T , typename A = std::vector<T>>
template<typename C >
Vector& CDPL::Math::Vector< T, A >::operator= ( const VectorContainer< C > &  c)
inline

◆ operator=() [5/5]

template<typename T , typename A = std::vector<T>>
template<typename E >
Vector& CDPL::Math::Vector< T, A >::operator= ( const VectorExpression< E > &  e)
inline

◆ operator+=() [1/3]

template<typename T , typename A = std::vector<T>>
template<typename C >
Vector& CDPL::Math::Vector< T, A >::operator+= ( const VectorContainer< C > &  c)
inline

◆ operator+=() [2/3]

template<typename T , typename A = std::vector<T>>
Vector& CDPL::Math::Vector< T, A >::operator+= ( InitializerListType  l)
inline

◆ operator+=() [3/3]

template<typename T , typename A = std::vector<T>>
template<typename E >
Vector& CDPL::Math::Vector< T, A >::operator+= ( const VectorExpression< E > &  e)
inline

◆ operator-=() [1/3]

template<typename T , typename A = std::vector<T>>
template<typename C >
Vector& CDPL::Math::Vector< T, A >::operator-= ( const VectorContainer< C > &  c)
inline

◆ operator-=() [2/3]

template<typename T , typename A = std::vector<T>>
Vector& CDPL::Math::Vector< T, A >::operator-= ( InitializerListType  l)
inline

◆ operator-=() [3/3]

template<typename T , typename A = std::vector<T>>
template<typename E >
Vector& CDPL::Math::Vector< T, A >::operator-= ( const VectorExpression< E > &  e)
inline

◆ operator*=()

template<typename T , typename A = std::vector<T>>
template<typename T1 >
std::enable_if<IsScalar<T1>::value, Vector>::type& CDPL::Math::Vector< 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, Vector>::type& CDPL::Math::Vector< T, A >::operator/= ( const T1 &  t)
inline

◆ assign() [1/2]

template<typename T , typename A = std::vector<T>>
template<typename E >
Vector& CDPL::Math::Vector< T, A >::assign ( const VectorExpression< E > &  e)
inline

◆ assign() [2/2]

template<typename T , typename A = std::vector<T>>
Vector& CDPL::Math::Vector< T, A >::assign ( InitializerListType  l)
inline

◆ plusAssign() [1/2]

template<typename T , typename A = std::vector<T>>
template<typename E >
Vector& CDPL::Math::Vector< T, A >::plusAssign ( const VectorExpression< E > &  e)
inline

◆ plusAssign() [2/2]

template<typename T , typename A = std::vector<T>>
Vector& CDPL::Math::Vector< T, A >::plusAssign ( InitializerListType  l)
inline

◆ minusAssign() [1/2]

template<typename T , typename A = std::vector<T>>
template<typename E >
Vector& CDPL::Math::Vector< T, A >::minusAssign ( const VectorExpression< E > &  e)
inline

◆ minusAssign() [2/2]

template<typename T , typename A = std::vector<T>>
Vector& CDPL::Math::Vector< T, A >::minusAssign ( InitializerListType  l)
inline

◆ swap()

template<typename T , typename A = std::vector<T>>
void CDPL::Math::Vector< T, A >::swap ( Vector< T, A > &  v)
inline

◆ clear()

template<typename T , typename A = std::vector<T>>
void CDPL::Math::Vector< T, A >::clear ( const ValueType &  v = ValueType())
inline

◆ resize()

template<typename T , typename A = std::vector<T>>
void CDPL::Math::Vector< T, A >::resize ( SizeType  n,
const ValueType &  v = ValueType() 
)
inline

Friends And Related Function Documentation

◆ swap

template<typename T , typename A = std::vector<T>>
void swap ( Vector< T, A > &  v1,
Vector< T, A > &  v2 
)
friend
The documentation for this class was generated from the following files:
Generated by doxygen 1.8.20