FM / stepper

/usr/include/boost/numeric/odeint/stepper/

/usr/include/boost/numeric/odeint/stepper

Name	Size	Mode	Actions
base/	-	0755	rm
detail/	-	0755	rm
generation/	-	0755	rm
adams_bashforth.hpp	15264	0644	edit dl rm
adams_bashforth_moulton.hpp	12015	0644	edit dl rm
adams_moulton.hpp	6112	0644	edit dl rm
adaptive_adams_bashforth_moulton.hpp	8311	0644	edit dl rm
bulirsch_stoer.hpp	26189	0644	edit dl rm
bulirsch_stoer_dense_out.hpp	33859	0644	edit dl rm
controlled_adams_bashforth_moulton.hpp	10080	0644	edit dl rm
controlled_runge_kutta.hpp	38301	0644	edit dl rm
controlled_step_result.hpp	1092	0644	edit dl rm
dense_output_runge_kutta.hpp	14590	0644	edit dl rm
euler.hpp	6587	0644	edit dl rm
explicit_error_generic_rk.hpp	10708	0644	edit dl rm
explicit_generic_rk.hpp	8491	0644	edit dl rm
extrapolation_stepper.hpp	11155	0644	edit dl rm
generation.hpp	1477	0644	edit dl rm
implicit_euler.hpp	5236	0644	edit dl rm
modified_midpoint.hpp	10566	0644	edit dl rm
rosenbrock4.hpp	14602	0644	edit dl rm
rosenbrock4_controller.hpp	7290	0644	edit dl rm
rosenbrock4_dense_output.hpp	5595	0644	edit dl rm
runge_kutta4.hpp	5860	0644	edit dl rm
runge_kutta4_classic.hpp	9255	0644	edit dl rm
runge_kutta_cash_karp54.hpp	8676	0644	edit dl rm
runge_kutta_cash_karp54_classic.hpp	14318	0644	edit dl rm
runge_kutta_dopri5.hpp	21484	0644	edit dl rm
runge_kutta_fehlberg78.hpp	15005	0644	edit dl rm
stepper_categories.hpp	2162	0644	edit dl rm
symplectic_euler.hpp	3937	0644	edit dl rm
symplectic_rkn_sb3a_m4_mclachlan.hpp	5120	0644	edit dl rm
symplectic_rkn_sb3a_mclachlan.hpp	5389	0644	edit dl rm
velocity_verlet.hpp	13544	0644	edit dl rm

Edit: /usr/include/boost/numeric/odeint/stepper/runge_kutta4.hpp (5860B)

/*
 [auto_generated]
 boost/numeric/odeint/stepper/runge_kutta4.hpp

[begin_description]
 Implementation of the classical Runge-Kutta stepper with the generic stepper.
 [end_description]

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_RUNGE_KUTTA4_HPP_INCLUDED
#define BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA4_HPP_INCLUDED

#include <boost/fusion/container/vector.hpp>
#include <boost/fusion/container/generation/make_vector.hpp>

#include <boost/numeric/odeint/stepper/explicit_generic_rk.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/array.hpp>

#include <boost/numeric/odeint/util/resizer.hpp>

namespace boost {
namespace numeric {
namespace odeint {

#ifndef DOXYGEN_SKIP
template< class Value = double >
struct rk4_coefficients_a1 : boost::array< Value , 1 >
{
    rk4_coefficients_a1( void )
    {
        (*this)[0] = static_cast< Value >( 1 ) / static_cast< Value >( 2 );
    }
};

template< class Value = double >
struct rk4_coefficients_a2 : boost::array< Value , 2 >
{
    rk4_coefficients_a2( void )
    {
        (*this)[0] = static_cast<Value>(0);
        (*this)[1] = static_cast< Value >( 1 ) / static_cast< Value >( 2 );
    }
};

template< class Value = double >
struct rk4_coefficients_a3 : boost::array< Value , 3 >
{
    rk4_coefficients_a3( void )
            {
        (*this)[0] = static_cast<Value>(0);
        (*this)[1] = static_cast<Value>(0);
        (*this)[2] = static_cast<Value>(1);
            }
};

template< class Value = double >
struct rk4_coefficients_b : boost::array< Value , 4 >
{
    rk4_coefficients_b( void )
    {
        (*this)[0] = static_cast<Value>(1)/static_cast<Value>(6);
        (*this)[1] = static_cast<Value>(1)/static_cast<Value>(3);
        (*this)[2] = static_cast<Value>(1)/static_cast<Value>(3);
        (*this)[3] = static_cast<Value>(1)/static_cast<Value>(6);
    }
};

template< class Value = double >
struct rk4_coefficients_c : boost::array< Value , 4 >
{
    rk4_coefficients_c( void )
    {
        (*this)[0] = static_cast<Value>(0);
        (*this)[1] = static_cast< Value >( 1 ) / static_cast< Value >( 2 );
        (*this)[2] = static_cast< Value >( 1 ) / static_cast< Value >( 2 );
        (*this)[3] = static_cast<Value>(1);
    }
};
#endif

template<
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 runge_kutta4 : public explicit_generic_rk< 4 , 4 , State , Value , Deriv , Time ,
Algebra , Operations , Resizer >
#else
class runge_kutta4 : public explicit_generic_rk
#endif
{

public:

#ifndef DOXYGEN_SKIP
    typedef explicit_generic_rk< 4 , 4 , State , Value , Deriv , Time ,
            Algebra , Operations , Resizer > 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::wrapped_state_type wrapped_state_type;
    typedef typename stepper_base_type::wrapped_deriv_type wrapped_deriv_type;
    typedef typename stepper_base_type::stepper_type stepper_type;
    #endif

runge_kutta4( const algebra_type &algebra = algebra_type() ) : stepper_base_type(
            boost::fusion::make_vector( rk4_coefficients_a1<Value>() , rk4_coefficients_a2<Value>() , rk4_coefficients_a3<Value>() ) ,
            rk4_coefficients_b<Value>() , rk4_coefficients_c<Value>() , algebra )
    { }

};

/**
 * \class runge_kutta4
 * \brief The classical Runge-Kutta stepper of fourth order.
 *
 * The Runge-Kutta method of fourth order is one standard method for
 * solving ordinary differential equations and is widely used, see also
 * <a href="http://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods">en.wikipedia.org/wiki/Runge-Kutta_methods</a>
 * The method is  explicit and fulfills the Stepper concept. Step size control
 * or continuous output are not provided.
 * 
 * This class derives from explicit_stepper_base and inherits its interface via CRTP (current recurring template pattern).
 * Furthermore, it derivs from explicit_generic_rk which is a generic Runge-Kutta algorithm. For more details see
 * explicit_stepper_base and explicit_generic_rk.
 *
 * \tparam State The state type.
 * \tparam Value The value type.
 * \tparam Deriv The type representing the time derivative of the state.
 * \tparam Time The time representing the independent variable - the time.
 * \tparam Algebra The algebra type.
 * \tparam Operations The operations type.
 * \tparam Resizer The resizer policy type.
 */

/**
 * \fn runge_kutta4::runge_kutta4( const algebra_type &algebra = algebra_type() )
 * \brief Constructs the runge_kutta4 class. This constructor can be used as a default
 * constructor if the algebra has a default constructor.
 * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
 */

}
}
}

#endif // BOOST_NUMERIC_ODEINT_STEPPER_RUNGE_KUTTA4_HPP_INCLUDED

cmd: