272 lines
6.5 KiB
C++
272 lines
6.5 KiB
C++
/*
|
|
[auto_generated]
|
|
libs/numeric/odeint/test/integrate_stepper_refs.cpp
|
|
|
|
[begin_description]
|
|
Tests the integrate functions with boost::ref( stepper)
|
|
[end_description]
|
|
|
|
Copyright 2009-2013 Karsten Ahnert
|
|
Copyright 2009-2013 Mario Mulansky
|
|
|
|
Distributed under the Boost Software License, Version 1.0.
|
|
(See accompanying file LICENSE_1_0.txt or
|
|
copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
*/
|
|
|
|
|
|
#define BOOST_TEST_MODULE odeint_integrate_stepper_refs
|
|
|
|
#include <vector>
|
|
#include <cmath>
|
|
#include <iostream>
|
|
|
|
#include <boost/numeric/odeint/config.hpp>
|
|
|
|
#include <boost/noncopyable.hpp>
|
|
#include <boost/test/unit_test.hpp>
|
|
#include <boost/iterator/counting_iterator.hpp>
|
|
|
|
#include <boost/mpl/vector.hpp>
|
|
|
|
#include <boost/numeric/odeint/integrate/integrate_const.hpp>
|
|
#include <boost/numeric/odeint/integrate/integrate_adaptive.hpp>
|
|
#include <boost/numeric/odeint/integrate/integrate_times.hpp>
|
|
#include <boost/numeric/odeint/integrate/integrate_n_steps.hpp>
|
|
#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
|
|
|
|
|
|
using namespace boost::unit_test;
|
|
using namespace boost::numeric::odeint;
|
|
namespace mpl = boost::mpl;
|
|
|
|
typedef double value_type;
|
|
typedef std::vector< value_type > state_type;
|
|
|
|
// minimal non-copyable basic stepper
|
|
template<
|
|
class State
|
|
>
|
|
class simple_stepper_nc : boost::noncopyable
|
|
{
|
|
public :
|
|
typedef State state_type;
|
|
typedef double value_type;
|
|
typedef state_type deriv_type;
|
|
typedef double time_type;
|
|
typedef size_t order_type;
|
|
typedef stepper_tag stepper_category;
|
|
|
|
template< class System >
|
|
void do_step( System system , state_type &in , time_type t , time_type dt )
|
|
{
|
|
// empty
|
|
|
|
}
|
|
};
|
|
|
|
// minimal non-copyable controlled stepper
|
|
template<
|
|
class State
|
|
>
|
|
class controlled_stepper_nc : boost::noncopyable
|
|
{
|
|
public :
|
|
typedef State state_type;
|
|
typedef double value_type;
|
|
typedef state_type deriv_type;
|
|
typedef double time_type;
|
|
typedef size_t order_type;
|
|
typedef controlled_stepper_tag stepper_category;
|
|
|
|
template< class System >
|
|
controlled_step_result try_step( System system , state_type &in , time_type &t , time_type &dt )
|
|
{
|
|
std::cout << "dense out stepper: " << t << " , " << dt << std::endl;
|
|
t += dt;
|
|
return success;
|
|
}
|
|
};
|
|
|
|
// minimal non-copyable dense_output stepper
|
|
template<
|
|
class State
|
|
>
|
|
class dense_out_stepper_nc : boost::noncopyable
|
|
{
|
|
public :
|
|
typedef State state_type;
|
|
typedef double value_type;
|
|
typedef state_type deriv_type;
|
|
typedef double time_type;
|
|
typedef size_t order_type;
|
|
typedef dense_output_stepper_tag stepper_category;
|
|
|
|
void initialize( const state_type &x0 , const time_type t0 , const time_type dt0 )
|
|
{
|
|
m_x = x0;
|
|
m_t = t0;
|
|
m_dt = dt0;
|
|
std::cout << "initialize: " << m_t << " , " << m_dt << std::endl;
|
|
}
|
|
|
|
template< class System >
|
|
void do_step( System system )
|
|
{
|
|
std::cout << "dense out stepper: " << m_t << " , " << m_dt << std::endl;
|
|
m_t += m_dt;
|
|
}
|
|
|
|
void calc_state( const time_type t_inter , state_type &x )
|
|
{
|
|
x = m_x;
|
|
}
|
|
|
|
const state_type& current_state() const
|
|
{ return m_x; }
|
|
|
|
time_type current_time() const
|
|
{ return m_t; }
|
|
|
|
time_type current_time_step() const
|
|
{ return m_dt; }
|
|
|
|
|
|
private :
|
|
time_type m_t;
|
|
time_type m_dt;
|
|
state_type m_x;
|
|
};
|
|
|
|
|
|
void lorenz( const state_type &x , state_type &dxdt , const value_type t )
|
|
{
|
|
//const value_type sigma( 10.0 );
|
|
const value_type R( 28.0 );
|
|
const value_type b( value_type( 8.0 ) / value_type( 3.0 ) );
|
|
|
|
// first component trivial
|
|
dxdt[0] = 1.0; //sigma * ( x[1] - x[0] );
|
|
dxdt[1] = R * x[0] - x[1] - x[0] * x[2];
|
|
dxdt[2] = -b * x[2] + x[0] * x[1];
|
|
}
|
|
|
|
struct push_back_time
|
|
{
|
|
std::vector< double >& m_times;
|
|
|
|
state_type& m_x;
|
|
|
|
push_back_time( std::vector< double > × , state_type &x )
|
|
: m_times( times ) , m_x( x ) { }
|
|
|
|
void operator()( const state_type &x , double t )
|
|
{
|
|
m_times.push_back( t );
|
|
boost::numeric::odeint::copy( x , m_x );
|
|
}
|
|
};
|
|
|
|
template< class Stepper >
|
|
struct perform_integrate_const_test
|
|
{
|
|
void operator()()
|
|
{
|
|
state_type x( 3 , 10.0 ) , x_end( 3 );
|
|
|
|
std::vector< value_type > times;
|
|
|
|
Stepper stepper;
|
|
|
|
integrate_const( boost::ref(stepper) , lorenz , x , 0.0 , 1.0 ,
|
|
0.1, push_back_time( times , x_end ) );
|
|
}
|
|
};
|
|
|
|
template< class Stepper >
|
|
struct perform_integrate_adaptive_test
|
|
{
|
|
void operator()()
|
|
{
|
|
state_type x( 3 , 10.0 ) , x_end( 3 );
|
|
|
|
std::vector< value_type > times;
|
|
|
|
Stepper stepper;
|
|
|
|
integrate_adaptive( boost::ref(stepper) , lorenz , x , 0.0 , 1.0 ,
|
|
0.1, push_back_time( times , x_end ) );
|
|
}
|
|
};
|
|
|
|
template< class Stepper >
|
|
struct perform_integrate_n_steps_test
|
|
{
|
|
void operator()()
|
|
{
|
|
state_type x( 3 , 10.0 ) , x_end( 3 );
|
|
|
|
std::vector< value_type > times;
|
|
|
|
Stepper stepper;
|
|
|
|
integrate_n_steps( boost::ref(stepper) , lorenz , x , 0.0 , 0.1 ,
|
|
10 , push_back_time( times , x_end ) );
|
|
}
|
|
};
|
|
|
|
template< class Stepper >
|
|
struct perform_integrate_times_test
|
|
{
|
|
void operator()()
|
|
{
|
|
state_type x( 3 , 10.0 ) , x_end( 3 );
|
|
|
|
std::vector< value_type > times;
|
|
|
|
Stepper stepper;
|
|
|
|
integrate_times( boost::ref(stepper) , lorenz , x ,
|
|
boost::counting_iterator<int>(0) , boost::counting_iterator<int>(10) , 0.1 ,
|
|
push_back_time( times , x_end ) );
|
|
}
|
|
};
|
|
|
|
class stepper_methods : public mpl::vector<
|
|
simple_stepper_nc< state_type > ,
|
|
controlled_stepper_nc< state_type >,
|
|
dense_out_stepper_nc< state_type > > { };
|
|
|
|
BOOST_AUTO_TEST_SUITE( integrate_stepper_refs )
|
|
|
|
BOOST_AUTO_TEST_CASE_TEMPLATE( integrate_const_test_case , Stepper, stepper_methods )
|
|
{
|
|
std::cout << "integrate const" << std::endl;
|
|
perform_integrate_const_test< Stepper > tester;
|
|
tester();
|
|
}
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE_TEMPLATE( integrate_adaptive_test_case , Stepper, stepper_methods )
|
|
{
|
|
std::cout << "integrate adaptive" << std::endl;
|
|
perform_integrate_adaptive_test< Stepper > tester;
|
|
tester();
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE_TEMPLATE( integrate_n_steps_test_case , Stepper, stepper_methods )
|
|
{
|
|
std::cout << "integrate n steps" << std::endl;
|
|
perform_integrate_n_steps_test< Stepper > tester;
|
|
tester();
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE_TEMPLATE( integrate_times_test_case , Stepper, stepper_methods )
|
|
{
|
|
std::cout << "integrate times" << std::endl;
|
|
perform_integrate_times_test< Stepper > tester;
|
|
tester();
|
|
}
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|