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 explicit_error_stepper_base(const algebra_type & algebra=algebra_type ())96 explicit_error_stepper_base( const algebra_type &algebra = algebra_type() ) 97 : algebra_stepper_base_type( algebra ) 98 { } 99 order(void) const100 order_type order( void ) const 101 { 102 return order_value; 103 } 104 stepper_order(void) const105 order_type stepper_order( void ) const 106 { 107 return stepper_order_value; 108 } 109 error_order(void) const110 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 > do_step(System system,StateInOut & x,time_type t,time_type dt)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 > do_step(System system,const StateInOut & x,time_type t,time_type dt)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 do_step(System system,StateInOut & x,const DerivIn & dxdt,time_type t,time_type dt)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 > do_step_dxdt_impl(System system,StateInOut & x,const DerivIn & dxdt,time_type t,time_type dt)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 do_step(System system,const StateIn & in,time_type t,StateOut & out,time_type dt)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 do_step(System system,const StateIn & in,const DerivIn & dxdt,time_type t,StateOut & out,time_type dt)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 > do_step_dxdt_impl(System system,const StateIn & in,const DerivIn & dxdt,time_type t,StateOut & out,time_type dt)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 > do_step(System system,StateInOut & x,time_type t,time_type dt,Err & xerr)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 > do_step(System system,const StateInOut & x,time_type t,time_type dt,Err & xerr)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 do_step(System system,StateInOut & x,const DerivIn & dxdt,time_type t,time_type dt,Err & xerr)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 > do_step(System system,const StateIn & in,time_type t,StateOut & out,time_type dt,Err & xerr)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 > do_step(System system,const StateIn & in,const DerivIn & dxdt,time_type t,StateOut & out,time_type dt,Err & xerr)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 > adjust_size(const StateIn & x)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 > do_step_v1(System system,StateInOut & x,time_type t,time_type dt)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 > do_step_v5(System system,StateInOut & x,time_type t,time_type dt,Err & xerr)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 > resize_impl(const StateIn & x)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 stepper(void)312 stepper_type& stepper( void ) 313 { 314 return *static_cast< stepper_type* >( this ); 315 } 316 stepper(void) const317 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 589