vec

distributed vector

Description

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

Example

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

Implementation

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