[Boost-commit] svn:boost r63649 - sandbox/odeint/libs/numeric/odeint/doc

Subject: [Boost-commit] svn:boost r63649 - sandbox/odeint/libs/numeric/odeint/doc
From: mario.mulansky_at_[hidden]
Date: 2010-07-05 10:28:11

Author: mariomulansky
Date: 2010-07-05 10:28:09 EDT (Mon, 05 Jul 2010)
New Revision: 63649
URL: http://svn.boost.org/trac/boost/changeset/63649

Log:
small typo corrections in the doc
Text files modified: 
   sandbox/odeint/libs/numeric/odeint/doc/concepts.qbk |     2 +-                                      
   sandbox/odeint/libs/numeric/odeint/doc/odeint.qbk   |    10 +++++-----                              
   sandbox/odeint/libs/numeric/odeint/doc/tutorial.qbk |    11 +++++------                             
   3 files changed, 11 insertions(+), 12 deletions(-)

Modified: sandbox/odeint/libs/numeric/odeint/doc/concepts.qbk
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/concepts.qbk	(original)
+++ sandbox/odeint/libs/numeric/odeint/doc/concepts.qbk	2010-07-05 10:28:09 EDT (Mon, 05 Jul 2010)
@@ -102,7 +102,7 @@
 Error steppers execute one timestep of a specific order with a given stepsize.
 Additionally, an error estimation of the obtained result is computed that can 
 be used to control the error introduced by the time discretization.
-As the basic steppers, error steppers usually allocate internal memory to store
+Like the basic steppers, error steppers usually allocate internal memory to store
 intermediate function call results. If state types with variable size are used 
 (e.g. `vector`), it has to be assured that the stepper gets informed about any 
 change of the state size by calling its `adjust_size` method.

Modified: sandbox/odeint/libs/numeric/odeint/doc/odeint.qbk
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/odeint.qbk	(original)
+++ sandbox/odeint/libs/numeric/odeint/doc/odeint.qbk	2010-07-05 10:28:09 EDT (Mon, 05 Jul 2010)
@@ -23,7 +23,7 @@
 The easiest algorithm is the /Euler-Scheme/, where starting at x(0) one 
 finds x(dt) = x(0) + dt*f(x(0),0).
 Now one can use x(dt) and obtain x(2dt) in a similar way and so on.
-The Euler method is of order 1, that means the error at each step is ~ dt[superscript 2].
+The Euler method is of order 1, that means the error at each step is ~ dt^2.
 This is, of course, not very satisfying, which is why the Euler method is 
 merely used for real life problems and serves just as illustrative example.
 In [*odeint], the following algorithms are implemented:
@@ -43,11 +43,9 @@
 [section Short Example]
 
 This section gives a quick introduction to the most important features of the 
-library. Image, for example, you want to numerically integrate a harmonic oscillator with friction. The equations of motion are given by x'' = -x + gamma x'.
+library. Imagine, for example, you want to numerically integrate a harmonic oscillator with friction. The equations of motion are given by x'' = -x + gamma x'.
 This can be transformed to a system of two first-order differential equations 
-design the right hand side of the equation w' = f(w) where in this case 
-with new variables x and p=x'. To apply numerical integration one first has to 
-w = (x,p):
+by introducing the new variable p = x'. If we now use w = (x,p) the equation of motion above can be written as w' = f(w):
 
 [import ../examples/doc_harm_osc.cpp]
 [rhs_function]
@@ -55,6 +53,8 @@
 Here we chose [*vector<double>] as the state type, but others are also possible,
 for example [*tr1/array<double,2>]. Odeint is designed in such a way that it 
 works with basically any container that can be accessed via iterators.
+Moreover, any structure can be used as state type, provided vector-space operations
+are provided for them.
 The parameter structure of the function is crucial: the integration methods will
 always call them in the form [*f(x, dxdt, t)]. So even if there is no explicit
 time dependence, one has to define [*t] as a function parameter.

Modified: sandbox/odeint/libs/numeric/odeint/doc/tutorial.qbk
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/tutorial.qbk	(original)
+++ sandbox/odeint/libs/numeric/odeint/doc/tutorial.qbk	2010-07-05 10:28:09 EDT (Mon, 05 Jul 2010)
@@ -7,13 +7,12 @@
 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 than 
-vector as well, e.g. `tr1/array< double , N >` as long as it is able to obtain
+the system state. However, odeint can deal with other container types as well, e.g. `tr1/array< double , N >` as long as it is able to obtain
 a ForwardIterator going through all of the container's elements. The scalar type
-must have several operators ( +, -, +=, -= ) and the `abs()`-fcuntion defined . 
+must have several operations ( + , - , += , -= ) and the `abs()`-function defined. 
 Furthermore, one can choose the datatype of the time (that is, the parameter to 
 which respect the differentiation is done). The standard type for this is 
-`double`, but one might be able to choose, for example, `complex< double >` as
+`double`, but it should be possible to use, for example, `complex< double >` as
 well (untested). It must be possible to multiply the time type and the scalar 
 type of the vector. For the most cases `vector< double >` as state type and the
 standard `double` for the time type should be sufficient.
@@ -41,7 +40,7 @@
 [endsect]
 
 [section Stepper Types]
-Numerical integration works iteratevly, that means you start at a state ['x(t)] 
+Numerical integration works iteratively, that means you start at a state ['x(t)] 
 and performs a timestep 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] than it is 
@@ -102,7 +101,7 @@
 The usual way to create a controlled stepper is via the 
 `make_controlled_stepper_standard( ErrorStepper , eps_abs , eps_rel , a_x , a_dxdt )` 
 function that takes an error stepper as parameter and four values defining the maximal
-absolute and relative error allowed for on integration step.
+absolute and relative error allowed for one integration step.
 The standard controlled stepper created by this method ensures that the error ['err]
 of the solution fulfills 
 ['err < eps_abs + eps_rel * ( a_x * |x| + a_dxdt * dt * |dxdt| ) ]