size_t integrate_adaptive(
Stepper stepper , System system , State &start_state ,
Time start_time , Time end_time , Time dt ,
Observer observer , dense_output_stepper_tag )
{
typename omplext_odeint::unwrap_reference< Observer >::type &obs = observer;
size_t count = 0;
stepper.initialize( start_state , start_time , dt );
while( less_with_sign( stepper.current_time() , end_time , stepper.current_time_step() ) )
{
while( less_eq_with_sign( stepper.current_time() + stepper.current_time_step() ,
end_time ,
stepper.current_time_step() ) )
{ //make sure we don't go beyond the end_time
obs( stepper.current_state() , stepper.current_time() );
stepper.do_step( system );
++count;
}
stepper.initialize( stepper.current_state() , stepper.current_time() , end_time - stepper.current_time() );
}
obs( stepper.current_state() , stepper.current_time() );
// overwrite start_state with the final point
boost::numeric::omplext_odeint::copy( stepper.current_state() , start_state );
return count;
}
Time integrate_n_steps(
Stepper stepper , System system , State &start_state ,
Time start_time , Time dt , size_t num_of_steps ,
Observer observer , dense_output_stepper_tag )
{
typename odeint::unwrap_reference< Observer >::type &obs = observer;
Time time = start_time;
const Time end_time = start_time + static_cast< typename unit_value_type<Time>::type >(num_of_steps) * dt;
stepper.initialize( start_state , time , dt );
size_t step = 0;
while( step < num_of_steps )
{
while( less_with_sign( time , stepper.current_time() , stepper.current_time_step() ) )
{
stepper.calc_state( time , start_state );
obs( start_state , time );
++step;
// direct computation of the time avoids error propagation happening when using time += dt
// we need clumsy type analysis to get boost units working here
time = start_time + static_cast< typename unit_value_type<Time>::type >(step) * dt;
}
// we have not reached the end, do another real step
if( less_with_sign( stepper.current_time()+stepper.current_time_step() ,
end_time ,
stepper.current_time_step() ) )
{
stepper.do_step( system );
}
else if( less_with_sign( stepper.current_time() , end_time , stepper.current_time_step() ) )
{ // do the last step ending exactly on the end point
stepper.initialize( stepper.current_state() , stepper.current_time() , end_time - stepper.current_time() );
stepper.do_step( system );
}
}
while( stepper.current_time() < end_time )
{
if( less_with_sign( end_time ,
stepper.current_time()+stepper.current_time_step() ,
stepper.current_time_step() ) )
stepper.initialize( stepper.current_state() , stepper.current_time() , end_time - stepper.current_time() );
stepper.do_step( system );
}
// observation at end point, only if we ended exactly on the end-point (or above due to finite precision)
obs( stepper.current_state() , end_time );
return time;
}
void operator()( void )
{
Stepper stepper;
initializing_stepper init_stepper;
const int o = stepper.order()+1; //order of the error is order of approximation + 1
const state_type x0 = {{ 0.0 , 1.0 }};
state_type x1 = x0;
double t = 0.0;
double dt = 0.2;
// initialization, does a number of steps already to fill internal buffer, t is increased
// we use the rk78 as initializing stepper
stepper.initialize( boost::ref(init_stepper) , osc() , x1 , t , dt );
double A = std::sqrt( x1[0]*x1[0] + x1[1]*x1[1] );
double phi = std::asin(x1[0]/A) - t;
// do a number of steps to fill the buffer with results from adams bashforth
for( size_t n=0 ; n < stepper.steps ; ++n )
{
stepper.do_step( osc() , x1 , t , dt );
t += dt;
}
// now we do the actual step
stepper.do_step( osc() , x1 , t , dt );
// only examine the error of the adams-bashforth step, not the initialization
const double f = 2.0 * std::abs( A*sin(t+dt+phi) - x1[0] ) / std::pow( dt , o ); // upper bound
std::cout << o << " , " << f << std::endl;
/* as long as we have errors above machine precision */
while( f*std::pow( dt , o ) > 1E-16 )
{
x1 = x0;
t = 0.0;
stepper.initialize( boost::ref(init_stepper) , osc() , x1 , t , dt );
A = std::sqrt( x1[0]*x1[0] + x1[1]*x1[1] );
phi = std::asin(x1[0]/A) - t;
// now we do the actual step
stepper.do_step( osc() , x1 , t , dt );
// only examine the error of the adams-bashforth step, not the initialization
std::cout << "Testing dt=" << dt << " , " << std::abs( A*sin(t+dt+phi) - x1[0] ) << std::endl;
BOOST_CHECK_LT( std::abs( A*sin(t+dt+phi) - x1[0] ) , f*std::pow( dt , o ) );
dt *= 0.5;
}
}
size_t integrate_adaptive(
Stepper stepper , System system , State &start_state ,
Time start_time , Time end_time , Time dt ,
Observer observer , dense_output_stepper_tag )
{
typename boost::unwrap_reference< Observer >::type &obs = observer;
size_t count = 0;
stepper.initialize( start_state , start_time , dt );
while( stepper.current_time() < end_time )
{
while( stepper.current_time() + stepper.current_time_step() <= end_time )
{ //make sure we don't go beyond the end_time
obs( stepper.current_state() , stepper.current_time() );
stepper.do_step( system );
++count;
}
stepper.initialize( stepper.current_state() , stepper.current_time() , end_time - stepper.current_time() );
}
obs( stepper.current_state() , stepper.current_time() );
return count;
}
void operator()( void )
{
double t = 0;
const double dt = 0.1;
state_type x = 0;
Stepper stepper;
InitStepper init_stepper;
stepper.initialize( init_stepper, rhs, x, t, dt );
// ab-stepper needs order-1 init steps: t and x should be (order-1)*dt
BOOST_CHECK_CLOSE( t , (stepper.order()-1)*dt , 1E-16 );
BOOST_CHECK_CLOSE( x, ( stepper.order() - 1 ) * dt, 2E-14 );
}
void check_dense_output_stepper( Stepper &stepper )
{
typedef Stepper stepper_type;
typedef typename stepper_type::state_type state_type;
typedef typename stepper_type::value_type value_type;
typedef typename stepper_type::deriv_type deriv_type;
typedef typename stepper_type::time_type time_type;
// typedef typename stepper_type::order_type order_type;
time_type t( 0.0 * si::second );
time_type dt( 0.1 * si::second );
state_type x( 1.0 * si::meter , 0.0 * si::meter_per_second ) , x2;
stepper.initialize( x , t , dt );
stepper.do_step( oscillator );
stepper.calc_state( dt / 2.0 , x2 );
}
