branch(2rheolef) [debian man page]

branch(2rheolef)						    rheolef-6.1 						  branch(2rheolef)

NAME

       branch - a parameter-dependent sequence of field

DESCRIPTION

       Stores a field sequence together with its associated parameter value: a branch variable represents a pair (t,uh(t)) for a specific value of
       the parameter t.  Applications concern time-dependent problems and continuation methods.

       This class is convenient for file inputs/outputs and building graphical animations.

EXAMPLES

       Coming soon...

LIMITATIONS

       This class is under development.

       The branch class store pointers on field class without reference counting. Thus, branch automatic variables cannot  be  returned  by  func-
       tions. branch variable are limited to local variables.

IMPLEMENTATION

       template <class T, class M = rheo_default_memory_model>
       class branch_basic : public std::vector<std::pair<std::string,field_basic<T,M> > > {
       public :
       // typedefs:

	 typedef std::vector<std::pair<std::string,field_basic<T,M> > >     base;
	 typedef typename base::size_type				    size_type;

       // allocators:

	 branch_basic ();
	 branch_basic (const std::string& parameter_name, const std::string& u0);
	 branch_basic (const std::string& parameter_name, const std::string& u0, const std::string& u1);
	 ~branch_basic();

       // accessors:

	 const T&  parameter () const;
	 const std::string& parameter_name () const;
	 size_type     n_value () const;
	 size_type     n_field () const;

       // modifiers:

	 void set_parameter (const T& value);
	 void set_range (const std::pair<T,T>& u_range);

       // input/output:

	 // get/set current value
	 __obranch<T,M> operator()  (const T& t, const field_basic<T,M>& u0);
	 __obranch<T,M> operator()  (const T& t, const field_basic<T,M>& u0, const field_basic<T,M>& u1);

	 __iobranch<T,M> operator() (T& t, field_basic<T,M>& u0);
	 __iobranch<T,M> operator() (T& t, field_basic<T,M>& u0, field_basic<T,M>& u1);

	 __branch_header<T,M>	      header ();
	 __const_branch_header<T,M>   header () const;
	 __const_branch_finalize<T,M> finalize () const;

rheolef-6.1							    rheolef-6.1 						  branch(2rheolef)

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)