Provided by: librheolef-dev_6.6-1build2_amd64 bug


       vec - vector in distributed environment (rheolef-6.6)


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


       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 use array<T,M>.


       template <class T, class M = rheo_default_memory_model>
       class vec : public array<T, M> {

       // typedef:

           typedef array<T, M> base;
           typedef typename base::size_type                         size_type;
           typedef std::ptrdiff_t                                   difference_type;
       #ifdef TODO
           // pb compile avec boost sur foehn:
           typedef typename base::difference_type                   difference_type;
       #endif // TODO
           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;

       // allocator/deallocator:

           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 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<typename Expr>
           vec (const vec_expr<Expr>& expr);

           template<typename Expr>
           vec<T,M>& operator= (const vec_expr<Expr>& expr);

       // initializer list (c++ 2011):

           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);