vec - distributed vector (rheolef-7.2)

       Pierre  Saramito  <Pierre.Saramito@imag.fr>

       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.

rheolef                                            Version 7.2                                     vec(4rheolef)

       This vector class supports both the sequential and the distributed memory model. In addition, standard
       linear algebra is supported.

           vec<double> x (100, 3.14);
           vec<double> y (100, 6.28);
           vec<double> z = 2.5*x + y;
           dout << x << endl;

       This documentation has been generated from file linalg/lib/vec.h

       The vec class is a template class with both the floating type and the memory model as parameters. The
       implementation bases on the disarray(4) container.

       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 range                                            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 (const std::initializer_list<details::vec_concat_value<T,M> >& init_list);

           vec<T,M>& operator= (const std::initializer_list<details::vec_concat_value<T,M> >& init_list);
           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;

           int constraint_process_rank() 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);
       };

       vec - distributed vector (rheolef-7.2)