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< SelfTypeClosureType
 
typedef const VectorReference< const SelfTypeConstClosureType
 
typedef SelfType VectorTemporaryType
 
typedef std::shared_ptr< SelfTypeSharedPointer
 
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
 
ArrayTypegetData ()
 
const ArrayTypegetData () const
 
Vectoroperator= (const Vector &v)
 
Vectoroperator= (Vector &&v)
 
Vectoroperator= (InitializerListType l)
 
template<typename C >
Vectoroperator= (const VectorContainer< C > &c)
 
template<typename E >
Vectoroperator= (const VectorExpression< E > &e)
 
template<typename C >
Vectoroperator+= (const VectorContainer< C > &c)
 
Vectoroperator+= (InitializerListType l)
 
template<typename E >
Vectoroperator+= (const VectorExpression< E > &e)
 
template<typename C >
Vectoroperator-= (const VectorContainer< C > &c)
 
Vectoroperator-= (InitializerListType l)
 
template<typename E >
Vectoroperator-= (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 >
Vectorassign (const VectorExpression< E > &e)
 
Vectorassign (InitializerListType l)
 
template<typename E >
VectorplusAssign (const VectorExpression< E > &e)
 
VectorplusAssign (InitializerListType l)
 
template<typename E >
VectorminusAssign (const VectorExpression< E > &e)
 
VectorminusAssign (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: