NAME

       branch - parameter-dependent sequence of field (rheolef-7.2)

DESCRIPTION

       The branch class 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 for building animations. It extends to multi-field
       sequences, such as (t,uh(t),ph(t)), up to an arbitrarily number of fields. See also the
       branch(1) unix command for running animations.

IMPLEMENTATION

       This documentation has been generated from file main/lib/branch.h

       The branch class is simply an alias to the branch_basic class

       typedef branch_basic<Float> branch;

       The branch_basic class provides an interface to a n-uplet of fields together with a
       parameter value:

       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();
         branch_basic (const branch_basic<T,M>&);
         branch_basic<T,M>& operator= (const branch_basic<T,M>&);

         template <typename... Args>
         branch_basic(const std::string& parameter, Args... names);

       // 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_name (const std::string& name);
         void set_parameter (const T& value);
         void set_range (const std::pair<T,T>& u_range);

       };
       template <class T, class M> idiststream& operator>> (idiststream&, branch_basic<T,M>&);
       template <class T, class M> odiststream& operator<< (odiststream&, const branch_basic<T,M>&);

AUTHOR

       Pierre  Saramito  <Pierre.Saramito@imag.fr>

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.