Hydra  4.0.1
A header-only templated C++ framework to perform data analysis on massively parallel platforms.
Public Types | Public Member Functions
hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > > Class Template Reference

#include <multiarray.h>

Collaboration diagram for hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >:

Public Types

template<typename Functor >
using caster_iterator = hydra::thrust::transform_iterator< Functor, iterator, typename std::result_of< Functor(tuple_type &)>::type >
 
template<typename Functor >
using caster_reverse_iterator = hydra::thrust::transform_iterator< Functor, reverse_iterator, typename std::result_of< Functor(tuple_type &)>::type >
 
typedef system_t::template container< T > column_type
 
typedef hydra::thrust::zip_iterator< const_iterator_t > const_iterator
 
typedef std::array< const_iterator_v, N > const_iterator_a
 
typedef detail::tuple_type< N, const_iterator_v >::type const_iterator_t
 
typedef column_type::const_iterator const_iterator_v
 
typedef column_type::const_pointer const_pointer_v
 
typedef hydra::thrust::iterator_traits< const_iterator >::reference const_reference
 
typedef column_type::const_reference const_reference_v
 
typedef hydra::thrust::zip_iterator< const_reverse_iterator_t > const_reverse_iterator
 
typedef std::array< const_reverse_iterator_v, N > const_reverse_iterator_a
 
typedef detail::tuple_type< N, const_reverse_iterator_v >::type const_reverse_iterator_t
 
typedef column_type::const_reverse_iterator const_reverse_iterator_v
 
typedef hydra::thrust::iterator_traits< iterator >::difference_type difference_type
 
typedef hydra::thrust::zip_iterator< iterator_t > iterator
 
typedef std::array< iterator_v, N > iterator_a
 
typedef hydra::thrust::iterator_traits< iterator >::iterator_category iterator_category
 
typedef detail::tuple_type< N, iterator_v >::type iterator_t
 
typedef column_type::iterator iterator_v
 
typedef column_type::pointer pointer_v
 
typedef hydra::thrust::iterator_traits< iterator >::reference reference
 
typedef column_type::reference reference_v
 
typedef hydra::thrust::zip_iterator< reverse_iterator_t > reverse_iterator
 
typedef std::array< reverse_iterator_v, N > reverse_iterator_a
 
typedef detail::tuple_type< N, reverse_iterator_v >::type reverse_iterator_t
 
typedef column_type::reverse_iterator reverse_iterator_v
 
typedef size_t size_type
 
typedef detail::tuple_type< N, T >::type tuple_type
 
typedef hydra::thrust::iterator_traits< iterator >::value_type value_type
 

Public Member Functions

 multiarray ()=default
 
 multiarray (size_t n)
 
 multiarray (size_t n, value_type const &value)
 
template<typename Int , typename = typename hydra::thrust::detail::enable_if<std::is_integral<Int>::value>::type>
 multiarray (hydra::pair< Int, typename detail::tuple_type< N, T >::type > const &pair)
 
 multiarray (multiarray< T, N, detail::BackendPolicy< BACKEND >> const &other)
 
 multiarray (multiarray< T, N, detail::BackendPolicy< BACKEND >> &&other)
 
template<hydra::detail::Backend BACKEND2>
 multiarray (multiarray< T, N, detail::BackendPolicy< BACKEND2 >> const &other)
 
template<typename Iterator >
 multiarray (Iterator first, Iterator last)
 
template<typename Iterable , typename = typename std::enable_if< (detail::is_iterable<Iterable>::value) && !(detail::is_iterator<Iterable>::value) && (std::is_convertible<decltype(*std::declval<Iterable>().begin()), value_type>::value) >::type>
 multiarray (Iterable &&other)
 
reference back ()
 
const_reference back () const
 
iterator begin ()
 
template<typename Functor >
caster_iterator< Functor > begin (Functor const &caster)
 
const_iterator begin () const
 
iterator_v begin (size_t i)
 
const_iterator_v begin (size_t i) const
 
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator< typename detail::tuple_type< sizeof...(IN)+2, iterator_v >::type > begin (placeholders::placeholder< I1 > c1, placeholders::placeholder< I2 > c2, placeholders::placeholder< IN > ...cn)
 
template<unsigned int I>
iterator_v begin (placeholders::placeholder< I >)
 
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator< typename detail::tuple_type< sizeof...(IN)+2, const_iterator_v >::type > begin (placeholders::placeholder< I1 > c1, placeholders::placeholder< I2 > c2, placeholders::placeholder< IN > ...cn) const
 
