# Boost-Commit :

Subject: [Boost-commit] svn:boost r82310 - in branches/release: boost/numeric/odeint boost/numeric/odeint/external/mkl boost/numeric/odeint/external/mtl4 boost/numeric/odeint/integrate boost/numeric/odeint/integrate/detail boost/numeric/odeint/stepper boost/numeric/odeint/stepper/base boost/numeric/odeint/util boost/numeric/odeint/util/detail libs/numeric/odeint libs/numeric/odeint/doc libs/numeric/odeint/doc/concepts libs/numeric/odeint/examples libs/numeric/odeint/examples/2d_lattice
From: karsten.ahnert_at_[hidden]
Date: 2013-01-01 13:48:36

Author: karsten
Date: 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
New Revision: 82310
URL: http://svn.boost.org/trac/boost/changeset/82310

Log:
applied typo patch for odeint
Properties modified:
branches/release/boost/numeric/odeint/ (props changed)
branches/release/libs/numeric/odeint/ (props changed)
Text files modified:
branches/release/boost/numeric/odeint/external/mkl/mkl_operations.hpp | 2
branches/release/boost/numeric/odeint/external/mtl4/implicit_euler_mtl4.hpp | 2
branches/release/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp | 2
branches/release/boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp | 2
branches/release/boost/numeric/odeint/integrate/integrate.hpp | 8 ++--
branches/release/boost/numeric/odeint/integrate/integrate_adaptive.hpp | 4 +-
branches/release/boost/numeric/odeint/integrate/integrate_const.hpp | 2
branches/release/boost/numeric/odeint/integrate/integrate_n_steps.hpp | 2
branches/release/boost/numeric/odeint/integrate/integrate_times.hpp | 2
branches/release/boost/numeric/odeint/stepper/adams_bashforth.hpp | 12 ++++----
branches/release/boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp | 12 ++++----
branches/release/boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp | 4 +-
branches/release/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp | 32 ++++++++++----------
branches/release/boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp | 44 ++++++++++++++--------------
branches/release/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp | 20 ++++++------
branches/release/boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp | 12 ++++----
branches/release/boost/numeric/odeint/stepper/bulirsch_stoer.hpp | 28 +++++++++---------
branches/release/boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp | 16 +++++-----
branches/release/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp | 60 ++++++++++++++++++++--------------------
branches/release/boost/numeric/odeint/stepper/controlled_step_result.hpp | 2
branches/release/boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp | 6 ++--
branches/release/boost/numeric/odeint/stepper/euler.hpp | 6 ++--
branches/release/boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp | 6 ++--
branches/release/boost/numeric/odeint/stepper/explicit_generic_rk.hpp | 2
branches/release/boost/numeric/odeint/stepper/modified_midpoint.hpp | 2
branches/release/boost/numeric/odeint/stepper/rosenbrock4.hpp | 2
branches/release/boost/numeric/odeint/stepper/runge_kutta4.hpp | 4 +-
branches/release/boost/numeric/odeint/stepper/runge_kutta4_classic.hpp | 6 ++--
branches/release/boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp | 4 +-
branches/release/boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp | 8 ++--
branches/release/boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp | 12 ++++----
branches/release/boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp | 4 +-
branches/release/boost/numeric/odeint/stepper/symplectic_euler.hpp | 2
branches/release/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp | 2
branches/release/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp | 4 +-
branches/release/boost/numeric/odeint/util/detail/is_range.hpp | 2
branches/release/boost/numeric/odeint/util/resize.hpp | 6 ++--
branches/release/boost/numeric/odeint/util/same_size.hpp | 4 +-
branches/release/boost/numeric/odeint/util/state_wrapper.hpp | 4 +-
branches/release/boost/numeric/odeint/util/ublas_wrapper.hpp | 4 +-
branches/release/boost/numeric/odeint/util/unit_helper.hpp | 2
branches/release/libs/numeric/odeint/doc/concepts/error_stepper.qbk | 2
branches/release/libs/numeric/odeint/doc/details_steppers.qbk | 2
branches/release/libs/numeric/odeint/doc/examples_table.qbk | 2
branches/release/libs/numeric/odeint/doc/tutorial_stiff_systems.qbk | 2
branches/release/libs/numeric/odeint/doc/tutorial_thrust_cuda.qbk | 2
branches/release/libs/numeric/odeint/examples/2d_lattice/lattice2d.hpp | 2
branches/release/libs/numeric/odeint/examples/gram_schmidt.hpp | 2
branches/release/libs/numeric/odeint/examples/list_lattice.cpp | 2
branches/release/libs/numeric/odeint/examples/my_vector.cpp | 2
branches/release/libs/numeric/odeint/examples/resizing_lattice.cpp | 2
51 files changed, 190 insertions(+), 190 deletions(-)

Modified: branches/release/boost/numeric/odeint/external/mkl/mkl_operations.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/external/mkl/mkl_operations.hpp (original)
+++ branches/release/boost/numeric/odeint/external/mkl/mkl_operations.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -28,7 +28,7 @@
/* exemplary example for writing bindings to the Intel MKL library
* see test/mkl for how to use mkl with odeint
* this is a quick and dirty implementation showing the general possibility.
- * It works only with containers based on double and sequentiel memory allocation.
+ * It works only with containers based on double and sequential memory allocation.
*/

namespace boost {

Modified: branches/release/boost/numeric/odeint/external/mtl4/implicit_euler_mtl4.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/external/mtl4/implicit_euler_mtl4.hpp (original)
+++ branches/release/boost/numeric/odeint/external/mtl4/implicit_euler_mtl4.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -116,7 +116,7 @@

/*
- Applying approximate iteractive linear solvers
+ Applying approximate iterative linear solvers
default solver is Biconjugate gradient stabilized method
itl::bicgstab(A, x, b, L, iter);
*/

Modified: branches/release/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp (original)
+++ branches/release/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -127,7 +127,7 @@

} // namespace odeint
-} // namesapce numeric
+} // namespace numeric
} // namespace boost

#endif // BOOST_NUMERIC_ODEINT_EXTERNAL_MTL4_RESIZE_HPP_INCLUDED

Modified: branches/release/boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp (original)
+++ branches/release/boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -69,7 +69,7 @@

