vec(2rheolef)							    rheolef-6.1 						     vec(2rheolef)

NAME

       vec - vector in distributed environment (rheolef-6.1)

SYNOPSYS

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

EXAMPLE

       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 NOTE

       Implementation use array<T,M>.

IMPLEMENTATION

       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 Expr& expr);

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

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

	   template<typename Expr>
	   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
       };

rheolef-6.1							    rheolef-6.1 						     vec(2rheolef)