template<unsigned int I>
const_iterator_v begin (placeholders::placeholder< I >) const
 
size_type capacity () const
 
const_iterator cbegin () const
 
const_iterator_v cbegin (size_t i) const
 
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator< typename detail::tuple_type< sizeof...(IN)+2, const_iterator_v >::type > cbegin (placeholders::placeholder< I1 > c1, placeholders::placeholder< I2 > c2, placeholders::placeholder< IN > ...cn) const
 
template<unsigned int I>
const_iterator_v cbegin (placeholders::placeholder< I >) const
 
const_iterator cend () const
 
const_iterator_v cend (size_t i) const
 
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator< typename detail::tuple_type< sizeof...(IN)+2, const_iterator_v >::type > cend (placeholders::placeholder< I1 > c1, placeholders::placeholder< I2 > c2, placeholders::placeholder< IN > ...cn) const
 
template<unsigned int I>
const_iterator_v cend (placeholders::placeholder< I >) const
 
void clear ()
 
const column_type & column (size_t i) const
 
template<unsigned int I>
const column_type & column (placeholders::placeholder< I >) const
 
const_reverse_iterator crbegin () const
 
const_reverse_iterator_v crbegin (size_t i) const
 
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator< typename detail::tuple_type< sizeof...(IN)+2, const_reverse_iterator_v >::type > crbegin (placeholders::placeholder< I1 > c1, placeholders::placeholder< I2 > c2, placeholders::placeholder< IN > ...cn) const
 
template<unsigned int I>
const_reverse_iterator_v crbegin (placeholders::placeholder< I >) const
 
const_reverse_iterator crend () const
 
const_reverse_iterator_v crend (size_t i) const
 
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator< typename detail::tuple_type< sizeof...(IN)+2, const_reverse_iterator_v >::type > crend (placeholders::placeholder< I1 > c1, placeholders::placeholder< I2 > c2, placeholders::placeholder< IN > ...cn) const
 
template<unsigned int I>
const_reverse_iterator_v crend (placeholders::placeholder< I >) const
 
bool empty () const
 
iterator end ()
 
template<typename Functor >
caster_iterator< Functor > end (Functor const &caster)
 
const_iterator end () const
 
iterator_v end (size_t i)
 
const_iterator_v end (size_t i) const
 
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator< typename detail::tuple_type< sizeof...(IN)+2, iterator_v >::type > end (placeholders::placeholder< I1 > c1, placeholders::placeholder< I2 > c2, placeholders::placeholder< IN > ...cn)
 
template<unsigned int I>
iterator_v end (placeholders::placeholder< I >)
 
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator< typename detail::tuple_type< sizeof...(IN)+2, const_iterator_v >::type > end (placeholders::placeholder< I1 > c1, placeholders::placeholder< I2 > c2, placeholders::placeholder< IN > ...cn) const
 
template<unsigned int I>
const_iterator_v end (placeholders::placeholder< I >) const
 
iterator erase (iterator pos)
 
iterator erase (iterator first, iterator last)
 
reference front ()
 
const_reference front () const
 
iterator insert (iterator pos, const value_type &x)
 
void insert (iterator pos, size_type n, const value_type &x)
 
template<typename InputIterator >
hydra::thrust::detail::enable_if< detail::is_instantiation_of< hydra::thrust::zip_iterator, InputIterator >::value, void >::type insert (iterator pos, InputIterator first, InputIterator last)
 
multiarray< T, N, detail::BackendPolicy< BACKEND > > & operator= (multiarray< T, N, detail::BackendPolicy< BACKEND >> const &other)
 
multiarray< T, N, detail::BackendPolicy< BACKEND > > & operator= (multiarray< T, N, detail::BackendPolicy< BACKEND > > &&other)
 
template<hydra::detail::Backend BACKEND2>
multiarray< T, N, detail::BackendPolicy< BACKEND > > & operator= (multiarray< T, N, detail::BackendPolicy< BACKEND2 > > const &other)
 
template<typename Functor >
caster_iterator< Functor > operator[] (Functor const &caster)
 
template<unsigned int I>
iterator_v operator[] (placeholders::placeholder< I > index)
 
template<unsigned int I>
const_iterator_v operator[] (placeholders::placeholder< I > index) const
 
reference operator[] (size_t n)
 
const_reference operator[] (size_t n) const
 
void pop_back ()
 
void push_back (value_type const &value)
 
template<typename Functor , typename Obj >
void push_back (Functor const &functor, Obj const &obj)
 
