vec

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> {
public:
// 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):
#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
};