294 lines
11 KiB
Plaintext
294 lines
11 KiB
Plaintext
/*
|
|
[auto_generated]
|
|
boost/numeric/odeint/stepper/extrapolation_stepper.hpp
|
|
|
|
[begin_description]
|
|
extrapolation stepper
|
|
[end_description]
|
|
|
|
Copyright 2009-2015 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)
|
|
*/
|
|
|
|
#ifndef BOOST_NUMERIC_ODEINT_STEPPER_EXTRAPOLATION_STEPPER_HPP_INCLUDED
|
|
#define BOOST_NUMERIC_ODEINT_STEPPER_EXTRAPOLATION_STEPPER_HPP_INCLUDED
|
|
|
|
#include <iostream>
|
|
|
|
#include <algorithm>
|
|
|
|
#include <boost/config.hpp> // for min/max guidelines
|
|
#include <boost/static_assert.hpp>
|
|
|
|
#include <boost/numeric/odeint/util/bind.hpp>
|
|
#include <boost/numeric/odeint/util/unwrap_reference.hpp>
|
|
|
|
#include <boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp>
|
|
#include <boost/numeric/odeint/stepper/modified_midpoint.hpp>
|
|
#include <boost/numeric/odeint/stepper/controlled_step_result.hpp>
|
|
#include <boost/numeric/odeint/algebra/range_algebra.hpp>
|
|
#include <boost/numeric/odeint/algebra/default_operations.hpp>
|
|
#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
|
|
#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>
|
|
|
|
#include <boost/numeric/odeint/util/state_wrapper.hpp>
|
|
#include <boost/numeric/odeint/util/is_resizeable.hpp>
|
|
#include <boost/numeric/odeint/util/resizer.hpp>
|
|
#include <boost/numeric/odeint/util/unit_helper.hpp>
|
|
#include <boost/numeric/odeint/util/detail/less_with_sign.hpp>
|
|
|
|
namespace boost
|
|
{
|
|
namespace numeric
|
|
{
|
|
namespace odeint
|
|
{
|
|
|
|
template < unsigned short Order, class State, class Value = double,
|
|
class Deriv = State, class Time = Value,
|
|
class Algebra = typename algebra_dispatcher< State >::algebra_type,
|
|
class Operations =
|
|
typename operations_dispatcher< State >::operations_type,
|
|
class Resizer = initially_resizer >
|
|
#ifndef DOXYGEN_SKIP
|
|
class extrapolation_stepper
|
|
: public explicit_error_stepper_base<
|
|
extrapolation_stepper< Order, State, Value, Deriv, Time, Algebra,
|
|
Operations, Resizer >,
|
|
Order, Order, Order - 2, State, Value, Deriv, Time, Algebra,
|
|
Operations, Resizer >
|
|
#else
|
|
class extrapolation_stepper : public explicit_error_stepper_base
|
|
#endif
|
|
{
|
|
|
|
private:
|
|
// check for Order being odd
|
|
BOOST_STATIC_ASSERT_MSG(
|
|
( ( Order % 2 ) == 0 ) && ( Order > 2 ),
|
|
"extrapolation_stepper requires even Order larger than 2" );
|
|
|
|
public:
|
|
#ifndef DOXYGEN_SKIP
|
|
typedef explicit_error_stepper_base<
|
|
extrapolation_stepper< Order, State, Value, Deriv, Time, Algebra,
|
|
Operations, Resizer >,
|
|
Order, Order, Order - 2, State, Value, Deriv, Time, Algebra, Operations,
|
|
Resizer > stepper_base_type;
|
|
#else
|
|
typedef explicit_error_stepper_base< extrapolation_stepper< ... >, ... >
|
|
stepper_base_type;
|
|
#endif
|
|
|
|
typedef typename stepper_base_type::state_type state_type;
|
|
typedef typename stepper_base_type::value_type value_type;
|
|
typedef typename stepper_base_type::deriv_type deriv_type;
|
|
typedef typename stepper_base_type::time_type time_type;
|
|
typedef typename stepper_base_type::algebra_type algebra_type;
|
|
typedef typename stepper_base_type::operations_type operations_type;
|
|
typedef typename stepper_base_type::resizer_type resizer_type;
|
|
|
|
#ifndef DOXYGEN_SKIP
|
|
typedef typename stepper_base_type::stepper_type stepper_type;
|
|
typedef typename stepper_base_type::wrapped_state_type wrapped_state_type;
|
|
typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
|
|
|
|
typedef std::vector< value_type > value_vector;
|
|
typedef std::vector< value_vector > value_matrix;
|
|
typedef std::vector< size_t > int_vector;
|
|
typedef std::vector< wrapped_state_type > state_table_type;
|
|
typedef modified_midpoint< state_type, value_type, deriv_type, time_type,
|
|
algebra_type, operations_type,
|
|
resizer_type > midpoint_stepper_type;
|
|
|
|
#endif // DOXYGEN_SKIP
|
|
|
|
typedef unsigned short order_type;
|
|
static const order_type order_value = stepper_base_type::order_value;
|
|
static const order_type stepper_order_value =
|
|
stepper_base_type::stepper_order_value;
|
|
static const order_type error_order_value =
|
|
stepper_base_type::error_order_value;
|
|
|
|
const static size_t m_k_max = ( order_value - 2 ) / 2;
|
|
|
|
extrapolation_stepper( const algebra_type &algebra = algebra_type() )
|
|
: stepper_base_type( algebra ), m_interval_sequence( m_k_max + 1 ),
|
|
m_coeff( m_k_max + 1 ), m_table( m_k_max )
|
|
{
|
|
for ( unsigned short i = 0; i < m_k_max + 1; i++ )
|
|
{
|
|
m_interval_sequence[i] = 2 * ( i + 1 );
|
|
m_coeff[i].resize( i );
|
|
for ( size_t k = 0; k < i; ++k )
|
|
{
|
|
const value_type r =
|
|
static_cast< value_type >( m_interval_sequence[i] ) /
|
|
static_cast< value_type >( m_interval_sequence[k] );
|
|
m_coeff[i][k] =
|
|
static_cast< value_type >( 1 ) /
|
|
( r * r - static_cast< value_type >(
|
|
1 ) ); // coefficients for extrapolation
|
|
}
|
|
}
|
|
}
|
|
|
|
template < class System, class StateIn, class DerivIn, class StateOut,
|
|
class Err >
|
|
void do_step_impl( System system, const StateIn &in, const DerivIn &dxdt,
|
|
time_type t, StateOut &out, time_type dt, Err &xerr )
|
|
{
|
|
// std::cout << "dt: " << dt << std::endl;
|
|
// normal step
|
|
do_step_impl( system, in, dxdt, t, out, dt );
|
|
|
|
static const value_type val1( 1.0 );
|
|
// additionally, perform the error calculation
|
|
stepper_base_type::m_algebra.for_each3(
|
|
xerr, out, m_table[0].m_v,
|
|
typename operations_type::template scale_sum2<
|
|
value_type, value_type >( val1, -val1 ) );
|
|
}
|
|
|
|
template < class System, class StateInOut, class DerivIn, class Err >
|
|
void do_step_impl_io( System system, StateInOut &inout, const DerivIn &dxdt,
|
|
time_type t, time_type dt, Err &xerr )
|
|
{
|
|
// normal step
|
|
do_step_impl_io( system, inout, dxdt, t, dt );
|
|
|
|
static const value_type val1( 1.0 );
|
|
// additionally, perform the error calculation
|
|
stepper_base_type::m_algebra.for_each3(
|
|
xerr, inout, m_table[0].m_v,
|
|
typename operations_type::template scale_sum2<
|
|
value_type, value_type >( val1, -val1 ) );
|
|
}
|
|
|
|
template < class System, class StateIn, class DerivIn, class StateOut >
|
|
void do_step_impl( System system, const StateIn &in, const DerivIn &dxdt,
|
|
time_type t, StateOut &out, time_type dt )
|
|
{
|
|
m_resizer.adjust_size(
|
|
in, detail::bind( &stepper_type::template resize_impl< StateIn >,
|
|
detail::ref( *this ), detail::_1 ) );
|
|
size_t k = 0;
|
|
m_midpoint.set_steps( m_interval_sequence[k] );
|
|
m_midpoint.do_step( system, in, dxdt, t, out, dt );
|
|
for ( k = 1; k <= m_k_max; ++k )
|
|
{
|
|
m_midpoint.set_steps( m_interval_sequence[k] );
|
|
m_midpoint.do_step( system, in, dxdt, t, m_table[k - 1].m_v, dt );
|
|
extrapolate( k, m_table, m_coeff, out );
|
|
}
|
|
}
|
|
|
|
template < class System, class StateInOut, class DerivIn >
|
|
void do_step_impl_io( System system, StateInOut &inout, const DerivIn &dxdt,
|
|
time_type t, time_type dt )
|
|
{
|
|
// special care for inout
|
|
m_xout_resizer.adjust_size(
|
|
inout,
|
|
detail::bind( &stepper_type::template resize_m_xout< StateInOut >,
|
|
detail::ref( *this ), detail::_1 ) );
|
|
do_step_impl( system, inout, dxdt, t, m_xout.m_v, dt );
|
|
boost::numeric::odeint::copy( m_xout.m_v, inout );
|
|
}
|
|
|
|
template < class System, class StateInOut, class DerivIn >
|
|
void do_step_dxdt_impl( System system, StateInOut &x, const DerivIn &dxdt,
|
|
time_type t, time_type dt )
|
|
{
|
|
do_step_impl_io( system , x , dxdt , t , dt );
|
|
}
|
|
|
|
template < class System, class StateIn, class DerivIn, class StateOut >
|
|
void do_step_dxdt_impl( System system, const StateIn &in,
|
|
const DerivIn &dxdt, time_type t, StateOut &out,
|
|
time_type dt )
|
|
{
|
|
do_step_impl( system , in , dxdt , t , out , dt );
|
|
}
|
|
|
|
|
|
template < class StateIn > void adjust_size( const StateIn &x )
|
|
{
|
|
resize_impl( x );
|
|
m_midpoint.adjust_size( x );
|
|
}
|
|
|
|
private:
|
|
template < class StateIn > bool resize_impl( const StateIn &x )
|
|
{
|
|
bool resized( false );
|
|
for ( size_t i = 0; i < m_k_max; ++i )
|
|
resized |= adjust_size_by_resizeability(
|
|
m_table[i], x, typename is_resizeable< state_type >::type() );
|
|
return resized;
|
|
}
|
|
|
|
template < class StateIn > bool resize_m_xout( const StateIn &x )
|
|
{
|
|
return adjust_size_by_resizeability(
|
|
m_xout, x, typename is_resizeable< state_type >::type() );
|
|
}
|
|
|
|
template < class StateInOut >
|
|
void extrapolate( size_t k, state_table_type &table,
|
|
const value_matrix &coeff, StateInOut &xest )
|
|
/* polynomial extrapolation, see http://www.nr.com/webnotes/nr3web21.pdf
|
|
uses the obtained intermediate results to extrapolate to dt->0
|
|
*/
|
|
{
|
|
static const value_type val1 = static_cast< value_type >( 1.0 );
|
|
|
|
for ( int j = k - 1; j > 0; --j )
|
|
{
|
|
stepper_base_type::m_algebra.for_each3(
|
|
table[j - 1].m_v, table[j].m_v, table[j - 1].m_v,
|
|
typename operations_type::template scale_sum2<
|
|
value_type, value_type >( val1 + coeff[k][j],
|
|
-coeff[k][j] ) );
|
|
}
|
|
stepper_base_type::m_algebra.for_each3(
|
|
xest, table[0].m_v, xest,
|
|
typename operations_type::template scale_sum2<
|
|
value_type, value_type >( val1 + coeff[k][0], -coeff[k][0] ) );
|
|
}
|
|
|
|
private:
|
|
midpoint_stepper_type m_midpoint;
|
|
|
|
resizer_type m_resizer;
|
|
resizer_type m_xout_resizer;
|
|
|
|
int_vector m_interval_sequence; // stores the successive interval counts
|
|
value_matrix m_coeff;
|
|
|
|
wrapped_state_type m_xout;
|
|
state_table_type m_table; // sequence of states for extrapolation
|
|
};
|
|
|
|
/******** DOXYGEN *******/
|
|
|
|
/**
|
|
* \class extrapolation_stepper
|
|
* \brief Extrapolation stepper with configurable order, and error estimation.
|
|
*
|
|
* The extrapolation stepper is a stepper with error estimation and configurable
|
|
* order. The order is given as template parameter and needs to be an _odd_
|
|
* number. The stepper is based on several executions of the modified midpoint
|
|
* method and a Richardson extrapolation. This is essentially the same technique
|
|
* as for bulirsch_stoer, but without the variable order.
|
|
*
|
|
* \note The Order parameter has to be an even number greater 2.
|
|
*/
|
|
}
|
|
}
|
|
}
|
|
#endif
|