NAME¶

vec - vector in distributed environment (rheolef-7.0)

SYNOPSIS¶

STL-like vector container for a sequential or distributed memory machine model. Additional operation fom classical algebra.

EXAMPLE¶

A sample usage of the class is:

     int main(int argc, char**argv) {


        environment distributed(argc, argv);


        vec<double> x(100, 3.14);


        dout << x << endl;


     }

IMPLEMENTATION NOTE¶

Implementation use disarray<T,M>.

IMPLEMENTATION¶

template <class T, class M = rheo_default_memory_model>
class vec : public disarray<T, M> {
public:
// typedef:


    typedef disarray<T, M> base;


    typedef T                                                value_type;


    typedef typename base::size_type                         size_type;


    typedef std::ptrdiff_t                                   difference_type;


    typedef basic_range<size_type, difference_type>          range_type;


    typedef typename base::reference                         reference;


    typedef typename base::const_reference                   const_reference;


    typedef typename base::iterator                          iterator;


    typedef typename base::const_iterator                    const_iterator;


    typedef typename float_traits <value_type>::type         float_type;
// allocator/deallocator:


    vec (const vec<T,M>&);


    vec<T,M>& operator= (const vec<T,M>& x);


    vec (const distributor& ownership,


        const T&  init_val = std::numeric_limits<T>::max());


    vec(size_type dis_size = 0,


        const T&  init_val = std::numeric_limits<T>::max());


    void resize (


        const distributor& ownership,


        const T&  init_val = std::numeric_limits<T>::max());


    void resize (


        size_type size = 0,


        const T&  init_val = std::numeric_limits<T>::max());
// accessors:


    const_reference operator[] (size_type i) const;


    reference       operator[] (size_type i);


    T min () const;


    T max () const;


    T max_abs () const;
// range:


    vec(const vec_range<T,M>& vr);


    vec(const vec_range_const<T,M>& vr);


    vec<T,M>& operator= (const vec_range<T,M>& vr);


    vec<T,M>& operator= (const vec_range_const<T,M>& vr);


    vec_range_const<T,M> operator[] (const range_type& r) const;


    vec_range<T,M>       operator[] (const range_type& r);
// assignment to a constant:


    vec<T,M>& operator= (const int& expr);


    vec<T,M>& operator= (const T& expr);
// expression template:


    template <class Expr,


              class Sfinae


                  = typename std::enable_if<


                             details::is_vec_expr_v2_arg<Expr>::value


                        && ! details::is_vec<Expr>::value


                    >::type>


    vec (const Expr& expr);


    template <class Expr,


              class Sfinae


                  = typename std::enable_if<


                             details::is_vec_expr_v2_arg<Expr>::value


                        && ! details::is_vec<Expr>::value


                    >::type>


    vec<T, M>& operator=  (const Expr& expr);
// initializer list (c++ 2011):
#ifdef _RHEOLEF_HAVE_STD_INITIALIZER_LIST


    vec (const std::initializer_list<vec_concat_value<T,M> >& init_list);


    vec<T,M>& operator= (const std::initializer_list<vec_concat_value<T,M> >& init_list);
#endif // _RHEOLEF_HAVE_STD_INITIALIZER_LIST
};

COPYRIGHT¶

Copyright (C) 2000-2018 Pierre Saramito <Pierre.Saramito@imag.fr> GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>. This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law.