.\"
.de Id
..
.de Sp
.if n .sp
.if t .sp 0.4
..
.TH vec 2rheolef "rheolef-7.0" "rheolef-7.0" "rheolef-7.0"
.\" label: /*Class:vec
.SH NAME
\fBvec\fP - vector in distributed environment (rheolef-7.0)
.SH SYNOPSIS

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

A sample usage of the class is:
.\" begin_example
.Sp
.nf
     int main(int argc, char**argv) {
        environment distributed(argc, argv);
        vec<double> x(100, 3.14);
        dout << x << endl;
     }
.Sp
.fi
.\" end_example
.SH IMPLEMENTATION NOTE

Implementation use disarray<T,M>.
.\" skip start:SEE ALSO:
.\" skip start:AUTHORS:
.\" skip start:DATE:
.\" END
.SH IMPLEMENTATION
.\" begin_example
.Sp
.nf
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
};
.Sp
.fi
.\" end_example
.SH 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.