ECOGEN 6.0
Evolutive, Compressible, Open, Genuine, Easy, N-phase
Loading...
Searching...
No Matches
math::vector< T, N > Class Template Reference

#include <vector.hpp>

Public Types

using data_type = std::array<T, N>
using value_type = typename data_type::value_type
using size_type = typename data_type::size_type
using difference_type = typename data_type::difference_type
using reference = typename data_type::reference
using const_reference = typename data_type::const_reference
using pointer = typename data_type::pointer
using const_pointer = typename data_type::const_pointer
using iterator = typename data_type::iterator
using const_iterator = typename data_type::const_iterator
using reverse_iterator = typename data_type::reverse_iterator
using const_reverse_iterator = typename data_type::const_reverse_iterator

Public Member Functions

 vector ()=default
 vector (const T &element)
 vector (const vector &)=default
 vector (vector &&)=default
 vector (const T *ptr)
template<typename T2>
 vector (const vector< T2, N > &other)
 vector (const std::array< T, N > &_data)
 vector (std::array< T, N > &&_data)
vector & operator= (const vector &) &=default
vector & operator= (vector &&) &=default
vector & operator= (const T &element) &
reference operator[] (size_type pos)
const_reference operator[] (size_type pos) const
reference operator() (size_type i)
const_reference operator() (size_type i) const
reference front ()
const_reference front () const
reference back ()
const_reference back () const
reference x ()
const_reference x () const
reference y ()
const_reference y () const
reference z ()
const_reference z () const
reference w ()
const_reference w () const
iterator begin ()
const_iterator begin () const
const_iterator cbegin () const
iterator end ()
const_iterator end () const
const_iterator cend () const
reverse_iterator rbegin ()
const_reverse_iterator rbegin () const
const_reverse_iterator crbegin () const
reverse_iterator rend ()
const_reverse_iterator rend () const
const_reverse_iterator crend () const
vector & operator+= (const vector &other)
vector & operator+= (const T &element)
vector & operator-= (const vector &other)
vector & operator-= (const T &element)
vector & operator*= (const vector &other)
vector & operator*= (const T &element)
vector & operator/= (const vector &other)
vector & operator/= (const T &element)

Static Public Member Functions

static constexpr std::size_t size ()

Public Attributes

data_type data

Friends

std::ostream & operator<< (std::ostream &os, const vector &v)

Member Typedef Documentation

◆ const_iterator

template<typename T, std::size_t N>
using math::vector< T, N >::const_iterator = typename data_type::const_iterator

◆ const_pointer

template<typename T, std::size_t N>
using math::vector< T, N >::const_pointer = typename data_type::const_pointer

◆ const_reference

template<typename T, std::size_t N>
using math::vector< T, N >::const_reference = typename data_type::const_reference

◆ const_reverse_iterator

template<typename T, std::size_t N>
using math::vector< T, N >::const_reverse_iterator = typename data_type::const_reverse_iterator

◆ data_type

template<typename T, std::size_t N>
using math::vector< T, N >::data_type = std::array<T, N>

◆ difference_type

template<typename T, std::size_t N>
using math::vector< T, N >::difference_type = typename data_type::difference_type

◆ iterator

template<typename T, std::size_t N>
using math::vector< T, N >::iterator = typename data_type::iterator

◆ pointer

template<typename T, std::size_t N>
using math::vector< T, N >::pointer = typename data_type::pointer

◆ reference

template<typename T, std::size_t N>
using math::vector< T, N >::reference = typename data_type::reference

◆ reverse_iterator

template<typename T, std::size_t N>
using math::vector< T, N >::reverse_iterator = typename data_type::reverse_iterator

◆ size_type

template<typename T, std::size_t N>
using math::vector< T, N >::size_type = typename data_type::size_type

◆ value_type

template<typename T, std::size_t N>
using math::vector< T, N >::value_type = typename data_type::value_type

Constructor & Destructor Documentation

◆ vector() [1/8]

template<typename T, std::size_t N>
math::vector< T, N >::vector ( )
default

◆ vector() [2/8]

template<typename T, std::size_t N>
math::vector< T, N >::vector ( const T & element)
inline

◆ vector() [3/8]

template<typename T, std::size_t N>
math::vector< T, N >::vector ( const vector< T, N > & )
default

◆ vector() [4/8]

template<typename T, std::size_t N>
math::vector< T, N >::vector ( vector< T, N > && )
default

◆ vector() [5/8]

template<typename T, std::size_t N>
math::vector< T, N >::vector ( const T * ptr)
inlineexplicit

◆ vector() [6/8]

template<typename T, std::size_t N>
template<typename T2>
math::vector< T, N >::vector ( const vector< T2, N > & other)
inline

◆ vector() [7/8]

template<typename T, std::size_t N>
math::vector< T, N >::vector ( const std::array< T, N > & _data)
inline

◆ vector() [8/8]

template<typename T, std::size_t N>
math::vector< T, N >::vector ( std::array< T, N > && _data)
inline

Member Function Documentation

◆ back() [1/2]

template<typename T, std::size_t N>
reference math::vector< T, N >::back ( )
inline

◆ back() [2/2]

template<typename T, std::size_t N>
const_reference math::vector< T, N >::back ( ) const
inline

◆ begin() [1/2]

template<typename T, std::size_t N>
iterator math::vector< T, N >::begin ( )
inline

◆ begin() [2/2]

template<typename T, std::size_t N>
const_iterator math::vector< T, N >::begin ( ) const
inline

◆ cbegin()

template<typename T, std::size_t N>
const_iterator math::vector< T, N >::cbegin ( ) const
inline

◆ cend()

template<typename T, std::size_t N>
const_iterator math::vector< T, N >::cend ( ) const
inline

◆ crbegin()

template<typename T, std::size_t N>
const_reverse_iterator math::vector< T, N >::crbegin ( ) const
inline

◆ crend()

template<typename T, std::size_t N>
const_reverse_iterator math::vector< T, N >::crend ( ) const
inline

◆ end() [1/2]

template<typename T, std::size_t N>
iterator math::vector< T, N >::end ( )
inline

◆ end() [2/2]

template<typename T, std::size_t N>
const_iterator math::vector< T, N >::end ( ) const
inline

◆ front() [1/2]

template<typename T, std::size_t N>
reference math::vector< T, N >::front ( )
inline

◆ front() [2/2]

template<typename T, std::size_t N>
const_reference math::vector< T, N >::front ( ) const
inline

◆ operator()() [1/2]

template<typename T, std::size_t N>
reference math::vector< T, N >::operator() ( size_type i)
inline

◆ operator()() [2/2]

template<typename T, std::size_t N>
const_reference math::vector< T, N >::operator() ( size_type i) const
inline

◆ operator*=() [1/2]

template<typename T, std::size_t N>
vector & math::vector< T, N >::operator*= ( const T & element)
inline

◆ operator*=() [2/2]

template<typename T, std::size_t N>
vector & math::vector< T, N >::operator*= ( const vector< T, N > & other)
inline

◆ operator+=() [1/2]

template<typename T, std::size_t N>
vector & math::vector< T, N >::operator+= ( const T & element)
inline

◆ operator+=() [2/2]

template<typename T, std::size_t N>
vector & math::vector< T, N >::operator+= ( const vector< T, N > & other)
inline

◆ operator-=() [1/2]

template<typename T, std::size_t N>
vector & math::vector< T, N >::operator-= ( const T & element)
inline

◆ operator-=() [2/2]

template<typename T, std::size_t N>
vector & math::vector< T, N >::operator-= ( const vector< T, N > & other)
inline

◆ operator/=() [1/2]

template<typename T, std::size_t N>
vector & math::vector< T, N >::operator/= ( const T & element)
inline

◆ operator/=() [2/2]

template<typename T, std::size_t N>
vector & math::vector< T, N >::operator/= ( const vector< T, N > & other)
inline

◆ operator=() [1/3]

template<typename T, std::size_t N>
vector & math::vector< T, N >::operator= ( const T & element) &
inline

◆ operator=() [2/3]

template<typename T, std::size_t N>
vector & math::vector< T, N >::operator= ( const vector< T, N > & ) &
default

◆ operator=() [3/3]

template<typename T, std::size_t N>
vector & math::vector< T, N >::operator= ( vector< T, N > && ) &
default

◆ operator[]() [1/2]

template<typename T, std::size_t N>
reference math::vector< T, N >::operator[] ( size_type pos)
inline

◆ operator[]() [2/2]

template<typename T, std::size_t N>
const_reference math::vector< T, N >::operator[] ( size_type pos) const
inline

◆ rbegin() [1/2]

template<typename T, std::size_t N>
reverse_iterator math::vector< T, N >::rbegin ( )
inline

◆ rbegin() [2/2]

template<typename T, std::size_t N>
const_reverse_iterator math::vector< T, N >::rbegin ( ) const
inline

◆ rend() [1/2]

template<typename T, std::size_t N>
reverse_iterator math::vector< T, N >::rend ( )
inline

◆ rend() [2/2]

template<typename T, std::size_t N>
const_reverse_iterator math::vector< T, N >::rend ( ) const
inline

◆ size()

template<typename T, std::size_t N>
constexpr std::size_t math::vector< T, N >::size ( )
inlinestaticconstexpr

◆ w() [1/2]

template<typename T, std::size_t N>
reference math::vector< T, N >::w ( )
inline

◆ w() [2/2]

template<typename T, std::size_t N>
const_reference math::vector< T, N >::w ( ) const
inline

◆ x() [1/2]

template<typename T, std::size_t N>
reference math::vector< T, N >::x ( )
inline
Here is the caller graph for this function:

◆ x() [2/2]

template<typename T, std::size_t N>
const_reference math::vector< T, N >::x ( ) const
inline

◆ y() [1/2]

template<typename T, std::size_t N>
reference math::vector< T, N >::y ( )
inline
Here is the caller graph for this function:

◆ y() [2/2]

template<typename T, std::size_t N>
const_reference math::vector< T, N >::y ( ) const
inline

◆ z() [1/2]

template<typename T, std::size_t N>
reference math::vector< T, N >::z ( )
inline
Here is the caller graph for this function:

◆ z() [2/2]

template<typename T, std::size_t N>
const_reference math::vector< T, N >::z ( ) const
inline

◆ operator<<

template<typename T, std::size_t N>
std::ostream & operator<< ( std::ostream & os,
const vector< T, N > & v )
friend

Member Data Documentation

◆ data

template<typename T, std::size_t N>
data_type math::vector< T, N >::data
The documentation for this class was generated from the following file:
  • /home/runner/work/ECOGEN/ECOGEN/doc_sources/src/Parallel/vector.hpp