Provided by: librheolef-dev_7.0-3_amd64 bug


       continuation -- continuation algorithm for nonlinear problems


       This  function  applies  a  continuation  algorithm  for  the  resolution of the following

              F(lambda,u) = 0

       where lambda is a parameter and u is the corresponding solution.   The  main  idea  is  to
       follow  a branch of solution u(lambda) when the parameter lambda varies.  A simple call to
       the algorithm writes:

           my_problem P;
           field uh (Vh,0);
           continuation (P, uh, &dout, &derr);

       The continuation algorithm bases on the  damped_newton  (see  damped_newton(4))  and  thus
       requirement for the my_problem class may contains methods for the evaluation of F (aka the
       residue) and its derivative:

           class my_problem {
             typedef value_type;
             typedef float_type;
             string parameter_name() const;
             float_type parameter() const;
             void set_parameter (float_type lambda);
             value_type residue          (const value_type& uh) const;
             void update_derivative      (const value_type& uh) const;
             csr<float_type> derivative  (const value_type& uh) const;
             value_type derivative_versus_parameter (const field& uh) const;
             value_type derivative_solve      (const value_type& mrh) const;
             value_type derivative_trans_mult (const value_type& mrh) const;
             bool stop (const value_type& xh) const;
             idiststream& get (idiststream& is,       value_type& uh);
             odiststream& put (odiststream& os, const value_type& uh) const;
             float_type space_norm (const value_type& uh) const;
             float_type dual_space_norm (const value_type& mrh) const;
             float_type space_dot (const value_type& xh, const value_type& yh) const;
             float_type dual_space_dot (const value_type& mrh, const value_type& msh) const;
             value_type massify   (const value_type& uh) const;
             value_type unmassify (const value_type& mrh) const;

       See the example combustion.h in the user's documentation for more.  The optional  argument
       of  type class continuation_option (see continuation_option(2)) allows one to control some
       features of the algorithm.


       template<class Problem>
       continuation (
         Problem&                        F,
         typename Problem::value_type&   uh,
         odiststream*                    p_out,
         odiststream*                    p_err,
         const continuation_option& opts = continuation_option())


       damped_newton(4), continuation_option(2)


       Copyright (C) 2000-2018 Pierre Saramito <> GPLv3+: GNU GPL  version
       3  or  later  <>.   This is free software: you are free to
       change and redistribute it.  There is NO WARRANTY, to the extent permitted by law.