A controlled stepper following this Controlled Stepper concept provides the
- possibilty to perform one step of the solution x(t)
+ possibility to perform one step of the solution x(t)
of an ODE with step-size dt to obtain x(t+dt)
with a given step-size dt. Depending on an error estimate
of the solution the step might be rejected and a smaller step-size is suggested.
@@ -135,7 +135,7 @@
Tries one step of step size dt.
- If the step was succesfull, success
+ If the step was successful, success
is returned, the resulting state is written to x,
the new time is stored in t
and dt now contains
diff --git a/doc/boost_sandbox_numeric_odeint/concepts/dense_output_stepper.html b/doc/boost_sandbox_numeric_odeint/concepts/dense_output_stepper.html
index 2e9f4fc9..cd0ab6b3 100644
--- a/doc/boost_sandbox_numeric_odeint/concepts/dense_output_stepper.html
+++ b/doc/boost_sandbox_numeric_odeint/concepts/dense_output_stepper.html
@@ -21,7 +21,7 @@
Output Stepper
- This concept specifies the interface a dense ouput stepper has to fulfill
+ This concept specifies the interface a dense output stepper has to fulfill
to be used within integrate
functions.
- A dense ouput stepper following this Dense Output Stepper concept provides
+ A dense output stepper following this Dense Output Stepper concept provides
the possibility to perform a single step of the solution x(t)
of an ODE to obtain x(t+dt). The step-size dt might be adjusted automatically due
to error control. Dense output steppers also can interpolate the solution
diff --git a/doc/boost_sandbox_numeric_odeint/concepts/observer.html b/doc/boost_sandbox_numeric_odeint/concepts/observer.html
index c58f79c1..d43e0d61 100644
--- a/doc/boost_sandbox_numeric_odeint/concepts/observer.html
+++ b/doc/boost_sandbox_numeric_odeint/concepts/observer.html
@@ -119,8 +119,8 @@
- Calls the observer which can do some analyzation of the state
- x at time t.
+ Calls the observer which can do some analysis or output of the
+ state x at time t.
The following does not apply to implicit steppers like implicit_euler or
- rosenbrock 4 as there the state_type
+ Rosenbrock 4 as there the state_type
can not be changed from ublas::vector
and no algebra/operations are used.
@@ -672,7 +672,7 @@
Anything that defines operators + within itself and * with scalar
- (Mathematically spoken, anyhting that is a vector space).
+ (Mathematically spoken, anything that is a vector space).
- This concepts specifies the interface a simple stepper has to fullfill to
+ This concepts specifies the interface a simple stepper has to fulfill to
be used within the integrate
functions.
- Standard method with error control and dense ouput, to be used
+ Standard method with error control and dense output, to be used
in controlled_error_stepper and in dense_output_controlled_explicit_fsal.
@@ -676,9 +676,9 @@
- Dense ouput for Stepper
+ Dense output for Stepper
and Error
- Stepper from above if they provide dense ouput functionality
+ Stepper from above if they provide dense output functionality
(like euler and
runge_kutta_dopri5).
Order depends on the given stepper.
@@ -778,8 +778,8 @@
- Stepper with step size and order control as well as dense ouput.
- Very good if high precision and dense ouput is required.
+ Stepper with step size and order control as well as dense output.
+ Very good if high precision and dense output is required.
@@ -1090,7 +1090,7 @@
differential equations. Be sure, you will find them in every discipline.
They also occur if partial differential equations (PDEs) are discretized
in one coordinate. Then, a system of coupled ordinary differential occurs,
- sometimes also refered as lattices ODEs.
+ sometimes also referred as lattices ODEs.
diff --git a/doc/boost_sandbox_numeric_odeint/getting_started/short_example.html b/doc/boost_sandbox_numeric_odeint/getting_started/short_example.html
index e92f2639..ce13dde4 100644
--- a/doc/boost_sandbox_numeric_odeint/getting_started/short_example.html
+++ b/doc/boost_sandbox_numeric_odeint/getting_started/short_example.html
@@ -70,7 +70,7 @@
For the integration itself we'll use the integrate
function, which is a convenient way to get quick results. It is based on
the error-controlled runge_kutta_rk5_ck
- stepper (5th order) and uses adaptive stepsize.
+ stepper (5th order) and uses adaptive step-size.
@@ -84,7 +84,7 @@
above, the initial state x,
the start-and end-time of the integration as well as the initial time step.
Note, that integrate
- uses an adaptive stepsize during the integration steps so the time points
+ uses an adaptive step-size during the integration steps so the time points
will not be equally spaced. The integration returns the number of steps that
were applied.
diff --git a/doc/boost_sandbox_numeric_odeint/odeint_in_detail/generation_functions.html b/doc/boost_sandbox_numeric_odeint/odeint_in_detail/generation_functions.html
index af9627af..42156507 100644
--- a/doc/boost_sandbox_numeric_odeint/odeint_in_detail/generation_functions.html
+++ b/doc/boost_sandbox_numeric_odeint/odeint_in_detail/generation_functions.html
@@ -108,7 +108,7 @@
Of course, all controllers and dense-output steppers in odeint can be used
with these mechanisms. In the table below you will find, which steppers is
- contructed from make_controlled
+ constructed from make_controlled
or make_dense_output if applied
on a stepper from odeint:
- If observer calls at equdistant time intervals dt are
+ If observer calls at equidistant time intervals dt are
needed, the integrate_const
function should be used.
@@ -271,10 +271,10 @@
Warning
- This function works only with steppers fullfilling the Stepper
+ This function works only with steppers fulfilling the Stepper
or Error
Stepper concept! Providing a Controlled
- Stepper or __dense_out_stepper results in a compilationerror.
+ Stepper or __dense_out_stepper results in a compilation error.
@@ -301,7 +301,7 @@
starting at x0 and t0. If provided,
observer is called after
every step and at the beginning with t0.
- This function works only with steppers fullfilling the Stepper
+ This function works only with steppers fulfilling the Stepper
or Error
Stepper concept! It performs exactly n
steps with fixed step size dt
@@ -319,7 +319,7 @@
Additionally to the sophisticated integrate function above odeint also provides
a simple integrate routine
- which uses a dense ouput stepper based on runge_kutta_dopri5
+ which uses a dense output stepper based on runge_kutta_dopri5
with standard error bounds 10-6 for the steps.
diff --git a/doc/boost_sandbox_numeric_odeint/odeint_in_detail/state_types__algebras_and_operations.html b/doc/boost_sandbox_numeric_odeint/odeint_in_detail/state_types__algebras_and_operations.html
index f23eede8..b6a33d70 100644
--- a/doc/boost_sandbox_numeric_odeint/odeint_in_detail/state_types__algebras_and_operations.html
+++ b/doc/boost_sandbox_numeric_odeint/odeint_in_detail/state_types__algebras_and_operations.html
@@ -33,7 +33,7 @@
the user full control over the state type and the mathematical operations
for this state type. Technically, this is done by introducing three concepts:
StateType, Algebra, Operations. Most of the steppers in odeint expect three
- classes types fullfilling these concepts as template parameters. Note that
+ classes types fulfilling these concepts as template parameters. Note that
these concepts are not fully independent of each other but rather a valid
combination must be provided in order to make the steppers work. In the following
we will give some examples on reasonable state_type-algebra-operations combinations.
@@ -755,7 +755,7 @@
A similar class exists for the const
version of the iterator. Then we have a function returning the end iterator
- (similarily for const again):
+ (similarly for const again):
gsl_vector_iteratorend_iterator(gsl_vector*x){
@@ -786,7 +786,7 @@
Again with similar definitions for the const
versions. This eventually makes odeint work with gsl vectors as state
types. The full code for these bindings is found in gsl_wrapper.hpp.
- It might look rather complicated but keep in mind that gsl is a pre compiled
+ It might look rather complicated but keep in mind that gsl is a pre-compiled
C library so it is quite an achievement that it's possible to get it
working at all in the first place.
@@ -934,7 +934,7 @@
- Definign these operators makes your state type work with any basic Runge-Kutta
+ Defining these operators makes your state type work with any basic Runge-Kutta
stepper. However, if you want to use step-size control, some more functionality
is required. Specifically, operations like maxi( |erri| / (alpha
* |si|) ) have to be performed. err and
@@ -992,7 +992,7 @@
- Calculates the elementwise division 'x/y'
+ Calculates the element-wise division 'x/y'
@@ -1074,7 +1074,7 @@
As an example for the employment of the vector_space_algebra
we will adopt ublas::vector from Boost.UBlas
- to work as a state type in odeint. This is particularily easy because
+ to work as a state type in odeint. This is particularly easy because
ublas::vector supports vector-vector addition
and scalar-vector multiplication described above as well as boost::size. It also has a resize member function
so all that has to be done in this case is to declare resizability:
@@ -1230,7 +1230,7 @@
use controlled steppers. For simple steppers definition of the simple
+= and *=
operators are sufficient. Having defined such a point type, we can easily
- perform the integration on a lorenz system by using the vector_space_algebra again:
+ perform the integration on a Lorenz system by using the vector_space_algebra again:
diff --git a/doc/boost_sandbox_numeric_odeint/odeint_in_detail/steppers.html b/doc/boost_sandbox_numeric_odeint/odeint_in_detail/steppers.html
index e58d3df5..b7bf08e3 100644
--- a/doc/boost_sandbox_numeric_odeint/odeint_in_detail/steppers.html
+++ b/doc/boost_sandbox_numeric_odeint/odeint_in_detail/steppers.html
@@ -40,7 +40,7 @@
own steppers
- Solving ordinary differential equation numerically is ususally done iteratively,
+ Solving ordinary differential equation numerically is usually done iteratively,
that is a given state of an ordinary differential equation is iterated forward
x(t) -> x(t+dt) -> x(t+2dt). The steppers in odeint
perform one single step. The most general stepper type is described by the
@@ -50,7 +50,7 @@
we briefly present the mathematical and numerical details of the steppers.
The Stepper
has two versions of the do_step
- method, one with an in-place transform of the currrent state and one with
+ method, one with an in-place transform of the current state and one with
an out-of-place transform:
@@ -90,7 +90,7 @@
Other types of system function represent Hamiltonian systems or system which
- also compute the Jacobian needed in implicit steppers. For informations which
+ also compute the Jacobian needed in implicit steppers. For information which
stepper uses which system function see the stepper table below. It might
be possible, that odeint will introduce new system types in near future.
Since the system function is strongly related to the stepper type, such an
@@ -171,7 +171,7 @@
This method also fills the derivative at time t+dt
into dxdtout. Of course,
the performance gain of such FSAL steppers only appears when combining
- with intergrate error estimation, like in the Runge-Kutta-Dopri5 stepper.
+ with integrate error estimation, like in the Runge-Kutta-Dopri5 stepper.
The FSAL-trick is sometimes also referred as the Fehlberg-Trick. An example
how the FSAL steppers can be used is
@@ -221,11 +221,11 @@
A special class of symplectic systems are separable systems which can be
written in the form dqdt/dt = f1(p), dpdt/dt
= f2(q), where (q,p) are the state of system.
- The space of (q,p) is sometimes refered as the phase
+ The space of (q,p) is sometimes referred as the phase
space and q and p are said the
be the phase space variables. Symplectic systems in this special form occur
widely in nature. For example the complete classical mechanics as written
- down by Newton, Lagrange and Hamilton can be forumulated in this framework.
+ down by Newton, Lagrange and Hamilton can be formulated in this framework.
Of course, the separability of the system depends on the specific choice
of coordinates.
@@ -233,7 +233,7 @@
Integrable symplectic systems can be solved by odeint by means of the symplectic_euler
stepper and a symplectic Runge-Kutta-Nystrom method of sixth-order. These
stepper assume that the system is autonomous, hence the time will not explicitly
- occur. Furhter they fullfil in principle the default Stepper concept, but
+ occur. Further they fulfill in principle the default Stepper concept, but
they expect the system to be a pair of callable objects. The first entry
of this pair calculates f1(p) while the second calculates
f2(q). The syntax is sys.first(p,dqdt)
@@ -314,7 +314,7 @@
form. This kind of system can be used in the symplectic solvers, by simply
passing f(p) to the do_step
method, again f(p) will be represented by a simple
- C-function or a functor. Here, the above example of the harmonic oscaillator
+ C-function or a functor. Here, the above example of the harmonic oscillator
can be written as
@@ -331,7 +331,7 @@
is exactly the same function as in the above examples.
- Note, that the state of the ODE must not be contructed explicitly via
+ Note, that the state of the ODE must not be constructed explicitly via
pair<vector_type,vector_type>
@@ -369,7 +369,7 @@
system possesses two or more time scales of very different order. Solvers
for stiff systems are usually implicit, meaning that they solve equations
like x(t+dt) = x(t) + dt * f(x(t+1)). This particular
- scheme is the implicit euler method. Implicit methods usually solve the
+ scheme is the implicit Euler method. Implicit methods usually solve the
system of equations by a root finding algorithm like the Newton method
and therefore need to know the Jacobian of the system Jij = dfi /
dxj.
@@ -392,15 +392,15 @@
Another large class of solvers are multi-step method. They save a small
part of the history of the solution and compute the next step with the
- help of this history. Since multistep methods know a part of their history
+ help of this history. Since multi-step methods know a part of their history
they do not need to compute the system function very often, usually it
- is only computed once. This makes multistep methods preferable if a call
+ is only computed once. This makes multi-step methods preferable if a call
of the system function is expensive. Examples are ODEs defined on networks,
where the computation of the interaction is usually where expensive (and
might be of order O(N^2)).
- Multistep methods differ from the normal steppers. They safe a part of
+ Multi-step methods differ from the normal steppers. They safe a part of
their history and this part has to be explicitly calculated and initialized.
In the following example an Adams-Bashforth-stepper with a history of 5
steps is instantiated and initialized;
@@ -429,7 +429,7 @@
- Many multistep methods are also explicit steppers, hence the parameter
+ Many multi-step methods are also explicit steppers, hence the parameter
of do_step method do not
differ from the explicit steppers.
@@ -439,7 +439,7 @@
Caution
- The multistep methods have some internal variables which depend on the
+ The multi-step methods have some internal variables which depend on the
explicit solution. Hence you can not exchange the system of the state
between two consecutive calls of do_step
since then the internal variable do not correspond with the ODE and the
@@ -456,7 +456,7 @@
Many of the above introduced steppers possess the possibility to use adaptive
- stepsize control. Adaptive step size integration works in principle as
+ step-size control. Adaptive step size integration works in principle as
follows:
@@ -469,8 +469,8 @@
This error is compared against some predefined error tolerances. Are
- the tolerance violated the step is reject and the stepsize is decreases.
- Otherwise the step is accepted and possibly the stepsize is increased.
+ the tolerance violated the step is reject and the step-size is decreases.
+ Otherwise the step is accepted and possibly the step-size is increased.
@@ -478,8 +478,8 @@
Stepper concept. They are usually constructed from the underlying
error steppers. An example is the controller for the explicit Runge-Kutta
steppers. The Runge-Kutta steppers enter the controller as a template argument.
- Additionally one can pass the Runge-Kutta stepper to the contructor, but
- this step is not neccessary; the stepper is default-constructed if possible.
+ Additionally one can pass the Runge-Kutta stepper to the constructor, but
+ this step is not necessary; the stepper is default-constructed if possible.
Different step size controlling mechanism exist. They all have in common
@@ -491,7 +491,7 @@
in the integration functions.
- A classical way to decide wether a step is rejected or accepted is
+ A classical way to decide whether a step is rejected or accepted is
To ease to generation of the controlled stepper generation functions exist
which take the absolute and relative error tolerances and a predefined
- error stepper and contruct from this knowledge an appropirate controlled
- stepper. The generation functions are explained in detail in XYZ.
+ error stepper and construct from this knowledge an appropriate controlled
+ stepper. The generation functions are explained in detail in Generation
+ functions.
@@ -695,11 +696,11 @@
Dense output stepper have their own concept. The main difference is that
they control the state by them-self. If you call do_step,
- only the ODE is passed as argument. Furhtermore do_step
+ only the ODE is passed as argument. Furthermore do_step
return the last time interval, hence you interpolate the solution between
these two times points. Another difference is that they must be initialized
with initialize, otherwise
- the internal state of the stepper is default contructed which might produce
+ the internal state of the stepper is default constructed which might produce
funny errors or bugs.
@@ -716,8 +717,8 @@
- Of course, this statement is also lengthly; it demonstrates how make_dense_output can be used with the
- result_of protocoll. The
+ Of course, this statement is also lengthy; it demonstrates how make_dense_output can be used with the
+ result_of protocol. The
parameters to make_dense_output
are the absolute error tolerance, the relative error tolerance and the
stepper. This explicitly assumes that the underlying stepper is a controlled
@@ -739,8 +740,8 @@
steppers
- This section contains some general informations about the usage of the
- steppers in odeint.
+ This section contains some general information about the usage of the steppers
+ in odeint.
Steppers are copied by value
@@ -763,13 +764,13 @@
- Some steppers require to store some informations about the state of the
- ODE between two steps. Examples are the multistep method which store a
+ Some steppers require to store some information about the state of the
+ ODE between two steps. Examples are the multi-step method which store a
part of the solution during the evolution of the ODE, or the FSAL steppers
which store the last derivative at time t+dt, to be
used in the next step. In both cases the steppers expect that consecutive
calls of do_step are from
- the same solution and the same ODE. In this case it is absolutely neccessary
+ the same solution and the same ODE. In this case it is absolutely necessary
that you call do_step with
the same system function and the same state, see also the examples for
the FSAL steppers above.
@@ -789,10 +790,10 @@
All these stepper have in common, that they initially fill their internal
- state by themself. Hence you are not required to call initialize. See how
- this works for the Adams-Bashforth-Moulton stepper: in the example we instantiate
- a fourth order Adams-Bashforth-Moulton stepper, meaning that it will store
- 4 internal derivatives of the solution at times (t-dt,t-2dt,t-3dt,t-4dt).
+ state by themselves. Hence you are not required to call initialize. See
+ how this works for the Adams-Bashforth-Moulton stepper: in the example
+ we instantiate a fourth order Adams-Bashforth-Moulton stepper, meaning
+ that it will store 4 internal derivatives of the solution at times (t-dt,t-2dt,t-3dt,t-4dt).
@@ -826,7 +827,7 @@
all stepper have a method adjust_size
which takes a parameter representing a state type and which manually adjusts
the size of the internal variables. Before performing the actual resizing
- odeint always checks if the sizes of the state and the interal variable
+ odeint always checks if the sizes of the state and the internal variable
differ and only resizes if they are different.
@@ -836,7 +837,7 @@
system and your state you have to call adjust_size
by hand. The second resizer is the always_resizer
which tries to resize the internal variables at every call of do_step. Typical use cases for this kind
- of resizer are self expanding lattics like shown in the tutorial or partial
+ of resizer are self expanding lattices like shown in the tutorial or partial
differential equations with an adaptive grid. The third class of resizer
is the never_resizer which
means that the internal variables are never adjusted automatically and
@@ -844,15 +845,13 @@
There is a second mechanism which influences the resizing and which controls
- if a state type is at least resizeable - a metafunction is_resizeable.
- This metafunction returns a static boolean value if any type is resizable.
- For example it will return true
- for std::vector<
- T>
- but false for tr1::array<T>.
+ if a state type is at least resizeable - a meta-function is_resizeable. This meta-function returns
+ a static boolean value if any type is resizable. For example it will return
+ true for std::vector<T> but false
+ for tr1::array<T>.
By default and for unknown types is_resizeable
returns false, so if you have
- your own type you need to specialize this metafunction. For more details
+ your own type you need to specialize this meta-function. For more details
on the resizing mechanism see the section Adapt
you own state types.
@@ -875,7 +874,7 @@
runge_kutta4 is a good
stepper for constant step sizes. It is widely used and very well known.
- If you need to create artifical time series this stepper should be
+ If you need to create artificial time series this stepper should be
the first choice.
@@ -1193,7 +1192,7 @@
- Standard method with error control and dense ouput, to be used
+ Standard method with error control and dense output, to be used
in controlled_error_stepper and in dense_output_controlled_explicit_fsal.
@@ -1481,9 +1480,9 @@
- Dense ouput for Stepper
+ Dense output for Stepper
and Error
- Stepper from above if they provide dense ouput functionality
+ Stepper from above if they provide dense output functionality
(like euler and
runge_kutta_dopri5).
Order depends on the given stepper.
@@ -1583,8 +1582,8 @@
- Stepper with step size and order control as well as dense ouput.
- Very good if high precision and dense ouput is required.
+ Stepper with step size and order control as well as dense output.
+ Very good if high precision and dense output is required.
Of course, one can write own steppers which are fully compatible with odeint.
- They only have to fullfil one or several of the stepper Concepts
+ They only have to fulfill one or several of the stepper Concepts
of odeint.
We will illustrate how to write your own stepper with the example of the
- stochastic euler method. This method is suited to solve stochastic differential
+ stochastic Euler method. This method is suited to solve stochastic differential
equations (SDEs). A SDE has the form
@@ -1918,8 +1917,8 @@
the SDE is said to have additive noise. It is not possible to solve SDE
with the classical solvers for ODEs since the noisy part of the SDE has
to be scaled differently then the deterministic part with respect to the
- time step. BUt there exist many solvers for SDEs. A classical and easy
- method is the stochastic euler solver. It works by iterating
+ time step. But there exist many solvers for SDEs. A classical and easy
+ method is the stochastic Euler solver. It works by iterating
The types are needed in order to fulfill the stepper concept. As internal
- state and deriv type we use simple arrays in the stochastic euler, they
+ state and deriv type we use simple arrays in the stochastic Euler, they
are needed for the temporaries. The stepper has the order one which is
returned from the order() function.
@@ -1988,7 +1987,7 @@
- This is all. It is quite simple and the stochastic euler stepper implement
+ This is all. It is quite simple and the stochastic Euler stepper implement
here is quite general. Of course it can be enhanced, for example
@@ -2018,7 +2017,7 @@
where ξ is Gaussian white noise with standard deviation σ.
Implementing the Ornstein-Uhlenbeck process is quite simple. We need two
- functions or funtors - one for the deterministic and one for the stochastic
+ functions or functors - one for the deterministic and one for the stochastic
part:
Most steppers in odeint also accept the state give as a range. A range is
- sequence of values modelled by a range concept. See Boost.Range
+ sequence of values modeled by a range concept. See Boost.Range
for an overview over existing concepts and examples of ranges. This means
that the state_type of the
stepper must not necessarily used to call the do_step
@@ -40,7 +40,7 @@
Another use case is a system consisting of coupled units where you want to
initialize each unit separately with the ODE of the uncoupled unit. An example
- is a chain of coupled van-der-Pol-oscillators which are initialized uniformily
+ is a chain of coupled van-der-Pol-oscillators which are initialized uniformly
from the uncoupled van-der-Pol-oscillator. Then you can use Boost.Range
to solve only one individual oscillator in the chain.
- This behaviour is suitable for most systems, especially if your system only
+ This behavior is suitable for most systems, especially if your system only
does not contain any data or only a few parameters. However, in some cases
you might pass some large amount of data with you system function and passing
them by value is not desired since the data will be copied.
@@ -41,8 +41,8 @@
In such cases you can easily use boost::ref (and
its relative boost::cref) which passes its argument by reference
- (or const reference). odeint will unpack the arguments and no copying at
- all of you system will take place:
+ (or constant reference). odeint will unpack the arguments and no copying
+ at all of you system will take place:
- The 2D phase oscillator example shows how a two-dimenstional lattice
+ The 2D phase oscillator example shows how a two-dimensional lattice
can used with odeint and how matrix types can be used as state
types in odeint.
@@ -210,7 +210,7 @@
- The Lorenz paramaters examples show how ensembles of ordinary differential
+ The Lorenz parameters examples show how ensembles of ordinary differential
equations can be solved by means of Thrust to study the dependence
of an ODE on some parameters.
@@ -224,7 +224,7 @@
- The MTL-Gauss-packet example shows how the mtl can be easily used
+ The MTL-Gauss-packet example shows how the MTL can be easily used
with odeint.
diff --git a/doc/boost_sandbox_numeric_odeint/tutorial/chaotic_systems_and_lyapunov_exponents.html b/doc/boost_sandbox_numeric_odeint/tutorial/chaotic_systems_and_lyapunov_exponents.html
index 566791b9..a35a275a 100644
--- a/doc/boost_sandbox_numeric_odeint/tutorial/chaotic_systems_and_lyapunov_exponents.html
+++ b/doc/boost_sandbox_numeric_odeint/tutorial/chaotic_systems_and_lyapunov_exponents.html
@@ -37,16 +37,16 @@
system. In principle n of these perturbations exit,
they form a hypercube and evolve in the time. The Lyapunov exponents are
then defined as logarithmic growth rates of the perturbations. If one Lyapunov
- exponent is larger then zero nearby trajectories divergy exponentially hence
+ exponent is larger then zero nearby trajectories diverge exponentially hence
they are chaotic. If the largest Lyapunov exponent is zero one is usually
faced with periodic motion. In the case of a largest Lyapunov exponent smaller
- then zero the converges the a fixed point. More informations about Lyapunov
+ then zero the converges the a fixed point. More information's about Lyapunov
exponents and nonlinear dynamical systems can be found in many textbooks,
see for example .
To calculate the Lyapunov exponents numerically one usually solves the equations
- of motion for n perturbations und orthonormalized them
+ of motion for n perturbations and orthonormalizes them
every k steps. The Lyapunov exponent is the average
the logarithm of the stretching factor of each perturbation.
@@ -78,7 +78,7 @@
We need also need to integrate the set of the perturbations. This is done
in parallel to the original system, hence within one system function. Of
- course, we want to use the above defintion of the Lorenz system, hence the
+ course, we want to use the above definition of the Lorenz system, hence the
definition of the system function including the Lorenz system itself and
the perturbation could look like:
@@ -161,7 +161,7 @@
The problem is now, that x
is the full state containing also the perturbations and integrate_n_steps
does not know that it should only use 3 element. In detail, odeint and its
- steppers determine the length of the system under consideration be determing
+ steppers determine the length of the system under consideration be determining
the length of the state. In the classical solvers from the problem was solved
by pointer to the state and an appropriate length, something similar to
@@ -219,7 +219,7 @@
We initialize the perturbations. They are stored linearly behind the
state of the Lorenz system. The perturbation are initialized such that
- they fullfill < p i , pj > = δ ij where <,>
+ they fulfill < p i , pj > = δ ij where <,>
is the classical scalar product and δ ij is the Kronecker
symbol.
diff --git a/doc/boost_sandbox_numeric_odeint/tutorial/harmonic_oscillator.html b/doc/boost_sandbox_numeric_odeint/tutorial/harmonic_oscillator.html
index 5332e1bd..1a68df0f 100644
--- a/doc/boost_sandbox_numeric_odeint/tutorial/harmonic_oscillator.html
+++ b/doc/boost_sandbox_numeric_odeint/tutorial/harmonic_oscillator.html
@@ -36,12 +36,12 @@
the ODE
- First of all, you have to specify the datatype that represents a state
+ First of all, you have to specify the data type that represents a state
of your system x. Mathematically, this usually is
an n-dimensional vector with real numbers or complex numbers as scalar
objects. For odeint the most natural way is to use vector<double> or vector<complex<double>>
to represent the system state. However, odeint can deal with other container
- types as well, e.g. tr1::array<double,N> as long as it is fullfils some requirements
+ types as well, e.g. tr1::array<double,N> as long as it is fulfills some requirements
defined below.
@@ -108,10 +108,10 @@
Numerical integration works iteratively, that means you start at a state
- x(t) and perform a timestep of length dt
+ x(t) and perform a time-step of length dt
to obtain the approximate state x(t+dt). There exist
- many different methods to perform such a timestep each of which has a certain
- order q. If the order of a method is q
+ many different methods to perform such a time-step each of which has a
+ certain order q. If the order of a method is q
than it is accurate up to term ~dtq that means the
error in x made by such a step is ~dtq+1.
odeint provides several steppers of different orders from which you can
@@ -414,7 +414,7 @@
- Standard method with error control and dense ouput, to be used
+ Standard method with error control and dense output, to be used
in controlled_error_stepper and in dense_output_controlled_explicit_fsal.
@@ -702,9 +702,9 @@
- Dense ouput for Stepper
+ Dense output for Stepper
and Error
- Stepper from above if they provide dense ouput functionality
+ Stepper from above if they provide dense output functionality
(like euler and
runge_kutta_dopri5).
Order depends on the given stepper.
@@ -804,8 +804,8 @@
- Stepper with step size and order control as well as dense ouput.
- Very good if high precision and dense ouput is required.
+ Stepper with step size and order control as well as dense output.
+ Very good if high precision and dense output is required.
- The basic stepper just performs one timestep and doesn't give you any information
- about the error that was made (except that you know it is of order q+1).
- Such steppers are used with constant step size that should be chosen small
- enough to have reasonable small errors. However, you should apply some
- sort of validity check of your results (such as observing conserved quantities)
- becasue you have no other control of the error. The following example defines
- a basic stepper based on the classical Runge-Kutta scheme of 4th order.
- The declaration of the stepper requires the state type as template parameter.
- The integration can now be done by using the integrate_const(Stepper,System,state,start_time,end_time,step_size
+ The basic stepper just performs one time-step and doesn't give you any
+ information about the error that was made (except that you know it is of
+ order q+1). Such steppers are used with constant step
+ size that should be chosen small enough to have reasonable small errors.
+ However, you should apply some sort of validity check of your results (such
+ as observing conserved quantities) because you have no other control of
+ the error. The following example defines a basic stepper based on the classical
+ Runge-Kutta scheme of 4th order. The declaration of the stepper requires
+ the state type as template parameter. The integration can now be done by
+ using the integrate_const(Stepper,System,state,start_time,end_time,step_size) function from odeint:
@@ -1145,7 +1146,7 @@
This call integrates the system defined by harmonic_oscillator
using the RK4 method from t=0 to 10
- with a stepsize dt=0.01 and the initial condition
+ with a step-size dt=0.01 and the initial condition
given in x. The result,
x(t=10) is stored in x
(in-place). Each stepper defines a do_step
@@ -1207,7 +1208,7 @@
This is a nice technique; however one drawback is that one always needs
to define both steppers. Of course, one could also write the instantiation
of the controlled stepper into the call of the integrate function but a
- complete knowledge of the underlying stepper types is still neccessary.
+ complete knowledge of the underlying stepper types is still necessary.
Another point is, that the error tolerances for the step size control are
not easily included into the controlled stepper. Both issues can be solved
by using make_controlled:
@@ -1257,7 +1258,7 @@
In the tables below, one can find all steppers which are working with
- make_controlled and make_dense_output which is the analogon
+ make_controlled and make_dense_output which is the analog
for the dense output steppers.
- General informations about numerical integration of
+ General information about numerical integration of
ordinary differential equations:
diff --git a/doc/boost_sandbox_numeric_odeint/tutorial/solar_system.html b/doc/boost_sandbox_numeric_odeint/tutorial/solar_system.html
index 927dddd0..1449f43b 100644
--- a/doc/boost_sandbox_numeric_odeint/tutorial/solar_system.html
+++ b/doc/boost_sandbox_numeric_odeint/tutorial/solar_system.html
@@ -81,7 +81,7 @@
to ensure these conservation laws. The odeint library provides classes
for separable Hamiltonian systems, which can be written in the form H
= Σ pi2 / (2mi) + Hq(q), where Hq(q) only
- depends on the coordinates. Alltough this functional form might look a
+ depends on the coordinates. Although this functional form might look a
bit arbitrary it covers nearly all classical mechanical systems with inertia
and without dissipation, or where the equations of motion can be written
in the form dqi / dt = pi / mi , dpi / dt =
@@ -151,7 +151,7 @@
pair<container_type,container_type>
- since it needs the informations about the coordinates and the momenta.
+ since it needs the information about the coordinates and the momenta.
As system function we have to provide f(p) and f(q):
@@ -206,7 +206,7 @@
In general a three body-system is chaotic, hence we can not expect that
- arbitray initial conditions of the system will lead to a dynamic which
+ arbitrary initial conditions of the system will lead to a dynamic which
is comparable with the solar system. That is we have to define proper initial
conditions, which are taken from the book of Hairer, Wannier, Lubich.
- Of courst, one can also use classical functions to implement the state
+ Of course, one can also use classical functions to implement the state
function. In this cast the Stuart-Landau oscillator looks like
@@ -148,7 +148,7 @@
The FPU is solved again by a symplectic solver, but in our case we can
speed up the computation because the q components
trivially reduce to dqi / dt = pi. odeint is capable
- of doing this peformance improvement. All you have to do is to call the
+ of doing this performance improvement. All you have to do is to call the
symplectic solver with an state function for the p
components. Here, is how this function looks like
- The natural frequencies ωi of each oscialltor follow
+ The natural frequencies ωi of each oscillator follow
some distribution and ε is the coupling strength. We
choose here a Lorentzian distribution for ωi. Interestingly
- a phase transition can be observed if the coupling strenght exceeds a critical
+ a phase transition can be observed if the coupling strength exceeds a critical
value. Above this value synchronization sets in and some of the oscillators
oscillate with the same frequency despite their different natural frequencies.
The transition is also called Kuramoto transition. Its behavior can be
@@ -486,7 +486,7 @@
Note, that the state_type
and the deriv_type are
now a compile-time fusion sequences. They have to be explicitly defined.
- Next, we define the ordinary differential equation which is completety
+ Next, we define the ordinary differential equation which is completely
equivalent to the example in the first section of this tutorial
@@ -588,7 +588,7 @@
By default, odeint can be used with ublas::matrix<T> as state type for matrices. A simple
example is a two-dimensional lattice of coupled phase oscillators. We like
- phas oscillators, they are extremly easy and might serve for different
+ phase oscillators, they are extremely easy and might serve for different
demonstration purposes. Other matrix types like mtl::dense_matrix
or blitz arrays and matrices can used as well but need some kind of activation
in order to work with odeint. This activation is described in following
@@ -678,7 +678,7 @@
double, complex<double> you can also use arbitrary precision
types, like the types from gmp
and mpfr. But you have to be
- carful about instantiating any numbers.
+ careful about instantiating any numbers.
For gmp types you have to set the default precision before any number is
@@ -766,8 +766,8 @@
and adjust it's internal storage accordingly.
- We exemplarily show this for a Hamiltonian system of nonlinear, disordered
- oscillators with nonlinear nearest neighbour coupling.
+ We exemplary show this for a Hamiltonian system of nonlinear, disordered
+ oscillators with nonlinear nearest neighbor coupling.
The system function is implemented in terms of a class that also provides
diff --git a/doc/boost_sandbox_numeric_odeint/tutorial/stiff_systems.html b/doc/boost_sandbox_numeric_odeint/tutorial/stiff_systems.html
index a874b455..b98d79c9 100644
--- a/doc/boost_sandbox_numeric_odeint/tutorial/stiff_systems.html
+++ b/doc/boost_sandbox_numeric_odeint/tutorial/stiff_systems.html
@@ -24,7 +24,7 @@
An important class of ordinary differential equations are so called stiff
system which are characterized by two or more time scales of different order.
Examples of such systems are found in chemical systems where reaction rates
- of individual subreaction might differ over large ranges.
+ of individual sub-reaction might differ over large ranges.
CHECK:
diff --git a/doc/boost_sandbox_numeric_odeint/tutorial/using_cuda_and_thrust.html b/doc/boost_sandbox_numeric_odeint/tutorial/using_cuda_and_thrust.html
index ba716c69..51670ea6 100644
--- a/doc/boost_sandbox_numeric_odeint/tutorial/using_cuda_and_thrust.html
+++ b/doc/boost_sandbox_numeric_odeint/tutorial/using_cuda_and_thrust.html
@@ -82,7 +82,7 @@
perfectly suited for such kinds of problems where one needs a large number
of particles (oscillators). We start by defining the state type which is
a thrust::device_vector. The content of this vector
- lives on the GPU. If you are not familar with this we recommend reading
+ lives on the GPU. If you are not familiar with this we recommend reading
the Getting started section on the Thrust
website.
@@ -317,7 +317,7 @@
In principle we can use all the techniques from the previous phase oscillator
ensemble example, but we have to take special care about the coupling of
the oscillators. To efficiently implement the coupling you can use a very
- elegant way employing Thrust's permutation iterator. A permuation iterator
+ elegant way employing Thrust's permutation iterator. A permutation iterator
behaves like a normal iterator on a vector but it does not iterate along
the usual order of the elements. It rather iterates along some permutation
of the elements defined by some index map. To realize the nearest neighbor
@@ -402,9 +402,9 @@
Note, how easy you can obtain the value for the left and right neighboring
oscillator in the system functor using the permutation iterators. But,
the call of the thrust::for_each
- function looks relativ complicated. Every term of the r.h.s. of the ODE
- is resembled by one iterator packed in exactly the same way as it is unpacked
- in the functor above.
+ function looks relatively complicated. Every term of the r.h.s. of the
+ ODE is resembled by one iterator packed in exactly the same way as it is
+ unpacked in the functor above.
Now we put everything together. We create random initial conditions and
@@ -456,8 +456,8 @@
and Cuda are parameter studies of relatively small systems. Consider for
example the three-dimensional Lorenz system from the chaotic systems example
in the previous section which has three parameters. If you want to study
- the behaviour of this system for different parameters you usually have
- to integrate the system for many parameter values. Using thrust and odeint
+ the behavior of this system for different parameters you usually have to
+ integrate the system for many parameter values. Using thrust and odeint
you can do this integration in parallel, hence you integrate a whole ensemble
of Lorenz systems where each individual realization has a different parameter
value.
@@ -465,7 +465,7 @@
In the following we will show how you can use Thrust
to integrate the above mentioned ensemble of Lorenz systems. We will vary
- only the parameter β but it is straightfoward to vary
+ only the parameter β but it is straightforward to vary
other parameters or even two or all three parameters. Furthermore, we will
use the largest Lyapunov exponent to quantify the behavior of the system
(chaoticity).
@@ -551,7 +551,7 @@
The length of the state is 3N where N
is the number of systems. The system is encoded into this vector such that
all x components come first, then every y
- compoents and finally every z components. Implementing
+ components and finally every z components. Implementing
the device function is then a simple task, you only have to decompose the
tuple originating from the zip iterators.
@@ -559,7 +559,7 @@
Besides the system without perturbations we furthermore need to calculate
the system including linearized equations governing the time evolution
of small perturbations. Using the method from above this is straightforward,
- with a small difficulty that thrust's tuples have a maximal arity of 10.
+ with a small difficulty that Thrust's tuples have a maximal arity of 10.
But this is only a small problem since we can create a zip iterator packed
with zip iterators. So the top level zip iterator contains one zip iterator
for the state, one normal iterator for the parameter, and one zip iterator
@@ -604,10 +604,10 @@
We initialize them such that x=y=z=10, dx=1,
and dy=dz=0. We define a stepper type, a controlled
Runge-Kutta Dormand-Prince 5 stepper. We start with some integration to
- overcome the transient behavior. For this, we do not involve the pertubation
+ overcome the transient behavior. For this, we do not involve the perturbation
and run the algorithm only on the state x,y,z without
any observer. Note, how Boost.Range
- is used for partial integration of the state vector without pertubations
+ is used for partial integration of the state vector without perturbations
(the first half of the whole state). After the transient, the full system
with perturbations is integrated and the Lyapunov exponents are calculated
and written to stdout.
diff --git a/doc/index.html b/doc/index.html
index 4aeac1c7..52cf60e0 100644
--- a/doc/index.html
+++ b/doc/index.html
@@ -1,20 +1,20 @@
-Chapter 1. boost.sandbox.numeric.odeint
+Chapter 1. Boost.Numeric.Odeint
-
-
+
+
+