ceph/src/boost/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp

   1 /*
   2  [auto_generated]
   3  boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp
   4
   5  [begin_description]
   6  Base class for all explicit Runge Kutta stepper which are also error steppers.
   7  [end_description]
   8
   9  Copyright 2010-2013 Karsten Ahnert
  10  Copyright 2010-2012 Mario Mulansky
  11  Copyright 2012 Christoph Koke
  12
  13  Distributed under the Boost Software License, Version 1.0.
  14  (See accompanying file LICENSE_1_0.txt or
  15  copy at http://www.boost.org/LICENSE_1_0.txt)
  16  */
  17
  18
  19 #ifndef BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_BASE_HPP_INCLUDED
  20 #define BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_BASE_HPP_INCLUDED
  21
  22 #include <boost/utility/enable_if.hpp>
  23 #include <boost/type_traits/is_same.hpp>
  24
  25
  26 #include <boost/numeric/odeint/util/bind.hpp>
  27 #include <boost/numeric/odeint/util/unwrap_reference.hpp>
  28 #include <boost/numeric/odeint/util/state_wrapper.hpp>
  29 #include <boost/numeric/odeint/util/is_resizeable.hpp>
  30 #include <boost/numeric/odeint/util/resizer.hpp>
  31
  32 #include <boost/numeric/odeint/stepper/stepper_categories.hpp>
  33
  34 #include <boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp>
  35
  36 namespace boost {
  37 namespace numeric {
  38 namespace odeint {
  39
  40
  41 /*
  42  * base class for explicit stepper and error steppers
  43  * models the stepper AND the error stepper concept
  44  *
  45  * this class provides the following do_step variants:
  46     * do_step( sys , x , t , dt )
  47     * do_step( sys , x , dxdt , t , dt )
  48     * do_step( sys , in , t , out , dt )
  49     * do_step( sys , in , dxdt , t , out , dt )
  50     * do_step( sys , x , t , dt , xerr )
  51     * do_step( sys , x , dxdt , t , dt , xerr )
  52     * do_step( sys , in , t , out , dt , xerr )
  53     * do_step( sys , in , dxdt , t , out , dt , xerr )
  54  */
  55 template<
  56 class Stepper ,
  57 unsigned short Order ,
  58 unsigned short StepperOrder ,
  59 unsigned short ErrorOrder ,
  60 class State ,
  61 class Value ,
  62 class Deriv ,
  63 class Time ,
  64 class Algebra ,
  65 class Operations ,
  66 class Resizer
  67 >
  68 class explicit_error_stepper_base : public algebra_stepper_base< Algebra , Operations >
  69 {
  70 public:
  71
  72     typedef algebra_stepper_base< Algebra , Operations > algebra_stepper_base_type;
  73     typedef typename algebra_stepper_base_type::algebra_type algebra_type;
  74
  75
  76     typedef State state_type;
  77     typedef Value value_type;
  78     typedef Deriv deriv_type;
  79     typedef Time time_type;
  80     typedef Resizer resizer_type;
  81     typedef Stepper stepper_type;
  82     typedef explicit_error_stepper_tag stepper_category;
  83     #ifndef DOXYGEN_SKIP
  84     typedef state_wrapper< state_type > wrapped_state_type;
  85     typedef state_wrapper< deriv_type > wrapped_deriv_type;
  86     typedef explicit_error_stepper_base< Stepper , Order , StepperOrder , ErrorOrder ,
  87             State , Value , Deriv , Time , Algebra , Operations , Resizer > internal_stepper_base_type;
  88     #endif
  89
  90     typedef unsigned short order_type;
  91     static const order_type order_value = Order;
  92     static const order_type stepper_order_value = StepperOrder;
  93     static const order_type error_order_value = ErrorOrder;
  94
  95
  96     explicit_error_stepper_base( const algebra_type &algebra = algebra_type() )
  97     : algebra_stepper_base_type( algebra )
  98     { }
  99
 100     order_type order( void ) const
 101     {
 102         return order_value;
 103     }
 104
 105     order_type stepper_order( void ) const
 106     {
 107         return stepper_order_value;
 108     }
 109
 110     order_type error_order( void ) const
 111     {
 112         return error_order_value;
 113     }
 114
 115
 116
 117     /*
 118      * Version 1 : do_step( sys , x , t , dt )
 119      *
 120      * the two overloads are needed in order to solve the forwarding problem
 121      */
 122     template< class System , class StateInOut >
 123     void do_step( System system , StateInOut &x , time_type t , time_type dt )
 124     {
 125         do_step_v1( system , x , t , dt );
 126     }
 127
 128     /**
 129      * \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.
 130      */
 131     template< class System , class StateInOut >
 132     void do_step( System system , const StateInOut &x , time_type t , time_type dt )
 133     {
 134         do_step_v1( system , x , t , dt );
 135     }
 136
 137
 138
 139     /*
 140      * Version 2 : do_step( sys , x , dxdt , t , dt )
 141      *
 142      * this version does not solve the forwarding problem, boost.range can not be used
 143      *
 144      * the disable is needed to avoid ambiguous overloads if state_type = time_type
 145      */
 146     template< class System , class StateInOut , class DerivIn >
 147     typename boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type
 148     do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt )
 149     {
 150         this->stepper().do_step_impl( system , x , dxdt , t , x , dt );
 151     }
 152
 153
 154     /*
 155      * named Version 2: do_step_dxdt_impl( sys , in , dxdt , t , dt )
 156      *
 157      * this version is needed when this stepper is used for initializing
 158      * multistep stepper like adams-bashforth. Hence we provide an explicitely
 159      * named version that is not disabled. Meant for internal use only.
 160      */
 161     template < class System, class StateInOut, class DerivIn >
 162     void do_step_dxdt_impl( System system, StateInOut &x, const DerivIn &dxdt,
 163                             time_type t, time_type dt )
 164     {
 165         this->stepper().do_step_impl( system , x , dxdt , t , x , dt );
 166     }
 167
 168
 169
 170     /*
 171      * Version 3 : do_step( sys , in , t , out , dt )
 172      *
 173      * this version does not solve the forwarding problem, boost.range can not be used
 174      *
 175      * the disable is needed to avoid ambiguous overloads if state_type = time_type
 176      */
 177     template< class System , class StateIn , class StateOut >
 178     typename boost::disable_if< boost::is_same< StateIn , time_type > , void >::type
 179     do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
 180     {
 181         typename odeint::unwrap_reference< System >::type &sys = system;
 182         m_resizer.adjust_size( in , detail::bind( &internal_stepper_base_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) );
 183         sys( in , m_dxdt.m_v ,t );
 184         this->stepper().do_step_impl( system , in , m_dxdt.m_v , t , out , dt );
 185     }
 186
 187     /*
 188      * Version 4 :do_step( sys , in , dxdt , t , out , dt )
 189      *
 190      * this version does not solve the forwarding problem, boost.range can not be used
 191      *
 192      * the disable is needed to avoid ambiguous overloads if state_type = time_type
 193      */
 194     template< class System , class StateIn , class DerivIn , class StateOut >
 195     typename boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type
 196     do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
 197     {
 198         this->stepper().do_step_impl( system , in , dxdt , t , out , dt );
 199     }
 200
 201     /*
 202      * named Version 4: do_step_dxdt_impl( sys , in , dxdt , t , out, dt )
 203      *
 204      * this version is needed when this stepper is used for initializing
 205      * multistep stepper like adams-bashforth. Hence we provide an explicitely
 206      * named version that is not disabled. Meant for internal use only.
 207      */
 208     template < class System, class StateIn, class DerivIn, class StateOut >
 209     void do_step_dxdt_impl( System system, const StateIn &in,
 210                             const DerivIn &dxdt, time_type t, StateOut &out,
 211                             time_type dt )
 212     {
 213         this->stepper().do_step_impl( system , in , dxdt , t , out , dt );
 214     }
 215
 216     /*
 217      * Version  5 :do_step( sys , x , t , dt , xerr )
 218      *
 219      * the two overloads are needed in order to solve the forwarding problem
 220      */
 221     template< class System , class StateInOut , class Err >
 222     void do_step( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
 223     {
 224         do_step_v5( system , x , t , dt , xerr );
 225     }
 226
 227     /**
 228      * \brief Second version to solve the forwarding problem, can be called with Boost.Range as StateInOut.
 229      */
 230     template< class System , class StateInOut , class Err >
 231     void do_step( System system , const StateInOut &x , time_type t , time_type dt , Err &xerr )
 232     {
 233         do_step_v5( system , x , t , dt , xerr );
 234     }
 235
 236
 237     /*
 238      * Version 6 :do_step( sys , x , dxdt , t , dt , xerr )
 239      *
 240      * this version does not solve the forwarding problem, boost.range can not be used
 241      *
 242      * the disable is needed to avoid ambiguous overloads if state_type = time_type
 243      */
 244     template< class System , class StateInOut , class DerivIn , class Err >
 245     typename boost::disable_if< boost::is_same< DerivIn , time_type > , void >::type
 246     do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt , Err &xerr )
 247     {
 248         this->stepper().do_step_impl( system , x , dxdt , t , x , dt , xerr );
 249     }
 250
 251
 252     /*
 253      * Version 7 : do_step( sys , in , t , out , dt , xerr )
 254      *
 255      * this version does not solve the forwarding problem, boost.range can not be used
 256      */
 257     template< class System , class StateIn , class StateOut , class Err >
 258     void do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt , Err &xerr )
 259     {
 260         typename odeint::unwrap_reference< System >::type &sys = system;
 261         m_resizer.adjust_size( in , detail::bind( &internal_stepper_base_type::template resize_impl<StateIn> , detail::ref( *this ) , detail::_1 ) );
 262         sys( in , m_dxdt.m_v ,t );
 263         this->stepper().do_step_impl( system , in , m_dxdt.m_v , t , out , dt , xerr );
 264     }
 265
 266
 267     /*
 268      * Version 8 : do_step( sys , in , dxdt , t , out , dt , xerr )
 269      *
 270      * this version does not solve the forwarding problem, boost.range can not be used
 271      */
 272     template< class System , class StateIn , class DerivIn , class StateOut , class Err >
 273     void do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt , Err &xerr )
 274     {
 275         this->stepper().do_step_impl( system , in , dxdt , t , out , dt , xerr );
 276     }
 277
 278     template< class StateIn >
 279     void adjust_size( const StateIn &x )
 280     {
 281         resize_impl( x );
 282     }
 283
 284
 285
 286 private:
 287
 288     template< class System , class StateInOut >
 289     void do_step_v1( System system , StateInOut &x , time_type t , time_type dt )
 290     {
 291         typename odeint::unwrap_reference< System >::type &sys = system;
 292         m_resizer.adjust_size( x , detail::bind( &internal_stepper_base_type::template resize_impl<StateInOut> , detail::ref( *this ) , detail::_1 ) );
 293         sys( x , m_dxdt.m_v , t );
 294         this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , dt );
 295     }
 296
 297     template< class System , class StateInOut , class Err >
 298     void do_step_v5( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
 299     {
 300         typename odeint::unwrap_reference< System >::type &sys = system;
 301         m_resizer.adjust_size( x , detail::bind( &internal_stepper_base_type::template resize_impl<StateInOut> , detail::ref( *this ) , detail::_1 ) );
 302         sys( x , m_dxdt.m_v ,t );
 303         this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , dt , xerr );
 304     }
 305
 306     template< class StateIn >
 307     bool resize_impl( const StateIn &x )
 308     {
 309         return adjust_size_by_resizeability( m_dxdt , x , typename is_resizeable<deriv_type>::type() );
 310     }
 311
 312     stepper_type& stepper( void )
 313     {
 314         return *static_cast< stepper_type* >( this );
 315     }
 316
 317     const stepper_type& stepper( void ) const
 318     {
 319         return *static_cast< const stepper_type* >( this );
 320     }
 321
 322
 323     resizer_type m_resizer;
 324
 325 protected:
 326
 327     wrapped_deriv_type m_dxdt;
 328 };
 329
 330
 331
 332
 333 /******** DOXYGEN *******/
 334
 335 /**
 336  * \class explicit_error_stepper_base
 337  * \brief Base class for explicit steppers with error estimation. This class can used with
 338  * controlled steppers for step size control.
 339  *
 340  * This class serves as the base class for all explicit steppers with algebra and operations. In contrast to
 341  * explicit_stepper_base it also estimates the error and can be used in a controlled stepper to provide
 342  * step size control.
 343  *
 344  * \note This stepper provides `do_step` methods with and without error estimation. It has therefore three orders,
 345  * one for the order of a step if the error is not estimated. The other two orders are the orders of the step and
 346  * the error step if the error estimation is performed.
 347  *
 348  * explicit_error_stepper_base  is used as the interface in a CRTP (currently recurring template
 349  * pattern). In order to work correctly the parent class needs to have a method
 350  * `do_step_impl( system , in , dxdt_in , t , out , dt , xerr )`.
 351  * explicit_error_stepper_base derives from algebra_stepper_base.
 352  *
 353  * explicit_error_stepper_base provides several overloaded `do_step` methods, see the list below. Only two of them
 354  * are needed to fulfill the Error Stepper concept. The other ones are for convenience and for performance. Some
 355  * of them simply update the state out-of-place, while other expect that the first derivative at `t` is passed to the
 356  * stepper.
 357  *
 358  * - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fulfill the Error Stepper concept. The
 359  *      state is updated in-place. A type modelling a Boost.Range can be used for x.
 360  * - `do_step( sys , x , dxdt , t , dt )` - This method updates the state in-place, but the derivative at the point `t`
 361  *      must be explicitly passed in `dxdt`.
 362  * - `do_step( sys , in , t , out , dt )` - This method updates the state out-of-place, hence the result of the step
 363  *      is stored in `out`.
 364  * - `do_step( sys , in , dxdt , t , out , dt )` - This method update the state out-of-place and expects that the
 365  *     derivative at the point `t` is explicitly passed in `dxdt`. It is a combination of the two `do_step` methods
 366  *     above.
 367  * - `do_step( sys , x , t , dt , xerr )` - This `do_step` method is needed to fulfill the Error Stepper concept. The
 368  *     state is updated in-place and an error estimate is calculated. A type modelling a Boost.Range can be used for x.
 369  * - `do_step( sys , x , dxdt , t , dt , xerr )` - This method updates the state in-place, but the derivative at the
 370  *      point `t` must be passed in `dxdt`. An error estimate is calculated.
 371  * - `do_step( sys , in , t , out , dt , xerr )` - This method updates the state out-of-place and estimates the error
 372  *      during the step.
 373  * - `do_step( sys , in , dxdt , t , out , dt , xerr )` - This methods updates the state out-of-place and estimates
 374  *      the error during the step. Furthermore, the derivative at `t` must be passed in `dxdt`.
 375  *
 376  * \note The system is always passed as value, which might result in poor performance if it contains data. In this
 377  *      case it can be used with `boost::ref` or `std::ref`, for example `stepper.do_step( boost::ref( sys ) , x , t , dt );`
 378  *
 379  * \note The time `t` is not advanced by the stepper. This has to done manually, or by the appropriate `integrate`
 380  *      routines or `iterator`s.
 381  *
 382  * \tparam Stepper The stepper on which this class should work. It is used via CRTP, hence explicit_stepper_base
 383  * provides the interface for the Stepper.
 384  * \tparam Order The order of a stepper if the stepper is used without error estimation.
 385  * \tparam StepperOrder The order of a step if the stepper is used with error estimation. Usually Order and StepperOrder have
 386  * the same value.
 387  * \tparam ErrorOrder The order of the error step if the stepper is used with error estimation.
 388  * \tparam State The state type for the stepper.
 389  * \tparam Value The value type for the stepper. This should be a floating point type, like float,
 390  * double, or a multiprecision type. It must not necessary be the value_type of the State. For example
 391  * the State can be a `vector< complex< double > >` in this case the Value must be double.
 392  * The default value is double.
 393  * \tparam Deriv The type representing time derivatives of the state type. It is usually the same type as the
 394  * state type, only if used with Boost.Units both types differ.
 395  * \tparam Time The type representing the time. Usually the same type as the value type. When Boost.Units is
 396  * used, this type has usually a unit.
 397  * \tparam Algebra The algebra type which must fulfill the Algebra Concept.
 398  * \tparam Operations The type for the operations which must fulfill the Operations Concept.
 399  * \tparam Resizer The resizer policy class.
 400  */
 401
 402
 403     /**
 404      * \fn explicit_error_stepper_base::explicit_error_stepper_base( const algebra_type &algebra = algebra_type() )
 405      *
 406      * \brief Constructs a explicit_error_stepper_base class. This constructor can be used as a default
 407      * constructor if the algebra has a default constructor.
 408      * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
 409      */
 410
 411     /**
 412      * \fn explicit_error_stepper_base::order( void ) const
 413      * \return Returns the order of the stepper if it used without error estimation.
 414      */
 415
 416     /**
 417      * \fn explicit_error_stepper_base::stepper_order( void ) const
 418      * \return Returns the order of a step if the stepper is used without error estimation.
 419      */
 420
 421     /**
 422      * \fn explicit_error_stepper_base::error_order( void ) const
 423      * \return Returns the order of an error step if the stepper is used without error estimation.
 424      */
 425
 426     /**
 427      * \fn explicit_error_stepper_base::do_step( System system , StateInOut &x , time_type t , time_type dt )
 428      * \brief This method performs one step. It transforms the result in-place.
 429      *
 430      * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
 431      *               Simple System concept.
 432      * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
 433      * \param t The value of the time, at which the step should be performed.
 434      * \param dt The step size.
 435      */
 436
 437     /**
 438      * \fn explicit_error_stepper_base::do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt )
 439      * \brief The method performs one step with the stepper passed by Stepper. Additionally to the other method
 440      * the derivative of x is also passed to this method. It is supposed to be used in the following way:
 441      *
 442      * \code
 443      * sys( x , dxdt , t );
 444      * stepper.do_step( sys , x , dxdt , t , dt );
 445      * \endcode
 446      *
 447      * The result is updated in place in x. This method is disabled if Time and Deriv are of the same type. In this
 448      * case the method could not be distinguished from other `do_step` versions.
 449      *
 450      * \note This method does not solve the forwarding problem.
 451      *
 452      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
 453      *               Simple System concept.
 454      * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
 455      * \param dxdt The derivative of x at t.
 456      * \param t The value of the time, at which the step should be performed.
 457      * \param dt The step size.
 458      */
 459
 460     /**
 461      * \fn explicit_error_stepper_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
 462      * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
 463      * This method is disabled if StateIn and Time are the same type. In this case the method can not be distinguished from
 464      * other `do_step` variants.
 465      * \note This method does not solve the forwarding problem.
 466      *
 467      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
 468      *               Simple System concept.
 469      * \param in The state of the ODE which should be solved. in is not modified in this method
 470      * \param t The value of the time, at which the step should be performed.
 471      * \param out The result of the step is written in out.
 472      * \param dt The step size.
 473      */
 474
 475
 476     /**
 477      * \fn explicit_error_stepper_base::do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt )
 478      * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
 479      * Furthermore, the derivative of x at t is passed to the stepper. It is supposed to be used in the following way:
 480      *
 481      * \code
 482      * sys( in , dxdt , t );
 483      * stepper.do_step( sys , in , dxdt , t , out , dt );
 484      * \endcode
 485      *
 486      * This method is disabled if DerivIn and Time are of same type.
 487      *
 488      * \note This method does not solve the forwarding problem.
 489      *
 490      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
 491      *               Simple System concept.
 492      * \param in The state of the ODE which should be solved. in is not modified in this method
 493      * \param dxdt The derivative of x at t.
 494      * \param t The value of the time, at which the step should be performed.
 495      * \param out The result of the step is written in out.
 496      * \param dt The step size.
 497      */
 498
 499     /**
 500      * \fn explicit_error_stepper_base::do_step( System system , StateInOut &x , time_type t , time_type dt , Err &xerr )
 501      * \brief The method performs one step with the stepper passed by Stepper and estimates the error. The state of the ODE
 502      * is updated in-place.
 503      *
 504      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
 505      *               Simple System concept.
 506      * \param x The state of the ODE which should be solved. x is updated by this method.
 507      * \param t The value of the time, at which the step should be performed.
 508      * \param dt The step size.
 509      * \param xerr The estimation of the error is stored in xerr.
 510      */
 511
 512     /**
 513      * \fn explicit_error_stepper_base::do_step( System system , StateInOut &x , const DerivIn &dxdt , time_type t , time_type dt , Err &xerr )
 514      * \brief The method performs one step with the stepper passed by Stepper. Additionally to the other method
 515      * the derivative of x is also passed to this method. It is supposed to be used in the following way:
 516      *
 517      * \code
 518      * sys( x , dxdt , t );
 519      * stepper.do_step( sys , x , dxdt , t , dt , xerr );
 520      * \endcode
 521      *
 522      * The result is updated in place in x. This method is disabled if Time and DerivIn are of the same type. In this
 523      * case the method could not be distinguished from other `do_step` versions.
 524      *
 525      * \note This method does not solve the forwarding problem.
 526      *
 527      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
 528      *               Simple System concept.
 529      * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
 530      * \param dxdt The derivative of x at t.
 531      * \param t The value of the time, at which the step should be performed.
 532      * \param dt The step size.
 533      * \param xerr The error estimate is stored in xerr.
 534      */
 535
 536     /**
 537      * \fn explicit_error_stepper_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt , Err &xerr )
 538      * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
 539      * Furthermore, the error is estimated.
 540      *
 541      * \note This method does not solve the forwarding problem.
 542      *
 543      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
 544      *               Simple System concept.
 545      * \param in The state of the ODE which should be solved. in is not modified in this method
 546      * \param t The value of the time, at which the step should be performed.
 547      * \param out The result of the step is written in out.
 548      * \param dt The step size.
 549      * \param xerr The error estimate.
 550      */
 551
 552
 553     /**
 554      * \fn explicit_error_stepper_base::do_step( System system , const StateIn &in , const DerivIn &dxdt , time_type t , StateOut &out , time_type dt , Err &xerr )
 555      * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
 556      * Furthermore, the derivative of x at t is passed to the stepper and the error is estimated. It is supposed to be used in the following way:
 557      *
 558      * \code
 559      * sys( in , dxdt , t );
 560      * stepper.do_step( sys , in , dxdt , t , out , dt );
 561      * \endcode
 562      *
 563      * This method is disabled if DerivIn and Time are of same type.
 564      *
 565      * \note This method does not solve the forwarding problem.
 566      *
 567      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
 568      *               Simple System concept.
 569      * \param in The state of the ODE which should be solved. in is not modified in this method
 570      * \param dxdt The derivative of x at t.
 571      * \param t The value of the time, at which the step should be performed.
 572      * \param out The result of the step is written in out.
 573      * \param dt The step size.
 574      * \param xerr The error estimate.
 575      */
 576
 577
 578     /**
 579      * \fn explicit_error_stepper_base::adjust_size( const StateIn &x )
 580      * \brief Adjust the size of all temporaries in the stepper manually.
 581      * \param x A state from which the size of the temporaries to be resized is deduced.
 582      */
 583
 584 } // odeint
 585 } // numeric
 586 } // boost
 587
 588 #endif // BOOST_NUMERIC_ODEINT_STEPPER_BASE_EXPLICIT_ERROR_STEPPER_BASE_HPP_INCLUDED