/*
- * classical integrate adpative
+ * classical integrate adaptive
*/
template< class Stepper , class System , class State , class Time , class Observer >
size_t integrate_adaptive(

Modified: branches/release/boost/numeric/odeint/integrate/integrate.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/integrate/integrate.hpp (original)
+++ branches/release/boost/numeric/odeint/integrate/integrate.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -59,7 +59,7 @@
* \brief Integrates the ODE.
*
* Integrates the ODE given by system from start_time to end_time starting
- * with start_state as initial condtition and dt as initial time step.
+ * with start_state as initial condition and dt as initial time step.
* This function uses a dense output dopri5 stepper and performs an adaptive
* integration with step size control, thus dt changes during the integration.
* This method uses standard error bounds of 1E-6.
@@ -70,7 +70,7 @@
* \param start_state The initial state.
* \param start_time Start time of the integration.
* \param end_time End time of the integration.
- * \param dt Initial step size, will be adjusted durinf the integration.
+ * \param dt Initial step size, will be adjusted during the integration.
* \param observer Observer that will be called after each time step.
* \return The number of steps performed.
*/
@@ -81,7 +81,7 @@
* \brief Integrates the ODE without observer calls.
*
* Integrates the ODE given by system from start_time to end_time starting
- * with start_state as initial condtition and dt as initial time step.
+ * with start_state as initial condition and dt as initial time step.
* This function uses a dense output dopri5 stepper and performs an adaptive
* integration with step size control, thus dt changes during the integration.
* This method uses standard error bounds of 1E-6.
@@ -92,7 +92,7 @@
* \param start_state The initial state.
* \param start_time Start time of the integration.
* \param end_time End time of the integration.
- * \param dt Initial step size, will be adjusted durinf the integration.
+ * \param dt Initial step size, will be adjusted during the integration.
* \return The number of steps performed.
*/

Modified: branches/release/boost/numeric/odeint/integrate/integrate_adaptive.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/integrate/integrate_adaptive.hpp (original)
+++ branches/release/boost/numeric/odeint/integrate/integrate_adaptive.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -102,7 +102,7 @@
*
* This function integrates the ODE given by system with the given stepper.
* The observer is called after each step. If the stepper has no error
- * control, the step size remains constant and the observer is calleda at
+ * control, the step size remains constant and the observer is called at
* equidistant time points t0+n*dt. If the stepper is a ControlledStepper,
* the step size is adjusted and the observer is called in non-equidistant
* intervals.
@@ -112,7 +112,7 @@
* \param start_state The initial condition x0.
* \param start_time The initial time t0.
* \param end_time The final integration time tend.
- * \param dt The time step between observer calls, _not_ neccessarily the
+ * \param dt The time step between observer calls, _not_ necessarily the
* time step of the integration.
* \param observer Function/Functor called at equidistant time intervals.
* \return The number of steps performed.

Modified: branches/release/boost/numeric/odeint/integrate/integrate_const.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/integrate/integrate_const.hpp (original)
+++ branches/release/boost/numeric/odeint/integrate/integrate_const.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -141,7 +141,7 @@
* \param start_state The initial condition x0.
* \param start_time The initial time t0.
* \param end_time The final integration time tend.
- * \param dt The time step between observer calls, _not_ neccessarily the
+ * \param dt The time step between observer calls, _not_ necessarily the
* time step of the integration.
* \param observer Function/Functor called at equidistant time intervals.
* \return The number of steps performed.

Modified: branches/release/boost/numeric/odeint/integrate/integrate_n_steps.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/integrate/integrate_n_steps.hpp (original)
+++ branches/release/boost/numeric/odeint/integrate/integrate_n_steps.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -106,7 +106,7 @@
* \param system Function/Functor defining the rhs of the ODE.
* \param start_state The initial condition x0.
* \param start_time The initial time t0.
- * \param dt The time step between observer calls, _not_ neccessarily the
+ * \param dt The time step between observer calls, _not_ necessarily the
* time step of the integration.
* \param num_of_steps Number of steps to be performed
* \param observer Function/Functor called at equidistant time intervals.

Modified: branches/release/boost/numeric/odeint/integrate/integrate_times.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/integrate/integrate_times.hpp (original)
+++ branches/release/boost/numeric/odeint/integrate/integrate_times.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -114,7 +114,7 @@
* \param start_state The initial condition x0.
* \param times_start Iterator to the start time
* \param times_end Iterator to the end time
- * \param dt The time step between observer calls, _not_ neccessarily the
+ * \param dt The time step between observer calls, _not_ necessarily the
* time step of the integration.
* \param observer Function/Functor called at equidistant time intervals.
* \return The number of steps performed.

Modified: branches/release/boost/numeric/odeint/stepper/adams_bashforth.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/adams_bashforth.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/adams_bashforth.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -283,8 +283,8 @@
* then uses the result from the previous Steps steps. See also
* en.wikipedia.org/wiki/Linear_multistep_method.
* Currently, a maximum of Steps=8 is supported.
- * The method is explicit and fullfils the Stepper concept. Step size control
- * or continous output are not provided.
+ * The method is explicit and fulfills the Stepper concept. Step size control
+ * or continuous output are not provided.
*
* This class derives from algebra_base and inherits its interface via
* CRTP (current recurring template pattern). For more details see
@@ -318,7 +318,7 @@
* \fn void adams_bashforth::do_step( System system , StateInOut &x , time_type t , time_type dt )
* \brief This method performs one step. It transforms the result in-place.
*
- * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param t The value of the time, at which the step should be performed.
@@ -329,7 +329,7 @@
* \fn void adams_bashforth::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
* \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param t The value of the time, at which the step should be performed.
@@ -360,7 +360,7 @@
* \fn void adams_bashforth::initialize( ExplicitStepper explicit_stepper , System system , StateIn &x , time_type &t , time_type dt )
* \brief Initialized the stepper. Does Steps-1 steps with the explicit_stepper to fill the buffer.
* \param explicit_stepper the stepper used to fill the buffer of previous step results
- * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param t The value of the time, at which the step should be performed.
@@ -371,7 +371,7 @@
* \fn void adams_bashforth::initialize( System system , StateIn &x , time_type &t , time_type dt )
* \brief Initialized the stepper. Does Steps-1 steps with an internal instance of InitializingStepper to fill the buffer.
* \note The state x and time t are updated to the values after Steps-1 initial steps.
- * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
* Simple System concept.
* \param x The initial state of the ODE which should be solved, updated in this method.
* \param t The initial value of the time, updated in this method.

Modified: branches/release/boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -164,8 +164,8 @@
* See also
* en.wikipedia.org/wiki/Linear_multistep_method.
* Currently, a maximum of Steps=8 is supported.
- * The method is explicit and fullfils the Stepper concept. Step size control
- * or continous output are not provided.
+ * The method is explicit and fulfills the Stepper concept. Step size control
+ * or continuous output are not provided.
*
* This class derives from algebra_base and inherits its interface via
* CRTP (current recurring template pattern). For more details see
@@ -199,7 +199,7 @@
* \fn adams_bashforth_moulton::do_step( System system , StateInOut &x , time_type t , time_type dt )
* \brief This method performs one step. It transforms the result in-place.
*
- * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param t The value of the time, at which the step should be performed.
@@ -211,7 +211,7 @@
* \fn adams_bashforth_moulton::do_step( System system , const StateIn &in , time_type t , const StateOut &out , time_type dt )
* \brief The method performs one step with the stepper passed by Stepper. The state of the ODE is updated out-of-place.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param t The value of the time, at which the step should be performed.
@@ -230,7 +230,7 @@
* \brief Initialized the stepper. Does Steps-1 steps with the explicit_stepper to fill the buffer.
* \note The state x and time t are updated to the values after Steps-1 initial steps.
* \param explicit_stepper the stepper used to fill the buffer of previous step results
- * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
* Simple System concept.
* \param x The initial state of the ODE which should be solved, updated after in this method.
* \param t The initial time, updated in this method.
@@ -241,7 +241,7 @@
* \fn adams_bashforth_moulton::initialize( System system , StateIn &x , time_type &t , time_type dt )
* \brief Initialized the stepper. Does Steps-1 steps using the standard initializing stepper
* of the underlying adams_bashforth stepper.
- * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param t The value of the time, at which the step should be performed.

Modified: branches/release/boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -60,9 +60,9 @@
* algebra and provides access to the algebra. The operations are not instantiated, since they are
* static classes inside the operations class.
*
- * \tparam Algebra The type of the algebra. Must fullfil the Algebra Concept, at least partially to work
+ * \tparam Algebra The type of the algebra. Must fulfill the Algebra Concept, at least partially to work
* with the stepper.
- * \tparam Operations The type of the operations. Must fullfil the Operations Concept, at least partially
+ * \tparam Operations The type of the operations. Must fulfill the Operations Concept, at least partially
* to work with the stepper.
*/

Modified: branches/release/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -323,20 +323,20 @@
* explicit_error_stepper_base derives from algebra_stepper_base.
*
* explicit_error_stepper_base provides several overloaded `do_step` methods, see the list below. Only two of them
- * are needed to fullfil the Error Stepper concept. The other ones are for convenience and for performance. Some
+ * are needed to fulfill the Error Stepper concept. The other ones are for convenience and for performance. Some
* of them simply update the state out-of-place, while other expect that the first derivative at `t` is passed to the
* stepper.
*
- * - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fullfil the Error Stepper concept. The
+ * - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fulfill the Error Stepper concept. The
* state is updated in-place. A type modelling a Boost.Range can be used for x.
* - `do_step( sys , x , dxdt , t , dt )` - This method updates the state in-place, but the derivative at the point `t`
- * must be explicitely passed in `dxdt`.
+ * must be explicitly passed in `dxdt`.
* - `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`.
* - `do_step( sys , in , dxdt , t , out , dt )` - This method update the state out-of-place and expects that the
- * derivative at the point `t` is explicitely passed in `dxdt`. It is a combination of the two `do_step` methods
+ * derivative at the point `t` is explicitly passed in `dxdt`. It is a combination of the two `do_step` methods
* above.
- * - `do_step( sys , x , t , dt , xerr )` - This `do_step` method is needed to fullfil the Error Stepper concept. The
+ * - `do_step( sys , x , t , dt , xerr )` - This `do_step` method is needed to fulfill the Error Stepper concept. The
* state is updated in-place and an error estimate is calculated. A type modelling a Boost.Range can be used for x.
* - `do_step( sys , x , dxdt , t , dt , xerr )` - This method updates the state in-place, but the derivative at the
* point `t` must be passed in `dxdt`. An error estimate is calculated.
@@ -359,15 +359,15 @@
* \tparam ErrorOrder The order of the error step if the stepper is used with error estimation.
* \tparam State The state type for the stepper.
* \tparam Value The value type for the stepper. This should be a floating point type, like float,
- * double, or a multiprecision type. It must not neccessary be the value_type of the State. For example
+ * double, or a multiprecision type. It must not necessary be the value_type of the State. For example
* the State can be a `vector< complex< double > >` in this case the Value must be double.
* The default value is double.
* \tparam Deriv The type representing time derivatives of the state type. It is usually the same type as the
* state type, only if used with Boost.Units both types differ.
* \tparam Time The type representing the time. Usually the same type as the value type. When Boost.Units is
* used, this type has usually a unit.
- * \tparam Algebra The algebra type which must fullfil the Algebra Concept.
- * \tparam Operations The type for the operations wich must fullfil the Operations Concept.
+ * \tparam Algebra The algebra type which must fulfill the Algebra Concept.
+ * \tparam Operations The type for the operations which must fulfill the Operations Concept.
* \tparam Resizer The resizer policy class.
*/

@@ -399,7 +399,7 @@
* \fn explicit_error_stepper_base::do_step( System system , StateInOut &x , time_type t , time_type dt )
* \brief This method performs one step. It transforms the result in-place.
*
- * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param t The value of the time, at which the step should be performed.
@@ -421,7 +421,7 @@
*
* \note This method does not solve the forwarding problem.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param dxdt The derivative of x at t.
@@ -436,7 +436,7 @@
* other `do_step` variants.
* \note This method does not solve the forwarding problem.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param t The value of the time, at which the step should be performed.
@@ -459,7 +459,7 @@
*
* \note This method does not solve the forwarding problem.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.
@@ -473,7 +473,7 @@
* \brief The method performs one step with the stepper passed by Stepper and estimates the error. The state of the ODE
* is updated in-place.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. x is updated by this method.
* \param t The value of the time, at which the step should be performed.
@@ -496,7 +496,7 @@
*
* \note This method does not solve the forwarding problem.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param dxdt The derivative of x at t.
@@ -512,7 +512,7 @@
*
* \note This method does not solve the forwarding problem.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param t The value of the time, at which the step should be performed.
@@ -536,7 +536,7 @@
*
* \note This method does not solve the forwarding problem.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.

Modified: branches/release/boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -340,15 +340,15 @@

/**
* \class explicit_error_stepper_fsal_base
- * \brief Base class for explicit steppers with error estimation and stepper fullfiling the FSAL (first-same-as-last)
+ * \brief Base class for explicit steppers with error estimation and stepper fulfilling the FSAL (first-same-as-last)
* property. This class can be used with controlled steppers for step size control.
*
- * This class serves as the base class for all explicit steppers with algebra and operations and which fullfil the FSAL
+ * This class serves as the base class for all explicit steppers with algebra and operations and which fulfill the FSAL
* property. In contrast to explicit_stepper_base it also estimates the error and can be used in a controlled stepper
* to provide step size control.
*
* The FSAL property means that the derivative of the system at t+dt is already used in the current step going from
- * t to t +dt. Therefore, some more do_steps method can be introduced and the controlled steppers can explicitely make use
+ * t to t +dt. Therefore, some more do_steps method can be introduced and the controlled steppers can explicitly make use
* of this property.
*
* \note This stepper provides `do_step` methods with and without error estimation. It has therefore three orders,
@@ -363,7 +363,7 @@
* This class can have an intrinsic state depending on the explicit usage of the `do_step` method. This means that some
* `do_step` methods are expected to be called in order. For example the `do_step( sys , x , t , dt , xerr )` will keep track
* of the derivative of `x` which is the internal state. The first call of this method is recognized such that one
- * does not explicitely initialize the internal state, so it is safe to use this method like
+ * does not explicitly initialize the internal state, so it is safe to use this method like
*
* \code
* stepper_type stepper;
@@ -376,18 +376,18 @@
* internal state with the `initialize` method or reset the internal state with the `reset` method.
*
* explicit_error_stepper_fsal_base provides several overloaded `do_step` methods, see the list below. Only two of them are needed
- * to fullfil the Error Stepper concept. The other ones are for convenience and for better performance. Some of them
+ * to fulfill the Error Stepper concept. The other ones are for convenience and for better performance. Some of them
* simply update the state out-of-place, while other expect that the first derivative at `t` is passed to the stepper.
*
- * - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fullfil the Error Stepper concept. The
+ * - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fulfill the Error Stepper concept. The
* state is updated in-place. A type modelling a Boost.Range can be used for x.
* - `do_step( sys , x , dxdt , t , dt )` - This method updates the state x and the derivative dxdt in-place. It is expected
* that dxdt has the value of the derivative of x at time t.
* - `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`.
* - `do_step( sys , in , dxdt_in , t , out , dxdt_out , dt )` - This method updates the state and the derivative
- * out-of-place. It expects that the derivative at the point `t` is explicitely passed in `dxdt_in`.
- * - `do_step( sys , x , t , dt , xerr )` - This `do_step` method is needed to fullfil the Error Stepper concept. The
+ * out-of-place. It expects that the derivative at the point `t` is explicitly passed in `dxdt_in`.
+ * - `do_step( sys , x , t , dt , xerr )` - This `do_step` method is needed to fulfill the Error Stepper concept. The
* state is updated in-place and an error estimate is calculated. A type modelling a Boost.Range can be used for x.
* - `do_step( sys , x , dxdt , t , dt , xerr )` - This method updates the state and the derivative in-place. It is assumed
* that the dxdt has the value of the derivative of x at time t. An error estimate is calculated.
@@ -410,15 +410,15 @@
* \tparam ErrorOrder The order of the error step if the stepper is used with error estimation.
* \tparam State The state type for the stepper.
* \tparam Value The value type for the stepper. This should be a floating point type, like float,
- * double, or a multiprecision type. It must not neccessary be the value_type of the State. For example
+ * double, or a multiprecision type. It must not necessary be the value_type of the State. For example
* the State can be a `vector< complex< double > >` in this case the Value must be double.
* The default value is double.
* \tparam Deriv The type representing time derivatives of the state type. It is usually the same type as the
* state type, only if used with Boost.Units both types differ.
* \tparam Time The type representing the time. Usually the same type as the value type. When Boost.Units is
* used, this type has usually a unit.
- * \tparam Algebra The algebra type which must fullfil the Algebra Concept.
- * \tparam Operations The type for the operations wich must fullfil the Operations Concept.
+ * \tparam Algebra The algebra type which must fulfill the Algebra Concept.
+ * \tparam Operations The type for the operations which must fulfill the Operations Concept.
* \tparam Resizer The resizer policy class.
*/

@@ -454,7 +454,7 @@
*
* \note This method uses the internal state of the stepper.
*
- * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param t The value of the time, at which the step should be performed.
@@ -476,7 +476,7 @@
* }
* \endcode
*
- * \note This method does NOT use the initial state, since the first derivative is explicitely passed to this method.
+ * \note This method does NOT use the initial state, since the first derivative is explicitly passed to this method.
*
* The result is updated in place in x as well as the derivative dxdt. This method is disabled if
* Time and StateInOut are of the same type. In this case the method could not be distinguished from other `do_step`
@@ -484,7 +484,7 @@
*
* \note This method does not solve the forwarding problem.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param dxdt The derivative of x at t. After calling `do_step` dxdt is updated to the new value.
@@ -502,7 +502,7 @@
*
* \note This method does not solve the forwarding problem.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param t The value of the time, at which the step should be performed.
@@ -520,7 +520,7 @@
*
* \note This method does NOT use the internal state of the stepper.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt_in The derivative of x at t.
@@ -538,7 +538,7 @@
*
* \note This method uses the internal state of the stepper.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. x is updated by this method.
* \param t The value of the time, at which the step should be performed.
@@ -561,7 +561,7 @@
*
* \note This method does not solve the forwarding problem.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param dxdt The derivative of x at t. After calling `do_step` this value is updated to the new value at `t+dt`.
@@ -580,7 +580,7 @@
*
* \note This method does not solve the forwarding problem.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param t The value of the time, at which the step should be performed.
@@ -598,7 +598,7 @@
*
* \note This method does not solve the forwarding problem.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt_in The derivative of x at t.
@@ -623,14 +623,14 @@

