Ticket #7835: fix_typo_in_odeint.patch

File fix_typo_in_odeint.patch, 93.4 KB (added by Michel Morin, 10 years ago)

  • boost/numeric/odeint/external/mtl4/mtl4_resize.hpp

     
    127127
    128128
    129129} // namespace odeint
    130 } // namesapce numeric
     130} // namespace numeric
    131131} // namespace boost
    132132
    133133#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_MTL4_RESIZE_HPP_INCLUDED

  • boost/numeric/odeint/external/mtl4/implicit_euler_mtl4.hpp

     
    116116
    117117
    118118    /*
    119       Applying approximate iteractive linear solvers
     119      Applying approximate iterative linear solvers
    120120      default solver is Biconjugate gradient stabilized method
    121121      itl::bicgstab(A, x, b, L, iter);
    122122    */

  • boost/numeric/odeint/external/mkl/mkl_operations.hpp

     
    2828/* exemplary example for writing bindings to the Intel MKL library
    2929 * see test/mkl for how to use mkl with odeint
    3030 * this is a quick and dirty implementation showing the general possibility.
    31  * It works only with containers based on double and sequentiel memory allocation.
     31 * It works only with containers based on double and sequential memory allocation.
    3232 */
    3333
    3434namespace boost {

  • boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp

     
    6969
    7070
    7171/*
    72  * classical integrate adpative
     72 * classical integrate adaptive
    7373 */
    7474template< class Stepper , class System , class State , class Time , class Observer >
    7575size_t integrate_adaptive(

  • boost/numeric/odeint/integrate/integrate_n_steps.hpp

     
    106106     * \param system Function/Functor defining the rhs of the ODE.
    107107     * \param start_state The initial condition x0.
    108108     * \param start_time The initial time t0.
    109      * \param dt The time step between observer calls, _not_ neccessarily the
     109     * \param dt The time step between observer calls, _not_ necessarily the
    110110     * time step of the integration.
    111111     * \param num_of_steps Number of steps to be performed
    112112     * \param observer Function/Functor called at equidistant time intervals.

  • boost/numeric/odeint/integrate/integrate_adaptive.hpp

     
    102102     *
    103103     * This function integrates the ODE given by system with the given stepper.
    104104     * The observer is called after each step. If the stepper has no error
    105      * control, the step size remains constant and the observer is calleda at
     105     * control, the step size remains constant and the observer is called at
    106106     * equidistant time points t0+n*dt. If the stepper is a ControlledStepper,
    107107     * the step size is adjusted and the observer is called in non-equidistant
    108108     * intervals.
    … …  
    112112     * \param start_state The initial condition x0.
    113113     * \param start_time The initial time t0.
    114114     * \param end_time The final integration time tend.
    115      * \param dt The time step between observer calls, _not_ neccessarily the
     115     * \param dt The time step between observer calls, _not_ necessarily the
    116116     * time step of the integration.
    117117     * \param observer Function/Functor called at equidistant time intervals.
    118118     * \return The number of steps performed.

  • boost/numeric/odeint/integrate/integrate.hpp

     
    5959 * \brief Integrates the ODE.
    6060 *
    6161 * Integrates the ODE given by system from start_time to end_time starting
    62  * with start_state as initial condtition and dt as initial time step.
     62 * with start_state as initial condition and dt as initial time step.
    6363 * This function uses a dense output dopri5 stepper and performs an adaptive
    6464 * integration with step size control, thus dt changes during the integration.
    6565 * This method uses standard error bounds of 1E-6.
    … …  
    7070 * \param start_state The initial state.
    7171 * \param start_time Start time of the integration.
    7272 * \param end_time End time of the integration.
    73  * \param dt Initial step size, will be adjusted durinf the integration.
     73 * \param dt Initial step size, will be adjusted during the integration.
    7474 * \param observer Observer that will be called after each time step.
    7575 * \return The number of steps performed.
    7676 */
    … …  
    8181 * \brief Integrates the ODE without observer calls.
    8282 *
    8383 * Integrates the ODE given by system from start_time to end_time starting
    84  * with start_state as initial condtition and dt as initial time step.
     84 * with start_state as initial condition and dt as initial time step.
    8585 * This function uses a dense output dopri5 stepper and performs an adaptive
    8686 * integration with step size control, thus dt changes during the integration.
    8787 * This method uses standard error bounds of 1E-6.
    … …  
    9292 * \param start_state The initial state.
    9393 * \param start_time Start time of the integration.
    9494 * \param end_time End time of the integration.
    95  * \param dt Initial step size, will be adjusted durinf the integration.
     95 * \param dt Initial step size, will be adjusted during the integration.
    9696 * \return The number of steps performed.
    9797 */
    9898

  • boost/numeric/odeint/integrate/integrate_times.hpp

     
    114114     * \param start_state The initial condition x0.
    115115     * \param times_start Iterator to the start time
    116116     * \param times_end Iterator to the end time
    117      * \param dt The time step between observer calls, _not_ neccessarily the
     117     * \param dt The time step between observer calls, _not_ necessarily the
    118118     * time step of the integration.
    119119     * \param observer Function/Functor called at equidistant time intervals.
    120120     * \return The number of steps performed.

  • boost/numeric/odeint/integrate/integrate_const.hpp

     
    141141     * \param start_state The initial condition x0.
    142142     * \param start_time The initial time t0.
    143143     * \param end_time The final integration time tend.
    144      * \param dt The time step between observer calls, _not_ neccessarily the
     144     * \param dt The time step between observer calls, _not_ necessarily the
    145145     * time step of the integration.
    146146     * \param observer Function/Functor called at equidistant time intervals.
    147147     * \return The number of steps performed.

  • boost/numeric/odeint/stepper/rosenbrock4.hpp

     
    167167    template< class System >
    168168    void do_step( System system , const state_type &x , time_type t , state_type &xout , time_type dt , state_type &xerr )
    169169    {
    170         // get the systen and jacobi function
     170        // get the system and jacobi function
    171171        typedef typename odeint::unwrap_reference< System >::type system_type;
    172172        typedef typename odeint::unwrap_reference< typename system_type::first_type >::type deriv_func_type;
    173173        typedef typename odeint::unwrap_reference< typename system_type::second_type >::type jacobi_func_type;

  • boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp

     
    114114
    115115        for( unsigned short i = 0; i < m_k_max+1; i++ )
    116116        {
    117             /* only this specific sequence allows for dense ouput */
     117            /* only this specific sequence allows for dense output */
    118118            m_interval_sequence[i] = 2 + 4*i;  // 2 6 10 14 ...
    119119            m_derivs[i].resize( m_interval_sequence[i] );
    120120            if( i == 0 )
    … …  
    696696 * The Bulirsch-Stoer is a controlled stepper that adjusts both step size
    697697 * and order of the method. The algorithm uses the modified midpoint and
    698698 * a polynomial extrapolation compute the solution. This class also provides
    699  * dense outout facility.
     699 * dense output facility.
    700700 *
    701701 * \tparam State The state type.
    702702 * \tparam Value The value type.
    … …  
    729729     * step size dt is reduced. If the error estimate is acceptably small, the
    730730     * step is performed, success is returned and dt might be increased to make
    731731     * the steps as large as possible. This method also updates t if a step is
    732      * performed. Also, the internal order of the stepper is adjusted if requried.
     732     * performed. Also, the internal order of the stepper is adjusted if required.
    733733     *
    734734     * \param system The system function to solve, hence the r.h.s. of the ODE.
    735      * It must fullfil the Simple System concept.
     735     * It must fulfill the Simple System concept.
    736736     * \param in The state of the ODE which should be solved.
    737737     * \param dxdt The derivative of state.
    738      * \param t The value of the time. Updated if the step is successfull.
     738     * \param t The value of the time. Updated if the step is successful.
    739739     * \param out Used to store the result of the step.
    740740     * \param dt The step size. Updated.
    741741     * \return success if the step was accepted, fail otherwise.
    … …  
    755755     * \brief Does one time step. This is the main method that should be used to
    756756     * integrate an ODE with this stepper.
    757757     * \note initialize has to be called before using this method to set the
    758      * inital conditions x,t and the stepsize.
     758     * initial conditions x,t and the stepsize.
    759759     * \param system The system function to solve, hence the r.h.s. of the
    760      * ordinary differential equation. It must fullfil the Simple System concept.
     760     * ordinary differential equation. It must fulfill the Simple System concept.
    761761     * \return Pair with start and end time of the integration step.
    762762     */
    763763
    764764    /**
    765765     * \fn bulirsch_stoer_dense_out::calc_state( time_type t , StateOut &x ) const
    766      * \brief Calculates the solution at an intermediate point within the las step
     766     * \brief Calculates the solution at an intermediate point within the last step
    767767     * \param t The time at which the solution should be calculated, has to be
    768768     * in the current time interval.
    769769     * \param x The output variable where the result is written into.

  • boost/numeric/odeint/stepper/controlled_step_result.hpp

     
    3131typedef enum
    3232{
    3333    success , /**< The trial step was successful, hence the state and the time have been advanced. */
    34     fail      /**< The step was not succesful and might possibly be repeated with a small step size. */
     34    fail      /**< The step was not successful and might possibly be repeated with a small step size. */
    3535} controlled_step_result;
    3636
    3737} // namespace odeint

  • boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp

     
    125125
    126126/**
    127127 * \class symplectic_rkn_sb3a_mclachlan
    128  * \brief Implement of the symetric B3A method of Runge-Kutta-Nystroem method of sixth order.
     128 * \brief Implement of the symmetric B3A method of Runge-Kutta-Nystroem method of sixth order.
    129129 *
    130130 * The method is of fourth order and has six stages. It is described HERE. This method cannot be used
    131131 * with multiprecision types since the coefficients are not defined analytically.
    … …  
    135135 * \tparam Order The order of the stepper.
    136136 * \tparam Coor The type representing the coordinates q.
    137137 * \tparam Momentum The type representing the coordinates p.
    138  * \tparam Value The basic value type. Should be somethink like float, double or a high-precision type.
     138 * \tparam Value The basic value type. Should be something like float, double or a high-precision type.
    139139 * \tparam CoorDeriv The type representing the time derivative of the coordinate dq/dt.
    140140 * \tparam MomemtnumDeriv The type representing the time derivative of the momentum dp/dt.
    141141 * \tparam Time The type representing the time t.

  • boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp

     
    130130 * \tparam Order The order of the stepper.
    131131 * \tparam Coor The type representing the coordinates q.
    132132 * \tparam Momentum The type representing the coordinates p.
    133  * \tparam Value The basic value type. Should be somethink like float, double or a high-precision type.
     133 * \tparam Value The basic value type. Should be something like float, double or a high-precision type.
    134134 * \tparam CoorDeriv The type representing the time derivative of the coordinate dq/dt.
    135135 * \tparam MomemtnumDeriv The type representing the time derivative of the momentum dp/dt.
    136136 * \tparam Time The type representing the time t.

  • boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp

     
    164164 * See also
    165165 * <a href="http://en.wikipedia.org/wiki/Linear_multistep_method">en.wikipedia.org/wiki/Linear_multistep_method</a>.
    166166 * Currently, a maximum of Steps=8 is supported.
    167  * The method is explicit and fullfils the Stepper concept. Step size control
    168  * or continous output are not provided.
     167 * The method is explicit and fulfills the Stepper concept. Step size control
     168 * or continuous output are not provided.
    169169 *
    170170 * This class derives from algebra_base and inherits its interface via
    171171 * CRTP (current recurring template pattern). For more details see
    … …  
    199199     * \fn adams_bashforth_moulton::do_step( System system , StateInOut &x , time_type t , time_type dt )
    200200     * \brief This method performs one step. It transforms the result in-place.
    201201     *
    202      * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
     202     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
    203203     *               Simple System concept.
    204204     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
    205205     * \param t The value of the time, at which the step should be performed.
    … …  
    211211     * \fn adams_bashforth_moulton::do_step( System system , const StateIn &in , time_type t , const StateOut &out , time_type dt )
    212212     * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
    213213     *
    214      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     214     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    215215     *               Simple System concept.
    216216     * \param in The state of the ODE which should be solved. in is not modified in this method
    217217     * \param t The value of the time, at which the step should be performed.
    … …  
    230230     * \brief Initialized the stepper. Does Steps-1 steps with the explicit_stepper to fill the buffer.
    231231     * \note The state x and time t are updated to the values after Steps-1 initial steps.
    232232     * \param explicit_stepper the stepper used to fill the buffer of previous step results
    233      * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
     233     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
    234234     *               Simple System concept.
    235235     * \param x The initial state of the ODE which should be solved, updated after in this method.
    236236     * \param t The initial time, updated in this method.
    … …  
    241241     * \fn adams_bashforth_moulton::initialize( System system , StateIn &x , time_type &t , time_type dt )
    242242     * \brief Initialized the stepper. Does Steps-1 steps using the standard initializing stepper
    243243     * of the underlying adams_bashforth stepper.
    244      * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
     244     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
    245245     *               Simple System concept.
    246246     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
    247247     * \param t The value of the time, at which the step should be performed.

  • boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp

     
    341341 * \brief The Runge-Kutta Fehlberg 78 method.
    342342 *
    343343 * The Runge-Kutta Fehlberg 78 method is a standard method for high-precision applications.
    344  * The method is explicit and fullfils the Error Stepper concept. Step size control
    345  * is provided but continous output is not available for this method.
     344 * The method is explicit and fulfills the Error Stepper concept. Step size control
     345 * is provided but continuous output is not available for this method.
    346346 *
    347347 * This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring template pattern).
    348348 * Furthermore, it derivs from explicit_error_generic_rk which is a generic Runge-Kutta algorithm with error estimation.

  • boost/numeric/odeint/stepper/symplectic_euler.hpp

     
    110110 * \tparam Order The order of the stepper.
    111111 * \tparam Coor The type representing the coordinates q.
    112112 * \tparam Momentum The type representing the coordinates p.
    113  * \tparam Value The basic value type. Should be somethink like float, double or a high-precision type.
     113 * \tparam Value The basic value type. Should be something like float, double or a high-precision type.
    114114 * \tparam CoorDeriv The type representing the time derivative of the coordinate dq/dt.
    115115 * \tparam MomemtnumDeriv The type representing the time derivative of the momentum dp/dt.
    116116 * \tparam Time The type representing the time t.

  • boost/numeric/odeint/stepper/explicit_generic_rk.hpp

     
    221221     * Access to this step functionality is provided by explicit_stepper_base and
    222222     * `do_step_impl` should not be called directly.
    223223     *
    224      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     224     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    225225     *               Simple System concept.
    226226     * \param in The state of the ODE which should be solved. in is not modified in this method
    227227     * \param dxdt The derivative of x at t.

  • boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp

     
    255255        const value_type b7_theta = B + C * X7;
    256256
    257257        // const state_type &k1 = *m_old_deriv;
    258         // onst state_type &k3 = dopri5().m_k3;
     258        // const state_type &k3 = dopri5().m_k3;
    259259        // const state_type &k4 = dopri5().m_k4;
    260260        // const state_type &k5 = dopri5().m_k5;
    261261        // const state_type &k6 = dopri5().m_k6;
    … …  
    314314 *
    315315 * The Runge-Kutta Dormand-Prince 5 method is a very popular method for solving ODEs, see
    316316 * <a href=""></a>.
    317  * The method is explicit and fullfils the Error Stepper concept. Step size control
    318  * is provided but continous output is available which make this method favourable for many applications.
     317 * The method is explicit and fulfills the Error Stepper concept. Step size control
     318 * is provided but continuous output is available which make this method favourable for many applications.
    319319 *
    320320 * This class derives from explicit_error_stepper_fsal_base and inherits its interface via CRTP (current recurring
    321321 * template pattern). The method possesses the FSAL (first-same-as-last) property. See
    … …  
    347347     * Access to this step functionality is provided by explicit_error_stepper_fsal_base and
    348348     * `do_step_impl` should not be called directly.
    349349     *
    350      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     350     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    351351     *               Simple System concept.
    352352     * \param in The state of the ODE which should be solved. in is not modified in this method
    353353     * \param dxdt_in The derivative of x at t. dxdt_in is not modified by this method
    … …  
    367367     * `do_step_impl` should not be called directly.
    368368     * An estimation of the error is calculated.
    369369     *
    370      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     370     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    371371     *               Simple System concept.
    372372     * \param in The state of the ODE which should be solved. in is not modified in this method
    373373     * \param dxdt_in The derivative of x at t. dxdt_in is not modified by this method
    … …  
    380380
    381381    /**
    382382     * \fn runge_kutta_dopri5::calc_state( time_type t , StateOut &x , const StateIn1 &x_old , const DerivIn1 &deriv_old , time_type t_old , const StateIn2 &  , const DerivIn2 &deriv_new , time_type t_new ) const
    383      * \brief This method is used for continous output and it calculates the state `x` at a time `t` from the
     383     * \brief This method is used for continuous output and it calculates the state `x` at a time `t` from the
    384384     * knowledge of two states `old_state` and `current_state` at time points `t_old` and `t_new`. It also uses
    385385     * internal variables to calculate the result. Hence this method must be called after two successful `do_step`
    386386     * calls.

  • boost/numeric/odeint/stepper/euler.hpp

     
    106106 *
    107107 * The Euler method is a very simply solver for ordinary differential equations. This method should not be used
    108108 * for real applications. It is only useful for demonstration purposes. Step size control is not provided but
    109  * trivial continous output is available.
     109 * trivial continuous output is available.
    110110 *
    111111 * This class derives from explicit_stepper_base and inherits its interface via CRTP (current recurring template pattern),
    112112 * see explicit_stepper_base
    … …  
    134134     * Access to this step functionality is provided by explicit_stepper_base and
    135135     * `do_step_impl` should not be called directly.
    136136     *
    137      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     137     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    138138     *               Simple System concept.
    139139     * \param in The state of the ODE which should be solved. in is not modified in this method
    140140     * \param dxdt The derivative of x at t.
    … …  
    146146
    147147    /**
    148148     * \fn euler::calc_state( StateOut &x , time_type t ,  const StateIn1 &old_state , time_type t_old , const StateIn2 &current_state , time_type t_new ) const
    149      * \brief This method is used for continous output and it calculates the state `x` at a time `t` from the
     149     * \brief This method is used for continuous output and it calculates the state `x` at a time `t` from the
    150150     * knowledge of two states `old_state` and `current_state` at time points `t_old` and `t_new`.
    151151     */
    152152

  • boost/numeric/odeint/stepper/runge_kutta4.hpp

     
    148148 * The Runge-Kutta method of fourth order is one standard method for
    149149 * solving ordinary differential equations and is widely used, see also
    150150 * <a href="http://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods">en.wikipedia.org/wiki/Runge-Kutta_methods</a>
    151  * The method is  explicit and fullfils the Stepper concept. Step size control
    152  * or continous output are not provided.
     151 * The method is  explicit and fulfills the Stepper concept. Step size control
     152 * or continuous output are not provided.
    153153 *
    154154 * This class derives from explicit_stepper_base and inherits its interface via CRTP (current recurring template pattern).
    155155 * Furthermore, it derivs from explicit_generic_rk which is a generic Runge-Kutta algorithm. For more details see

  • boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp

     
    199199 * The Runge-Kutta Cash-Karp method is one of the standard methods for
    200200 * solving ordinary differential equations, see
    201201 * <a href="http://en.wikipedia.org/wiki/Cash%E2%80%93Karp_methods">en.wikipedia.org/wiki/Cash-Karp_methods</a>.
    202  * The method is explicit and fullfils the Error Stepper concept. Step size control
    203  * is provided but continous output is not available for this method.
     202 * The method is explicit and fulfills the Error Stepper concept. Step size control
     203 * is provided but continuous output is not available for this method.
    204204 *
    205205 * This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring template pattern).
    206206 * Furthermore, it derivs from explicit_error_generic_rk which is a generic Runge-Kutta algorithm with error estimation.

  • boost/numeric/odeint/stepper/controlled_runge_kutta.hpp

     
    132132 * This class implements the step size control for standard Runge-Kutta
    133133 * steppers with error estimation.
    134134 *
    135  * \tparam ErrorStepper The stepper type with error estimation, has to fullfill the ErrorStepper concept.
     135 * \tparam ErrorStepper The stepper type with error estimation, has to fulfill the ErrorStepper concept.
    136136 * \tparam ErrorChecker The error checker
    137137 * \tparam Resizer The resizer policy type.
    138138 */
    … …  
    194194     * the steps as large as possible. This method also updates t if a step is
    195195     * performed.
    196196     *
    197      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     197     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    198198     *               Simple System concept.
    199199     * \param x The state of the ODE which should be solved. Overwritten if
    200      * the step is successfull.
    201      * \param t The value of the time. Updated if the step is successfull.
     200     * the step is successful.
     201     * \param t The value of the time. Updated if the step is successful.
    202202     * \param dt The step size. Updated.
    203203     * \return success if the step was accepted, fail otherwise.
    204204     */
    … …  
    219219     * the steps as large as possible. This method also updates t if a step is
    220220     * performed.
    221221     *
    222      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     222     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    223223     *               Simple System concept.
    224224     * \param x The state of the ODE which should be solved. Overwritten if
    225      * the step is successfull. Can be a boost range.
    226      * \param t The value of the time. Updated if the step is successfull.
     225     * the step is successful. Can be a boost range.
     226     * \param t The value of the time. Updated if the step is successful.
    227227     * \param dt The step size. Updated.
    228228     * \return success if the step was accepted, fail otherwise.
    229229     */
    … …  
    250250     * the steps as large as possible. This method also updates t if a step is
    251251     * performed.
    252252     *
    253      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     253     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    254254     *               Simple System concept.
    255255     * \param x The state of the ODE which should be solved. Overwritten if
    256      * the step is successfull.
     256     * the step is successful.
    257257     * \param dxdt The derivative of state.
    258      * \param t The value of the time. Updated if the step is successfull.
     258     * \param t The value of the time. Updated if the step is successful.
    259259     * \param dt The step size. Updated.
    260260     * \return success if the step was accepted, fail otherwise.
    261261     */
    … …  
    290290     * the steps as large as possible. This method also updates t if a step is
    291291     * performed.
    292292     *
    293      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     293     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    294294     *               Simple System concept.
    295295     * \param in The state of the ODE which should be solved.
    296      * \param t The value of the time. Updated if the step is successfull.
     296     * \param t The value of the time. Updated if the step is successful.
    297297     * \param out Used to store the result of the step.
    298298     * \param dt The step size. Updated.
    299299     * \return success if the step was accepted, fail otherwise.
    … …  
    324324     * the steps as large as possible. This method also updates t if a step is
    325325     * performed.
    326326     *
    327      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     327     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    328328     *               Simple System concept.
    329329     * \param in The state of the ODE which should be solved.
    330330     * \param dxdt The derivative of state.
    331      * \param t The value of the time. Updated if the step is successfull.
     331     * \param t The value of the time. Updated if the step is successful.
    332332     * \param out Used to store the result of the step.
    333333     * \param dt The step size. Updated.
    334334     * \return success if the step was accepted, fail otherwise.
    … …  
    487487 * This class implements the step size control for FSAL Runge-Kutta
    488488 * steppers with error estimation.
    489489 *
    490  * \tparam ErrorStepper The stepper type with error estimation, has to fullfill the ErrorStepper concept.
     490 * \tparam ErrorStepper The stepper type with error estimation, has to fulfill the ErrorStepper concept.
    491491 * \tparam ErrorChecker The error checker
    492492 * \tparam Resizer The resizer policy type.
    493493 */
    … …  
    547547     * the steps as large as possible. This method also updates t if a step is
    548548     * performed.
    549549     *
    550      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     550     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    551551     *               Simple System concept.
    552552     * \param x The state of the ODE which should be solved. Overwritten if
    553      * the step is successfull.
    554      * \param t The value of the time. Updated if the step is successfull.
     553     * the step is successful.
     554     * \param t The value of the time. Updated if the step is successful.
    555555     * \param dt The step size. Updated.
    556556     * \return success if the step was accepted, fail otherwise.
    557557     */
    … …  
    573573     * the steps as large as possible. This method also updates t if a step is
    574574     * performed.
    575575     *
    576      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     576     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    577577     *               Simple System concept.
    578578     * \param x The state of the ODE which should be solved. Overwritten if
    579      * the step is successfull. Can be a boost range.
    580      * \param t The value of the time. Updated if the step is successfull.
     579     * the step is successful. Can be a boost range.
     580     * \param t The value of the time. Updated if the step is successful.
    581581     * \param dt The step size. Updated.
    582582     * \return success if the step was accepted, fail otherwise.
    583583     */
    … …  
    594594     *
    595595     * This version does not solve the forwarding problem, boost::range can not be used.
    596596     *
    597      * The disabler is needed to solve ambigous overloads
     597     * The disabler is needed to solve ambiguous overloads
    598598     */
    599599    /**
    600600     * \brief Tries to perform one step.
    … …  
    608608     * the steps as large as possible. This method also updates t if a step is
    609609     * performed.
    610610     *
    611      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     611     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    612612     *               Simple System concept.
    613613     * \param in The state of the ODE which should be solved.
    614      * \param t The value of the time. Updated if the step is successfull.
     614     * \param t The value of the time. Updated if the step is successful.
    615615     * \param out Used to store the result of the step.
    616616     * \param dt The step size. Updated.
    617617     * \return success if the step was accepted, fail otherwise.
    … …  
    643643     * the steps as large as possible. This method also updates t if a step is
    644644     * performed.
    645645     *
    646      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     646     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    647647     *               Simple System concept.
    648648     * \param x The state of the ODE which should be solved. Overwritten if
    649      * the step is successfull.
     649     * the step is successful.
    650650     * \param dxdt The derivative of state.
    651      * \param t The value of the time. Updated if the step is successfull.
     651     * \param t The value of the time. Updated if the step is successful.
    652652     * \param dt The step size. Updated.
    653653     * \return success if the step was accepted, fail otherwise.
    654654     */
    … …  
    682682     * the steps as large as possible. This method also updates t if a step is
    683683     * performed.
    684684     *
    685      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     685     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    686686     *               Simple System concept.
    687687     * \param in The state of the ODE which should be solved.
    688688     * \param dxdt The derivative of state.
    689      * \param t The value of the time. Updated if the step is successfull.
     689     * \param t The value of the time. Updated if the step is successful.
    690690     * \param out Used to store the result of the step.
    691691     * \param dt The step size. Updated.
    692692     * \return success if the step was accepted, fail otherwise.
    … …  
    757757    /**
    758758     * \brief Initializes the internal state storing an internal copy of the derivative.
    759759     *
    760      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     760     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    761761     *               Simple System concept.
    762762     * \param x The initial state of the ODE which should be solved.
    763763     * \param t The initial time.

  • boost/numeric/odeint/stepper/runge_kutta4_classic.hpp

     
    165165 * The Runge-Kutta method of fourth order is one standard method for
    166166 * solving ordinary differential equations and is widely used, see also
    167167 * <a href="http://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods">en.wikipedia.org/wiki/Runge-Kutta_methods</a>
    168  * The method is explicit and fullfils the Stepper concept. Step size control
    169  * or continous output are not provided.  This class implements the method directly, hence the
     168 * The method is explicit and fulfills the Stepper concept. Step size control
     169 * or continuous output are not provided.  This class implements the method directly, hence the
    170170 * generic Runge-Kutta algorithm is not used.
    171171 *
    172172 * This class derives from explicit_stepper_base and inherits its interface via
    … …  
    197197     * Access to this step functionality is provided by explicit_stepper_base and
    198198     * `do_step_impl` should not be called directly.
    199199     *
    200      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     200     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    201201     *               Simple System concept.
    202202     * \param in The state of the ODE which should be solved. in is not modified in this method
    203203     * \param dxdt The derivative of x at t.

  • boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp

     
    216216 * The Runge-Kutta Cash-Karp method is one of the standard methods for
    217217 * solving ordinary differential equations, see
    218218 * <a href="http://en.wikipedia.org/wiki/Cash%E2%80%93Karp_method">en.wikipedia.org/wiki/Cash-Karp_method</a>.
    219  * The method is explicit and fullfils the Error Stepper concept. Step size control
    220  * is provided but continous output is not available for this method.
     219 * The method is explicit and fulfills the Error Stepper concept. Step size control
     220 * is provided but continuous output is not available for this method.
    221221 *
    222222 * This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring
    223223 * template pattern). This class implements the method directly, hence the generic Runge-Kutta algorithm is not used.
    … …  
    250250     * `do_step_impl` should not be called directly.
    251251
    252252     *
    253      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     253     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    254254     *               Simple System concept.
    255255     * \param in The state of the ODE which should be solved. in is not modified in this method
    256256     * \param dxdt The derivative of x at t.
    … …  
    267267     * Access to this step functionality is provided by explicit_error_stepper_base and
    268268     * `do_step_impl` should not be called directly.
    269269     *
    270      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     270     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    271271     *               Simple System concept.
    272272     * \param in The state of the ODE which should be solved. in is not modified in this method
    273273     * \param dxdt The derivative of x at t.

  • boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp

     
    172172/**
    173173 * \class explicit_error_generic_rk
    174174 * \brief A generic implementation of explicit Runge-Kutta algorithms with error estimation. This class is as a
    175  * base class for all explicit Runge-Kutta steppers with error estimateion.
     175 * base class for all explicit Runge-Kutta steppers with error estimation.
    176176 *
    177177 * This class implements the explicit Runge-Kutta algorithms with error estimation in a generic way.
    178178 * The Butcher tableau is passed to the stepper which constructs the stepper scheme with the help of a
    … …  
    212212     * The result is updated out-of-place, hence the input is in `in` and the output in `out`. Futhermore, an
    213213     * estimation of the error is stored in `xerr`. `do_step_impl` is used by explicit_error_stepper_base.
    214214     *
    215      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     215     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    216216     *               Simple System concept.
    217217     * \param in The state of the ODE which should be solved. in is not modified in this method
    218218     * \param dxdt The derivative of x at t.
    … …  
    229229     * Access to this step functionality is provided by explicit_stepper_base and
    230230     * `do_step_impl` should not be called directly.
    231231     *
    232      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     232     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    233233     *               Simple System concept.
    234234     * \param in The state of the ODE which should be solved. in is not modified in this method
    235235     * \param dxdt The derivative of x at t.

  • boost/numeric/odeint/stepper/modified_midpoint.hpp

     
    298298 * \class modified_midpoint_dense_out
    299299 *
    300300 * Implementation of the modified midpoint method with a configurable
    301  * number of intermediate steps. This class is used by the dense ouput
     301 * number of intermediate steps. This class is used by the dense output
    302302 * Bulirsch-Stoer algorithm and is not meant for direct usage.
    303303 * \note This stepper is for internal use only and does not meet
    304304 * any stepper concept.

  • boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp

     
    6060 * algebra and provides access to the algebra.  The operations are not instantiated, since they are
    6161 * static classes inside the operations class.
    6262 *
    63  * \tparam Algebra The type of the algebra. Must fullfil the Algebra Concept, at least partially to work
     63 * \tparam Algebra The type of the algebra. Must fulfill the Algebra Concept, at least partially to work
    6464 * with the stepper.
    65  * \tparam Operations The type of the operations. Must fullfil the Operations Concept, at least partially
     65 * \tparam Operations The type of the operations. Must fulfill the Operations Concept, at least partially
    6666 * to work with the stepper.
    6767 */
    6868

  • boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp

     
    340340
    341341/**
    342342 * \class explicit_error_stepper_fsal_base
    343  * \brief Base class for explicit steppers with error estimation and stepper fullfiling the FSAL (first-same-as-last)
     343 * \brief Base class for explicit steppers with error estimation and stepper fulfilling the FSAL (first-same-as-last)
    344344 * property. This class can be used with controlled steppers for step size control.
    345345 *
    346  * This class serves as the base class for all explicit steppers with algebra and operations and which fullfil the FSAL
     346 * This class serves as the base class for all explicit steppers with algebra and operations and which fulfill the FSAL
    347347 * property. In contrast to explicit_stepper_base it also estimates the error and can be used in a controlled stepper
    348348 * to provide step size control.
    349349 *
    350350 * The FSAL property means that the derivative of the system at t+dt is already used in the current step going from
    351  * t to t +dt. Therefore, some more do_steps method can be introduced and the controlled steppers can explicitely make use
     351 * t to t +dt. Therefore, some more do_steps method can be introduced and the controlled steppers can explicitly make use
    352352 * of this property.
    353353 *
    354354 * \note This stepper provides `do_step` methods with and without error estimation. It has therefore three orders,
    … …  
    363363 * This class can have an intrinsic state depending on the explicit usage of the `do_step` method. This means that some
    364364 * `do_step` methods are expected to be called in order. For example the `do_step( sys , x , t , dt , xerr )` will keep track
    365365 * of the derivative of `x` which is the internal state. The first call of this method is recognized such that one
    366  * does not explicitely initialize the internal state, so it is safe to use this method like
     366 * does not explicitly initialize the internal state, so it is safe to use this method like
    367367 *
    368368 * \code
    369369 * stepper_type stepper;
    … …  
    376376 * internal state with the `initialize` method or reset the internal state with the `reset` method.
    377377 *
    378378 * explicit_error_stepper_fsal_base provides several overloaded `do_step` methods, see the list below. Only two of them are needed
    379  * to fullfil the Error Stepper concept. The other ones are for convenience and for better performance. Some of them
     379 * to fulfill the Error Stepper concept. The other ones are for convenience and for better performance. Some of them
    380380 * simply update the state out-of-place, while other expect that the first derivative at `t` is passed to the stepper.
    381381 *
    382  * - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fullfil the Error Stepper concept. The
     382 * - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fulfill the Error Stepper concept. The
    383383 *      state is updated in-place. A type modelling a Boost.Range can be used for x.
    384384 * - `do_step( sys , x , dxdt , t , dt )` - This method updates the state x and the derivative dxdt in-place. It is expected
    385385 *     that dxdt has the value of the derivative of x at time t.
    386386 * - `do_step( sys , in , t , out , dt )` - This method updates the state out-of-place, hence the result of the step
    387387 *      is stored in `out`.
    388388 * - `do_step( sys , in , dxdt_in , t , out , dxdt_out , dt )` - This method updates the state and the derivative
    389  *     out-of-place. It expects that the derivative at the point `t` is explicitely passed in `dxdt_in`.
    390  * - `do_step( sys , x , t , dt , xerr )` - This `do_step` method is needed to fullfil the Error Stepper concept. The
     389 *     out-of-place. It expects that the derivative at the point `t` is explicitly passed in `dxdt_in`.
     390 * - `do_step( sys , x , t , dt , xerr )` - This `do_step` method is needed to fulfill the Error Stepper concept. The
    391391 *     state is updated in-place and an error estimate is calculated. A type modelling a Boost.Range can be used for x.
    392392 * - `do_step( sys , x , dxdt , t , dt , xerr )` - This method updates the state and the derivative in-place. It is assumed
    393393 *      that the dxdt has the value of the derivative of x at time t. An error estimate is calculated.
    … …  
    410410 * \tparam ErrorOrder The order of the error step if the stepper is used with error estimation.
    411411 * \tparam State The state type for the stepper.
    412412 * \tparam Value The value type for the stepper. This should be a floating point type, like float,
    413  * double, or a multiprecision type. It must not neccessary be the value_type of the State. For example
     413 * double, or a multiprecision type. It must not necessary be the value_type of the State. For example
    414414 * the State can be a `vector< complex< double > >` in this case the Value must be double.
    415415 * The default value is double.
    416416 * \tparam Deriv The type representing time derivatives of the state type. It is usually the same type as the
    417417 * state type, only if used with Boost.Units both types differ.
    418418 * \tparam Time The type representing the time. Usually the same type as the value type. When Boost.Units is
    419419 * used, this type has usually a unit.
    420  * \tparam Algebra The algebra type which must fullfil the Algebra Concept.
    421  * \tparam Operations The type for the operations wich must fullfil the Operations Concept.
     420 * \tparam Algebra The algebra type which must fulfill the Algebra Concept.
     421 * \tparam Operations The type for the operations which must fulfill the Operations Concept.
    422422 * \tparam Resizer The resizer policy class.
    423423 */
    424424
    … …  
    454454     *
    455455     * \note This method uses the internal state of the stepper.
    456456     *
    457      * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
     457     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
    458458     *               Simple System concept.
    459459     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
    460460     * \param t The value of the time, at which the step should be performed.
    … …  
    476476     * }
    477477     * \endcode
    478478     *
    479      * \note This method does NOT use the initial state, since the first derivative is explicitely passed to this method.
     479     * \note This method does NOT use the initial state, since the first derivative is explicitly passed to this method.
    480480     *
    481481     * The result is updated in place in x as well as the derivative dxdt. This method is disabled if
    482482     * Time and StateInOut are of the same type. In this case the method could not be distinguished from other `do_step`
    … …  
    484484     *
    485485     * \note This method does not solve the forwarding problem.
    486486     *
    487      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     487     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    488488     *               Simple System concept.
    489489     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
    490490     * \param dxdt The derivative of x at t. After calling `do_step` dxdt is updated to the new value.
    … …  
    502502     *
    503503     * \note This method does not solve the forwarding problem.
    504504     *
    505      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     505     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    506506     *               Simple System concept.
    507507     * \param in The state of the ODE which should be solved. in is not modified in this method
    508508     * \param t The value of the time, at which the step should be performed.
    … …  
    520520     *
    521521     * \note This method does NOT use the internal state of the stepper.
    522522     *
    523      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     523     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    524524     *               Simple System concept.
    525525     * \param in The state of the ODE which should be solved. in is not modified in this method
    526526     * \param dxdt_in The derivative of x at t.
    … …  
    538538     *
    539539     * \note This method uses the internal state of the stepper.
    540540     *
    541      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     541     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    542542     *               Simple System concept.
    543543     * \param x The state of the ODE which should be solved. x is updated by this method.
    544544     * \param t The value of the time, at which the step should be performed.
    … …  
    561561     *
    562562     * \note This method does not solve the forwarding problem.
    563563     *
    564      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     564     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    565565     *               Simple System concept.
    566566     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
    567567     * \param dxdt The derivative of x at t. After calling `do_step` this value is updated to the new value at `t+dt`.
    … …  
    580580     *
    581581     * \note This method does not solve the forwarding problem.
    582582     *
    583      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     583     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    584584     *               Simple System concept.
    585585     * \param in The state of the ODE which should be solved. in is not modified in this method
    586586     * \param t The value of the time, at which the step should be performed.
    … …  
    598598     *
    599599     * \note This method does not solve the forwarding problem.
    600600     *
    601      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     601     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    602602     *               Simple System concept.
    603603     * \param in The state of the ODE which should be solved. in is not modified in this method
    604604     * \param dxdt_in The derivative of x at t.
    … …  
    623623
    624624    /**
    625625     * \fn explicit_error_stepper_fsal_base::initialize( const DerivIn &deriv )
    626      * \brief Initializes the interal state of the stepper.
     626     * \brief Initializes the internal state of the stepper.
    627627     * \param deriv The derivative of x. The next call of `do_step` expects that the derivative of `x` passed to `do_step`
    628628     *              has the value of `deriv`.
    629629     */
    630630
    631631    /**
    632632     * \fn explicit_error_stepper_fsal_base::initialize( System system , const StateIn &x , time_type t )
    633      * \brief Initializes the interal state of the stepper.
     633     * \brief Initializes the internal state of the stepper.
    634634     *
    635635     * This method is equivalent to
    636636     * \code

  • boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp

     
    256256 * \endcode
    257257 *
    258258 * In detail explicit_stepper_base provides the following `do_step` variants
    259  *   - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fullfil the Stepper concept. The state is updated in-place.
     259 *   - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fulfill the Stepper concept. The state is updated in-place.
    260260 *      A type modelling a Boost.Range can be used for x.
    261261 *   - `do_step( sys , in , t , out , dt )` - This method updates the state out-of-place, hence the result of the step is stored in `out`.
    262262 *   - `do_step( sys , x , dxdt , t , dt )` - This method updates the state in-place, but the derivative at the point `t` must be
    263  *      explicitely passed in `dxdt`. For an example see the code snippet above.
     263 *      explicitly passed in `dxdt`. For an example see the code snippet above.
    264264 *   - `do_step( sys , in , dxdt , t , out , dt )` - This method update the state out-of-place and expects that the derivative at the point
    265  *     `t` is explicitely passed in `dxdt`. It is a combination of the two `do_step` methods above.
     265 *     `t` is explicitly passed in `dxdt`. It is a combination of the two `do_step` methods above.
    266266 *
    267267 * \note The system is always passed as value, which might result in poor performance if it contains data. In this case it can be used with `boost::ref`
    268268 * or `std::ref`, for example `stepper.do_step( boost::ref( sys ) , x , t , dt );`
    … …  
    274274 * \tparam Order The order of the stepper.
    275275 * \tparam State The state type for the stepper.
    276276 * \tparam Value The value type for the stepper. This should be a floating point type, like float,
    277  * double, or a multiprecision type. It must not neccessary be the value_type of the State. For example
     277 * double, or a multiprecision type. It must not necessary be the value_type of the State. For example
    278278 * the State can be a `vector< complex< double > >` in this case the Value must be double.
    279279 * The default value is double.
    280280 * \tparam Deriv The type representing time derivatives of the state type. It is usually the same type as the
    281281 * state type, only if used with Boost.Units both types differ.
    282282 * \tparam Time The type representing the time. Usually the same type as the value type. When Boost.Units is
    283283 * used, this type has usually a unit.
    284  * \tparam Algebra The algebra type which must fullfil the Algebra Concept.
    285  * \tparam Operations The type for the operations wich must fullfil the Operations Concept.
     284 * \tparam Algebra The algebra type which must fulfill the Algebra Concept.
     285 * \tparam Operations The type for the operations which must fulfill the Operations Concept.
    286286 * \tparam Resizer The resizer policy class.
    287287 */
    288288
    … …  
    303303     * \fn explicit_stepper_base::do_step( System system , StateInOut &x , time_type t , time_type dt )
    304304     * \brief This method performs one step. It transforms the result in-place.
    305305     *
    306      * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
     306     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
    307307     *               Simple System concept.
    308308     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
    309309     * \param t The value of the time, at which the step should be performed.
    … …  
    327327     *
    328328     * \note This method does not solve the forwarding problem.
    329329     *
    330      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     330     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    331331     *               Simple System concept.
    332332     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
    333333     * \param dxdt The derivative of x at t.
    … …  
    340340     * \brief The method performs one step. The state of the ODE is updated out-of-place.
    341341     * \note This method does not solve the forwarding problem.
    342342     *
    343      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     343     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    344344     *               Simple System concept.
    345345     * \param in The state of the ODE which should be solved. in is not modified in this method
    346346     * \param t The value of the time, at which the step should be performed.
    … …  
    361361     *
    362362     * \note This method does not solve the forwarding problem.
    363363     *
    364      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     364     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    365365     *               Simple System concept.
    366366     * \param in The state of the ODE which should be solved. in is not modified in this method
    367367     * \param dxdt The derivative of x at t.

  • boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp

     
    328328 *    for the coordinate or the momentum part or one function object for the momentum part. `x` is a pair of coordinate
    329329 *    and momentum. The state is updated in-place.
    330330 * - `do_step( sys , q , p , t , dt )` - This method is similar to the method above with the difference that the coordinate
    331  *    and the momentum are passed explicitely and not packed into a pair.
     331 *    and the momentum are passed explicitly and not packed into a pair.
    332332 * - `do_step( sys , x_in , t , x_out , dt )` - This method transforms the state out-of-place. `x_in` and `x_out` are here pairs
    333333 *    of coordinate and momentum.
    334334 *
    … …  
    336336 * \tparam Order The order of the stepper.
    337337 * \tparam Coor The type representing the coordinates q.
    338338 * \tparam Momentum The type representing the coordinates p.
    339  * \tparam Value The basic value type. Should be somethink like float, double or a high-precision type.
     339 * \tparam Value The basic value type. Should be something like float, double or a high-precision type.
    340340 * \tparam CoorDeriv The type representing the time derivative of the coordinate dq/dt.
    341341 * \tparam MomemtnumDeriv The type representing the time derivative of the momentum dp/dt.
    342342 * \tparam Time The type representing the time t.
    … …  
    362362    /**
    363363     * \fn symplectic_nystroem_stepper_base::do_step( System system , const StateInOut &state , time_type t , time_type dt )
    364364     * \brief This method performs one step. The system can be either a pair of two function object
    365      * decribing the momentum part and the coordinate part or one function object describing only
     365     * describing the momentum part and the coordinate part or one function object describing only
    366366     * the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state
    367367     * is updated in-place.
    368368     *
    … …  
    381381    /**
    382382     * \fn symplectic_nystroem_stepper_base::do_step( System system , CoorInOut &q , MomentumInOut &p , time_type t , time_type dt )
    383383     * \brief This method performs one step. The system can be either a pair of two function object
    384      * decribing the momentum part and the coordinate part or one function object describing only
     384     * describing the momentum part and the coordinate part or one function object describing only
    385385     * the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state
    386386     * is updated in-place.
    387387     *
    … …  
    391391     * \note This method solves the forwarding problem.
    392392     *
    393393     * \param system The system, can be represented as a pair of two function object or one function object. See above.
    394      * \param q The coordinate of the ODE. It is updated in-place. Therefore, the new value of the coorindate will be written
     394     * \param q The coordinate of the ODE. It is updated in-place. Therefore, the new value of the coordinate will be written
    395395     * into this variable.
    396396     * \param p The momentum of the ODE. It is updated in-place. Therefore, the new value of the momentum will be written info
    397397     * this variable.
    … …  
    402402    /**
    403403     * \fn symplectic_nystroem_stepper_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
    404404     * \brief This method performs one step. The system can be either a pair of two function object
    405      * decribing the momentum part and the coordinate part or one function object describing only
     405     * describing the momentum part and the coordinate part or one function object describing only
    406406     * the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state
    407407     * is updated out-of-place.
    408408     *

  • boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp

     
    323323 * explicit_error_stepper_base derives from algebra_stepper_base.
    324324 *
    325325 * explicit_error_stepper_base provides several overloaded `do_step` methods, see the list below. Only two of them
    326  * are needed to fullfil the Error Stepper concept. The other ones are for convenience and for performance. Some
     326 * are needed to fulfill the Error Stepper concept. The other ones are for convenience and for performance. Some
    327327 * of them simply update the state out-of-place, while other expect that the first derivative at `t` is passed to the
    328328 * stepper.
    329329 *
    330  * - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fullfil the Error Stepper concept. The
     330 * - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fulfill the Error Stepper concept. The
    331331 *      state is updated in-place. A type modelling a Boost.Range can be used for x.
    332332 * - `do_step( sys , x , dxdt , t , dt )` - This method updates the state in-place, but the derivative at the point `t`
    333  *      must be explicitely passed in `dxdt`.
     333 *      must be explicitly passed in `dxdt`.
    334334 * - `do_step( sys , in , t , out , dt )` - This method updates the state out-of-place, hence the result of the step
    335335 *      is stored in `out`.
    336336 * - `do_step( sys , in , dxdt , t , out , dt )` - This method update the state out-of-place and expects that the
    337  *     derivative at the point `t` is explicitely passed in `dxdt`. It is a combination of the two `do_step` methods
     337 *     derivative at the point `t` is explicitly passed in `dxdt`. It is a combination of the two `do_step` methods
    338338 *     above.
    339  * - `do_step( sys , x , t , dt , xerr )` - This `do_step` method is needed to fullfil the Error Stepper concept. The
     339 * - `do_step( sys , x , t , dt , xerr )` - This `do_step` method is needed to fulfill the Error Stepper concept. The
    340340 *     state is updated in-place and an error estimate is calculated. A type modelling a Boost.Range can be used for x.
    341341 * - `do_step( sys , x , dxdt , t , dt , xerr )` - This method updates the state in-place, but the derivative at the
    342342 *      point `t` must be passed in `dxdt`. An error estimate is calculated.
    … …  
    359359 * \tparam ErrorOrder The order of the error step if the stepper is used with error estimation.
    360360 * \tparam State The state type for the stepper.
    361361 * \tparam Value The value type for the stepper. This should be a floating point type, like float,
    362  * double, or a multiprecision type. It must not neccessary be the value_type of the State. For example
     362 * double, or a multiprecision type. It must not necessary be the value_type of the State. For example
    363363 * the State can be a `vector< complex< double > >` in this case the Value must be double.
    364364 * The default value is double.
    365365 * \tparam Deriv The type representing time derivatives of the state type. It is usually the same type as the
    366366 * state type, only if used with Boost.Units both types differ.
    367367 * \tparam Time The type representing the time. Usually the same type as the value type. When Boost.Units is
    368368 * used, this type has usually a unit.
    369  * \tparam Algebra The algebra type which must fullfil the Algebra Concept.
    370  * \tparam Operations The type for the operations wich must fullfil the Operations Concept.
     369 * \tparam Algebra The algebra type which must fulfill the Algebra Concept.
     370 * \tparam Operations The type for the operations which must fulfill the Operations Concept.
    371371 * \tparam Resizer The resizer policy class.
    372372 */
    373373
    … …  
    399399     * \fn explicit_error_stepper_base::do_step( System system , StateInOut &x , time_type t , time_type dt )
    400400     * \brief This method performs one step. It transforms the result in-place.
    401401     *
    402      * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
     402     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
    403403     *               Simple System concept.
    404404     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
    405405     * \param t The value of the time, at which the step should be performed.
    … …  
    421421     *
    422422     * \note This method does not solve the forwarding problem.
    423423     *
    424      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     424     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    425425     *               Simple System concept.
    426426     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
    427427     * \param dxdt The derivative of x at t.
    … …  
    436436     * other `do_step` variants.
    437437     * \note This method does not solve the forwarding problem.
    438438     *
    439      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     439     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    440440     *               Simple System concept.
    441441     * \param in The state of the ODE which should be solved. in is not modified in this method
    442442     * \param t The value of the time, at which the step should be performed.
    … …  
    459459     *
    460460     * \note This method does not solve the forwarding problem.
    461461     *
    462      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     462     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    463463     *               Simple System concept.
    464464     * \param in The state of the ODE which should be solved. in is not modified in this method
    465465     * \param dxdt The derivative of x at t.
    … …  
    473473     * \brief The method performs one step with the stepper passed by Stepper and estimates the error. The state of the ODE
    474474     * is updated in-place.
    475475     *
    476      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     476     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    477477     *               Simple System concept.
    478478     * \param x The state of the ODE which should be solved. x is updated by this method.
    479479     * \param t The value of the time, at which the step should be performed.
    … …  
    496496     *
    497497     * \note This method does not solve the forwarding problem.
    498498     *
    499      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     499     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    500500     *               Simple System concept.
    501501     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
    502502     * \param dxdt The derivative of x at t.
    … …  
    512512     *
    513513     * \note This method does not solve the forwarding problem.
    514514     *
    515      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     515     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    516516     *               Simple System concept.
    517517     * \param in The state of the ODE which should be solved. in is not modified in this method
    518518     * \param t The value of the time, at which the step should be performed.
    … …  
    536536     *
    537537     * \note This method does not solve the forwarding problem.
    538538     *
    539      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     539     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    540540     *               Simple System concept.
    541541     * \param in The state of the ODE which should be solved. in is not modified in this method
    542542     * \param dxdt The derivative of x at t.

  • boost/numeric/odeint/stepper/adams_bashforth.hpp

     
    283283 * then uses the result from the previous Steps steps. See also
    284284 * <a href="http://en.wikipedia.org/wiki/Linear_multistep_method">en.wikipedia.org/wiki/Linear_multistep_method</a>.
    285285 * Currently, a maximum of Steps=8 is supported.
    286  * The method is explicit and fullfils the Stepper concept. Step size control
    287  * or continous output are not provided.
     286 * The method is explicit and fulfills the Stepper concept. Step size control
     287 * or continuous output are not provided.
    288288 *
    289289 * This class derives from algebra_base and inherits its interface via
    290290 * CRTP (current recurring template pattern). For more details see
    … …  
    318318     * \fn void adams_bashforth::do_step( System system , StateInOut &x , time_type t , time_type dt )
    319319     * \brief This method performs one step. It transforms the result in-place.
    320320     *
    321      * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
     321     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
    322322     *               Simple System concept.
    323323     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
    324324     * \param t The value of the time, at which the step should be performed.
    … …  
    329329     * \fn void adams_bashforth::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
    330330     * \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
    331331     *
    332      * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
     332     * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
    333333     *               Simple System concept.
    334334     * \param in The state of the ODE which should be solved. in is not modified in this method
    335335     * \param t The value of the time, at which the step should be performed.
    … …  
    360360     * \fn void adams_bashforth::initialize( ExplicitStepper explicit_stepper , System system , StateIn &x , time_type &t , time_type dt )
    361361     * \brief Initialized the stepper. Does Steps-1 steps with the explicit_stepper to fill the buffer.
    362362     * \param explicit_stepper the stepper used to fill the buffer of previous step results
    363      * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
     363     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
    364364     *               Simple System concept.
    365365     * \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
    366366     * \param t The value of the time, at which the step should be performed.
    … …  
    371371     * \fn void adams_bashforth::initialize( System system , StateIn &x , time_type &t , time_type dt )
    372372     * \brief Initialized the stepper. Does Steps-1 steps with an internal instance of InitializingStepper to fill the buffer.
    373373     * \note The state x and time t are updated to the values after Steps-1 initial steps.
    374      * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
     374     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
    375375     *               Simple System concept.
    376376     * \param x The initial state of the ODE which should be solved, updated in this method.
    377377     * \param t The initial value of the time, updated in this method.

  • boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp

     
    9393    /**
    9494     * \brief Initializes the stepper. Has to be called before do_step can be
    9595     * used to set the initial conditions and the step size.
    96      * \param x0 The inital state of the ODE which should be solved.
     96     * \param x0 The initial state of the ODE which should be solved.
    9797     * \param t0 The initial time, at which the step should be performed.
    9898     * \param dt0 The step size.
    9999     */
    … …  
    109109    /**
    110110     * \brief Does one time step.
    111111     * \note initialize has to be called before using this method to set the
    112      * inital conditions x,t and the stepsize.
    113      * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
     112     * initial conditions x,t and the stepsize.
     113     * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
    114114     *               Simple System concept.
    115115     * \return Pair with start and end time of the integration step.
    116116     */

  • boost/numeric/odeint/stepper/bulirsch_stoer.hpp

     
    533533     * step size dt is reduced. If the error estimate is acceptably small, the
    534534     * step is performed, success is returned and dt might be increased to make
    535535     * the steps as large as possible. This method also updates t if a step is
    536      * performed. Also, the internal order of the stepper is adjusted if requried.
     536     * performed. Also, the internal order of the stepper is adjusted if required.
    537537     *
    538538     * \param system The system function to solve, hence the r.h.s. of the ODE.
    539      * It must fullfil the Simple System concept.
     539     * It must fulfill the Simple System concept.
    540540     * \param x The state of the ODE which should be solved. Overwritten if
    541      * the step is successfull.
    542      * \param t The value of the time. Updated if the step is successfull.
     541     * the step is successful.
     542     * \param t The value of the time. Updated if the step is successful.
    543543     * \param dt The step size. Updated.
    544544     * \return success if the step was accepted, fail otherwise.
    545545     */
    … …  
    553553     * step size dt is reduced. If the error estimate is acceptably small, the
    554554     * step is performed, success is returned and dt might be increased to make
    555555     * the steps as large as possible. This method also updates t if a step is
    556      * performed. Also, the internal order of the stepper is adjusted if requried.
     556     * performed. Also, the internal order of the stepper is adjusted if required.
    557557     *
    558558     * \param system The system function to solve, hence the r.h.s. of the ODE.
    559      * It must fullfil the Simple System concept.
     559     * It must fulfill the Simple System concept.
    560560     * \param x The state of the ODE which should be solved. Overwritten if
    561      * the step is successfull.
     561     * the step is successful.
    562562     * \param dxdt The derivative of state.
    563      * \param t The value of the time. Updated if the step is successfull.
     563     * \param t The value of the time. Updated if the step is successful.
    564564     * \param dt The step size. Updated.
    565565     * \return success if the step was accepted, fail otherwise.
    566566     */
    … …  
    576576     * step size dt is reduced. If the error estimate is acceptably small, the
    577577     * step is performed, success is returned and dt might be increased to make
    578578     * the steps as large as possible. This method also updates t if a step is
    579      * performed. Also, the internal order of the stepper is adjusted if requried.
     579     * performed. Also, the internal order of the stepper is adjusted if required.
    580580     *
    581581     * \param system The system function to solve, hence the r.h.s. of the ODE.
    582      * It must fullfil the Simple System concept.
     582     * It must fulfill the Simple System concept.
    583583     * \param in The state of the ODE which should be solved.
    584      * \param t The value of the time. Updated if the step is successfull.
     584     * \param t The value of the time. Updated if the step is successful.
    585585     * \param out Used to store the result of the step.
    586586     * \param dt The step size. Updated.
    587587     * \return success if the step was accepted, fail otherwise.
    … …  
    597597     * step size dt is reduced. If the error estimate is acceptably small, the
    598598     * step is performed, success is returned and dt might be increased to make
    599599     * the steps as large as possible. This method also updates t if a step is
    600      * performed. Also, the internal order of the stepper is adjusted if requried.
     600     * performed. Also, the internal order of the stepper is adjusted if required.
    601601     *
    602602     * \param system The system function to solve, hence the r.h.s. of the ODE.
    603      * It must fullfil the Simple System concept.
     603     * It must fulfill the Simple System concept.
    604604     * \param in The state of the ODE which should be solved.
    605605     * \param dxdt The derivative of state.
    606      * \param t The value of the time. Updated if the step is successfull.
     606     * \param t The value of the time. Updated if the step is successful.
    607607     * \param out Used to store the result of the step.
    608608     * \param dt The step size. Updated.
    609609     * \return success if the step was accepted, fail otherwise.

  • boost/numeric/odeint/util/detail/is_range.hpp

     
    124124
    125125} // namespace detail
    126126
    127 } // namespaec odeint
     127} // namespace odeint
    128128} // namespace numeric
    129129} // namespace boost
    130130

  • boost/numeric/odeint/util/unit_helper.hpp

     
    33  boost/numeric/odeint/util/unit_helper.hpp
    44
    55  [begin_description]
    6   Get and set the the value of a unit.
     6  Get and set the value of a unit.
    77  [end_description]
    88
    99  Copyright 2009-2011 Karsten Ahnert

  • boost/numeric/odeint/util/same_size.hpp

     
    33 boost/numeric/odeint/util/state_wrapper.hpp
    44
    55 [begin_description]
    6  State wrapper for the state type in all stepper. The state wrappers are responsible for contruction,
    7  destruction, copying contruction, assignment and resizing.
     6 State wrapper for the state type in all stepper. The state wrappers are responsible for construction,
     7 destruction, copying construction, assignment and resizing.
    88 [end_description]
    99
    1010 Copyright 2009-2011 Karsten Ahnert

  • boost/numeric/odeint/util/state_wrapper.hpp

     
    33 boost/numeric/odeint/util/state_wrapper.hpp
    44
    55 [begin_description]
    6  State wrapper for the state type in all stepper. The state wrappers are responsible for contruction,
    7  destruction, copying contruction, assignment and resizing.
     6 State wrapper for the state type in all stepper. The state wrappers are responsible for construction,
     7 destruction, copying construction, assignment and resizing.
    88 [end_description]
    99
    1010 Copyright 2009-2011 Karsten Ahnert

  • boost/numeric/odeint/util/resize.hpp

     
    33 boost/numeric/odeint/util/state_wrapper.hpp
    44
    55 [begin_description]
    6  State wrapper for the state type in all stepper. The state wrappers are responsible for contruction,
    7  destruction, copying contruction, assignment and resizing.
     6 State wrapper for the state type in all stepper. The state wrappers are responsible for construction,
     7 destruction, copying construction, assignment and resizing.
    88 [end_description]
    99
    1010 Copyright 2009-2011 Karsten Ahnert
    … …  
    7878        }
    7979
    8080    };
    81 } // nanespace detail
     81} // namespace detail
    8282
    8383
    8484/*

  • boost/numeric/odeint/util/ublas_wrapper.hpp

     
    165165//namespace numeric {
    166166//namespace odeint {
    167167//
    168 ///* specialization for permutation matrizes wrapper because we need to change the construction */
     168///* specialization for permutation matrices wrapper because we need to change the construction */
    169169//template< class T , class A >
    170170//struct state_wrapper< boost::numeric::ublas::permutation_matrix< T , A > , true > // with resizing
    171171//{
    … …  
    254254    return x.data().end();
    255255}
    256256
    257 } } } // nampespace boost::numeric::ublas
     257} } } // namespace boost::numeric::ublas
    258258
    259259
    260260#endif // BOOST_NUMERIC_ODEINT_UTIL_UBLAS_WRAPPER_HPP_INCLUDED

  • libs/numeric/odeint/doc/examples_table.qbk

     
    3232  [The Fermi-Pasta-Ulam (FPU) example shows how odeint can be used to integrate lattice systems.]]
    3333
    3434  [[[github_link libs/numeric/odeint/examples/generation_functions.cpp generation_functions.cpp]]
    35   [Shows skeletal code on how to implemente own factory functions.]]
     35  [Shows skeletal code on how to implement own factory functions.]]
    3636
    3737  [[[github_link libs/numeric/odeint/examples/harmonic_oscillator.cpp harmonic_oscillator.cpp]]
    3838  [The harmonic oscillator examples gives a brief introduction to odeint and shows the usage of the classical Runge-Kutta-solvers.]]

  • libs/numeric/odeint/doc/concepts/error_stepper.qbk

     
    1313
    1414[section Error Stepper]
    1515
    16 This concepts specifies the interface an error stepper has to fulfill to be used within a ControlledErrorStepper. An error stepper must always fullfil the stepper concept. This can trivially implemented by
     16This concepts specifies the interface an error stepper has to fulfill to be used within a ControlledErrorStepper. An error stepper must always fulfill the stepper concept. This can trivially implemented by
    1717
    1818``
    1919template< class System >

  • libs/numeric/odeint/doc/tutorial_thrust_cuda.qbk

     
    2121[important Thrust also supports parallelization using OpenMP and Intel Threading Building Blocks (TBB). You can switch
    2222between CUDA, OpenMP and TBB parallelizations by a simple compiler
    2323switch. Hence, this also provides an easy way to get basic OpenMP
    24 parallelization into odeint. The examples discussed below are focued on GPU parallelization, though. ]
     24parallelization into odeint. The examples discussed below are focused on GPU parallelization, though. ]
    2525
    2626To use odeint with CUDA a few points have to be taken into account. First of all, the problem has to be well chosen. It makes absolutely no sense to try to parallelize the code for a three dimensional system, it is simply too small and not worth the effort. One single function call (kernel execution) on the GPU is slow but you can do the operation on a huge set of data with only one call. We have experienced that the vector size over which is parallelized should be of the order of ['10[super 6]] to make full use of the GPU. Secondly, you have to use __thrust's algorithms and functors when implementing the rhs the ODE. This might be tricky since it involves some kind of functional programming knowledge.
    2727

  • libs/numeric/odeint/doc/details_steppers.qbk

     
    6969
    7070`do_step( sys , in , dxdtin , out , dxdtout , t , dt )`
    7171
    72 This method takes the derivative at time `t` and also also stores
     72This method takes the derivative at time `t` and also stores
    7373the derivative at time ['t+dt]. Calling these functions subsequently iterating
    7474along the solution one saves one function call by passing the result for dxdt
    7575into the next function call.

  • libs/numeric/odeint/doc/tutorial_stiff_systems.qbk

     
    3535
    3636The state type has to be a `ublas::vector` and the matrix type must by a
    3737`ublas::matrix` since the stiff integrator only accepts these types.
    38 However, you might want use non-stiff intgrators on this system, too - we will
     38However, you might want use non-stiff integrators on this system, too - we will
    3939do so later for demonstration. Therefore we want to use the same function also
    4040with other state_types, realized by templatizing the `operator()`:
    4141

  • libs/numeric/odeint/examples/gram_schmidt.hpp

     
    7070        for( size_t k=0 ; k<j ; ++k )
    7171            substract_vector( beg1 , end1 , first + k*n , tmp[k] );
    7272
    73         // nromalize j-th vector
     73        // normalize j-th vector
    7474        norm[j] = sqrt( std::inner_product( beg1 , end1 , beg1 , 0.0 ) );
    7575        // clog << j << " " << norm[j] << "\n";
    7676        normalize( beg1 , end1 , norm[j] );

  • libs/numeric/odeint/examples/resizing_lattice.cpp

     
    33 *
    44 * Demonstrates the usage of resizing of the state type during integration.
    55 * Examplary system is a strongly nonlinear, disordered Hamiltonian lattice
    6  * where the spreading of energy is invastigated
     6 * where the spreading of energy is investigated
    77 *
    88 * Copyright 2009-2012 Karsten Ahnert and Mario Mulansky.
    99 * Distributed under the Boost Software License, Version 1.0. (See

  • libs/numeric/odeint/examples/my_vector.cpp

     
    6868};
    6969
    7070//[my_vector_resizeable
    71 // define my_vector as reizeable
     71// define my_vector as resizeable
    7272
    7373namespace boost { namespace numeric { namespace odeint {
    7474

  • libs/numeric/odeint/examples/list_lattice.cpp

     
    2323
    2424template< >
    2525struct is_resizeable< state_type >
    26 { // declare resizeablility
     26{ // declare resizeability
    2727    typedef boost::true_type type;
    2828    const static bool value = type::value;
    2929};

  • libs/numeric/odeint/examples/2d_lattice/lattice2d.hpp

     
    88 */
    99
    1010
    11 /* stronlgy nonlinear hamiltonian lattice in 2d */
     11/* strongly nonlinear hamiltonian lattice in 2d */
    1212
    1313#ifndef LATTICE2D_HPP
    1414#define LATTICE2D_HPP