template<typename Functor >
caster_reverse_iterator< Functor > rbegin (Functor const &caster)
 
reverse_iterator rbegin ()
 
const_reverse_iterator rbegin () const
 
reverse_iterator_v rbegin (size_t i)
 
const_reverse_iterator_v rbegin (size_t i) const
 
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator< typename detail::tuple_type< sizeof...(IN)+2, reverse_iterator_v >::type > rbegin (placeholders::placeholder< I1 > c1, placeholders::placeholder< I2 > c2, placeholders::placeholder< IN > ...cn)
 
template<unsigned int I>
reverse_iterator_v rbegin (placeholders::placeholder< I >)
 
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator< typename detail::tuple_type< sizeof...(IN)+2, const_reverse_iterator_v >::type > rbegin (placeholders::placeholder< I1 > c1, placeholders::placeholder< I2 > c2, placeholders::placeholder< IN > ...cn) const
 
template<unsigned int I>
const_reverse_iterator_v rbegin (placeholders::placeholder< I >) const
 
template<typename Functor >
caster_reverse_iterator< Functor > rend (Functor const &caster)
 
reverse_iterator rend ()
 
const_reverse_iterator rend () const
 
reverse_iterator_v rend (size_t i)
 
const_reverse_iterator_v rend (size_t i) const
 
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator< typename detail::tuple_type< sizeof...(IN)+2, reverse_iterator_v >::type > rend (placeholders::placeholder< I1 > c1, placeholders::placeholder< I2 > c2, placeholders::placeholder< IN > ...cn)
 
template<unsigned int I>
reverse_iterator_v rend (placeholders::placeholder< I >)
 
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator< typename detail::tuple_type< sizeof...(IN)+2, const_reverse_iterator_v >::type > rend (placeholders::placeholder< I1 > c1, placeholders::placeholder< I2 > c2, placeholders::placeholder< IN > ...cn) const
 
template<unsigned int I>
const_reverse_iterator_v rend (placeholders::placeholder< I >) const
 
void reserve (size_type size)
 
void resize (size_type size)
 
void shrink_to_fit ()
 
size_type size () const
 

Detailed Description

template<typename T, size_t N, hydra::detail::Backend BACKEND>
class hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >

Member Typedef Documentation

◆ caster_iterator

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<typename Functor >
using hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::caster_iterator = hydra::thrust::transform_iterator< Functor, iterator, typename std::result_of<Functor(tuple_type&)>::type >

◆ caster_reverse_iterator

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<typename Functor >
using hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::caster_reverse_iterator = hydra::thrust::transform_iterator< Functor, reverse_iterator, typename std::result_of<Functor(tuple_type&)>::type >

◆ column_type

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef system_t::template container<T> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::column_type

◆ const_iterator

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef hydra::thrust::zip_iterator<const_iterator_t> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::const_iterator

◆ const_iterator_a

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef std::array<const_iterator_v, N> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::const_iterator_a

◆ const_iterator_t

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef detail::tuple_type<N, const_iterator_v>::type hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::const_iterator_t

◆ const_iterator_v

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef column_type::const_iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::const_iterator_v

◆ const_pointer_v

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef column_type::const_pointer hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::const_pointer_v

◆ const_reference

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef hydra::thrust::iterator_traits<const_iterator>::reference hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::const_reference

◆ const_reference_v

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef column_type::const_reference hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::const_reference_v

◆ const_reverse_iterator

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef hydra::thrust::zip_iterator<const_reverse_iterator_t> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::const_reverse_iterator

◆ const_reverse_iterator_a

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef std::array<const_reverse_iterator_v, N> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::const_reverse_iterator_a

◆ const_reverse_iterator_t

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef detail::tuple_type<N, const_reverse_iterator_v>::type hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::const_reverse_iterator_t

◆ const_reverse_iterator_v

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef column_type::const_reverse_iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::const_reverse_iterator_v

◆ difference_type

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef hydra::thrust::iterator_traits<iterator>::difference_type hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::difference_type

◆ iterator

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef hydra::thrust::zip_iterator<iterator_t> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::iterator

◆ iterator_a

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef std::array<iterator_v, N> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::iterator_a

◆ iterator_category

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef hydra::thrust::iterator_traits<iterator>::iterator_category hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::iterator_category

◆ iterator_t

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef detail::tuple_type<N, iterator_v>::type hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::iterator_t

◆ iterator_v

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef column_type::iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::iterator_v