/**
* \fn explicit_error_stepper_fsal_base::initialize( const DerivIn &deriv )
- * \brief Initializes the interal state of the stepper.
+ * \brief Initializes the internal state of the stepper.
* \param deriv The derivative of x. The next call of `do_step` expects that the derivative of `x` passed to `do_step`
* has the value of `deriv`.
*/

/**
* \fn explicit_error_stepper_fsal_base::initialize( System system , const StateIn &x , time_type t )
- * \brief Initializes the interal state of the stepper.
+ * \brief Initializes the internal state of the stepper.
*
* This method is equivalent to
* \code

Modified: branches/release/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -256,13 +256,13 @@
* \endcode
*
* In detail explicit_stepper_base provides the following `do_step` variants
- * - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fullfil the Stepper concept. The state is updated in-place.
+ * - `do_step( sys , x , t , dt )` - The classical `do_step` method needed to fulfill the Stepper concept. The state is updated in-place.
* A type modelling a Boost.Range can be used for x.
* - `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`.
* - `do_step( sys , x , dxdt , t , dt )` - This method updates the state in-place, but the derivative at the point `t` must be
- * explicitely passed in `dxdt`. For an example see the code snippet above.
+ * explicitly passed in `dxdt`. For an example see the code snippet above.
* - `do_step( sys , in , dxdt , t , out , dt )` - This method update the state out-of-place and expects that the derivative at the point
- * `t` is explicitely passed in `dxdt`. It is a combination of the two `do_step` methods above.
+ * `t` is explicitly passed in `dxdt`. It is a combination of the two `do_step` methods above.
*
* \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`
* or `std::ref`, for example `stepper.do_step( boost::ref( sys ) , x , t , dt );`
@@ -274,15 +274,15 @@
* \tparam Order The order of the stepper.
* \tparam State The state type for the stepper.
* \tparam Value The value type for the stepper. This should be a floating point type, like float,
- * double, or a multiprecision type. It must not neccessary be the value_type of the State. For example
+ * double, or a multiprecision type. It must not necessary be the value_type of the State. For example
* the State can be a `vector< complex< double > >` in this case the Value must be double.
* The default value is double.
* \tparam Deriv The type representing time derivatives of the state type. It is usually the same type as the
* state type, only if used with Boost.Units both types differ.
* \tparam Time The type representing the time. Usually the same type as the value type. When Boost.Units is
* used, this type has usually a unit.
- * \tparam Algebra The algebra type which must fullfil the Algebra Concept.
- * \tparam Operations The type for the operations wich must fullfil the Operations Concept.
+ * \tparam Algebra The algebra type which must fulfill the Algebra Concept.
+ * \tparam Operations The type for the operations which must fulfill the Operations Concept.
* \tparam Resizer The resizer policy class.
*/

@@ -303,7 +303,7 @@
* \fn explicit_stepper_base::do_step( System system , StateInOut &x , time_type t , time_type dt )
* \brief This method performs one step. It transforms the result in-place.
*
- * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param t The value of the time, at which the step should be performed.
@@ -327,7 +327,7 @@
*
* \note This method does not solve the forwarding problem.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. After calling do_step the result is updated in x.
* \param dxdt The derivative of x at t.
@@ -340,7 +340,7 @@
* \brief The method performs one step. The state of the ODE is updated out-of-place.
* \note This method does not solve the forwarding problem.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param t The value of the time, at which the step should be performed.
@@ -361,7 +361,7 @@
*
* \note This method does not solve the forwarding problem.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.

Modified: branches/release/boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -328,7 +328,7 @@
* for the coordinate or the momentum part or one function object for the momentum part. `x` is a pair of coordinate
* and momentum. The state is updated in-place.
* - `do_step( sys , q , p , t , dt )` - This method is similar to the method above with the difference that the coordinate
- * and the momentum are passed explicitely and not packed into a pair.
+ * and the momentum are passed explicitly and not packed into a pair.
* - `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
* of coordinate and momentum.
*
@@ -336,7 +336,7 @@
* \tparam Order The order of the stepper.
* \tparam Coor The type representing the coordinates q.
* \tparam Momentum The type representing the coordinates p.
- * \tparam Value The basic value type. Should be somethink like float, double or a high-precision type.
+ * \tparam Value The basic value type. Should be something like float, double or a high-precision type.
* \tparam CoorDeriv The type representing the time derivative of the coordinate dq/dt.
* \tparam MomemtnumDeriv The type representing the time derivative of the momentum dp/dt.
* \tparam Time The type representing the time t.
@@ -362,7 +362,7 @@
/**
* \fn symplectic_nystroem_stepper_base::do_step( System system , const StateInOut &state , time_type t , time_type dt )
* \brief This method performs one step. The system can be either a pair of two function object
- * decribing the momentum part and the coordinate part or one function object describing only
+ * describing the momentum part and the coordinate part or one function object describing only
* the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state
* is updated in-place.
*
@@ -381,7 +381,7 @@
/**
* \fn symplectic_nystroem_stepper_base::do_step( System system , CoorInOut &q , MomentumInOut &p , time_type t , time_type dt )
* \brief This method performs one step. The system can be either a pair of two function object
- * decribing the momentum part and the coordinate part or one function object describing only
+ * describing the momentum part and the coordinate part or one function object describing only
* the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state
* is updated in-place.
*
@@ -391,7 +391,7 @@
* \note This method solves the forwarding problem.
*
* \param system The system, can be represented as a pair of two function object or one function object. See above.
- * \param q The coordinate of the ODE. It is updated in-place. Therefore, the new value of the coorindate will be written
+ * \param q The coordinate of the ODE. It is updated in-place. Therefore, the new value of the coordinate will be written
* into this variable.
* \param p The momentum of the ODE. It is updated in-place. Therefore, the new value of the momentum will be written info
* this variable.
@@ -402,7 +402,7 @@
/**
* \fn symplectic_nystroem_stepper_base::do_step( System system , const StateIn &in , time_type t , StateOut &out , time_type dt )
* \brief This method performs one step. The system can be either a pair of two function object
- * decribing the momentum part and the coordinate part or one function object describing only
+ * describing the momentum part and the coordinate part or one function object describing only
* the momentum part. In this case the coordinate is assumed to be trivial dq/dt = p. The state
* is updated out-of-place.
*

Modified: branches/release/boost/numeric/odeint/stepper/bulirsch_stoer.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/bulirsch_stoer.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/bulirsch_stoer.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -533,13 +533,13 @@
* step size dt is reduced. If the error estimate is acceptably small, the
* step is performed, success is returned and dt might be increased to make
* the steps as large as possible. This method also updates t if a step is
- * performed. Also, the internal order of the stepper is adjusted if requried.
+ * performed. Also, the internal order of the stepper is adjusted if required.
*
* \param system The system function to solve, hence the r.h.s. of the ODE.
- * It must fullfil the Simple System concept.
+ * It must fulfill the Simple System concept.
* \param x The state of the ODE which should be solved. Overwritten if
- * the step is successfull.
- * \param t The value of the time. Updated if the step is successfull.
+ * the step is successful.
+ * \param t The value of the time. Updated if the step is successful.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.
*/
@@ -553,14 +553,14 @@
* step size dt is reduced. If the error estimate is acceptably small, the
* step is performed, success is returned and dt might be increased to make
* the steps as large as possible. This method also updates t if a step is
- * performed. Also, the internal order of the stepper is adjusted if requried.
+ * performed. Also, the internal order of the stepper is adjusted if required.
*
* \param system The system function to solve, hence the r.h.s. of the ODE.
- * It must fullfil the Simple System concept.
+ * It must fulfill the Simple System concept.
* \param x The state of the ODE which should be solved. Overwritten if
- * the step is successfull.
+ * the step is successful.
* \param dxdt The derivative of state.
- * \param t The value of the time. Updated if the step is successfull.
+ * \param t The value of the time. Updated if the step is successful.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.
*/
@@ -576,12 +576,12 @@
* step size dt is reduced. If the error estimate is acceptably small, the
* step is performed, success is returned and dt might be increased to make
* the steps as large as possible. This method also updates t if a step is
- * performed. Also, the internal order of the stepper is adjusted if requried.
+ * performed. Also, the internal order of the stepper is adjusted if required.
*
* \param system The system function to solve, hence the r.h.s. of the ODE.
- * It must fullfil the Simple System concept.
+ * It must fulfill the Simple System concept.
* \param in The state of the ODE which should be solved.
- * \param t The value of the time. Updated if the step is successfull.
+ * \param t The value of the time. Updated if the step is successful.
* \param out Used to store the result of the step.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.
@@ -597,13 +597,13 @@
* step size dt is reduced. If the error estimate is acceptably small, the
* step is performed, success is returned and dt might be increased to make
* the steps as large as possible. This method also updates t if a step is
- * performed. Also, the internal order of the stepper is adjusted if requried.
+ * performed. Also, the internal order of the stepper is adjusted if required.
*
* \param system The system function to solve, hence the r.h.s. of the ODE.
- * It must fullfil the Simple System concept.
+ * It must fulfill the Simple System concept.
* \param in The state of the ODE which should be solved.
* \param dxdt The derivative of state.
- * \param t The value of the time. Updated if the step is successfull.
+ * \param t The value of the time. Updated if the step is successful.
* \param out Used to store the result of the step.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.

Modified: branches/release/boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -114,7 +114,7 @@

for( unsigned short i = 0; i < m_k_max+1; i++ )
{
- /* only this specific sequence allows for dense ouput */
+ /* only this specific sequence allows for dense output */
m_interval_sequence[i] = 2 + 4*i; // 2 6 10 14 ...
m_derivs[i].resize( m_interval_sequence[i] );
if( i == 0 )
@@ -696,7 +696,7 @@
* The Bulirsch-Stoer is a controlled stepper that adjusts both step size
* and order of the method. The algorithm uses the modified midpoint and
* a polynomial extrapolation compute the solution. This class also provides
- * dense outout facility.
+ * dense output facility.
*
* \tparam State The state type.
* \tparam Value The value type.
@@ -729,13 +729,13 @@
* step size dt is reduced. If the error estimate is acceptably small, the
* step is performed, success is returned and dt might be increased to make
* the steps as large as possible. This method also updates t if a step is
- * performed. Also, the internal order of the stepper is adjusted if requried.
+ * performed. Also, the internal order of the stepper is adjusted if required.
*
* \param system The system function to solve, hence the r.h.s. of the ODE.
- * It must fullfil the Simple System concept.
+ * It must fulfill the Simple System concept.
* \param in The state of the ODE which should be solved.
* \param dxdt The derivative of state.
- * \param t The value of the time. Updated if the step is successfull.
+ * \param t The value of the time. Updated if the step is successful.
* \param out Used to store the result of the step.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.
@@ -755,15 +755,15 @@
* \brief Does one time step. This is the main method that should be used to
* integrate an ODE with this stepper.
* \note initialize has to be called before using this method to set the
- * inital conditions x,t and the stepsize.
+ * initial conditions x,t and the stepsize.
* \param system The system function to solve, hence the r.h.s. of the
- * ordinary differential equation. It must fullfil the Simple System concept.
+ * ordinary differential equation. It must fulfill the Simple System concept.
* \return Pair with start and end time of the integration step.
*/

/**
* \fn bulirsch_stoer_dense_out::calc_state( time_type t , StateOut &x ) const
- * \brief Calculates the solution at an intermediate point within the las step
+ * \brief Calculates the solution at an intermediate point within the last step
* \param t The time at which the solution should be calculated, has to be
* in the current time interval.
* \param x The output variable where the result is written into.

Modified: branches/release/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -132,7 +132,7 @@
* This class implements the step size control for standard Runge-Kutta
* steppers with error estimation.
*
- * \tparam ErrorStepper The stepper type with error estimation, has to fullfill the ErrorStepper concept.
+ * \tparam ErrorStepper The stepper type with error estimation, has to fulfill the ErrorStepper concept.
* \tparam ErrorChecker The error checker
* \tparam Resizer The resizer policy type.
*/
@@ -194,11 +194,11 @@
* the steps as large as possible. This method also updates t if a step is
* performed.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. Overwritten if
- * the step is successfull.
- * \param t The value of the time. Updated if the step is successfull.
+ * the step is successful.
+ * \param t The value of the time. Updated if the step is successful.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.
*/
@@ -219,11 +219,11 @@
* the steps as large as possible. This method also updates t if a step is
* performed.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. Overwritten if
- * the step is successfull. Can be a boost range.
- * \param t The value of the time. Updated if the step is successfull.
+ * the step is successful. Can be a boost range.
+ * \param t The value of the time. Updated if the step is successful.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.
*/
@@ -250,12 +250,12 @@
* the steps as large as possible. This method also updates t if a step is
* performed.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. Overwritten if
- * the step is successfull.
+ * the step is successful.
* \param dxdt The derivative of state.
- * \param t The value of the time. Updated if the step is successfull.
+ * \param t The value of the time. Updated if the step is successful.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.
*/
@@ -290,10 +290,10 @@
* the steps as large as possible. This method also updates t if a step is
* performed.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved.
- * \param t The value of the time. Updated if the step is successfull.
+ * \param t The value of the time. Updated if the step is successful.
* \param out Used to store the result of the step.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.
@@ -324,11 +324,11 @@
* the steps as large as possible. This method also updates t if a step is
* performed.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved.
* \param dxdt The derivative of state.
- * \param t The value of the time. Updated if the step is successfull.
+ * \param t The value of the time. Updated if the step is successful.
* \param out Used to store the result of the step.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.
@@ -487,7 +487,7 @@
* This class implements the step size control for FSAL Runge-Kutta
* steppers with error estimation.
*
- * \tparam ErrorStepper The stepper type with error estimation, has to fullfill the ErrorStepper concept.
+ * \tparam ErrorStepper The stepper type with error estimation, has to fulfill the ErrorStepper concept.
* \tparam ErrorChecker The error checker
* \tparam Resizer The resizer policy type.
*/
@@ -547,11 +547,11 @@
* the steps as large as possible. This method also updates t if a step is
* performed.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. Overwritten if
- * the step is successfull.
- * \param t The value of the time. Updated if the step is successfull.
+ * the step is successful.
+ * \param t The value of the time. Updated if the step is successful.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.
*/
@@ -573,11 +573,11 @@
* the steps as large as possible. This method also updates t if a step is
* performed.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. Overwritten if
- * the step is successfull. Can be a boost range.
- * \param t The value of the time. Updated if the step is successfull.
+ * the step is successful. Can be a boost range.
+ * \param t The value of the time. Updated if the step is successful.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.
*/
@@ -594,7 +594,7 @@
*
* This version does not solve the forwarding problem, boost::range can not be used.
*
- * The disabler is needed to solve ambigous overloads
+ * The disabler is needed to solve ambiguous overloads
*/
/**
* \brief Tries to perform one step.
@@ -608,10 +608,10 @@
* the steps as large as possible. This method also updates t if a step is
* performed.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved.
- * \param t The value of the time. Updated if the step is successfull.
+ * \param t The value of the time. Updated if the step is successful.
* \param out Used to store the result of the step.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.
@@ -643,12 +643,12 @@
* the steps as large as possible. This method also updates t if a step is
* performed.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The state of the ODE which should be solved. Overwritten if
- * the step is successfull.
+ * the step is successful.
* \param dxdt The derivative of state.
- * \param t The value of the time. Updated if the step is successfull.
+ * \param t The value of the time. Updated if the step is successful.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.
*/
@@ -682,11 +682,11 @@
* the steps as large as possible. This method also updates t if a step is
* performed.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved.
* \param dxdt The derivative of state.
- * \param t The value of the time. Updated if the step is successfull.
+ * \param t The value of the time. Updated if the step is successful.
* \param out Used to store the result of the step.
* \param dt The step size. Updated.
* \return success if the step was accepted, fail otherwise.
@@ -757,7 +757,7 @@
/**
* \brief Initializes the internal state storing an internal copy of the derivative.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param x The initial state of the ODE which should be solved.
* \param t The initial time.

Modified: branches/release/boost/numeric/odeint/stepper/controlled_step_result.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/controlled_step_result.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/controlled_step_result.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -31,7 +31,7 @@
typedef enum
{
success , /**< The trial step was successful, hence the state and the time have been advanced. */
- fail /**< The step was not succesful and might possibly be repeated with a small step size. */
+ fail /**< The step was not successful and might possibly be repeated with a small step size. */
} controlled_step_result;

} // namespace odeint

Modified: branches/release/boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -93,7 +93,7 @@
/**
* \brief Initializes the stepper. Has to be called before do_step can be
* used to set the initial conditions and the step size.
- * \param x0 The inital state of the ODE which should be solved.
+ * \param x0 The initial state of the ODE which should be solved.
* \param t0 The initial time, at which the step should be performed.
* \param dt0 The step size.
*/
@@ -109,8 +109,8 @@
/**
* \brief Does one time step.
* \note initialize has to be called before using this method to set the
- * inital conditions x,t and the stepsize.
- * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fullfil the
+ * initial conditions x,t and the stepsize.
+ * \param system The system function to solve, hence the r.h.s. of the ordinary differential equation. It must fulfill the
* Simple System concept.
* \return Pair with start and end time of the integration step.
*/

Modified: branches/release/boost/numeric/odeint/stepper/euler.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/euler.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/euler.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -106,7 +106,7 @@
*
* The Euler method is a very simply solver for ordinary differential equations. This method should not be used
* for real applications. It is only useful for demonstration purposes. Step size control is not provided but
- * trivial continous output is available.
+ * trivial continuous output is available.
*
* This class derives from explicit_stepper_base and inherits its interface via CRTP (current recurring template pattern),
* see explicit_stepper_base
@@ -134,7 +134,7 @@
* Access to this step functionality is provided by explicit_stepper_base and
* `do_step_impl` should not be called directly.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.
@@ -146,7 +146,7 @@

/**
* \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
- * \brief This method is used for continous output and it calculates the state `x` at a time `t` from the
+ * \brief This method is used for continuous output and it calculates the state `x` at a time `t` from the
* knowledge of two states `old_state` and `current_state` at time points `t_old` and `t_new`.
*/

Modified: branches/release/boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -172,7 +172,7 @@
/**
* \class explicit_error_generic_rk
* \brief A generic implementation of explicit Runge-Kutta algorithms with error estimation. This class is as a
- * base class for all explicit Runge-Kutta steppers with error estimateion.
+ * base class for all explicit Runge-Kutta steppers with error estimation.
*
* This class implements the explicit Runge-Kutta algorithms with error estimation in a generic way.
* The Butcher tableau is passed to the stepper which constructs the stepper scheme with the help of a
@@ -212,7 +212,7 @@
* The result is updated out-of-place, hence the input is in `in` and the output in `out`. Futhermore, an
* estimation of the error is stored in `xerr`. `do_step_impl` is used by explicit_error_stepper_base.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.
@@ -229,7 +229,7 @@
* Access to this step functionality is provided by explicit_stepper_base and
* `do_step_impl` should not be called directly.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.

Modified: branches/release/boost/numeric/odeint/stepper/explicit_generic_rk.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/explicit_generic_rk.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/explicit_generic_rk.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -221,7 +221,7 @@
* Access to this step functionality is provided by explicit_stepper_base and
* `do_step_impl` should not be called directly.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.

Modified: branches/release/boost/numeric/odeint/stepper/modified_midpoint.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/modified_midpoint.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/modified_midpoint.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -298,7 +298,7 @@
* \class modified_midpoint_dense_out
*
* Implementation of the modified midpoint method with a configurable
- * number of intermediate steps. This class is used by the dense ouput
+ * number of intermediate steps. This class is used by the dense output
* Bulirsch-Stoer algorithm and is not meant for direct usage.
* \note This stepper is for internal use only and does not meet
* any stepper concept.

Modified: branches/release/boost/numeric/odeint/stepper/rosenbrock4.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/rosenbrock4.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/rosenbrock4.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -167,7 +167,7 @@
template< class System >
void do_step( System system , const state_type &x , time_type t , state_type &xout , time_type dt , state_type &xerr )
{
- // get the systen and jacobi function
+ // get the system and jacobi function
typedef typename odeint::unwrap_reference< System >::type system_type;
typedef typename odeint::unwrap_reference< typename system_type::first_type >::type deriv_func_type;
typedef typename odeint::unwrap_reference< typename system_type::second_type >::type jacobi_func_type;

Modified: branches/release/boost/numeric/odeint/stepper/runge_kutta4.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/runge_kutta4.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/runge_kutta4.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -148,8 +148,8 @@
* The Runge-Kutta method of fourth order is one standard method for
* solving ordinary differential equations and is widely used, see also
* en.wikipedia.org/wiki/Runge-Kutta_methods
- * The method is explicit and fullfils the Stepper concept. Step size control
- * or continous output are not provided.
+ * The method is explicit and fulfills the Stepper concept. Step size control
+ * or continuous output are not provided.
*
* This class derives from explicit_stepper_base and inherits its interface via CRTP (current recurring template pattern).
* Furthermore, it derivs from explicit_generic_rk which is a generic Runge-Kutta algorithm. For more details see

Modified: branches/release/boost/numeric/odeint/stepper/runge_kutta4_classic.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/runge_kutta4_classic.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/runge_kutta4_classic.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -165,8 +165,8 @@
* The Runge-Kutta method of fourth order is one standard method for
* solving ordinary differential equations and is widely used, see also
* en.wikipedia.org/wiki/Runge-Kutta_methods
- * The method is explicit and fullfils the Stepper concept. Step size control
- * or continous output are not provided. This class implements the method directly, hence the
+ * The method is explicit and fulfills the Stepper concept. Step size control
+ * or continuous output are not provided. This class implements the method directly, hence the
* generic Runge-Kutta algorithm is not used.
*
* This class derives from explicit_stepper_base and inherits its interface via
@@ -197,7 +197,7 @@
* Access to this step functionality is provided by explicit_stepper_base and
* `do_step_impl` should not be called directly.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.

Modified: branches/release/boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -199,8 +199,8 @@
* The Runge-Kutta Cash-Karp method is one of the standard methods for
* solving ordinary differential equations, see
* en.wikipedia.org/wiki/Cash-Karp_methods.
- * The method is explicit and fullfils the Error Stepper concept. Step size control
- * is provided but continous output is not available for this method.
+ * The method is explicit and fulfills the Error Stepper concept. Step size control
+ * is provided but continuous output is not available for this method.
*
* This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring template pattern).
* Furthermore, it derivs from explicit_error_generic_rk which is a generic Runge-Kutta algorithm with error estimation.

Modified: branches/release/boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -216,8 +216,8 @@
* The Runge-Kutta Cash-Karp method is one of the standard methods for
* solving ordinary differential equations, see
* en.wikipedia.org/wiki/Cash-Karp_method.
- * The method is explicit and fullfils the Error Stepper concept. Step size control
- * is provided but continous output is not available for this method.
+ * The method is explicit and fulfills the Error Stepper concept. Step size control
+ * is provided but continuous output is not available for this method.
*
* This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring
* template pattern). This class implements the method directly, hence the generic Runge-Kutta algorithm is not used.
@@ -250,7 +250,7 @@
* `do_step_impl` should not be called directly.

*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.
@@ -267,7 +267,7 @@
* Access to this step functionality is provided by explicit_error_stepper_base and
* `do_step_impl` should not be called directly.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt The derivative of x at t.

Modified: branches/release/boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -255,7 +255,7 @@
const value_type b7_theta = B + C * X7;

// const state_type &k1 = *m_old_deriv;
- // onst state_type &k3 = dopri5().m_k3;
+ // const state_type &k3 = dopri5().m_k3;
// const state_type &k4 = dopri5().m_k4;
// const state_type &k5 = dopri5().m_k5;
// const state_type &k6 = dopri5().m_k6;
@@ -314,8 +314,8 @@
*
* The Runge-Kutta Dormand-Prince 5 method is a very popular method for solving ODEs, see
* .
- * The method is explicit and fullfils the Error Stepper concept. Step size control
- * is provided but continous output is available which make this method favourable for many applications.
+ * The method is explicit and fulfills the Error Stepper concept. Step size control
+ * is provided but continuous output is available which make this method favourable for many applications.
*
* This class derives from explicit_error_stepper_fsal_base and inherits its interface via CRTP (current recurring
* template pattern). The method possesses the FSAL (first-same-as-last) property. See
@@ -347,7 +347,7 @@
* Access to this step functionality is provided by explicit_error_stepper_fsal_base and
* `do_step_impl` should not be called directly.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt_in The derivative of x at t. dxdt_in is not modified by this method
@@ -367,7 +367,7 @@
* `do_step_impl` should not be called directly.
* An estimation of the error is calculated.
*
- * \param system The system function to solve, hence the r.h.s. of the ODE. It must fullfil the
+ * \param system The system function to solve, hence the r.h.s. of the ODE. It must fulfill the
* Simple System concept.
* \param in The state of the ODE which should be solved. in is not modified in this method
* \param dxdt_in The derivative of x at t. dxdt_in is not modified by this method
@@ -380,7 +380,7 @@

/**
* \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
- * \brief This method is used for continous output and it calculates the state `x` at a time `t` from the
+ * \brief This method is used for continuous output and it calculates the state `x` at a time `t` from the
* knowledge of two states `old_state` and `current_state` at time points `t_old` and `t_new`. It also uses
* internal variables to calculate the result. Hence this method must be called after two successful `do_step`
* calls.

Modified: branches/release/boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -341,8 +341,8 @@
* \brief The Runge-Kutta Fehlberg 78 method.
*
* The Runge-Kutta Fehlberg 78 method is a standard method for high-precision applications.
- * The method is explicit and fullfils the Error Stepper concept. Step size control
- * is provided but continous output is not available for this method.
+ * The method is explicit and fulfills the Error Stepper concept. Step size control
+ * is provided but continuous output is not available for this method.
*
* This class derives from explicit_error_stepper_base and inherits its interface via CRTP (current recurring template pattern).
* Furthermore, it derivs from explicit_error_generic_rk which is a generic Runge-Kutta algorithm with error estimation.

Modified: branches/release/boost/numeric/odeint/stepper/symplectic_euler.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/symplectic_euler.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/symplectic_euler.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -110,7 +110,7 @@
* \tparam Order The order of the stepper.
* \tparam Coor The type representing the coordinates q.
* \tparam Momentum The type representing the coordinates p.
- * \tparam Value The basic value type. Should be somethink like float, double or a high-precision type.
+ * \tparam Value The basic value type. Should be something like float, double or a high-precision type.
* \tparam CoorDeriv The type representing the time derivative of the coordinate dq/dt.
* \tparam MomemtnumDeriv The type representing the time derivative of the momentum dp/dt.
* \tparam Time The type representing the time t.

Modified: branches/release/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -130,7 +130,7 @@
* \tparam Order The order of the stepper.
* \tparam Coor The type representing the coordinates q.
* \tparam Momentum The type representing the coordinates p.
- * \tparam Value The basic value type. Should be somethink like float, double or a high-precision type.
+ * \tparam Value The basic value type. Should be something like float, double or a high-precision type.
* \tparam CoorDeriv The type representing the time derivative of the coordinate dq/dt.
* \tparam MomemtnumDeriv The type representing the time derivative of the momentum dp/dt.
* \tparam Time The type representing the time t.

Modified: branches/release/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp (original)
+++ branches/release/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -125,7 +125,7 @@

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

Modified: branches/release/boost/numeric/odeint/util/detail/is_range.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/util/detail/is_range.hpp (original)
+++ branches/release/boost/numeric/odeint/util/detail/is_range.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -124,7 +124,7 @@

} // namespace detail

-} // namespaec odeint
+} // namespace odeint
} // namespace numeric
} // namespace boost

Modified: branches/release/boost/numeric/odeint/util/resize.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/util/resize.hpp (original)
+++ branches/release/boost/numeric/odeint/util/resize.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -3,8 +3,8 @@
boost/numeric/odeint/util/state_wrapper.hpp

[begin_description]
- State wrapper for the state type in all stepper. The state wrappers are responsible for contruction,
- destruction, copying contruction, assignment and resizing.
+ State wrapper for the state type in all stepper. The state wrappers are responsible for construction,
+ destruction, copying construction, assignment and resizing.
[end_description]

Copyright 2009-2011 Karsten Ahnert
@@ -78,7 +78,7 @@
}

};
-} // nanespace detail
+} // namespace detail

/*

Modified: branches/release/boost/numeric/odeint/util/same_size.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/util/same_size.hpp (original)
+++ branches/release/boost/numeric/odeint/util/same_size.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -3,8 +3,8 @@
boost/numeric/odeint/util/state_wrapper.hpp

[begin_description]
- State wrapper for the state type in all stepper. The state wrappers are responsible for contruction,
- destruction, copying contruction, assignment and resizing.
+ State wrapper for the state type in all stepper. The state wrappers are responsible for construction,
+ destruction, copying construction, assignment and resizing.
[end_description]

Copyright 2009-2011 Karsten Ahnert

Modified: branches/release/boost/numeric/odeint/util/state_wrapper.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/util/state_wrapper.hpp (original)
+++ branches/release/boost/numeric/odeint/util/state_wrapper.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -3,8 +3,8 @@
boost/numeric/odeint/util/state_wrapper.hpp

[begin_description]
- State wrapper for the state type in all stepper. The state wrappers are responsible for contruction,
- destruction, copying contruction, assignment and resizing.
+ State wrapper for the state type in all stepper. The state wrappers are responsible for construction,
+ destruction, copying construction, assignment and resizing.
[end_description]

Copyright 2009-2011 Karsten Ahnert

Modified: branches/release/boost/numeric/odeint/util/ublas_wrapper.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/util/ublas_wrapper.hpp (original)
+++ branches/release/boost/numeric/odeint/util/ublas_wrapper.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -165,7 +165,7 @@
//namespace numeric {
//namespace odeint {
//
-///* specialization for permutation matrizes wrapper because we need to change the construction */
+///* specialization for permutation matrices wrapper because we need to change the construction */
//template< class T , class A >
//struct state_wrapper< boost::numeric::ublas::permutation_matrix< T , A > , true > // with resizing
//{
@@ -254,7 +254,7 @@
return x.data().end();
}

-} } } // nampespace boost::numeric::ublas
+} } } // namespace boost::numeric::ublas

#endif // BOOST_NUMERIC_ODEINT_UTIL_UBLAS_WRAPPER_HPP_INCLUDED

Modified: branches/release/boost/numeric/odeint/util/unit_helper.hpp
==============================================================================
--- branches/release/boost/numeric/odeint/util/unit_helper.hpp (original)
+++ branches/release/boost/numeric/odeint/util/unit_helper.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -3,7 +3,7 @@
boost/numeric/odeint/util/unit_helper.hpp

[begin_description]
- Get and set the the value of a unit.
+ Get and set the value of a unit.
[end_description]

Copyright 2009-2011 Karsten Ahnert

Modified: branches/release/libs/numeric/odeint/doc/concepts/error_stepper.qbk
==============================================================================
--- branches/release/libs/numeric/odeint/doc/concepts/error_stepper.qbk (original)
+++ branches/release/libs/numeric/odeint/doc/concepts/error_stepper.qbk 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -13,7 +13,7 @@

[section Error Stepper]

-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
+This 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

``
template< class System >

Modified: branches/release/libs/numeric/odeint/doc/details_steppers.qbk
==============================================================================
--- branches/release/libs/numeric/odeint/doc/details_steppers.qbk (original)
+++ branches/release/libs/numeric/odeint/doc/details_steppers.qbk 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -69,7 +69,7 @@

`do_step( sys , in , dxdtin , out , dxdtout , t , dt )`

-This method takes the derivative at time `t` and also also stores
+This method takes the derivative at time `t` and also stores
the derivative at time ['t+dt]. Calling these functions subsequently iterating
along the solution one saves one function call by passing the result for dxdt
into the next function call.

Modified: branches/release/libs/numeric/odeint/doc/examples_table.qbk
==============================================================================
--- branches/release/libs/numeric/odeint/doc/examples_table.qbk (original)
+++ branches/release/libs/numeric/odeint/doc/examples_table.qbk 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -32,7 +32,7 @@
[The Fermi-Pasta-Ulam (FPU) example shows how odeint can be used to integrate lattice systems.]]

[[[github_link libs/numeric/odeint/examples/generation_functions.cpp generation_functions.cpp]]
- [Shows skeletal code on how to implemente own factory functions.]]
+ [Shows skeletal code on how to implement own factory functions.]]

[[[github_link libs/numeric/odeint/examples/harmonic_oscillator.cpp harmonic_oscillator.cpp]]
[The harmonic oscillator examples gives a brief introduction to odeint and shows the usage of the classical Runge-Kutta-solvers.]]

Modified: branches/release/libs/numeric/odeint/doc/tutorial_stiff_systems.qbk
==============================================================================
--- branches/release/libs/numeric/odeint/doc/tutorial_stiff_systems.qbk (original)
+++ branches/release/libs/numeric/odeint/doc/tutorial_stiff_systems.qbk 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -35,7 +35,7 @@

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

Modified: branches/release/libs/numeric/odeint/doc/tutorial_thrust_cuda.qbk
==============================================================================
--- branches/release/libs/numeric/odeint/doc/tutorial_thrust_cuda.qbk (original)
+++ branches/release/libs/numeric/odeint/doc/tutorial_thrust_cuda.qbk 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -21,7 +21,7 @@
[important Thrust also supports parallelization using OpenMP and Intel Threading Building Blocks (TBB). You can switch
between CUDA, OpenMP and TBB parallelizations by a simple compiler
switch. Hence, this also provides an easy way to get basic OpenMP
-parallelization into odeint. The examples discussed below are focued on GPU parallelization, though. ]
+parallelization into odeint. The examples discussed below are focused on GPU parallelization, though. ]

To 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.

Modified: branches/release/libs/numeric/odeint/examples/2d_lattice/lattice2d.hpp
==============================================================================
--- branches/release/libs/numeric/odeint/examples/2d_lattice/lattice2d.hpp (original)
+++ branches/release/libs/numeric/odeint/examples/2d_lattice/lattice2d.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -8,7 +8,7 @@
*/

-/* stronlgy nonlinear hamiltonian lattice in 2d */
+/* strongly nonlinear hamiltonian lattice in 2d */

#ifndef LATTICE2D_HPP
#define LATTICE2D_HPP

Modified: branches/release/libs/numeric/odeint/examples/gram_schmidt.hpp
==============================================================================
--- branches/release/libs/numeric/odeint/examples/gram_schmidt.hpp (original)
+++ branches/release/libs/numeric/odeint/examples/gram_schmidt.hpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -70,7 +70,7 @@
for( size_t k=0 ; k<j ; ++k )
substract_vector( beg1 , end1 , first + k*n , tmp[k] );

- // nromalize j-th vector
+ // normalize j-th vector
norm[j] = sqrt( std::inner_product( beg1 , end1 , beg1 , 0.0 ) );
// clog << j << " " << norm[j] << "\n";
normalize( beg1 , end1 , norm[j] );

Modified: branches/release/libs/numeric/odeint/examples/list_lattice.cpp
==============================================================================
--- branches/release/libs/numeric/odeint/examples/list_lattice.cpp (original)
+++ branches/release/libs/numeric/odeint/examples/list_lattice.cpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -23,7 +23,7 @@

template< >
struct is_resizeable< state_type >
-{ // declare resizeablility
+{ // declare resizeability
typedef boost::true_type type;
const static bool value = type::value;
};

Modified: branches/release/libs/numeric/odeint/examples/my_vector.cpp
==============================================================================
--- branches/release/libs/numeric/odeint/examples/my_vector.cpp (original)
+++ branches/release/libs/numeric/odeint/examples/my_vector.cpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -68,7 +68,7 @@
};

//[my_vector_resizeable
-// define my_vector as reizeable
+// define my_vector as resizeable

namespace boost { namespace numeric { namespace odeint {

Modified: branches/release/libs/numeric/odeint/examples/resizing_lattice.cpp
==============================================================================
--- branches/release/libs/numeric/odeint/examples/resizing_lattice.cpp (original)
+++ branches/release/libs/numeric/odeint/examples/resizing_lattice.cpp 2013-01-01 13:48:32 EST (Tue, 01 Jan 2013)
@@ -3,7 +3,7 @@
*
* Demonstrates the usage of resizing of the state type during integration.
* Examplary system is a strongly nonlinear, disordered Hamiltonian lattice
- * where the spreading of energy is invastigated
+ * where the spreading of energy is investigated
*
* Copyright 2009-2012 Karsten Ahnert and Mario Mulansky.
* Distributed under the Boost Software License, Version 1.0. (See