ceph/src/boost/boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp

   1 /*
   2  [auto_generated]
   3  boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp
   4
   5  [begin_description]
   6  Implementation of the Dormand-Prince 5(4) method. This stepper can also be used with the dense-output controlled stepper.
   7  [end_description]
   8
   9  Copyright 2010-2013 Karsten Ahnert
  10  Copyright 2010-2013 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_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED
  20 #define BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED
  21
  22
  23 #include <boost/numeric/odeint/util/bind.hpp>
  24
  25 #include <boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp>
  26 #include <boost/numeric/odeint/algebra/range_algebra.hpp>
  27 #include <boost/numeric/odeint/algebra/default_operations.hpp>
  28 #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
  29 #include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
  30 #include <boost/numeric/odeint/stepper/stepper_categories.hpp>
  31
  32 #include <boost/numeric/odeint/util/state_wrapper.hpp>
  33 #include <boost/numeric/odeint/util/is_resizeable.hpp>
  34 #include <boost/numeric/odeint/util/resizer.hpp>
  35 #include <boost/numeric/odeint/util/same_instance.hpp>
  36
  37 namespace boost {
  38 namespace numeric {
  39 namespace odeint {
  40
  41
  42
  43 template<
  44 class State ,
  45 class Value = double ,
  46 class Deriv = State ,
  47 class Time = Value ,
  48 class Algebra = typename algebra_dispatcher< State >::algebra_type ,
  49 class Operations = typename operations_dispatcher< State >::operations_type ,
  50 class Resizer = initially_resizer
  51 >
  52 class runge_kutta_dopri5
  53 #ifndef DOXYGEN_SKIP
  54 : public explicit_error_stepper_fsal_base<
  55   runge_kutta_dopri5< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
  56   5 , 5 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer >
  57 #else
  58 : public explicit_error_stepper_fsal_base
  59 #endif
  60 {
  61
  62 public :
  63
  64     #ifndef DOXYGEN_SKIP
  65     typedef explicit_error_stepper_fsal_base<
  66     runge_kutta_dopri5< State , Value , Deriv , Time , Algebra , Operations , Resizer > ,
  67     5 , 5 , 4 , State , Value , Deriv , Time , Algebra , Operations , Resizer > stepper_base_type;
  68     #else
  69     typedef explicit_error_stepper_fsal_base< runge_kutta_dopri5< ... > , ... > stepper_base_type;
  70     #endif
  71
  72     typedef typename stepper_base_type::state_type state_type;
  73     typedef typename stepper_base_type::value_type value_type;
  74     typedef typename stepper_base_type::deriv_type deriv_type;
  75     typedef typename stepper_base_type::time_type time_type;
  76     typedef typename stepper_base_type::algebra_type algebra_type;
  77     typedef typename stepper_base_type::operations_type operations_type;
  78     typedef typename stepper_base_type::resizer_type resizer_type;
  79
  80     #ifndef DOXYGEN_SKIP
  81     typedef typename stepper_base_type::stepper_type stepper_type;
  82     typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
  83     typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
  84     #endif // DOXYGEN_SKIP
  85
  86
  87     runge_kutta_dopri5( const algebra_type &algebra = algebra_type() ) : stepper_base_type( algebra )
  88     { }
  89
  90
  91     template< class System , class StateIn , class DerivIn , class StateOut , class DerivOut >
  92     void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t ,
  93             StateOut &out , DerivOut &dxdt_out , time_type dt )
  94     {
  95         const value_type a2 = static_cast<value_type> ( 1 ) / static_cast<value_type>( 5 );
  96         const value_type a3 = static_cast<value_type> ( 3 ) / static_cast<value_type> ( 10 );
  97         const value_type a4 = static_cast<value_type> ( 4 ) / static_cast<value_type> ( 5 );
  98         const value_type a5 = static_cast<value_type> ( 8 )/static_cast<value_type> ( 9 );
  99
 100         const value_type b21 = static_cast<value_type> ( 1 ) / static_cast<value_type> ( 5 );
 101
 102         const value_type b31 = static_cast<value_type> ( 3 ) / static_cast<value_type>( 40 );
 103         const value_type b32 = static_cast<value_type> ( 9 ) / static_cast<value_type>( 40 );
 104
 105         const value_type b41 = static_cast<value_type> ( 44 ) / static_cast<value_type> ( 45 );
 106         const value_type b42 = static_cast<value_type> ( -56 ) / static_cast<value_type> ( 15 );
 107         const value_type b43 = static_cast<value_type> ( 32 ) / static_cast<value_type> ( 9 );
 108
 109         const value_type b51 = static_cast<value_type> ( 19372 ) / static_cast<value_type>( 6561 );
 110         const value_type b52 = static_cast<value_type> ( -25360 ) / static_cast<value_type> ( 2187 );
 111         const value_type b53 = static_cast<value_type> ( 64448 ) / static_cast<value_type>( 6561 );
 112         const value_type b54 = static_cast<value_type> ( -212 ) / static_cast<value_type>( 729 );
 113
 114         const value_type b61 = static_cast<value_type> ( 9017 ) / static_cast<value_type>( 3168 );
 115         const value_type b62 = static_cast<value_type> ( -355 ) / static_cast<value_type>( 33 );
 116         const value_type b63 = static_cast<value_type> ( 46732 ) / static_cast<value_type>( 5247 );
 117         const value_type b64 = static_cast<value_type> ( 49 ) / static_cast<value_type>( 176 );
 118         const value_type b65 = static_cast<value_type> ( -5103 ) / static_cast<value_type>( 18656 );
 119
 120         const value_type c1 = static_cast<value_type> ( 35 ) / static_cast<value_type>( 384 );
 121         const value_type c3 = static_cast<value_type> ( 500 ) / static_cast<value_type>( 1113 );
 122         const value_type c4 = static_cast<value_type> ( 125 ) / static_cast<value_type>( 192 );
 123         const value_type c5 = static_cast<value_type> ( -2187 ) / static_cast<value_type>( 6784 );
 124         const value_type c6 = static_cast<value_type> ( 11 ) / static_cast<value_type>( 84 );
 125
 126         typename odeint::unwrap_reference< System >::type &sys = system;
 127
 128         m_k_x_tmp_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_k_x_tmp_impl<StateIn> , detail::ref( *this ) , detail::_1 ) );
 129
 130         //m_x_tmp = x + dt*b21*dxdt
 131         stepper_base_type::m_algebra.for_each3( m_x_tmp.m_v , in , dxdt_in ,
 132                 typename operations_type::template scale_sum2< value_type , time_type >( 1.0 , dt*b21 ) );
 133
 134         sys( m_x_tmp.m_v , m_k2.m_v , t + dt*a2 );
 135         // m_x_tmp = x + dt*b31*dxdt + dt*b32*m_k2
 136         stepper_base_type::m_algebra.for_each4( m_x_tmp.m_v , in , dxdt_in , m_k2.m_v ,
 137                 typename operations_type::template scale_sum3< value_type , time_type , time_type >( 1.0 , dt*b31 , dt*b32 ));
 138
 139         sys( m_x_tmp.m_v , m_k3.m_v , t + dt*a3 );
 140         // m_x_tmp = x + dt * (b41*dxdt + b42*m_k2 + b43*m_k3)
 141         stepper_base_type::m_algebra.for_each5( m_x_tmp.m_v , in , dxdt_in , m_k2.m_v , m_k3.m_v ,
 142                 typename operations_type::template scale_sum4< value_type , time_type , time_type , time_type >( 1.0 , dt*b41 , dt*b42 , dt*b43 ));
 143
 144         sys( m_x_tmp.m_v, m_k4.m_v , t + dt*a4 );
 145         stepper_base_type::m_algebra.for_each6( m_x_tmp.m_v , in , dxdt_in , m_k2.m_v , m_k3.m_v , m_k4.m_v ,
 146                 typename operations_type::template scale_sum5< value_type , time_type , time_type , time_type , time_type >( 1.0 , dt*b51 , dt*b52 , dt*b53 , dt*b54 ));
 147
 148         sys( m_x_tmp.m_v , m_k5.m_v , t + dt*a5 );
 149         stepper_base_type::m_algebra.for_each7( m_x_tmp.m_v , in , dxdt_in , m_k2.m_v , m_k3.m_v , m_k4.m_v , m_k5.m_v ,
 150                 typename operations_type::template scale_sum6< value_type , time_type , time_type , time_type , time_type , time_type >( 1.0 , dt*b61 , dt*b62 , dt*b63 , dt*b64 , dt*b65 ));
 151
 152         sys( m_x_tmp.m_v , m_k6.m_v , t + dt );
 153         stepper_base_type::m_algebra.for_each7( out , in , dxdt_in , m_k3.m_v , m_k4.m_v , m_k5.m_v , m_k6.m_v ,
 154                 typename operations_type::template scale_sum6< value_type , time_type , time_type , time_type , time_type , time_type >( 1.0 , dt*c1 , dt*c3 , dt*c4 , dt*c5 , dt*c6 ));
 155
 156         // the new derivative
 157         sys( out , dxdt_out , t + dt );
 158     }
 159
 160
 161
 162     template< class System , class StateIn , class DerivIn , class StateOut , class DerivOut , class Err >
 163     void do_step_impl( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t ,
 164             StateOut &out , DerivOut &dxdt_out , time_type dt , Err &xerr )
 165     {
 166         const value_type c1 = static_cast<value_type> ( 35 ) / static_cast<value_type>( 384 );
 167         const value_type c3 = static_cast<value_type> ( 500 ) / static_cast<value_type>( 1113 );
 168         const value_type c4 = static_cast<value_type> ( 125 ) / static_cast<value_type>( 192 );
 169         const value_type c5 = static_cast<value_type> ( -2187 ) / static_cast<value_type>( 6784 );
 170         const value_type c6 = static_cast<value_type> ( 11 ) / static_cast<value_type>( 84 );
 171
 172         const value_type dc1 = c1 - static_cast<value_type> ( 5179 ) / static_cast<value_type>( 57600 );
 173         const value_type dc3 = c3 - static_cast<value_type> ( 7571 ) / static_cast<value_type>( 16695 );
 174         const value_type dc4 = c4 - static_cast<value_type> ( 393 ) / static_cast<value_type>( 640 );
 175         const value_type dc5 = c5 - static_cast<value_type> ( -92097 ) / static_cast<value_type>( 339200 );
 176         const value_type dc6 = c6 - static_cast<value_type> ( 187 ) / static_cast<value_type>( 2100 );
 177         const value_type dc7 = static_cast<value_type>( -1 ) / static_cast<value_type> ( 40 );
 178
 179         /* ToDo: copy only if &dxdt_in == &dxdt_out ? */
 180         if( same_instance( dxdt_in , dxdt_out ) )
 181         {
 182             m_dxdt_tmp_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_dxdt_tmp_impl<StateIn> , detail::ref( *this ) , detail::_1 ) );
 183             boost::numeric::odeint::copy( dxdt_in , m_dxdt_tmp.m_v );
 184             do_step_impl( system , in , dxdt_in , t , out , dxdt_out , dt );
 185             //error estimate
 186             stepper_base_type::m_algebra.for_each7( xerr , m_dxdt_tmp.m_v , m_k3.m_v , m_k4.m_v , m_k5.m_v , m_k6.m_v , dxdt_out ,
 187                                                     typename operations_type::template scale_sum6< time_type , time_type , time_type , time_type , time_type , time_type >( dt*dc1 , dt*dc3 , dt*dc4 , dt*dc5 , dt*dc6 , dt*dc7 ) );
 188
 189         }
 190         else
 191         {
 192             do_step_impl( system , in , dxdt_in , t , out , dxdt_out , dt );
 193             //error estimate
 194             stepper_base_type::m_algebra.for_each7( xerr , dxdt_in , m_k3.m_v , m_k4.m_v , m_k5.m_v , m_k6.m_v , dxdt_out ,
 195                                                     typename operations_type::template scale_sum6< time_type , time_type , time_type , time_type , time_type , time_type >( dt*dc1 , dt*dc3 , dt*dc4 , dt*dc5 , dt*dc6 , dt*dc7 ) );
 196
 197         }
 198
 199     }
 200
 201
 202     /*
 203      * Calculates Dense-Output for Dopri5
 204      *
 205      * See Hairer, Norsett, Wanner: Solving Ordinary Differential Equations, Nonstiff Problems. I, p.191/192
 206      *
 207      * y(t+theta) = y(t) + h * sum_i^7 b_i(theta) * k_i
 208      *
 209      * A = theta^2 * ( 3 - 2 theta )
 210      * B = theta^2 * ( theta - 1 )
 211      * C = theta^2 * ( theta - 1 )^2
 212      * D = theta   * ( theta - 1 )^2
 213      *
 214      * b_1( theta ) = A * b_1 - C * X1( theta ) + D
 215      * b_2( theta ) = 0
 216      * b_3( theta ) = A * b_3 + C * X3( theta )
 217      * b_4( theta ) = A * b_4 - C * X4( theta )
 218      * b_5( theta ) = A * b_5 + C * X5( theta )
 219      * b_6( theta ) = A * b_6 - C * X6( theta )
 220      * b_7( theta ) = B + C * X7( theta )
 221      *
 222      * An alternative Method is described in:
 223      *
 224      * www-m2.ma.tum.de/homepages/simeon/numerik3/kap3.ps
 225      */
 226     template< class StateOut , class StateIn1 , class DerivIn1 , class StateIn2 , class DerivIn2 >
 227     void calc_state( time_type t , StateOut &x ,
 228                      const StateIn1 &x_old , const DerivIn1 &deriv_old , time_type t_old ,
 229                      const StateIn2 & /* x_new */ , const DerivIn2 &deriv_new , time_type t_new ) const
 230     {
 231         const value_type b1 = static_cast<value_type> ( 35 ) / static_cast<value_type>( 384 );
 232         const value_type b3 = static_cast<value_type> ( 500 ) / static_cast<value_type>( 1113 );
 233         const value_type b4 = static_cast<value_type> ( 125 ) / static_cast<value_type>( 192 );
 234         const value_type b5 = static_cast<value_type> ( -2187 ) / static_cast<value_type>( 6784 );
 235         const value_type b6 = static_cast<value_type> ( 11 ) / static_cast<value_type>( 84 );
 236
 237         const time_type dt = ( t_new - t_old );
 238         const value_type theta = ( t - t_old ) / dt;
 239         const value_type X1 = static_cast< value_type >( 5 ) * ( static_cast< value_type >( 2558722523LL ) - static_cast< value_type >( 31403016 ) * theta ) / static_cast< value_type >( 11282082432LL );
 240         const value_type X3 = static_cast< value_type >( 100 ) * ( static_cast< value_type >( 882725551 ) - static_cast< value_type >( 15701508 ) * theta ) / static_cast< value_type >( 32700410799LL );
 241         const value_type X4 = static_cast< value_type >( 25 ) * ( static_cast< value_type >( 443332067 ) - static_cast< value_type >( 31403016 ) * theta ) / static_cast< value_type >( 1880347072LL ) ;
 242         const value_type X5 = static_cast< value_type >( 32805 ) * ( static_cast< value_type >( 23143187 ) - static_cast< value_type >( 3489224 ) * theta ) / static_cast< value_type >( 199316789632LL );
 243         const value_type X6 = static_cast< value_type >( 55 ) * ( static_cast< value_type >( 29972135 ) - static_cast< value_type >( 7076736 ) * theta ) / static_cast< value_type >( 822651844 );
 244         const value_type X7 = static_cast< value_type >( 10 ) * ( static_cast< value_type >( 7414447 ) - static_cast< value_type >( 829305 ) * theta ) / static_cast< value_type >( 29380423 );
 245
 246         const value_type theta_m_1 = theta - static_cast< value_type >( 1 );
 247         const value_type theta_sq = theta * theta;
 248         const value_type A = theta_sq * ( static_cast< value_type >( 3 ) - static_cast< value_type >( 2 ) * theta );
 249         const value_type B = theta_sq * theta_m_1;
 250         const value_type C = theta_sq * theta_m_1 * theta_m_1;
 251         const value_type D = theta * theta_m_1 * theta_m_1;
 252
 253         const value_type b1_theta = A * b1 - C * X1 + D;
 254         const value_type b3_theta = A * b3 + C * X3;
 255         const value_type b4_theta = A * b4 - C * X4;
 256         const value_type b5_theta = A * b5 + C * X5;
 257         const value_type b6_theta = A * b6 - C * X6;
 258         const value_type b7_theta = B + C * X7;
 259
 260         // const state_type &k1 = *m_old_deriv;
 261         // const state_type &k3 = dopri5().m_k3;
 262         // const state_type &k4 = dopri5().m_k4;
 263         // const state_type &k5 = dopri5().m_k5;
 264         // const state_type &k6 = dopri5().m_k6;
 265         // const state_type &k7 = *m_current_deriv;
 266
 267         stepper_base_type::m_algebra.for_each8( x , x_old , deriv_old , m_k3.m_v , m_k4.m_v , m_k5.m_v , m_k6.m_v , deriv_new ,
 268                 typename operations_type::template scale_sum7< value_type , time_type , time_type , time_type , time_type , time_type , time_type >( 1.0 , dt * b1_theta , dt * b3_theta , dt * b4_theta , dt * b5_theta , dt * b6_theta , dt * b7_theta ) );
 269     }
 270
 271
 272     template< class StateIn >
 273     void adjust_size( const StateIn &x )
 274     {
 275         resize_k_x_tmp_impl( x );
 276         resize_dxdt_tmp_impl( x );
 277         stepper_base_type::adjust_size( x );
 278     }
 279
 280
 281 private:
 282
 283     template< class StateIn >
 284     bool resize_k_x_tmp_impl( const StateIn &x )
 285     {
 286         bool resized = false;
 287         resized |= adjust_size_by_resizeability( m_x_tmp , x , typename is_resizeable<state_type>::type() );
 288         resized |= adjust_size_by_resizeability( m_k2 , x , typename is_resizeable<deriv_type>::type() );
 289         resized |= adjust_size_by_resizeability( m_k3 , x , typename is_resizeable<deriv_type>::type() );
 290         resized |= adjust_size_by_resizeability( m_k4 , x , typename is_resizeable<deriv_type>::type() );
 291         resized |= adjust_size_by_resizeability( m_k5 , x , typename is_resizeable<deriv_type>::type() );
 292         resized |= adjust_size_by_resizeability( m_k6 , x , typename is_resizeable<deriv_type>::type() );
 293         return resized;
 294     }
 295
 296     template< class StateIn >
 297     bool resize_dxdt_tmp_impl( const StateIn &x )
 298     {
 299         return adjust_size_by_resizeability( m_dxdt_tmp , x , typename is_resizeable<deriv_type>::type() );
 300     }
 301
 302
 303
 304     wrapped_state_type m_x_tmp;
 305     wrapped_deriv_type m_k2 , m_k3 , m_k4 , m_k5 , m_k6 ;
 306     wrapped_deriv_type m_dxdt_tmp;
 307     resizer_type m_k_x_tmp_resizer;
 308     resizer_type m_dxdt_tmp_resizer;
 309 };
 310
 311
 312
 313 /************* DOXYGEN ************/
 314 /**
 315  * \class runge_kutta_dopri5
 316  * \brief The Runge-Kutta Dormand-Prince 5 method.
 317  *
 318  * The Runge-Kutta Dormand-Prince 5 method is a very popular method for solving ODEs, see
 319  * <a href=""></a>.
 320  * The method is explicit and fulfills the Error Stepper concept. Step size control
 321  * is provided but continuous output is available which make this method favourable for many applications.
 322  *
 323  * This class derives from explicit_error_stepper_fsal_base and inherits its interface via CRTP (current recurring
 324  * template pattern). The method possesses the FSAL (first-same-as-last) property. See
 325  * explicit_error_stepper_fsal_base for more details.
 326  *
 327  * \tparam State The state type.
 328  * \tparam Value The value type.
 329  * \tparam Deriv The type representing the time derivative of the state.
 330  * \tparam Time The time representing the independent variable - the time.
 331  * \tparam Algebra The algebra type.
 332  * \tparam Operations The operations type.
 333  * \tparam Resizer The resizer policy type.
 334  */
 335
 336
 337     /**
 338      * \fn runge_kutta_dopri5::runge_kutta_dopri5( const algebra_type &algebra )
 339      * \brief Constructs the runge_kutta_dopri5 class. This constructor can be used as a default
 340      * constructor if the algebra has a default constructor.
 341      * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
 342      */
 343
 344     /**
 345      * \fn runge_kutta_dopri5::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t , StateOut &out , DerivOut &dxdt_out , time_type dt )
 346      * \brief This method performs one step. The derivative `dxdt_in` of `in` at the time `t` is passed to the
 347      * method. The result is updated out-of-place, hence the input is in `in` and the output in `out`. Furthermore,
 348      * the derivative is update out-of-place, hence the input is assumed to be in `dxdt_in` and the output in
 349      * `dxdt_out`.
 350      * Access to this step functionality is provided by explicit_error_stepper_fsal_base and
 351      * `do_step_impl` should not be called directly.
 352      *
 353      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
 354      *               Simple System concept.
 355      * \param in The state of the ODE which should be solved. in is not modified in this method
 356      * \param dxdt_in The derivative of x at t. dxdt_in is not modified by this method
 357      * \param t The value of the time, at which the step should be performed.
 358      * \param out The result of the step is written in out.
 359      * \param dxdt_out The result of the new derivative at time t+dt.
 360      * \param dt The step size.
 361      */
 362
 363     /**
 364      * \fn runge_kutta_dopri5::do_step_impl( System system , const StateIn &in , const DerivIn &dxdt_in , time_type t , StateOut &out , DerivOut &dxdt_out , time_type dt , Err &xerr )
 365      * \brief This method performs one step. The derivative `dxdt_in` of `in` at the time `t` is passed to the
 366      * method. The result is updated out-of-place, hence the input is in `in` and the output in `out`. Furthermore,
 367      * the derivative is update out-of-place, hence the input is assumed to be in `dxdt_in` and the output in
 368      * `dxdt_out`.
 369      * Access to this step functionality is provided by explicit_error_stepper_fsal_base and
 370      * `do_step_impl` should not be called directly.
 371      * An estimation of the error is calculated.
 372      *
 373      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
 374      *               Simple System concept.
 375      * \param in The state of the ODE which should be solved. in is not modified in this method
 376      * \param dxdt_in The derivative of x at t. dxdt_in is not modified by this method
 377      * \param t The value of the time, at which the step should be performed.
 378      * \param out The result of the step is written in out.
 379      * \param dxdt_out The result of the new derivative at time t+dt.
 380      * \param dt The step size.
 381      * \param xerr An estimation of the error.
 382      */
 383
 384     /**
 385      * \fn runge_kutta_dopri5::calc_state( time_type t , StateOut &x , const StateIn1 &x_old , const DerivIn1 &deriv_old , time_type t_old , const StateIn2 &  , const DerivIn2 &deriv_new , time_type t_new ) const
 386      * \brief This method is used for continuous output and it calculates the state `x` at a time `t` from the
 387      * knowledge of two states `old_state` and `current_state` at time points `t_old` and `t_new`. It also uses
 388      * internal variables to calculate the result. Hence this method must be called after two successful `do_step`
 389      * calls.
 390      */
 391
 392     /**
 393      * \fn runge_kutta_dopri5::adjust_size( const StateIn &x )
 394      * \brief Adjust the size of all temporaries in the stepper manually.
 395      * \param x A state from which the size of the temporaries to be resized is deduced.
 396      */
 397
 398 } // odeint
 399 } // numeric
 400 } // boost
 401
 402
 403 #endif // BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA_DOPRI5_HPP_INCLUDED