◆ pointer_v

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef column_type::pointer hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::pointer_v

◆ reference

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef hydra::thrust::iterator_traits<iterator>::reference hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::reference

◆ reference_v

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef column_type::reference hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::reference_v

◆ reverse_iterator

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef hydra::thrust::zip_iterator<reverse_iterator_t> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::reverse_iterator

◆ reverse_iterator_a

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef std::array<reverse_iterator_v, N> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::reverse_iterator_a

◆ reverse_iterator_t

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef detail::tuple_type<N, reverse_iterator_v>::type hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::reverse_iterator_t

◆ reverse_iterator_v

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef column_type::reverse_iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::reverse_iterator_v

◆ size_type

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef size_t hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::size_type

◆ tuple_type

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef detail::tuple_type<N, T>::type hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::tuple_type

◆ value_type

template<typename T , size_t N, hydra::detail::Backend BACKEND>
typedef hydra::thrust::iterator_traits<iterator>::value_type hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::value_type

Constructor & Destructor Documentation

◆ multiarray() [1/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::multiarray ( )
default

◆ multiarray() [2/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::multiarray ( size_t  n)
inline

◆ multiarray() [3/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::multiarray ( size_t  n,
value_type const &  value 
)
inline

◆ multiarray() [4/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<typename Int , typename = typename hydra::thrust::detail::enable_if<std::is_integral<Int>::value>::type>
hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::multiarray ( hydra::pair< Int, typename detail::tuple_type< N, T >::type > const &  pair)
inline

◆ multiarray() [5/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::multiarray ( multiarray< T, N, detail::BackendPolicy< BACKEND >> const &  other)
inlineexplicit

◆ multiarray() [6/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::multiarray ( multiarray< T, N, detail::BackendPolicy< BACKEND >> &&  other)
inlineexplicit

◆ multiarray() [7/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<hydra::detail::Backend BACKEND2>
hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::multiarray ( multiarray< T, N, detail::BackendPolicy< BACKEND2 >> const &  other)
inlineexplicit

◆ multiarray() [8/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<typename Iterator >
hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::multiarray ( Iterator  first,
Iterator  last 
)
inline

◆ multiarray() [9/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<typename Iterable , typename = typename std::enable_if< (detail::is_iterable<Iterable>::value) && !(detail::is_iterator<Iterable>::value) && (std::is_convertible<decltype(*std::declval<Iterable>().begin()), value_type>::value) >::type>
hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::multiarray ( Iterable &&  other)
inline

Member Function Documentation

◆ back() [1/2]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
reference hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::back ( )
inline

◆ back() [2/2]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_reference hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::back ( ) const
inline

◆ begin() [1/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::begin ( )
inline

◆ begin() [2/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<typename Functor >
caster_iterator<Functor> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::begin ( Functor const &  caster)
inline

◆ begin() [3/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::begin ( ) const
inline

◆ begin() [4/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::begin ( size_t  i)
inline

◆ begin() [5/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::begin ( size_t  i) const
inline

◆ begin() [6/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator<typename detail::tuple_type< sizeof...(IN)+2, iterator_v >::type> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::begin ( placeholders::placeholder< I1 >  c1,
placeholders::placeholder< I2 >  c2,
placeholders::placeholder< IN > ...  cn 
)
inline

◆ begin() [7/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::begin ( placeholders::placeholder< I >  )
inline

◆ begin() [8/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator<typename detail::tuple_type< sizeof...(IN)+2, const_iterator_v >::type> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::begin ( placeholders::placeholder< I1 >  c1,
placeholders::placeholder< I2 >  c2,
placeholders::placeholder< IN > ...  cn 
) const
inline

◆ begin() [9/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
const_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::begin ( placeholders::placeholder< I >  ) const
inline

◆ capacity()

template<typename T , size_t N, hydra::detail::Backend BACKEND>
size_type hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::capacity ( ) const
inline

◆ cbegin() [1/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::cbegin ( ) const
inline

◆ cbegin() [2/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::cbegin ( size_t  i) const
inline

◆ cbegin() [3/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator<typename detail::tuple_type< sizeof...(IN)+2, const_iterator_v >::type> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::cbegin ( placeholders::placeholder< I1 >  c1,
placeholders::placeholder< I2 >  c2,
placeholders::placeholder< IN > ...  cn 
) const
inline

◆ cbegin() [4/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
const_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::cbegin ( placeholders::placeholder< I >  ) const
inline

◆ cend() [1/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::cend ( ) const
inline

◆ cend() [2/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::cend ( size_t  i) const
inline

◆ cend() [3/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator<typename detail::tuple_type< sizeof...(IN)+2, const_iterator_v >::type> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::cend ( placeholders::placeholder< I1 >  c1,
placeholders::placeholder< I2 >  c2,
placeholders::placeholder< IN > ...  cn 
) const
inline

◆ cend() [4/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
const_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::cend ( placeholders::placeholder< I >  ) const
inline

◆ clear()

template<typename T , size_t N, hydra::detail::Backend BACKEND>
void hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::clear ( )
inline

◆ column() [1/2]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const column_type& hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::column ( size_t  i) const
inline

◆ column() [2/2]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
const column_type& hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::column ( placeholders::placeholder< I >  ) const
inline

◆ crbegin() [1/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_reverse_iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::crbegin ( ) const
inline

◆ crbegin() [2/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_reverse_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::crbegin ( size_t  i) const
inline

◆ crbegin() [3/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator<typename detail::tuple_type< sizeof...(IN)+2, const_reverse_iterator_v >::type> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::crbegin ( placeholders::placeholder< I1 >  c1,
placeholders::placeholder< I2 >  c2,
placeholders::placeholder< IN > ...  cn 
) const
inline

◆ crbegin() [4/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
const_reverse_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::crbegin ( placeholders::placeholder< I >  ) const
inline

◆ crend() [1/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_reverse_iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::crend ( ) const
inline

◆ crend() [2/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_reverse_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::crend ( size_t  i) const
inline

◆ crend() [3/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator<typename detail::tuple_type< sizeof...(IN)+2, const_reverse_iterator_v >::type> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::crend ( placeholders::placeholder< I1 >  c1,
placeholders::placeholder< I2 >  c2,
placeholders::placeholder< IN > ...  cn 
) const
inline

◆ crend() [4/4]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
const_reverse_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::crend ( placeholders::placeholder< I >  ) const
inline

◆ empty()

template<typename T , size_t N, hydra::detail::Backend BACKEND>
bool hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::empty ( ) const
inline

◆ end() [1/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::end ( )
inline

◆ end() [2/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<typename Functor >
caster_iterator<Functor> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::end ( Functor const &  caster)
inline

◆ end() [3/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::end ( ) const
inline

◆ end() [4/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::end ( size_t  i)
inline

◆ end() [5/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::end ( size_t  i) const
inline

◆ end() [6/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator<typename detail::tuple_type< sizeof...(IN)+2, iterator_v >::type> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::end ( placeholders::placeholder< I1 >  c1,
placeholders::placeholder< I2 >  c2,
placeholders::placeholder< IN > ...  cn 
)
inline

◆ end() [7/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::end ( placeholders::placeholder< I >  )
inline

◆ end() [8/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator<typename detail::tuple_type< sizeof...(IN)+2, const_iterator_v >::type> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::end ( placeholders::placeholder< I1 >  c1,
placeholders::placeholder< I2 >  c2,
placeholders::placeholder< IN > ...  cn 
) const
inline

◆ end() [9/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
const_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::end ( placeholders::placeholder< I >  ) const
inline

◆ erase() [1/2]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::erase ( iterator  pos)
inline

◆ erase() [2/2]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::erase ( iterator  first,
iterator  last 
)
inline

◆ front() [1/2]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
reference hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::front ( )
inline

◆ front() [2/2]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_reference hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::front ( ) const
inline

◆ insert() [1/3]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::insert ( iterator  pos,
const value_type &  x 
)
inline

◆ insert() [2/3]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
void hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::insert ( iterator  pos,
size_type  n,
const value_type &  x 
)
inline

◆ insert() [3/3]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<typename InputIterator >
hydra::thrust::detail::enable_if< detail::is_instantiation_of< hydra::thrust::zip_iterator, InputIterator>::value, void>::type hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::insert ( iterator  pos,
InputIterator  first,
InputIterator  last 
)
inline

◆ operator=() [1/3]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
multiarray<T,N,detail::BackendPolicy<BACKEND> >& hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::operator= ( multiarray< T, N, detail::BackendPolicy< BACKEND >> const &  other)
inline

◆ operator=() [2/3]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
multiarray<T,N,detail::BackendPolicy<BACKEND> >& hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::operator= ( multiarray< T, N, detail::BackendPolicy< BACKEND > > &&  other)
inline

◆ operator=() [3/3]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<hydra::detail::Backend BACKEND2>
multiarray<T,N,detail::BackendPolicy<BACKEND> >& hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::operator= ( multiarray< T, N, detail::BackendPolicy< BACKEND2 > > const &  other)
inline

◆ operator[]() [1/5]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<typename Functor >
caster_iterator<Functor> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::operator[] ( Functor const &  caster)
inline

◆ operator[]() [2/5]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::operator[] ( placeholders::placeholder< I >  index)
inline

◆ operator[]() [3/5]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
const_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::operator[] ( placeholders::placeholder< I >  index) const
inline

◆ operator[]() [4/5]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
reference hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::operator[] ( size_t  n)
inline

◆ operator[]() [5/5]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_reference hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::operator[] ( size_t  n) const
inline

◆ pop_back()

template<typename T , size_t N, hydra::detail::Backend BACKEND>
void hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::pop_back ( )
inline

◆ push_back() [1/2]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
void hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::push_back ( value_type const &  value)
inline

◆ push_back() [2/2]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<typename Functor , typename Obj >
void hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::push_back ( Functor const &  functor,
Obj const &  obj 
)
inline

◆ rbegin() [1/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<typename Functor >
caster_reverse_iterator<Functor> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rbegin ( Functor const &  caster)
inline

◆ rbegin() [2/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
reverse_iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rbegin ( )
inline

◆ rbegin() [3/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_reverse_iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rbegin ( ) const
inline

◆ rbegin() [4/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
reverse_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rbegin ( size_t  i)
inline

◆ rbegin() [5/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_reverse_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rbegin ( size_t  i) const
inline

◆ rbegin() [6/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator<typename detail::tuple_type< sizeof...(IN)+2, reverse_iterator_v >::type> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rbegin ( placeholders::placeholder< I1 >  c1,
placeholders::placeholder< I2 >  c2,
placeholders::placeholder< IN > ...  cn 
)
inline

◆ rbegin() [7/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
reverse_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rbegin ( placeholders::placeholder< I >  )
inline

◆ rbegin() [8/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator<typename detail::tuple_type< sizeof...(IN)+2, const_reverse_iterator_v >::type> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rbegin ( placeholders::placeholder< I1 >  c1,
placeholders::placeholder< I2 >  c2,
placeholders::placeholder< IN > ...  cn 
) const
inline

◆ rbegin() [9/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
const_reverse_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rbegin ( placeholders::placeholder< I >  ) const
inline

◆ rend() [1/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<typename Functor >
caster_reverse_iterator<Functor> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rend ( Functor const &  caster)
inline

◆ rend() [2/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
reverse_iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rend ( )
inline

◆ rend() [3/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_reverse_iterator hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rend ( ) const
inline

◆ rend() [4/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
reverse_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rend ( size_t  i)
inline

◆ rend() [5/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
const_reverse_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rend ( size_t  i) const
inline

◆ rend() [6/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator<typename detail::tuple_type< sizeof...(IN)+2, reverse_iterator_v >::type> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rend ( placeholders::placeholder< I1 >  c1,
placeholders::placeholder< I2 >  c2,
placeholders::placeholder< IN > ...  cn 
)
inline

◆ rend() [7/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
reverse_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rend ( placeholders::placeholder< I >  )
inline

◆ rend() [8/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I1, unsigned int I2, unsigned int ... IN>
hydra::thrust::zip_iterator<typename detail::tuple_type< sizeof...(IN)+2, const_reverse_iterator_v >::type> hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rend ( placeholders::placeholder< I1 >  c1,
placeholders::placeholder< I2 >  c2,
placeholders::placeholder< IN > ...  cn 
) const
inline

◆ rend() [9/9]

template<typename T , size_t N, hydra::detail::Backend BACKEND>
template<unsigned int I>
const_reverse_iterator_v hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::rend ( placeholders::placeholder< I >  ) const
inline

◆ reserve()

template<typename T , size_t N, hydra::detail::Backend BACKEND>
void hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::reserve ( size_type  size)
inline

◆ resize()

template<typename T , size_t N, hydra::detail::Backend BACKEND>
void hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::resize ( size_type  size)
inline

◆ shrink_to_fit()

template<typename T , size_t N, hydra::detail::Backend BACKEND>
void hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::shrink_to_fit ( )
inline

◆ size()

template<typename T , size_t N, hydra::detail::Backend BACKEND>
size_type hydra::multiarray< T, N, hydra::detail::BackendPolicy< BACKEND > >::size ( ) const
inline
The documentation for this class was generated from the following file: