[Boost-commit] svn:boost r63648 - in sandbox/odeint/libs/numeric/odeint/doc: . html html/boost_numeric_odeint

Subject: [Boost-commit] svn:boost r63648 - in sandbox/odeint/libs/numeric/odeint/doc: . html html/boost_numeric_odeint
From: karsten.ahnert_at_[hidden]
Date: 2010-07-05 09:32:49

Author: karsten
Date: 2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
New Revision: 63648
URL: http://svn.boost.org/trac/boost/changeset/63648

Log:
reorganizing the documentation
Added:
   sandbox/odeint/libs/numeric/odeint/doc/concepts.qbk
      - copied, changed from r63521, /sandbox/odeint/libs/numeric/odeint/doc/steppers.qbk
   sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/concepts.html   (contents, props changed)
   sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/reference.html   (contents, props changed)
   sandbox/odeint/libs/numeric/odeint/doc/integrate_functions_reference.qbk
      - copied unchanged from r63521, /sandbox/odeint/libs/numeric/odeint/doc/integrate_functions.qbk
   sandbox/odeint/libs/numeric/odeint/doc/reference.qbk   (contents, props changed)
   sandbox/odeint/libs/numeric/odeint/doc/steppers_reference.qbk   (contents, props changed)
Removed:
   sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/container_traits.html
   sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/integration_functions.html
   sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/stepper.html
   sandbox/odeint/libs/numeric/odeint/doc/integrate_functions.qbk
   sandbox/odeint/libs/numeric/odeint/doc/steppers.qbk
Text files modified: 
   sandbox/odeint/libs/numeric/odeint/doc/concepts.qbk                                 |   125 ---------------                         
   sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/short_example.html |    22 -                                       
   sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/tutorial.html      |   277 +++++++++++++++++------------------     
   sandbox/odeint/libs/numeric/odeint/doc/html/index.html                              |   302 +++++++++++++++++++-------------------- 
   sandbox/odeint/libs/numeric/odeint/doc/html/standalone_HTML.manifest                |     5                                         
   sandbox/odeint/libs/numeric/odeint/doc/odeint.qbk                                   |    10                                         
   6 files changed, 300 insertions(+), 441 deletions(-)

Copied: sandbox/odeint/libs/numeric/odeint/doc/concepts.qbk (from r63521, /sandbox/odeint/libs/numeric/odeint/doc/steppers.qbk)
==============================================================================
--- /sandbox/odeint/libs/numeric/odeint/doc/steppers.qbk	(original)
+++ sandbox/odeint/libs/numeric/odeint/doc/concepts.qbk	2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
@@ -1,7 +1,8 @@
-[section Stepper]
+[section Concepts]
 
+The odeint library defines three concepts for stepping objects.
 
-[section Concepts]
+[/
 
 [section Dynamical system]
 
@@ -22,6 +23,10 @@
 
 [endsect]
 
+]
+
+
+
 [section Basic stepper]
 
 Basic steppers execute one timestep of a specific order with a given stepsize. 
@@ -248,119 +253,3 @@
 [endsect]
 
 [endsect]
-
-
-[section Stepper classes]
-
-[table Stepper Algorithms
-  [[Method] [Class] [Order] [Error Estimation]]
-  [[Euler]  [stepper_euler] [1] [No]]
-  [[Runge-Kutta 4] [stepper_rk4] [4] [No]]
-  [[Runge-Kutta Cash-Karp] [stepper_rk5_ck] [5] [Yes (Order 4)]]
-  [[Runge-Kutta Fehlberg] [stepper_rk78_fehlberg] [7] [Yes (Order 8)]]
-  [[Midpoint] [stepper_midpoint] [variable] [No]]
-  [[Bulirsch-Stoer] [controlled_stepper_bs] [variable] [Controlled]]
-]
-
-[section stepper_euler]
-
-[*Concept:] [link boost_sandbox_numeric_odeint.stepper.concepts.basic_stepper Basic stepper]
-
-[*Accuracy:] The produced solution is accurate up to order 1.
-
-[*Complexity:] This method uses 1 function evaluation.
-
-[*Template Parameters:]
-[template tpl_parameter_table_[]
-[table
-    [[Parameter] [Default Value] [Description]]
-    [[class Container] [no default value] [Type of container that stores the state of the system]]
-    [[class Time] [double] [Type of the time variable in the ode]]
-    [[class Traits] [container_traits< Container >] [container_traits used by the stepper]]
-]]
-[tpl_parameter_table_]
-
-The Euler algorithm used in this class performs one integration
-step according to the formula:
-[: x(t+dt) = x(t) + dt*f(x,t)]
-The Euler stepper is the most simple algorithm to integrate a 
-differential equation. It's only purpose in this library is for educational 
-reasons - use more sophisticated steppers for real life problems.
-
-[endsect]
-
-[section stepper_rk4]
-
-[*Concept:] [link boost_sandbox_numeric_odeint.stepper.concepts.basic_stepper Basic stepper]
-
-[*Accuracy:] The produced solution is accurate up to order 4.
-
-[*Complexity:] This method uses 4 function evaluations.
-
-[*Template Parameters:]
-
-[tpl_parameter_table_]
-
-The Runge-Kutta 4 algorithm is /the/ classical method to integrate odes.
-The [@http://en.wikipedia.org/wiki/Runge%e2%80%93Kutta_methods#Explicit_Runge.E2.80.93Kutta_methods 
-Butcher Tableau] for this method is as follows:
-
-[pre
-Butcher Tableau for Runge-Kutta 4
-   0  |
-  1/2 | 1/2
-  1/2 |  0   1/2
-   1  |  0    0    1
-  ------------------------
-      | 1/6  1/3  1/3  1/6
-]
-This method produces fast, though not too accurate solutions. Use it for quick
-preliminary results and then switch to error controlled methods like Cash-Karp
-for more reliable calculations.
-
-[endsect]
-
-[section stepper_rk5_ck]
-
-[*Concept:] [link boost_sandbox_numeric_odeint.stepper.concepts.error_stepper Error stepper]
-
-[*Accuracy:] The produced solution is accurate up to order 5 and the estimated 
-error is also of order 5.
-
-[*Complexity:] This method uses 6 function evaluation.
-
-[*Template Parameters:]
-
-[tpl_parameter_table_]
-
-The Runge-Kutta method of order 5 with Cash-Karp coefficients is a good trade-off
-between numerical effort and obtained accuracy with error estimation.
-It is the all-round method and suitable for most problems.
-See [@http://en.wikipedia.org/wiki/Cash%e2%80%93Karp_method wikipedia] for details and 
-the Butcher tableau.
-
-[endsect]
-
-[section stepper_rk78_fehlberg]
-
-[*Concept:] [link boost_sandbox_numeric_odeint.stepper.concepts.error_stepper Error Stepper]
-
-[*Accuracy:] The produced solution is accurate up to order 7 and the estimated 
-error is of order 8.
-
-[*Complexity:] This method uses 13 function evaluations.
-
-[*Template Parameters:]
-
-[tpl_parameter_table_]
-
-The Runge-Kutta 78 Fehlberg method is a high-order algorithm that produces very
-good accuracy but for the cost of high numerical effort.
-Whenever extra-ordinarily high precision is required, you can fall back to this
-method.
-
-[endsect]
-
-[endsect]
-
-[endsect]

Added: sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/concepts.html
==============================================================================
--- (empty file)
+++ sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/concepts.html	2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
@@ -0,0 +1,716 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Concepts</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter&#160;1.&#160;boost.numeric.odeint">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;boost.numeric.odeint">
+<link rel="prev" href="tutorial.html" title="Tutorial">
+<link rel="next" href="reference.html" title="Reference">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tutorial.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="reference.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_numeric_odeint.concepts"></a><a class="link" href="concepts.html" title="Concepts">Concepts</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section">Basic stepper</span></dt>
+<dt><span class="section">Error stepper</span></dt>
+<dt><span class="section"><a href="concepts.html#boost_numeric_odeint.concepts.controlled_stepper">Controlled
+      stepper</a></span></dt>
+</dl></div>
+<p>
+      The odeint library defines three concepts for stepping objects.
+    </p>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_numeric_odeint.concepts.basic_stepper"></a><a class="link" href="concepts.html#boost_numeric_odeint.concepts.basic_stepper" title="Basic stepper">Basic stepper</a>
+</h3></div></div></div>
+<p>
+        Basic steppers execute one timestep of a specific order with a given stepsize.
+        They usually allocate internal memory to store intermediate function call
+        results. If state types with variable size are used (e.g. <code class="computeroutput"><span class="identifier">vector</span></code>),
+        it has to be assured that the stepper gets informed about any change of the
+        state size by calling its <code class="computeroutput"><span class="identifier">adjust_size</span></code>
+        method.
+      </p>
+<p>
+        <span class="bold"><strong>Associated Types</strong></span>
+      </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                </p>
+              </th>
+<th>
+                <p>
+                </p>
+              </th>
+<th>
+                <p>
+                  Description
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+                  Time
+                </p>
+              </td>
+<td>
+                <p>
+                  Stepper::time_type
+                </p>
+              </td>
+<td>
+                <p>
+                  Type of the time variable, e.g. <code class="computeroutput"><span class="keyword">double</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  Container
+                </p>
+              </td>
+<td>
+                <p>
+                  Stepper::container_type
+                </p>
+              </td>
+<td>
+                <p>
+                  Type of the system state, e.g. <code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  Value
+                </p>
+              </td>
+<td>
+                <p>
+                  Stepper::value_type
+                </p>
+              </td>
+<td>
+                <p>
+                  Value type of the state, e.g. <code class="computeroutput"><span class="keyword">double</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  Order Type
+                </p>
+              </td>
+<td>
+                <p>
+                  Stepper::order_type
+                </p>
+              </td>
+<td>
+                <p>
+                  Type of the order parameter, usually <code class="computeroutput"><span class="keyword">unsigned</span>
+                  <span class="keyword">short</span></code>
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+        <span class="bold"><strong>Methods</strong></span>
+      </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput"><span class="identifier">Stepper</span><span class="special">()</span></code>
+          Constructor.
+        </li>
+<li>
+<code class="computeroutput"><span class="identifier">Stepper</span><span class="special">(</span>
+          <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span></code> Constructor
+          that allocates internal memory to store intermediate results of the same
+          size as <code class="computeroutput"><span class="identifier">x</span></code>.
+        </li>
+<li><code class="computeroutput"><span class="keyword">void</span> <span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">DynamicalSystem</span>
+          <span class="special">&amp;</span><span class="identifier">system</span>
+          <span class="special">,</span> <span class="identifier">container_type</span>
+          <span class="special">&amp;</span><span class="identifier">x</span>
+          <span class="special">,</span> <span class="identifier">time_type</span>
+          <span class="identifier">t</span> <span class="special">,</span>
+          <span class="identifier">time_type</span> <span class="identifier">dt</span>
+          <span class="special">)</span></code></li>
+</ul></div>
+<p>
+        Executes one timestep with the given parameters:
+      </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                  Parameter
+                </p>
+              </th>
+<th>
+                <p>
+                  Type
+                </p>
+              </th>
+<th>
+                <p>
+                  Description
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+                  system
+                </p>
+              </td>
+<td>
+                <p>
+                  DynamicalSystem
+                </p>
+              </td>
+<td>
+                <p>
+                  Function (callable object) that computes the rhs of the ode
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  x
+                </p>
+              </td>
+<td>
+                <p>
+                  container_type
+                </p>
+              </td>
+<td>
+                <p>
+                  The current state of the system <span class="bold"><strong>x(t)</strong></span>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  t
+                </p>
+              </td>
+<td>
+                <p>
+                  time_type
+                </p>
+              </td>
+<td>
+                <p>
+                  The current time <span class="bold"><strong>t</strong></span>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  dt
+                </p>
+              </td>
+<td>
+                <p>
+                  time_type
+                </p>
+              </td>
+<td>
+                <p>
+                  Length of the timestep to be executed
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+        The result of this method is the (approximate) state of the system <span class="bold"><strong>x(t+dt)</strong></span> and is stored in the variable <code class="computeroutput"><span class="identifier">x</span></code> (in-place). Note, that the time <code class="computeroutput"><span class="identifier">t</span></code> is not automatically increased by this
+        method.
+      </p>
+<div class="itemizedlist"><ul type="disc"><li><code class="computeroutput"><span class="keyword">void</span> <span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">DynamicalSystem</span>
+          <span class="special">&amp;</span><span class="identifier">system</span>
+          <span class="special">,</span> <span class="identifier">container_type</span>
+          <span class="special">&amp;</span><span class="identifier">x</span>
+          <span class="special">,</span> <span class="keyword">const</span>
+          <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">time_type</span> <span class="identifier">t</span>
+          <span class="special">,</span> <span class="identifier">time_type</span>
+          <span class="identifier">dt</span> <span class="special">)</span></code></li></ul></div>
+<p>
+        The same as above but with the additional parameter <code class="computeroutput"><span class="identifier">dxdt</span></code>
+        that represents the derivative <span class="bold"><strong>x'(t) = f(x,t)</strong></span>
+        at the time <span class="bold"><strong>t</strong></span>.
+      </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">adjust_size</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span></code> Adjusts
+          the internal memory to store intermediate results of the same size as
+          <code class="computeroutput"><span class="identifier">x</span></code>. This function <span class="emphasis"><em>must</em></span>
+          be called whenever the system size changes during the integration.
+        </li>
+<li>
+<code class="computeroutput"><span class="identifier">order_type</span> <span class="identifier">order_step</span><span class="special">()</span></code> Returns the order of the algorithm. If
+          <span class="bold"><strong>n</strong></span> is the order of a method, then the result
+          of one iteration with the timestep <span class="bold"><strong>dt</strong></span>
+          is accurate up to <span class="bold"><strong>dt^n</strong></span>. That means the
+          error made by the time discretization is of order <span class="bold"><strong>dt^(n+1)</strong></span>.
+        </li>
+</ul></div>
+<p>
+        <span class="bold"><strong>Stepper that model this concept</strong></span>
+      </p>
+<div class="itemizedlist"><ul type="disc">
+<li><code class="computeroutput"><span class="identifier">stepper_euler</span></code></li>
+<li><code class="computeroutput"><span class="identifier">stepper_rk4</span></code></li>
+<li><code class="computeroutput"><span class="identifier">stepper_rk78_fehlberg</span></code></li>
+</ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_numeric_odeint.concepts.error_stepper"></a><a class="link" href="concepts.html#boost_numeric_odeint.concepts.error_stepper" title="Error stepper">Error stepper</a>
+</h3></div></div></div>
+<p>
+        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
+        intermediate function call results. If state types with variable size are
+        used (e.g. <code class="computeroutput"><span class="identifier">vector</span></code>), it has
+        to be assured that the stepper gets informed about any change of the state
+        size by calling its <code class="computeroutput"><span class="identifier">adjust_size</span></code>
+        method.
+      </p>
+<p>
+        <span class="bold"><strong>Associated Types</strong></span>
+      </p>
+<p>
+        Same as for <span class="emphasis"><em>basic steppers</em></span> above.
+      </p>
+<p>
+        <span class="bold"><strong>Methods</strong></span>
+      </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput"><span class="identifier">Error_Stepper</span><span class="special">()</span></code>
+          Constructor.
+        </li>
+<li>
+<code class="computeroutput"><span class="identifier">Error_Stepper</span><span class="special">(</span>
+          <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span></code> Constructor
+          that allocates internal memory to store intermediate results of the same
+          size as <code class="computeroutput"><span class="identifier">x</span></code>.
+        </li>
+<li><code class="computeroutput"><span class="keyword">void</span> <span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">DynamicalSystem</span>
+          <span class="special">&amp;</span><span class="identifier">system</span>
+          <span class="special">,</span> <span class="identifier">container_type</span>
+          <span class="special">&amp;</span><span class="identifier">x</span>
+          <span class="special">,</span> <span class="identifier">time_type</span>
+          <span class="identifier">t</span> <span class="special">,</span>
+          <span class="identifier">time_type</span> <span class="identifier">dt</span>
+          <span class="special">,</span> <span class="identifier">container_type</span>
+          <span class="special">&amp;</span><span class="identifier">xerr</span><span class="special">)</span></code></li>
+</ul></div>
+<p>
+        Executes one timestep with the given parameters:
+      </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                  Parameter
+                </p>
+              </th>
+<th>
+                <p>
+                  Type
+                </p>
+              </th>
+<th>
+                <p>
+                  Description
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+                  system
+                </p>
+              </td>
+<td>
+                <p>
+                  DynamicalSystem
+                </p>
+              </td>
+<td>
+                <p>
+                  Function (callable object) that computes the rhs of the ode
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  x
+                </p>
+              </td>
+<td>
+                <p>
+                  container_type
+                </p>
+              </td>
+<td>
+                <p>
+                  The current state of the system <span class="bold"><strong>x(t)</strong></span>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  t
+                </p>
+              </td>
+<td>
+                <p>
+                  time_type
+                </p>
+              </td>
+<td>
+                <p>
+                  The current time <span class="bold"><strong>t</strong></span>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  dt
+                </p>
+              </td>
+<td>
+                <p>
+                  time_type
+                </p>
+              </td>
+<td>
+                <p>
+                  Length of the timestep to be executed
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  xerr
+                </p>
+              </td>
+<td>
+                <p>
+                  container_type
+                </p>
+              </td>
+<td>
+                <p>
+                  Used by the method to return the error estimation of this computation
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+        The result of this method is the (approximate) state of the system <span class="bold"><strong>x(t+dt)</strong></span>, which is returned in the variable <code class="computeroutput"><span class="identifier">x</span></code> (in-place), and the corresponding error
+        estimation returned in <code class="computeroutput"><span class="identifier">xerr</span></code>.
+        Note, that the time <code class="computeroutput"><span class="identifier">t</span></code> is
+        not automatically increased by this method.
+      </p>
+<div class="itemizedlist"><ul type="disc"><li><code class="computeroutput"><span class="keyword">void</span> <span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">DynamicalSystem</span>
+          <span class="special">&amp;</span><span class="identifier">system</span>
+          <span class="special">,</span> <span class="identifier">container_type</span>
+          <span class="special">&amp;</span><span class="identifier">x</span>
+          <span class="special">,</span> <span class="keyword">const</span>
+          <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">time_type</span> <span class="identifier">t</span>
+          <span class="special">,</span> <span class="identifier">time_type</span>
+          <span class="identifier">dt</span> <span class="special">,</span>
+          <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">xerr</span><span class="special">)</span></code></li></ul></div>
+<p>
+        The same as above but with the additional parameter <code class="computeroutput"><span class="identifier">dxdt</span></code>
+        that represents the derivative <span class="bold"><strong>x'(t) = f(x,t)</strong></span>
+        at the time <span class="bold"><strong>t</strong></span>.
+      </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">adjust_size</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span></code> Adjusts
+          the internal memory to store intermediate results of the same size as
+          <code class="computeroutput"><span class="identifier">x</span></code>. This function <span class="emphasis"><em>must</em></span>
+          be called whenever the system size changes during the integration.
+        </li>
+<li>
+<code class="computeroutput"><span class="identifier">order_type</span> <span class="identifier">order_error_step</span><span class="special">()</span></code> Returns the order of the result <span class="bold"><strong>x(t+dt)</strong></span> of the algorithm.
+        </li>
+<li>
+<code class="computeroutput"><span class="identifier">order_type</span> <span class="identifier">order_error</span><span class="special">()</span></code> Returns the order of the error estimation
+          of the algorithm.
+        </li>
+</ul></div>
+<p>
+        <span class="bold"><strong>Stepper that model this concept</strong></span>
+      </p>
+<div class="itemizedlist"><ul type="disc">
+<li><code class="computeroutput"><span class="identifier">stepper_rk5_ck</span></code></li>
+<li><code class="computeroutput"><span class="identifier">stepper_rk78_fehlberg</span></code></li>
+<li><code class="computeroutput"><span class="identifier">stepper_half_step</span></code></li>
+</ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_numeric_odeint.concepts.controlled_stepper"></a><a class="link" href="concepts.html#boost_numeric_odeint.concepts.controlled_stepper" title="Controlled stepper">Controlled
+      stepper</a>
+</h3></div></div></div>
+<p>
+        Controlled steppers try to execute a timestep with a given error threshold.
+        If the estimated error of the obtained solution is too big, the result is
+        rejected and a new stepsize is proposed. If the error is small enough the
+        timestep is accepted and possibly an increased stepsize is proposed.
+      </p>
+<p>
+        <span class="bold"><strong>Associated Types</strong></span>
+      </p>
+<p>
+        Same as for <span class="emphasis"><em>basic steppers</em></span> above.
+      </p>
+<p>
+        <span class="bold"><strong>Methods</strong></span>
+      </p>
+<div class="itemizedlist"><ul type="disc"><li><code class="computeroutput"><span class="identifier">Controlled_Stepper</span><span class="special">(</span>
+          <span class="identifier">time_type</span> <span class="identifier">abs_err</span><span class="special">,</span> <span class="identifier">time_type</span>
+          <span class="identifier">rel_err</span><span class="special">,</span>
+          <span class="identifier">time_type</span> <span class="identifier">factor_x</span><span class="special">,</span> <span class="identifier">time_type</span>
+          <span class="identifier">factor_dxdt</span> <span class="special">)</span></code></li></ul></div>
+<p>
+        Constructor that initializes the controlled stepper with several parameters
+        of the error control. The controlled stepper assures that the error done
+        by each individual timestep yields:
+      </p>
+<p>
+        <span class="bold"><strong>xerr &lt; 1.1 ( eps_abs + eps_rel * (factor_x |x| +
+        factor_dxdt h |x'|) ) </strong></span>
+      </p>
+<p>
+        The factor 1.1 is for safety to avoid unnecessary many stepsize adjustings.
+        The above inequality should be understand to hold for <span class="emphasis"><em>all</em></span>
+        components of the possibly more dimensional vectors <span class="bold"><strong>x</strong></span>,
+        <span class="bold"><strong>x'</strong></span> and <span class="bold"><strong>xerr</strong></span>.
+        If the estimated error is too large, a reduced stepsize will be suggested.
+        If the estimated error is less than half of the desired error, an increased
+        stepsize will be suggested.
+      </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput"><span class="identifier">Controlled_Stepper</span><span class="special">(</span>
+          <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">time_type</span>
+          <span class="identifier">abs_err</span><span class="special">,</span>
+          <span class="identifier">time_type</span> <span class="identifier">rel_err</span><span class="special">,</span> <span class="identifier">time_type</span>
+          <span class="identifier">factor_x</span><span class="special">,</span>
+          <span class="identifier">time_type</span> <span class="identifier">factor_dxdt</span>
+          <span class="special">)</span></code> Same as above, but with additional
+          allocation of the internal memory to store intermediate results of the
+          same size as <code class="computeroutput"><span class="identifier">x</span></code>.
+        </li>
+<li><code class="computeroutput"><span class="identifier">controlled_step_result</span> <span class="identifier">try_step</span><span class="special">(</span> <span class="identifier">DynamicalSystem</span> <span class="special">&amp;</span><span class="identifier">system</span><span class="special">,</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">time_type</span>
+          <span class="special">&amp;</span><span class="identifier">t</span><span class="special">,</span> <span class="identifier">time_type</span>
+          <span class="special">&amp;</span><span class="identifier">dt</span>
+          <span class="special">)</span></code></li>
+</ul></div>
+<p>
+        Tries one timestep with the given parameters
+      </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                  Parameter
+                </p>
+              </th>
+<th>
+                <p>
+                  Type
+                </p>
+              </th>
+<th>
+                <p>
+                  Description
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+                  system
+                </p>
+              </td>
+<td>
+                <p>
+                  DynamicalSystem
+                </p>
+              </td>
+<td>
+                <p>
+                  Function (callable object) that computes the rhs of the ode
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  x
+                </p>
+              </td>
+<td>
+                <p>
+                  container_type
+                </p>
+              </td>
+<td>
+                <p>
+                  The current state of the system <span class="bold"><strong>x(t)</strong></span>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  t
+                </p>
+              </td>
+<td>
+                <p>
+                  time_type
+                </p>
+              </td>
+<td>
+                <p>
+                  The current time <span class="bold"><strong>t</strong></span>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  dt
+                </p>
+              </td>
+<td>
+                <p>
+                  time_type
+                </p>
+              </td>
+<td>
+                <p>
+                  Length of the timestep to be executed
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+        This method has three possible outcomes represented by the returned value
+        <code class="computeroutput"><span class="identifier">result</span></code>: If <code class="computeroutput"><span class="identifier">result</span> <span class="special">=</span> <span class="identifier">success</span></code> the step has been applied and x
+        contains the new state <span class="bold"><strong>x(t)</strong></span> where the time
+        has also been increased <span class="bold"><strong>t += dt</strong></span>. If <code class="computeroutput"><span class="identifier">result</span> <span class="special">=</span> <span class="identifier">step_size_increased</span></code> the step has also been
+        accomplished, but the estimated error was so small that a new stepsize is
+        proposed in the variable <code class="computeroutput"><span class="identifier">dt</span></code>.
+        If <code class="computeroutput"><span class="identifier">result</span> <span class="special">=</span>
+        <span class="identifier">step_size_decreased</span></code> the step has
+        been rejected due to a too big error. <code class="computeroutput"><span class="identifier">x</span></code>
+        and <code class="computeroutput"><span class="identifier">t</span></code> remain unchanged and
+        <code class="computeroutput"><span class="identifier">dt</span></code> now containes the suggested
+        reduced stepsize that should give an error below the desired level.
+      </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput"><span class="identifier">controlled_step_result</span> <span class="identifier">try_step</span><span class="special">(</span> <span class="identifier">DynamicalSystem</span> <span class="special">&amp;</span><span class="identifier">system</span><span class="special">,</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span>
+          <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span><span class="special">,</span> <span class="identifier">time_type</span> <span class="special">&amp;</span><span class="identifier">t</span><span class="special">,</span> <span class="identifier">time_type</span>
+          <span class="special">&amp;</span><span class="identifier">dt</span>
+          <span class="special">)</span></code> Same as above but with the additional
+          parameter <code class="computeroutput"><span class="identifier">dxdt</span></code> that that
+          represents the derivative <span class="bold"><strong>x'(t) = f(x,t)</strong></span>
+          at the time <span class="bold"><strong>t</strong></span>.
+        </li>
+<li>
+<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">adjust_size</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span></code> Adjusts
+          the internal memory to store intermediate results of the same size as
+          <code class="computeroutput"><span class="identifier">x</span></code>. This function <span class="emphasis"><em>must</em></span>
+          be called whenever the system size changes during the integration.
+        </li>
+<li>
+<code class="computeroutput"><span class="identifier">order_type</span> <span class="identifier">order_error_step</span><span class="special">()</span></code> Returns the order of the result <span class="bold"><strong>x(t+dt)</strong></span> of the algorithm.
+        </li>
+</ul></div>
+<p>
+        <span class="bold"><strong>Stepper that model this concept</strong></span>
+      </p>
+<div class="itemizedlist"><ul type="disc">
+<li><code class="computeroutput"><span class="identifier">controlled_stepper_standard</span></code></li>
+<li><code class="computeroutput"><span class="identifier">controlled_stepper_bs</span></code></li>
+</ul></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2009 Karsten Ahnert and Mario Mulansky<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tutorial.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="reference.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Deleted: sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/container_traits.html
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/container_traits.html	2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
+++ (empty file)
@@ -1,51 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Container traits</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-<link rel="start" href="../index.html" title="Chapter&#160;1.&#160;boost.numeric.odeint">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;boost.numeric.odeint">
-<link rel="prev" href="integration_functions.html" title="Integration functions">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
-<td align="center">Home</td>
-<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
-<td align="center">More</td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="integration_functions.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_numeric_odeint.container_traits"></a><a class="link" href="container_traits.html" title="Container traits">Container traits</a>
-</h2></div></div></div>
-<div class="toc"><dl><dt><span class="section"><a href="container_traits.html#boost_numeric_odeint.container_traits.define_your_own_traits">Define
-      your own traits</a></span></dt></dl></div>
-<p>
-      definitions
-    </p>
-<div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title">
-<a name="boost_numeric_odeint.container_traits.define_your_own_traits"></a><a class="link" href="container_traits.html#boost_numeric_odeint.container_traits.define_your_own_traits" title="Define your own traits">Define
-      your own traits</a>
-</h3></div></div></div></div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2009 Karsten Ahnert and Mario Mulansky<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="integration_functions.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a>
-</div>
-</body>
-</html>

Deleted: sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/integration_functions.html
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/integration_functions.html	2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
+++ (empty file)
@@ -1,58 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Integration functions</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-<link rel="start" href="../index.html" title="Chapter&#160;1.&#160;boost.numeric.odeint">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;boost.numeric.odeint">
-<link rel="prev" href="stepper.html" title="Stepper">
-<link rel="next" href="container_traits.html" title="Container traits">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
-<td align="center">Home</td>
-<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
-<td align="center">More</td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="stepper.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="container_traits.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_numeric_odeint.integration_functions"></a><a class="link" href="integration_functions.html" title="Integration functions">Integration
-    functions</a>
-</h2></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section"><a href="integration_functions.html#boost_numeric_odeint.integration_functions.constant_step_size_functions">Constant
-      step-size functions</a></span></dt>
-<dt><span class="section"><a href="integration_functions.html#boost_numeric_odeint.integration_functions.adaptive_step_size_functions">Adaptive
-      step-size functions</a></span></dt>
-</dl></div>
-<div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title">
-<a name="boost_numeric_odeint.integration_functions.constant_step_size_functions"></a><a class="link" href="integration_functions.html#boost_numeric_odeint.integration_functions.constant_step_size_functions" title="Constant step-size functions">Constant
-      step-size functions</a>
-</h3></div></div></div></div>
-<div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title">
-<a name="boost_numeric_odeint.integration_functions.adaptive_step_size_functions"></a><a class="link" href="integration_functions.html#boost_numeric_odeint.integration_functions.adaptive_step_size_functions" title="Adaptive step-size functions">Adaptive
-      step-size functions</a>
-</h3></div></div></div></div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2009 Karsten Ahnert and Mario Mulansky<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="stepper.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="container_traits.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Added: sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/reference.html
==============================================================================
--- (empty file)
+++ sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/reference.html	2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
@@ -0,0 +1,235 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Reference</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter&#160;1.&#160;boost.numeric.odeint">
+<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;boost.numeric.odeint">
+<link rel="prev" href="concepts.html" title="Concepts">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="concepts.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_numeric_odeint.reference"></a><a class="link" href="reference.html" title="Reference">Reference</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="reference.html#boost_numeric_odeint.reference.stepper_classes">Stepper
+      classes</a></span></dt>
+<dt><span class="section"><a href="reference.html#boost_numeric_odeint.reference.integration_functions">Integration
+      functions</a></span></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_numeric_odeint.reference.stepper_classes"></a><a class="link" href="reference.html#boost_numeric_odeint.reference.stepper_classes" title="Stepper classes">Stepper
+      classes</a>
+</h3></div></div></div>
+<div class="table">
+<a name="boost_numeric_odeint.reference.stepper_classes.stepper_algorithms"></a><p class="title"><b>Table&#160;1.3.&#160;Stepper Algorithms</b></p>
+<div class="table-contents"><table class="table" summary="Stepper Algorithms">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                  Method
+                </p>
+              </th>
+<th>
+                <p>
+                  Class
+                </p>
+              </th>
+<th>
+                <p>
+                  Order
+                </p>
+              </th>
+<th>
+                <p>
+                  Error Estimation
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+                  Euler
+                </p>
+              </td>
+<td>
+                <p>
+                  stepper_euler
+                </p>
+              </td>
+<td>
+                <p>
+                  1
+                </p>
+              </td>
+<td>
+                <p>
+                  No
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  Runge-Kutta 4
+                </p>
+              </td>
+<td>
+                <p>
+                  stepper_rk4
+                </p>
+              </td>
+<td>
+                <p>
+                  4
+                </p>
+              </td>
+<td>
+                <p>
+                  No
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  Runge-Kutta Cash-Karp
+                </p>
+              </td>
+<td>
+                <p>
+                  stepper_rk5_ck
+                </p>
+              </td>
+<td>
+                <p>
+                  5
+                </p>
+              </td>
+<td>
+                <p>
+                  Yes (Order 4)
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  Runge-Kutta Fehlberg
+                </p>
+              </td>
+<td>
+                <p>
+                  stepper_rk78_fehlberg
+                </p>
+              </td>
+<td>
+                <p>
+                  7
+                </p>
+              </td>
+<td>
+                <p>
+                  Yes (Order 8)
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  Midpoint
+                </p>
+              </td>
+<td>
+                <p>
+                  stepper_midpoint
+                </p>
+              </td>
+<td>
+                <p>
+                  variable
+                </p>
+              </td>
+<td>
+                <p>
+                  No
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+                  Bulirsch-Stoer
+                </p>
+              </td>
+<td>
+                <p>
+                  controlled_stepper_bs
+                </p>
+              </td>
+<td>
+                <p>
+                  variable
+                </p>
+              </td>
+<td>
+                <p>
+                  Controlled
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break">
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_numeric_odeint.reference.integration_functions"></a><a class="link" href="reference.html#boost_numeric_odeint.reference.integration_functions" title="Integration functions">Integration
+      functions</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="reference.html#boost_numeric_odeint.reference.integration_functions.constant_step_size_functions">Constant
+        step-size functions</a></span></dt>
+<dt><span class="section"><a href="reference.html#boost_numeric_odeint.reference.integration_functions.adaptive_step_size_functions">Adaptive
+        step-size functions</a></span></dt>
+</dl></div>
+<div class="section" lang="en"><div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.reference.integration_functions.constant_step_size_functions"></a><a class="link" href="reference.html#boost_numeric_odeint.reference.integration_functions.constant_step_size_functions" title="Constant step-size functions">Constant
+        step-size functions</a>
+</h4></div></div></div></div>
+<div class="section" lang="en"><div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.reference.integration_functions.adaptive_step_size_functions"></a><a class="link" href="reference.html#boost_numeric_odeint.reference.integration_functions.adaptive_step_size_functions" title="Adaptive step-size functions">Adaptive
+        step-size functions</a>
+</h4></div></div></div></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2009 Karsten Ahnert and Mario Mulansky<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="concepts.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a>
+</div>
+</body>
+</html>

Modified: sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/short_example.html
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/short_example.html	(original)
+++ sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/short_example.html	2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
@@ -10,14 +10,7 @@
 <link rel="next" href="tutorial.html" title="Tutorial">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
-<td align="center">Home</td>
-<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
-<td align="center">More</td>
-</tr></table>
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
 <hr>
 <div class="spirit-nav">
 <a accesskey="p" href="../index.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="tutorial.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
@@ -28,19 +21,18 @@
 </h2></div></div></div>
 <p>
       This section gives a quick introduction to the most important features of the
-      library using a number of instructive examples. Image, 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):
+      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'. 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):
     </p>
 <p>
       </p>
 <p>
         
 </p>
-<pre class="programlisting"><span class="comment">/* The type of container used to hold the state vector */</span>
+<pre class="programlisting"><span class="comment">/* The state type used to hold the state vector */</span>
 <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
 
 <span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">gam</span> <span class="special">=</span> <span class="number">0.15</span><span class="special">;</span>

Deleted: sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/stepper.html
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/stepper.html	2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
+++ (empty file)
@@ -1,1401 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Stepper</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-<link rel="start" href="../index.html" title="Chapter&#160;1.&#160;boost.numeric.odeint">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;boost.numeric.odeint">
-<link rel="prev" href="tutorial.html" title="Tutorial">
-<link rel="next" href="integration_functions.html" title="Integration functions">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
-<td align="center">Home</td>
-<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
-<td align="center">More</td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="tutorial.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="integration_functions.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_numeric_odeint.stepper"></a><a class="link" href="stepper.html" title="Stepper">Stepper</a>
-</h2></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section">Concepts</span></dt>
-<dt><span class="section"><a href="stepper.html#boost_numeric_odeint.stepper.stepper_classes">Stepper
-      classes</a></span></dt>
-</dl></div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_numeric_odeint.stepper.concepts"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.concepts" title="Concepts">Concepts</a>
-</h3></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section"><a href="stepper.html#boost_numeric_odeint.stepper.concepts.dynamical_system">Dynamical
-        system</a></span></dt>
-<dt><span class="section"><a href="stepper.html#boost_numeric_odeint.stepper.concepts.basic_stepper">Basic
-        stepper</a></span></dt>
-<dt><span class="section"><a href="stepper.html#boost_numeric_odeint.stepper.concepts.error_stepper">Error
-        stepper</a></span></dt>
-<dt><span class="section"><a href="stepper.html#boost_numeric_odeint.stepper.concepts.controlled_stepper">Controlled
-        stepper</a></span></dt>
-</dl></div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_numeric_odeint.stepper.concepts.dynamical_system"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.concepts.dynamical_system" title="Dynamical system">Dynamical
-        system</a>
-</h4></div></div></div>
-<p>
-          The dynamical system represents the right hand side of the differential
-          equation:
-        </p>
-<p>
-          <span class="bold"><strong>x'(t) = f(x(t) , t)</strong></span>
-        </p>
-<p>
-          In this odeint library the dynamical system is realized by a callable object,
-          e.g. a function pointer, a functor or an instance of an object with an
-          appropriate <code class="computeroutput"><span class="special">()</span></code>-operator. The
-          parameter structure has to be the following:
-        </p>
-<p>
-          <code class="computeroutput"><span class="special">(</span><span class="keyword">const</span>
-          <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">container_type</span>
-          <span class="special">&amp;</span><span class="identifier">dxdt</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">time_type</span> <span class="identifier">t</span><span class="special">)</span></code>
-        </p>
-<p>
-          <code class="computeroutput"><span class="identifier">x</span></code> is the current state
-          of the system and <code class="computeroutput"><span class="identifier">t</span></code> is
-          the current time. The result <span class="bold"><strong>x' = f(x,t)</strong></span>
-          is then returned in <code class="computeroutput"><span class="identifier">dxdt</span></code>.
-          See the tutorial for examples on how to define the dynamical system.
-        </p>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_numeric_odeint.stepper.concepts.basic_stepper"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.concepts.basic_stepper" title="Basic stepper">Basic
-        stepper</a>
-</h4></div></div></div>
-<p>
-          Basic steppers execute one timestep of a specific order with a given stepsize.
-          They usually allocate internal memory to store intermediate function call
-          results. If state types with variable size are used (e.g. <code class="computeroutput"><span class="identifier">vector</span></code>), it has to be assured that the
-          stepper gets informed about any change of the state size by calling its
-          <code class="computeroutput"><span class="identifier">adjust_size</span></code> method.
-        </p>
-<p>
-          <span class="bold"><strong>Associated Types</strong></span>
-        </p>
-<div class="informaltable"><table class="table">
-<colgroup>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                <p>
-                </p>
-                </th>
-<th>
-                <p>
-                </p>
-                </th>
-<th>
-                <p>
-                  Description
-                </p>
-                </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                <p>
-                  Time
-                </p>
-                </td>
-<td>
-                <p>
-                  Stepper::time_type
-                </p>
-                </td>
-<td>
-                <p>
-                  Type of the time variable, e.g. <code class="computeroutput"><span class="keyword">double</span></code>
-                </p>
-                </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  Container
-                </p>
-                </td>
-<td>
-                <p>
-                  Stepper::container_type
-                </p>
-                </td>
-<td>
-                <p>
-                  Type of the system state, e.g. <code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span></code>
-                </p>
-                </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  Value
-                </p>
-                </td>
-<td>
-                <p>
-                  Stepper::value_type
-                </p>
-                </td>
-<td>
-                <p>
-                  Value type of the state, e.g. <code class="computeroutput"><span class="keyword">double</span></code>
-                </p>
-                </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  Order Type
-                </p>
-                </td>
-<td>
-                <p>
-                  Stepper::order_type
-                </p>
-                </td>
-<td>
-                <p>
-                  Type of the order parameter, usually <code class="computeroutput"><span class="keyword">unsigned</span>
-                  <span class="keyword">short</span></code>
-                </p>
-                </td>
-</tr>
-</tbody>
-</table></div>
-<p>
-          <span class="bold"><strong>Methods</strong></span>
-        </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-<code class="computeroutput"><span class="identifier">Stepper</span><span class="special">()</span></code>
-            Constructor.
-          </li>
-<li>
-<code class="computeroutput"><span class="identifier">Stepper</span><span class="special">(</span>
-            <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span></code>
-            Constructor that allocates internal memory to store intermediate results
-            of the same size as <code class="computeroutput"><span class="identifier">x</span></code>.
-          </li>
-<li><code class="computeroutput"><span class="keyword">void</span> <span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">DynamicalSystem</span>
-            <span class="special">&amp;</span><span class="identifier">system</span>
-            <span class="special">,</span> <span class="identifier">container_type</span>
-            <span class="special">&amp;</span><span class="identifier">x</span>
-            <span class="special">,</span> <span class="identifier">time_type</span>
-            <span class="identifier">t</span> <span class="special">,</span>
-            <span class="identifier">time_type</span> <span class="identifier">dt</span>
-            <span class="special">)</span></code></li>
-</ul></div>
-<p>
-          Executes one timestep with the given parameters:
-        </p>
-<div class="informaltable"><table class="table">
-<colgroup>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                <p>
-                  Parameter
-                </p>
-                </th>
-<th>
-                <p>
-                  Type
-                </p>
-                </th>
-<th>
-                <p>
-                  Description
-                </p>
-                </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                <p>
-                  system
-                </p>
-                </td>
-<td>
-                <p>
-                  DynamicalSystem
-                </p>
-                </td>
-<td>
-                <p>
-                  Function (callable object) that computes the rhs of the ode
-                </p>
-                </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  x
-                </p>
-                </td>
-<td>
-                <p>
-                  container_type
-                </p>
-                </td>
-<td>
-                <p>
-                  The current state of the system <span class="bold"><strong>x(t)</strong></span>
-                </p>
-                </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  t
-                </p>
-                </td>
-<td>
-                <p>
-                  time_type
-                </p>
-                </td>
-<td>
-                <p>
-                  The current time <span class="bold"><strong>t</strong></span>
-                </p>
-                </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  dt
-                </p>
-                </td>
-<td>
-                <p>
-                  time_type
-                </p>
-                </td>
-<td>
-                <p>
-                  Length of the timestep to be executed
-                </p>
-                </td>
-</tr>
-</tbody>
-</table></div>
-<p>
-          The result of this method is the (approximate) state of the system <span class="bold"><strong>x(t+dt)</strong></span> and is stored in the variable <code class="computeroutput"><span class="identifier">x</span></code> (in-place). Note, that the time <code class="computeroutput"><span class="identifier">t</span></code> is not automatically increased by this
-          method.
-        </p>
-<div class="itemizedlist"><ul type="disc"><li><code class="computeroutput"><span class="keyword">void</span> <span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">DynamicalSystem</span>
-            <span class="special">&amp;</span><span class="identifier">system</span>
-            <span class="special">,</span> <span class="identifier">container_type</span>
-            <span class="special">&amp;</span><span class="identifier">x</span>
-            <span class="special">,</span> <span class="keyword">const</span>
-            <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">time_type</span> <span class="identifier">t</span>
-            <span class="special">,</span> <span class="identifier">time_type</span>
-            <span class="identifier">dt</span> <span class="special">)</span></code></li></ul></div>
-<p>
-          The same as above but with the additional parameter <code class="computeroutput"><span class="identifier">dxdt</span></code>
-          that represents the derivative <span class="bold"><strong>x'(t) = f(x,t)</strong></span>
-          at the time <span class="bold"><strong>t</strong></span>.
-        </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">adjust_size</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span></code>
-            Adjusts the internal memory to store intermediate results of the same
-            size as <code class="computeroutput"><span class="identifier">x</span></code>. This function
-            <span class="emphasis"><em>must</em></span> be called whenever the system size changes
-            during the integration.
-          </li>
-<li>
-<code class="computeroutput"><span class="identifier">order_type</span> <span class="identifier">order_step</span><span class="special">()</span></code> Returns the order of the algorithm.
-            If <span class="bold"><strong>n</strong></span> is the order of a method, then
-            the result of one iteration with the timestep <span class="bold"><strong>dt</strong></span>
-            is accurate up to <span class="bold"><strong>dt^n</strong></span>. That means the
-            error made by the time discretization is of order <span class="bold"><strong>dt^(n+1)</strong></span>.
-          </li>
-</ul></div>
-<p>
-          <span class="bold"><strong>Stepper that model this concept</strong></span>
-        </p>
-<div class="itemizedlist"><ul type="disc">
-<li><code class="computeroutput"><span class="identifier">stepper_euler</span></code></li>
-<li><code class="computeroutput"><span class="identifier">stepper_rk4</span></code></li>
-<li><code class="computeroutput"><span class="identifier">stepper_rk78_fehlberg</span></code></li>
-</ul></div>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_numeric_odeint.stepper.concepts.error_stepper"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.concepts.error_stepper" title="Error stepper">Error
-        stepper</a>
-</h4></div></div></div>
-<p>
-          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 intermediate function call results. If state types with variable
-          size are used (e.g. <code class="computeroutput"><span class="identifier">vector</span></code>),
-          it has to be assured that the stepper gets informed about any change of
-          the state size by calling its <code class="computeroutput"><span class="identifier">adjust_size</span></code>
-          method.
-        </p>
-<p>
-          <span class="bold"><strong>Associated Types</strong></span>
-        </p>
-<p>
-          Same as for <span class="emphasis"><em>basic steppers</em></span> above.
-        </p>
-<p>
-          <span class="bold"><strong>Methods</strong></span>
-        </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-<code class="computeroutput"><span class="identifier">Error_Stepper</span><span class="special">()</span></code>
-            Constructor.
-          </li>
-<li>
-<code class="computeroutput"><span class="identifier">Error_Stepper</span><span class="special">(</span>
-            <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span></code>
-            Constructor that allocates internal memory to store intermediate results
-            of the same size as <code class="computeroutput"><span class="identifier">x</span></code>.
-          </li>
-<li><code class="computeroutput"><span class="keyword">void</span> <span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">DynamicalSystem</span>
-            <span class="special">&amp;</span><span class="identifier">system</span>
-            <span class="special">,</span> <span class="identifier">container_type</span>
-            <span class="special">&amp;</span><span class="identifier">x</span>
-            <span class="special">,</span> <span class="identifier">time_type</span>
-            <span class="identifier">t</span> <span class="special">,</span>
-            <span class="identifier">time_type</span> <span class="identifier">dt</span>
-            <span class="special">,</span> <span class="identifier">container_type</span>
-            <span class="special">&amp;</span><span class="identifier">xerr</span><span class="special">)</span></code></li>
-</ul></div>
-<p>
-          Executes one timestep with the given parameters:
-        </p>
-<div class="informaltable"><table class="table">
-<colgroup>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                <p>
-                  Parameter
-                </p>
-                </th>
-<th>
-                <p>
-                  Type
-                </p>
-                </th>
-<th>
-                <p>
-                  Description
-                </p>
-                </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                <p>
-                  system
-                </p>
-                </td>
-<td>
-                <p>
-                  DynamicalSystem
-                </p>
-                </td>
-<td>
-                <p>
-                  Function (callable object) that computes the rhs of the ode
-                </p>
-                </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  x
-                </p>
-                </td>
-<td>
-                <p>
-                  container_type
-                </p>
-                </td>
-<td>
-                <p>
-                  The current state of the system <span class="bold"><strong>x(t)</strong></span>
-                </p>
-                </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  t
-                </p>
-                </td>
-<td>
-                <p>
-                  time_type
-                </p>
-                </td>
-<td>
-                <p>
-                  The current time <span class="bold"><strong>t</strong></span>
-                </p>
-                </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  dt
-                </p>
-                </td>
-<td>
-                <p>
-                  time_type
-                </p>
-                </td>
-<td>
-                <p>
-                  Length of the timestep to be executed
-                </p>
-                </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  xerr
-                </p>
-                </td>
-<td>
-                <p>
-                  container_type
-                </p>
-                </td>
-<td>
-                <p>
-                  Used by the method to return the error estimation of this computation
-                </p>
-                </td>
-</tr>
-</tbody>
-</table></div>
-<p>
-          The result of this method is the (approximate) state of the system <span class="bold"><strong>x(t+dt)</strong></span>, which is returned in the variable <code class="computeroutput"><span class="identifier">x</span></code> (in-place), and the corresponding error
-          estimation returned in <code class="computeroutput"><span class="identifier">xerr</span></code>.
-          Note, that the time <code class="computeroutput"><span class="identifier">t</span></code> is
-          not automatically increased by this method.
-        </p>
-<div class="itemizedlist"><ul type="disc"><li><code class="computeroutput"><span class="keyword">void</span> <span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">DynamicalSystem</span>
-            <span class="special">&amp;</span><span class="identifier">system</span>
-            <span class="special">,</span> <span class="identifier">container_type</span>
-            <span class="special">&amp;</span><span class="identifier">x</span>
-            <span class="special">,</span> <span class="keyword">const</span>
-            <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">time_type</span> <span class="identifier">t</span>
-            <span class="special">,</span> <span class="identifier">time_type</span>
-            <span class="identifier">dt</span> <span class="special">,</span>
-            <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">xerr</span><span class="special">)</span></code></li></ul></div>
-<p>
-          The same as above but with the additional parameter <code class="computeroutput"><span class="identifier">dxdt</span></code>
-          that represents the derivative <span class="bold"><strong>x'(t) = f(x,t)</strong></span>
-          at the time <span class="bold"><strong>t</strong></span>.
-        </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">adjust_size</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span></code>
-            Adjusts the internal memory to store intermediate results of the same
-            size as <code class="computeroutput"><span class="identifier">x</span></code>. This function
-            <span class="emphasis"><em>must</em></span> be called whenever the system size changes
-            during the integration.
-          </li>
-<li>
-<code class="computeroutput"><span class="identifier">order_type</span> <span class="identifier">order_error_step</span><span class="special">()</span></code> Returns the order of the result <span class="bold"><strong>x(t+dt)</strong></span> of the algorithm.
-          </li>
-<li>
-<code class="computeroutput"><span class="identifier">order_type</span> <span class="identifier">order_error</span><span class="special">()</span></code> Returns the order of the error estimation
-            of the algorithm.
-          </li>
-</ul></div>
-<p>
-          <span class="bold"><strong>Stepper that model this concept</strong></span>
-        </p>
-<div class="itemizedlist"><ul type="disc">
-<li><code class="computeroutput"><span class="identifier">stepper_rk5_ck</span></code></li>
-<li><code class="computeroutput"><span class="identifier">stepper_rk78_fehlberg</span></code></li>
-<li><code class="computeroutput"><span class="identifier">stepper_half_step</span></code></li>
-</ul></div>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_numeric_odeint.stepper.concepts.controlled_stepper"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.concepts.controlled_stepper" title="Controlled stepper">Controlled
-        stepper</a>
-</h4></div></div></div>
-<p>
-          Controlled steppers try to execute a timestep with a given error threshold.
-          If the estimated error of the obtained solution is too big, the result
-          is rejected and a new stepsize is proposed. If the error is small enough
-          the timestep is accepted and possibly an increased stepsize is proposed.
-        </p>
-<p>
-          <span class="bold"><strong>Associated Types</strong></span>
-        </p>
-<p>
-          Same as for <span class="emphasis"><em>basic steppers</em></span> above.
-        </p>
-<p>
-          <span class="bold"><strong>Methods</strong></span>
-        </p>
-<div class="itemizedlist"><ul type="disc"><li><code class="computeroutput"><span class="identifier">Controlled_Stepper</span><span class="special">(</span>
-            <span class="identifier">time_type</span> <span class="identifier">abs_err</span><span class="special">,</span> <span class="identifier">time_type</span>
-            <span class="identifier">rel_err</span><span class="special">,</span>
-            <span class="identifier">time_type</span> <span class="identifier">factor_x</span><span class="special">,</span> <span class="identifier">time_type</span>
-            <span class="identifier">factor_dxdt</span> <span class="special">)</span></code></li></ul></div>
-<p>
-          Constructor that initializes the controlled stepper with several parameters
-          of the error control. The controlled stepper assures that the error done
-          by each individual timestep yields:
-        </p>
-<p>
-          <span class="bold"><strong>xerr &lt; 1.1 ( eps_abs + eps_rel * (factor_x |x|
-          + factor_dxdt h |x'|) ) </strong></span>
-        </p>
-<p>
-          The factor 1.1 is for safety to avoid unnecessary many stepsize adjustings.
-          The above inequality should be understand to hold for <span class="emphasis"><em>all</em></span>
-          components of the possibly more dimensional vectors <span class="bold"><strong>x</strong></span>,
-          <span class="bold"><strong>x'</strong></span> and <span class="bold"><strong>xerr</strong></span>.
-          If the estimated error is too large, a reduced stepsize will be suggested.
-          If the estimated error is less than half of the desired error, an increased
-          stepsize will be suggested.
-        </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-<code class="computeroutput"><span class="identifier">Controlled_Stepper</span><span class="special">(</span>
-            <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">time_type</span> <span class="identifier">abs_err</span><span class="special">,</span> <span class="identifier">time_type</span>
-            <span class="identifier">rel_err</span><span class="special">,</span>
-            <span class="identifier">time_type</span> <span class="identifier">factor_x</span><span class="special">,</span> <span class="identifier">time_type</span>
-            <span class="identifier">factor_dxdt</span> <span class="special">)</span></code>
-            Same as above, but with additional allocation of the internal memory
-            to store intermediate results of the same size as <code class="computeroutput"><span class="identifier">x</span></code>.
-          </li>
-<li><code class="computeroutput"><span class="identifier">controlled_step_result</span> <span class="identifier">try_step</span><span class="special">(</span>
-            <span class="identifier">DynamicalSystem</span> <span class="special">&amp;</span><span class="identifier">system</span><span class="special">,</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">time_type</span> <span class="special">&amp;</span><span class="identifier">t</span><span class="special">,</span> <span class="identifier">time_type</span> <span class="special">&amp;</span><span class="identifier">dt</span> <span class="special">)</span></code></li>
-</ul></div>
-<p>
-          Tries one timestep with the given parameters
-        </p>
-<div class="informaltable"><table class="table">
-<colgroup>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                <p>
-                  Parameter
-                </p>
-                </th>
-<th>
-                <p>
-                  Type
-                </p>
-                </th>
-<th>
-                <p>
-                  Description
-                </p>
-                </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                <p>
-                  system
-                </p>
-                </td>
-<td>
-                <p>
-                  DynamicalSystem
-                </p>
-                </td>
-<td>
-                <p>
-                  Function (callable object) that computes the rhs of the ode
-                </p>
-                </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  x
-                </p>
-                </td>
-<td>
-                <p>
-                  container_type
-                </p>
-                </td>
-<td>
-                <p>
-                  The current state of the system <span class="bold"><strong>x(t)</strong></span>
-                </p>
-                </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  t
-                </p>
-                </td>
-<td>
-                <p>
-                  time_type
-                </p>
-                </td>
-<td>
-                <p>
-                  The current time <span class="bold"><strong>t</strong></span>
-                </p>
-                </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  dt
-                </p>
-                </td>
-<td>
-                <p>
-                  time_type
-                </p>
-                </td>
-<td>
-                <p>
-                  Length of the timestep to be executed
-                </p>
-                </td>
-</tr>
-</tbody>
-</table></div>
-<p>
-          This method has three possible outcomes represented by the returned value
-          <code class="computeroutput"><span class="identifier">result</span></code>: If <code class="computeroutput"><span class="identifier">result</span> <span class="special">=</span> <span class="identifier">success</span></code> the step has been applied and
-          x contains the new state <span class="bold"><strong>x(t)</strong></span> where the
-          time has also been increased <span class="bold"><strong>t += dt</strong></span>.
-          If <code class="computeroutput"><span class="identifier">result</span> <span class="special">=</span>
-          <span class="identifier">step_size_increased</span></code> the step
-          has also been accomplished, but the estimated error was so small that a
-          new stepsize is proposed in the variable <code class="computeroutput"><span class="identifier">dt</span></code>.
-          If <code class="computeroutput"><span class="identifier">result</span> <span class="special">=</span>
-          <span class="identifier">step_size_decreased</span></code> the step
-          has been rejected due to a too big error. <code class="computeroutput"><span class="identifier">x</span></code>
-          and <code class="computeroutput"><span class="identifier">t</span></code> remain unchanged
-          and <code class="computeroutput"><span class="identifier">dt</span></code> now containes the
-          suggested reduced stepsize that should give an error below the desired
-          level.
-        </p>
-<div class="itemizedlist"><ul type="disc">
-<li>
-<code class="computeroutput"><span class="identifier">controlled_step_result</span> <span class="identifier">try_step</span><span class="special">(</span>
-            <span class="identifier">DynamicalSystem</span> <span class="special">&amp;</span><span class="identifier">system</span><span class="special">,</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">container_type</span>
-            <span class="special">&amp;</span><span class="identifier">dxdt</span><span class="special">,</span> <span class="identifier">time_type</span>
-            <span class="special">&amp;</span><span class="identifier">t</span><span class="special">,</span> <span class="identifier">time_type</span>
-            <span class="special">&amp;</span><span class="identifier">dt</span>
-            <span class="special">)</span></code> Same as above but with the additional
-            parameter <code class="computeroutput"><span class="identifier">dxdt</span></code> that that
-            represents the derivative <span class="bold"><strong>x'(t) = f(x,t)</strong></span>
-            at the time <span class="bold"><strong>t</strong></span>.
-          </li>
-<li>
-<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">adjust_size</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span></code>
-            Adjusts the internal memory to store intermediate results of the same
-            size as <code class="computeroutput"><span class="identifier">x</span></code>. This function
-            <span class="emphasis"><em>must</em></span> be called whenever the system size changes
-            during the integration.
-          </li>
-<li>
-<code class="computeroutput"><span class="identifier">order_type</span> <span class="identifier">order_error_step</span><span class="special">()</span></code> Returns the order of the result <span class="bold"><strong>x(t+dt)</strong></span> of the algorithm.
-          </li>
-</ul></div>
-<p>
-          <span class="bold"><strong>Stepper that model this concept</strong></span>
-        </p>
-<div class="itemizedlist"><ul type="disc">
-<li><code class="computeroutput"><span class="identifier">controlled_stepper_standard</span></code></li>
-<li><code class="computeroutput"><span class="identifier">controlled_stepper_bs</span></code></li>
-</ul></div>
-</div>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_numeric_odeint.stepper.stepper_classes"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.stepper_classes" title="Stepper classes">Stepper
-      classes</a>
-</h3></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section">stepper_euler</span></dt>
-<dt><span class="section">stepper_rk4</span></dt>
-<dt><span class="section">stepper_rk5_ck</span></dt>
-<dt><span class="section">stepper_rk78_fehlberg</span></dt>
-</dl></div>
-<div class="table">
-<a name="boost_numeric_odeint.stepper.stepper_classes.stepper_algorithms"></a><p class="title"><b>Table&#160;1.3.&#160;Stepper Algorithms</b></p>
-<div class="table-contents"><table class="table" summary="Stepper Algorithms">
-<colgroup>
-<col>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-            <p>
-              Method
-            </p>
-            </th>
-<th>
-            <p>
-              Class
-            </p>
-            </th>
-<th>
-            <p>
-              Order
-            </p>
-            </th>
-<th>
-            <p>
-              Error Estimation
-            </p>
-            </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-            <p>
-              Euler
-            </p>
-            </td>
-<td>
-            <p>
-              stepper_euler
-            </p>
-            </td>
-<td>
-            <p>
-              1
-            </p>
-            </td>
-<td>
-            <p>
-              No
-            </p>
-            </td>
-</tr>
-<tr>
-<td>
-            <p>
-              Runge-Kutta 4
-            </p>
-            </td>
-<td>
-            <p>
-              stepper_rk4
-            </p>
-            </td>
-<td>
-            <p>
-              4
-            </p>
-            </td>
-<td>
-            <p>
-              No
-            </p>
-            </td>
-</tr>
-<tr>
-<td>
-            <p>
-              Runge-Kutta Cash-Karp
-            </p>
-            </td>
-<td>
-            <p>
-              stepper_rk5_ck
-            </p>
-            </td>
-<td>
-            <p>
-              5
-            </p>
-            </td>
-<td>
-            <p>
-              Yes (Order 4)
-            </p>
-            </td>
-</tr>
-<tr>
-<td>
-            <p>
-              Runge-Kutta Fehlberg
-            </p>
-            </td>
-<td>
-            <p>
-              stepper_rk78_fehlberg
-            </p>
-            </td>
-<td>
-            <p>
-              7
-            </p>
-            </td>
-<td>
-            <p>
-              Yes (Order 8)
-            </p>
-            </td>
-</tr>
-<tr>
-<td>
-            <p>
-              Midpoint
-            </p>
-            </td>
-<td>
-            <p>
-              stepper_midpoint
-            </p>
-            </td>
-<td>
-            <p>
-              variable
-            </p>
-            </td>
-<td>
-            <p>
-              No
-            </p>
-            </td>
-</tr>
-<tr>
-<td>
-            <p>
-              Bulirsch-Stoer
-            </p>
-            </td>
-<td>
-            <p>
-              controlled_stepper_bs
-            </p>
-            </td>
-<td>
-            <p>
-              variable
-            </p>
-            </td>
-<td>
-            <p>
-              Controlled
-            </p>
-            </td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><div class="section" lang="en">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_numeric_odeint.stepper.stepper_classes.stepper_euler"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.stepper_classes.stepper_euler" title="stepper_euler">stepper_euler</a>
-</h4></div></div></div>
-<p>
-          <span class="bold"><strong>Concept:</strong></span> <a class="link" href="../">Basic
-          stepper</a>
-        </p>
-<p>
-          <span class="bold"><strong>Accuracy:</strong></span> The produced solution is accurate
-          up to order 1.
-        </p>
-<p>
-          <span class="bold"><strong>Complexity:</strong></span> This method uses 1 function
-          evaluation.
-        </p>
-<p>
-          <span class="bold"><strong>Template Parameters:</strong></span>
-        </p>
-<p>
-          </p>
-<div class="informaltable"><table class="table">
-<colgroup>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                  <p>
-                    Parameter
-                  </p>
-                  </th>
-<th>
-                  <p>
-                    Default Value
-                  </p>
-                  </th>
-<th>
-                  <p>
-                    Description
-                  </p>
-                  </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                  <p>
-                    class Container
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    no default value
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    Type of container that stores the state of the system
-                  </p>
-                  </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    class Time
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    double
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    Type of the time variable in the ode
-                  </p>
-                  </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    class Traits
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    container_traits&lt; Container &gt;
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    container_traits used by the stepper
-                  </p>
-                  </td>
-</tr>
-</tbody>
-</table></div>
-<p>
-        </p>
-<p>
-          The Euler algorithm used in this class performs one integration step according
-          to the formula:
-        </p>
-<div class="blockquote"><blockquote class="blockquote">
-<p>
-            </p>
-<p>
-              x(t+dt) = x(t) + dt*f(x,t)
-            </p>
-<p>
-          </p>
-</blockquote></div>
-<p>
-          The Euler stepper is the most simple algorithm to integrate a differential
-          equation. It's only purpose in this library is for educational reasons
-          - use more sophisticated steppers for real life problems.
-        </p>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_numeric_odeint.stepper.stepper_classes.stepper_rk4"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.stepper_classes.stepper_rk4" title="stepper_rk4">stepper_rk4</a>
-</h4></div></div></div>
-<p>
-          <span class="bold"><strong>Concept:</strong></span> <a class="link" href="../">Basic
-          stepper</a>
-        </p>
-<p>
-          <span class="bold"><strong>Accuracy:</strong></span> The produced solution is accurate
-          up to order 4.
-        </p>
-<p>
-          <span class="bold"><strong>Complexity:</strong></span> This method uses 4 function
-          evaluations.
-        </p>
-<p>
-          <span class="bold"><strong>Template Parameters:</strong></span>
-        </p>
-<p>
-          </p>
-<div class="informaltable"><table class="table">
-<colgroup>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                  <p>
-                    Parameter
-                  </p>
-                  </th>
-<th>
-                  <p>
-                    Default Value
-                  </p>
-                  </th>
-<th>
-                  <p>
-                    Description
-                  </p>
-                  </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                  <p>
-                    class Container
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    no default value
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    Type of container that stores the state of the system
-                  </p>
-                  </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    class Time
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    double
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    Type of the time variable in the ode
-                  </p>
-                  </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    class Traits
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    container_traits&lt; Container &gt;
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    container_traits used by the stepper
-                  </p>
-                  </td>
-</tr>
-</tbody>
-</table></div>
-<p>
-        </p>
-<p>
-          The Runge-Kutta 4 algorithm is <span class="emphasis"><em>the</em></span> classical method
-          to integrate odes. The <a href="http://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods#Explicit_Runge.E2.80.93Kutta_methods" target="_top">Butcher
-          Tableau</a> for this method is as follows:
-        </p>
-<pre class="programlisting">Butcher Tableau for Runge-Kutta 4
-   0  |
-  1/2 | 1/2
-  1/2 |  0   1/2
-   1  |  0    0    1
-  ------------------------
-      | 1/6  1/3  1/3  1/6
-</pre>
-<p>
-          This method produces fast, though not too accurate solutions. Use it for
-          quick preliminary results and then switch to error controlled methods like
-          Cash-Karp for more reliable calculations.
-        </p>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_numeric_odeint.stepper.stepper_classes.stepper_rk5_ck"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.stepper_classes.stepper_rk5_ck" title="stepper_rk5_ck">stepper_rk5_ck</a>
-</h4></div></div></div>
-<p>
-          <span class="bold"><strong>Concept:</strong></span> <a class="link" href="../">Error
-          stepper</a>
-        </p>
-<p>
-          <span class="bold"><strong>Accuracy:</strong></span> The produced solution is accurate
-          up to order 5 and the estimated error is also of order 5.
-        </p>
-<p>
-          <span class="bold"><strong>Complexity:</strong></span> This method uses 6 function
-          evaluation.
-        </p>
-<p>
-          <span class="bold"><strong>Template Parameters:</strong></span>
-        </p>
-<p>
-          </p>
-<div class="informaltable"><table class="table">
-<colgroup>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                  <p>
-                    Parameter
-                  </p>
-                  </th>
-<th>
-                  <p>
-                    Default Value
-                  </p>
-                  </th>
-<th>
-                  <p>
-                    Description
-                  </p>
-                  </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                  <p>
-                    class Container
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    no default value
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    Type of container that stores the state of the system
-                  </p>
-                  </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    class Time
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    double
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    Type of the time variable in the ode
-                  </p>
-                  </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    class Traits
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    container_traits&lt; Container &gt;
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    container_traits used by the stepper
-                  </p>
-                  </td>
-</tr>
-</tbody>
-</table></div>
-<p>
-        </p>
-<p>
-          The Runge-Kutta method of order 5 with Cash-Karp coefficients is a good
-          trade-off between numerical effort and obtained accuracy with error estimation.
-          It is the all-round method and suitable for most problems. See wikipedia
-          for details and the Butcher tableau.
-        </p>
-</div>
-<div class="section" lang="en">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_numeric_odeint.stepper.stepper_classes.stepper_rk78_fehlberg"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.stepper_classes.stepper_rk78_fehlberg" title="stepper_rk78_fehlberg">stepper_rk78_fehlberg</a>
-</h4></div></div></div>
-<p>
-          <span class="bold"><strong>Concept:</strong></span> <a class="link" href="../">Error
-          Stepper</a>
-        </p>
-<p>
-          <span class="bold"><strong>Accuracy:</strong></span> The produced solution is accurate
-          up to order 7 and the estimated error is of order 8.
-        </p>
-<p>
-          <span class="bold"><strong>Complexity:</strong></span> This method uses 13 function
-          evaluations.
-        </p>
-<p>
-          <span class="bold"><strong>Template Parameters:</strong></span>
-        </p>
-<p>
-          </p>
-<div class="informaltable"><table class="table">
-<colgroup>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                  <p>
-                    Parameter
-                  </p>
-                  </th>
-<th>
-                  <p>
-                    Default Value
-                  </p>
-                  </th>
-<th>
-                  <p>
-                    Description
-                  </p>
-                  </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                  <p>
-                    class Container
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    no default value
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    Type of container that stores the state of the system
-                  </p>
-                  </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    class Time
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    double
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    Type of the time variable in the ode
-                  </p>
-                  </td>
-</tr>
-<tr>
-<td>
-                  <p>
-                    class Traits
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    container_traits&lt; Container &gt;
-                  </p>
-                  </td>
-<td>
-                  <p>
-                    container_traits used by the stepper
-                  </p>
-                  </td>
-</tr>
-</tbody>
-</table></div>
-<p>
-        </p>
-<p>
-          The Runge-Kutta 78 Fehlberg method is a high-order algorithm that produces
-          very good accuracy but for the cost of high numerical effort. Whenever
-          extra-ordinarily high precision is required, you can fall back to this
-          method.
-        </p>
-</div>
-</div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#169; 2009 Karsten Ahnert and Mario Mulansky<p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-      </p>
-</div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="tutorial.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="integration_functions.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Modified: sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/tutorial.html
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/tutorial.html	(original)
+++ sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/tutorial.html	2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
@@ -7,20 +7,13 @@
 <link rel="start" href="../index.html" title="Chapter&#160;1.&#160;boost.numeric.odeint">
 <link rel="up" href="../index.html" title="Chapter&#160;1.&#160;boost.numeric.odeint">
 <link rel="prev" href="short_example.html" title="Short Example">
-<link rel="next" href="stepper.html" title="Stepper">
+<link rel="next" href="concepts.html" title="Concepts">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
-<td align="center">Home</td>
-<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
-<td align="center">More</td>
-</tr></table>
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="short_example.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="stepper.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="short_example.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="concepts.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
 </div>
 <div class="section" lang="en">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -86,7 +79,7 @@
 <p>
             
 </p>
-<pre class="programlisting"><span class="comment">/* The type of container used to hold the state vector */</span>
+<pre class="programlisting"><span class="comment">/* The state type used to hold the state vector */</span>
 <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
 
 <span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">gam</span> <span class="special">=</span> <span class="number">0.15</span><span class="special">;</span>
@@ -169,158 +162,158 @@
 </colgroup>
 <thead><tr>
 <th>
-              <p>
-                Method
-              </p>
-              </th>
+                  <p>
+                    Method
+                  </p>
+                </th>
 <th>
-              <p>
-                Class
-              </p>
-              </th>
+                  <p>
+                    Class
+                  </p>
+                </th>
 <th>
-              <p>
-                Order
-              </p>
-              </th>
+                  <p>
+                    Order
+                  </p>
+                </th>
 <th>
-              <p>
-                Error Estimation
-              </p>
-              </th>
+                  <p>
+                    Error Estimation
+                  </p>
+                </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
-              <p>
-                Euler
-              </p>
-              </td>
-<td>
-              <p>
-                stepper_euler
-              </p>
-              </td>
-<td>
-              <p>
-                1
-              </p>
-              </td>
-<td>
-              <p>
-                No
-              </p>
-              </td>
+                  <p>
+                    Euler
+                  </p>
+                </td>
+<td>
+                  <p>
+                    stepper_euler
+                  </p>
+                </td>
+<td>
+                  <p>
+                    1
+                  </p>
+                </td>
+<td>
+                  <p>
+                    No
+                  </p>
+                </td>
 </tr>
 <tr>
 <td>
-              <p>
-                Runge-Kutta 4
-              </p>
-              </td>
-<td>
-              <p>
-                stepper_rk4
-              </p>
-              </td>
-<td>
-              <p>
-                4
-              </p>
-              </td>
-<td>
-              <p>
-                No
-              </p>
-              </td>
+                  <p>
+                    Runge-Kutta 4
+                  </p>
+                </td>
+<td>
+                  <p>
+                    stepper_rk4
+                  </p>
+                </td>
+<td>
+                  <p>
+                    4
+                  </p>
+                </td>
+<td>
+                  <p>
+                    No
+                  </p>
+                </td>
 </tr>
 <tr>
 <td>
-              <p>
-                Runge-Kutta Cash-Karp
-              </p>
-              </td>
-<td>
-              <p>
-                stepper_rk5_ck
-              </p>
-              </td>
-<td>
-              <p>
-                5
-              </p>
-              </td>
-<td>
-              <p>
-                Yes (Order 4)
-              </p>
-              </td>
+                  <p>
+                    Runge-Kutta Cash-Karp
+                  </p>
+                </td>
+<td>
+                  <p>
+                    stepper_rk5_ck
+                  </p>
+                </td>
+<td>
+                  <p>
+                    5
+                  </p>
+                </td>
+<td>
+                  <p>
+                    Yes (Order 4)
+                  </p>
+                </td>
 </tr>
 <tr>
 <td>
-              <p>
-                Runge-Kutta Fehlberg
-              </p>
-              </td>
-<td>
-              <p>
-                stepper_rk78_fehlberg
-              </p>
-              </td>
-<td>
-              <p>
-                7
-              </p>
-              </td>
-<td>
-              <p>
-                Yes (Order 8)
-              </p>
-              </td>
+                  <p>
+                    Runge-Kutta Fehlberg
+                  </p>
+                </td>
+<td>
+                  <p>
+                    stepper_rk78_fehlberg
+                  </p>
+                </td>
+<td>
+                  <p>
+                    7
+                  </p>
+                </td>
+<td>
+                  <p>
+                    Yes (Order 8)
+                  </p>
+                </td>
 </tr>
 <tr>
 <td>
-              <p>
-                Midpoint
-              </p>
-              </td>
-<td>
-              <p>
-                stepper_midpoint
-              </p>
-              </td>
-<td>
-              <p>
-                variable
-              </p>
-              </td>
-<td>
-              <p>
-                No
-              </p>
-              </td>
+                  <p>
+                    Midpoint
+                  </p>
+                </td>
+<td>
+                  <p>
+                    stepper_midpoint
+                  </p>
+                </td>
+<td>
+                  <p>
+                    variable
+                  </p>
+                </td>
+<td>
+                  <p>
+                    No
+                  </p>
+                </td>
 </tr>
 <tr>
 <td>
-              <p>
-                Bulirsch-Stoer
-              </p>
-              </td>
-<td>
-              <p>
-                controlled_stepper_bs
-              </p>
-              </td>
-<td>
-              <p>
-                variable
-              </p>
-              </td>
-<td>
-              <p>
-                Controlled
-              </p>
-              </td>
+                  <p>
+                    Bulirsch-Stoer
+                  </p>
+                </td>
+<td>
+                  <p>
+                    controlled_stepper_bs
+                  </p>
+                </td>
+<td>
+                  <p>
+                    variable
+                  </p>
+                </td>
+<td>
+                  <p>
+                    Controlled
+                  </p>
+                </td>
 </tr>
 </tbody>
 </table></div>
@@ -564,7 +557,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="short_example.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="stepper.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+<a accesskey="p" href="short_example.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="concepts.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

Modified: sandbox/odeint/libs/numeric/odeint/doc/html/index.html
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/html/index.html	(original)
+++ sandbox/odeint/libs/numeric/odeint/doc/html/index.html	2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
@@ -8,14 +8,7 @@
 <link rel="next" href="boost_numeric_odeint/short_example.html" title="Short Example">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../boost.png"></td>
-<td align="center">Home</td>
-<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
-<td align="center">More</td>
-</tr></table>
+<table cellpadding="2" width="100%"><tr><td valign="top"></td></tr></table>
 <hr>
 <div class="spirit-nav"><a accesskey="n" href="boost_numeric_odeint/short_example.html"><img src="../../doc/html/images/next.png" alt="Next"></a></div>
 <div class="chapter" lang="en">
@@ -30,7 +23,7 @@
 </h3></div></div>
 <div><p class="copyright">Copyright &#169; 2009 Karsten Ahnert and Mario Mulansky</p></div>
 <div><div class="legalnotice">
-<a name="id325394"></a><p>
+<a name="id358088"></a><p>
         Distributed under the Boost Software License, Version 1.0. (See accompanying
         file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       </p>
@@ -48,23 +41,20 @@
 <dt><span class="section">Solar system</span></dt>
 <dt><span class="section">References</span></dt>
 </dl></dd>
-<dt><span class="section">Stepper</span></dt>
+<dt><span class="section">Concepts</span></dt>
 <dd><dl>
-<dt><span class="section">Concepts</span></dt>
-<dt><span class="section"><a href="boost_numeric_odeint/stepper.html#boost_numeric_odeint.stepper.stepper_classes">Stepper
-      classes</a></span></dt>
+<dt><span class="section">Basic stepper</span></dt>
+<dt><span class="section">Error stepper</span></dt>
+<dt><span class="section"><a href="boost_numeric_odeint/concepts.html#boost_numeric_odeint.concepts.controlled_stepper">Controlled
+      stepper</a></span></dt>
 </dl></dd>
-<dt><span class="section"><a href="boost_numeric_odeint/integration_functions.html">Integration
-    functions</a></span></dt>
+<dt><span class="section">Reference</span></dt>
 <dd><dl>
-<dt><span class="section"><a href="boost_numeric_odeint/integration_functions.html#boost_numeric_odeint.integration_functions.constant_step_size_functions">Constant
-      step-size functions</a></span></dt>
-<dt><span class="section"><a href="boost_numeric_odeint/integration_functions.html#boost_numeric_odeint.integration_functions.adaptive_step_size_functions">Adaptive
-      step-size functions</a></span></dt>
+<dt><span class="section"><a href="boost_numeric_odeint/reference.html#boost_numeric_odeint.reference.stepper_classes">Stepper
+      classes</a></span></dt>
+<dt><span class="section"><a href="boost_numeric_odeint/reference.html#boost_numeric_odeint.reference.integration_functions">Integration
+      functions</a></span></dt>
 </dl></dd>
-<dt><span class="section">Container traits</span></dt>
-<dd><dl><dt><span class="section"><a href="boost_numeric_odeint/container_traits.html#boost_numeric_odeint.container_traits.define_your_own_traits">Define
-      your own traits</a></span></dt></dl></dd>
 </dl>
 </div>
 <div class="section" lang="en">
@@ -85,10 +75,8 @@
       for real life problems and serves just as illustrative example. In <span class="bold"><strong>odeint</strong></span>, the following algorithms are implemented:
     </p>
 <div class="table">
-<a name="boost_numeric_odeint.overview.stepper_algorithms"></a><p class="title"><b>Table&#160;1.1.&#160;Stepper
-    Algorithms</b></p>
-<div class="table-contents"><table class="table" summary="Stepper
-    Algorithms">
+<a name="boost_numeric_odeint.overview.stepper_algorithms"></a><p class="title"><b>Table&#160;1.1.&#160;Stepper Algorithms</b></p>
+<div class="table-contents"><table class="table" summary="Stepper Algorithms">
 <colgroup>
 <col>
 <col>
@@ -97,158 +85,158 @@
 </colgroup>
 <thead><tr>
 <th>
-          <p>
-            Method
-          </p>
-          </th>
+              <p>
+                Method
+              </p>
+            </th>
 <th>
-          <p>
-            Class
-          </p>
-          </th>
+              <p>
+                Class
+              </p>
+            </th>
 <th>
-          <p>
-            Order
-          </p>
-          </th>
+              <p>
+                Order
+              </p>
+            </th>
 <th>
-          <p>
-            Error Estimation
-          </p>
-          </th>
+              <p>
+                Error Estimation
+              </p>
+            </th>
 </tr></thead>
 <tbody>
 <tr>
 <td>
-          <p>
-            Euler
-          </p>
-          </td>
-<td>
-          <p>
-            stepper_euler
-          </p>
-          </td>
-<td>
-          <p>
-            1
-          </p>
-          </td>
-<td>
-          <p>
-            No
-          </p>
-          </td>
+              <p>
+                Euler
+              </p>
+            </td>
+<td>
+              <p>
+                stepper_euler
+              </p>
+            </td>
+<td>
+              <p>
+                1
+              </p>
+            </td>
+<td>
+              <p>
+                No
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-          <p>
-            Runge-Kutta 4
-          </p>
-          </td>
-<td>
-          <p>
-            stepper_rk4
-          </p>
-          </td>
-<td>
-          <p>
-            4
-          </p>
-          </td>
-<td>
-          <p>
-            No
-          </p>
-          </td>
+              <p>
+                Runge-Kutta 4
+              </p>
+            </td>
+<td>
+              <p>
+                stepper_rk4
+              </p>
+            </td>
+<td>
+              <p>
+                4
+              </p>
+            </td>
+<td>
+              <p>
+                No
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-          <p>
-            Runge-Kutta Cash-Karp
-          </p>
-          </td>
-<td>
-          <p>
-            stepper_rk5_ck
-          </p>
-          </td>
-<td>
-          <p>
-            5
-          </p>
-          </td>
-<td>
-          <p>
-            Yes (Order 4)
-          </p>
-          </td>
+              <p>
+                Runge-Kutta Cash-Karp
+              </p>
+            </td>
+<td>
+              <p>
+                stepper_rk5_ck
+              </p>
+            </td>
+<td>
+              <p>
+                5
+              </p>
+            </td>
+<td>
+              <p>
+                Yes (Order 4)
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-          <p>
-            Runge-Kutta Fehlberg
-          </p>
-          </td>
-<td>
-          <p>
-            stepper_rk78_fehlberg
-          </p>
-          </td>
-<td>
-          <p>
-            7
-          </p>
-          </td>
-<td>
-          <p>
-            Yes (Order 8)
-          </p>
-          </td>
+              <p>
+                Runge-Kutta Fehlberg
+              </p>
+            </td>
+<td>
+              <p>
+                stepper_rk78_fehlberg
+              </p>
+            </td>
+<td>
+              <p>
+                7
+              </p>
+            </td>
+<td>
+              <p>
+                Yes (Order 8)
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-          <p>
-            Midpoint
-          </p>
-          </td>
-<td>
-          <p>
-            stepper_midpoint
-          </p>
-          </td>
-<td>
-          <p>
-            variable
-          </p>
-          </td>
-<td>
-          <p>
-            No
-          </p>
-          </td>
+              <p>
+                Midpoint
+              </p>
+            </td>
+<td>
+              <p>
+                stepper_midpoint
+              </p>
+            </td>
+<td>
+              <p>
+                variable
+              </p>
+            </td>
+<td>
+              <p>
+                No
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-          <p>
-            Bulirsch-Stoer
-          </p>
-          </td>
-<td>
-          <p>
-            controlled_stepper_bs
-          </p>
-          </td>
-<td>
-          <p>
-            variable
-          </p>
-          </td>
-<td>
-          <p>
-            Controlled
-          </p>
-          </td>
+              <p>
+                Bulirsch-Stoer
+              </p>
+            </td>
+<td>
+              <p>
+                controlled_stepper_bs
+              </p>
+            </td>
+<td>
+              <p>
+                variable
+              </p>
+            </td>
+<td>
+              <p>
+                Controlled
+              </p>
+            </td>
 </tr>
 </tbody>
 </table></div>
@@ -257,7 +245,7 @@
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: May 18, 2010 at 08:09:50 GMT</small></p></td>
+<td align="left"><p><small>Last revised: July 05, 2010 at 13:27:18 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

Modified: sandbox/odeint/libs/numeric/odeint/doc/html/standalone_HTML.manifest
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/html/standalone_HTML.manifest	(original)
+++ sandbox/odeint/libs/numeric/odeint/doc/html/standalone_HTML.manifest	2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
@@ -1,6 +1,5 @@
 index.html
 boost_numeric_odeint/short_example.html
 boost_numeric_odeint/tutorial.html
-boost_numeric_odeint/stepper.html
-boost_numeric_odeint/integration_functions.html
-boost_numeric_odeint/container_traits.html
+boost_numeric_odeint/concepts.html
+boost_numeric_odeint/reference.html

Deleted: sandbox/odeint/libs/numeric/odeint/doc/integrate_functions.qbk
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/integrate_functions.qbk	2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
+++ (empty file)
@@ -1,11 +0,0 @@
-[section Integration functions]
-
-[section Constant step-size functions]
-
-[endsect]
-
-[section Adaptive step-size functions]
-
-[endsect]
-
-[endsect]

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 09:32:45 EDT (Mon, 05 Jul 2010)
@@ -41,10 +41,9 @@
 [endsect]
 
 [section Short Example]
+
 This section gives a quick introduction to the most important features of the 
-library using a number of instructive examples.
-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. Image, 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 
@@ -94,8 +93,7 @@
 
 [include tutorial.qbk]
 
-[include steppers.qbk]
+[include concepts.qbk]
 
-[include integrate_functions.qbk]
+[include reference.qbk]
 
-[include container_traits.qbk]

Added: sandbox/odeint/libs/numeric/odeint/doc/reference.qbk
==============================================================================
--- (empty file)
+++ sandbox/odeint/libs/numeric/odeint/doc/reference.qbk	2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
@@ -0,0 +1,25 @@
+[section Reference]
+
+
+[include steppers_reference.qbk]
+
+[include integrate_functions_reference.qbk]
+
+[/
+[include container_traits.qbk]
+]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[endsect]

Deleted: sandbox/odeint/libs/numeric/odeint/doc/steppers.qbk
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/steppers.qbk	2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
+++ (empty file)
@@ -1,366 +0,0 @@
-[section Stepper]
-
-
-[section Concepts]
-
-[section Dynamical system]
-
-The dynamical system represents the right hand side of the differential equation:
-
-[* x'(t) = f(x(t) , t)]
-
-In this odeint library the dynamical system is realized by a callable object, 
-e.g. a function pointer, a functor or an instance of an object with an 
-appropriate `()`-operator.
-The parameter structure has to be the following:
-
-`(const container_type &x, container_type &dxdt, const time_type t)`
-
-`x` is the current state of the system and `t` is the current time. 
-The result *x' = f(x,t)* is then returned in `dxdt`.
-See the tutorial for examples on how to define the dynamical system.
-
-[endsect]
-
-[section Basic stepper]
-
-Basic steppers execute one timestep of a specific order with a given stepsize. 
-They 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.
-
-[*Associated Types]
-[table
-    [[] [] [Description]]
-    [[Time] [Stepper::time_type] [Type of the time variable, e.g. `double`]]
-    [[Container] [Stepper::container_type] [Type of the system state, e.g. `vector<double>`]]
-    [[Value] [Stepper::value_type] [Value type of the state, e.g. `double`]]
-    [[Order Type] [Stepper::order_type] [Type of the order parameter, usually `unsigned short`]]
-]
-
-[*Methods]
-
-*`Stepper()` Constructor.
-
-*`Stepper( container_type &x )` Constructor that allocates internal memory to 
-store intermediate results of the same size as `x`.
-
-*`void do_step( DynamicalSystem &system ,
-      		   container_type &x ,
-		       time_type t ,
-		       time_type dt )`
-
-Executes one timestep with the given parameters:
-[table
-    [[Parameter] [Type] [Description]]
-    [[system] [DynamicalSystem] [Function (callable object) that computes the rhs of the ode]]
-    [[x] [container_type] [The current state of the system *x(t)*]]
-    [[t] [time_type] [The current time  *t*]]
-    [[dt] [time_type] [Length of the timestep to be executed]]
-]
-The result of this method is the (approximate) state of the system *x(t+dt)* and 
-is stored in the variable `x` (in-place).
-Note, that the time `t` is not automatically increased by this method.
-
-*`void do_step( DynamicalSystem &system ,
-		      container_type &x ,
-		      const container_type &dxdt ,
-		      time_type t ,
-		      time_type dt )`
-
-The same as above but with the additional parameter `dxdt` that represents the
-derivative [*x'(t) = f(x,t)] at the time *t*.
-
-*`void adjust_size( const container_type &x )`
-Adjusts the internal memory to store intermediate results of the same size as 
-`x`.
-This function /must/ be called whenever the system size changes during the 
-integration.
-
-*`order_type order_step()`
-Returns the order of the algorithm. If *n* is the order of a method, then the
-result of one iteration with the timestep *dt* is accurate up to *dt^n*. That 
-means the error made by the time discretization is of order *dt^(n+1)*.
-
-[*Stepper that model this concept]
-
-*`stepper_euler`
-*`stepper_rk4`
-*`stepper_rk78_fehlberg`
-
-[endsect]
-
-[section Error stepper]
-
-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
-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.
-
-[*Associated Types]
-
-Same as for /basic steppers/ above.
-
-[*Methods]
-
-*`Error_Stepper()` Constructor.
-
-*`Error_Stepper( container_type &x )` Constructor that allocates internal memory to 
-store intermediate results of the same size as `x`.
-
-*`void do_step( DynamicalSystem &system ,
-      		   container_type &x ,
-		       time_type t ,
-		       time_type dt  ,
-               container_type &xerr)`
-
-Executes one timestep with the given parameters:
-[table
-    [[Parameter] [Type] [Description]]
-    [[system] [DynamicalSystem] [Function (callable object) that computes the rhs of the ode]]
-    [[x] [container_type] [The current state of the system *x(t)*]]
-    [[t] [time_type] [The current time  *t*]]
-    [[dt] [time_type] [Length of the timestep to be executed]]
-    [[xerr] [container_type] [Used by the method to return the error estimation of this computation]]
-]
-The result of this method is the (approximate) state of the system *x(t+dt)*, 
-which is returned in the variable `x` (in-place), and the corresponding error 
-estimation returned in `xerr`.
-Note, that the time `t` is not automatically increased by this method.
-
-*`void do_step( DynamicalSystem &system ,
-		      container_type &x ,
-		      const container_type &dxdt ,
-		      time_type t ,
-		      time_type dt ,
-              container_type &xerr)`
-
-The same as above but with the additional parameter `dxdt` that represents the
-derivative [*x'(t) = f(x,t)] at the time *t*.
-
-*`void adjust_size( const container_type &x )`
-Adjusts the internal memory to store intermediate results of the same size as 
-`x`.
-This function /must/ be called whenever the system size changes during the 
-integration.
-
-*`order_type order_error_step()`
-Returns the order of the result *x(t+dt)* of the algorithm.
-
-*`order_type order_error()`
-Returns the order of the error estimation of the algorithm.
-
-[*Stepper that model this concept]
-
-*`stepper_rk5_ck`
-*`stepper_rk78_fehlberg`
-*`stepper_half_step`
-
-[endsect]
-
-[section Controlled stepper]
-
-Controlled steppers try to execute a timestep with a given error threshold.
-If the estimated error of the obtained solution is too big, the result is 
-rejected and a new stepsize is proposed.
-If the error is small enough the timestep is accepted and possibly an increased
-stepsize is proposed.
-
-[*Associated Types]
-
-Same as for /basic steppers/ above.
-
-[*Methods]
-
-*`Controlled_Stepper( time_type abs_err, time_type rel_err, 
-                      time_type factor_x, time_type factor_dxdt )`
-
-Constructor that initializes the controlled stepper with several parameters of
-the error control. The controlled stepper assures that the error done by each 
-individual timestep yields:
-
-[* xerr < 1.1 ( eps_abs + eps_rel * (factor_x |x| + factor_dxdt h |x'|) ) ]
-
-The factor 1.1 is for safety to avoid unnecessary many stepsize adjustings.
-The above inequality should be understand to hold for /all/ components of the
-possibly more dimensional vectors *x*, *x'* and *xerr*.
-If the estimated error is too large, a reduced stepsize will be suggested.
-If the estimated error is less than half of the desired error, an increased
-stepsize will be suggested.
-
-*`Controlled_Stepper( container_type &x, time_type abs_err, time_type rel_err, 
-                      time_type factor_x, time_type factor_dxdt )`
-Same as above, but with additional allocation of the internal memory to store 
-intermediate results of the same size as `x`.
-
-*`controlled_step_result try_step( 
-                DynamicalSystem &system, 
-                container_type &x, 
-                time_type &t, 
-                time_type &dt )`
-
-Tries one timestep with the given parameters
-[table
-    [[Parameter] [Type] [Description]]
-    [[system] [DynamicalSystem] [Function (callable object) that computes the rhs of the ode]]
-    [[x] [container_type] [The current state of the system *x(t)*]]
-    [[t] [time_type] [The current time  *t*]]
-    [[dt] [time_type] [Length of the timestep to be executed]]
-]
-This method has three possible outcomes represented by the returned value `result`:
-If `result = success` the step has been applied and x contains the new state 
-*x(t)* where the time has also been increased *t += dt*.
-If `result = step_size_increased` the step has also been accomplished, but the 
-estimated error was so small that a new stepsize is proposed in the variable 
-`dt`.
-If `result = step_size_decreased` the step has been rejected due to a too big 
-error. `x` and `t` remain unchanged and `dt` now containes the suggested reduced
-stepsize that should give an error below the desired level.
-
-*`controlled_step_result try_step( 
-                DynamicalSystem &system, 
-                container_type &x, 
-                const container_type &dxdt,
-                time_type &t, 
-                time_type &dt )`
-Same as above but with the additional parameter `dxdt` that that represents the
-derivative *x'(t) = f(x,t)* at the time *t*.
-
-*`void adjust_size( const container_type &x )`
-Adjusts the internal memory to store intermediate results of the same size as 
-`x`.
-This function /must/ be called whenever the system size changes during the 
-integration.
-
-*`order_type order_error_step()`
-Returns the order of the result *x(t+dt)* of the algorithm.
-
-[*Stepper that model this concept]
-
-*`controlled_stepper_standard`
-*`controlled_stepper_bs`
-
-[endsect]
-
-[endsect]
-
-
-[section Stepper classes]
-
-[table Stepper Algorithms
-  [[Method] [Class] [Order] [Error Estimation]]
-  [[Euler]  [stepper_euler] [1] [No]]
-  [[Runge-Kutta 4] [stepper_rk4] [4] [No]]
-  [[Runge-Kutta Cash-Karp] [stepper_rk5_ck] [5] [Yes (Order 4)]]
-  [[Runge-Kutta Fehlberg] [stepper_rk78_fehlberg] [7] [Yes (Order 8)]]
-  [[Midpoint] [stepper_midpoint] [variable] [No]]
-  [[Bulirsch-Stoer] [controlled_stepper_bs] [variable] [Controlled]]
-]
-
-[section stepper_euler]
-
-[*Concept:] [link boost_sandbox_numeric_odeint.stepper.concepts.basic_stepper Basic stepper]
-
-[*Accuracy:] The produced solution is accurate up to order 1.
-
-[*Complexity:] This method uses 1 function evaluation.
-
-[*Template Parameters:]
-[template tpl_parameter_table_[]
-[table
-    [[Parameter] [Default Value] [Description]]
-    [[class Container] [no default value] [Type of container that stores the state of the system]]
-    [[class Time] [double] [Type of the time variable in the ode]]
-    [[class Traits] [container_traits< Container >] [container_traits used by the stepper]]
-]]
-[tpl_parameter_table_]
-
-The Euler algorithm used in this class performs one integration
-step according to the formula:
-[: x(t+dt) = x(t) + dt*f(x,t)]
-The Euler stepper is the most simple algorithm to integrate a 
-differential equation. It's only purpose in this library is for educational 
-reasons - use more sophisticated steppers for real life problems.
-
-[endsect]
-
-[section stepper_rk4]
-
-[*Concept:] [link boost_sandbox_numeric_odeint.stepper.concepts.basic_stepper Basic stepper]
-
-[*Accuracy:] The produced solution is accurate up to order 4.
-
-[*Complexity:] This method uses 4 function evaluations.
-
-[*Template Parameters:]
-
-[tpl_parameter_table_]
-
-The Runge-Kutta 4 algorithm is /the/ classical method to integrate odes.
-The [@http://en.wikipedia.org/wiki/Runge%e2%80%93Kutta_methods#Explicit_Runge.E2.80.93Kutta_methods 
-Butcher Tableau] for this method is as follows:
-
-[pre
-Butcher Tableau for Runge-Kutta 4
-   0  |
-  1/2 | 1/2
-  1/2 |  0   1/2
-   1  |  0    0    1
-  ------------------------
-      | 1/6  1/3  1/3  1/6
-]
-This method produces fast, though not too accurate solutions. Use it for quick
-preliminary results and then switch to error controlled methods like Cash-Karp
-for more reliable calculations.
-
-[endsect]
-
-[section stepper_rk5_ck]
-
-[*Concept:] [link boost_sandbox_numeric_odeint.stepper.concepts.error_stepper Error stepper]
-
-[*Accuracy:] The produced solution is accurate up to order 5 and the estimated 
-error is also of order 5.
-
-[*Complexity:] This method uses 6 function evaluation.
-
-[*Template Parameters:]
-
-[tpl_parameter_table_]
-
-The Runge-Kutta method of order 5 with Cash-Karp coefficients is a good trade-off
-between numerical effort and obtained accuracy with error estimation.
-It is the all-round method and suitable for most problems.
-See [@http://en.wikipedia.org/wiki/Cash%e2%80%93Karp_method wikipedia] for details and 
-the Butcher tableau.
-
-[endsect]
-
-[section stepper_rk78_fehlberg]
-
-[*Concept:] [link boost_sandbox_numeric_odeint.stepper.concepts.error_stepper Error Stepper]
-
-[*Accuracy:] The produced solution is accurate up to order 7 and the estimated 
-error is of order 8.
-
-[*Complexity:] This method uses 13 function evaluations.
-
-[*Template Parameters:]
-
-[tpl_parameter_table_]
-
-The Runge-Kutta 78 Fehlberg method is a high-order algorithm that produces very
-good accuracy but for the cost of high numerical effort.
-Whenever extra-ordinarily high precision is required, you can fall back to this
-method.
-
-[endsect]
-
-[endsect]
-
-[endsect]

Added: sandbox/odeint/libs/numeric/odeint/doc/steppers_reference.qbk
==============================================================================
--- (empty file)
+++ sandbox/odeint/libs/numeric/odeint/doc/steppers_reference.qbk	2010-07-05 09:32:45 EDT (Mon, 05 Jul 2010)
@@ -0,0 +1,118 @@
+[section Stepper classes]
+
+[table Stepper Algorithms
+  [[Method] [Class] [Order] [Error Estimation]]
+  [[Euler]  [stepper_euler] [1] [No]]
+  [[Runge-Kutta 4] [stepper_rk4] [4] [No]]
+  [[Runge-Kutta Cash-Karp] [stepper_rk5_ck] [5] [Yes (Order 4)]]
+  [[Runge-Kutta Fehlberg] [stepper_rk78_fehlberg] [7] [Yes (Order 8)]]
+  [[Midpoint] [stepper_midpoint] [variable] [No]]
+  [[Bulirsch-Stoer] [controlled_stepper_bs] [variable] [Controlled]]
+]
+
+[/
+
+[section stepper_euler]
+
+[*Concept:] [link boost_sandbox_numeric_odeint.stepper.concepts.basic_stepper Basic stepper]
+
+[*Accuracy:] The produced solution is accurate up to order 1.
+
+[*Complexity:] This method uses 1 function evaluation.
+
+[*Template Parameters:]
+[template tpl_parameter_table_[]
+[table
+    [[Parameter] [Default Value] [Description]]
+    [[class Container] [no default value] [Type of container that stores the state of the system]]
+    [[class Time] [double] [Type of the time variable in the ode]]
+    [[class Traits] [container_traits< Container >] [container_traits used by the stepper]]
+]]
+[tpl_parameter_table_]
+
+The Euler algorithm used in this class performs one integration
+step according to the formula:
+[: x(t+dt) = x(t) + dt*f(x,t)]
+The Euler stepper is the most simple algorithm to integrate a 
+differential equation. It's only purpose in this library is for educational 
+reasons - use more sophisticated steppers for real life problems.
+
+[endsect]
+
+[section stepper_rk4]
+
+[*Concept:] [link boost_sandbox_numeric_odeint.stepper.concepts.basic_stepper Basic stepper]
+
+[*Accuracy:] The produced solution is accurate up to order 4.
+
+[*Complexity:] This method uses 4 function evaluations.
+
+[*Template Parameters:]
+
+[tpl_parameter_table_]
+
+The Runge-Kutta 4 algorithm is /the/ classical method to integrate odes.
+The [@http://en.wikipedia.org/wiki/Runge%e2%80%93Kutta_methods#Explicit_Runge.E2.80.93Kutta_methods 
+Butcher Tableau] for this method is as follows:
+
+[pre
+Butcher Tableau for Runge-Kutta 4
+   0  |
+  1/2 | 1/2
+  1/2 |  0   1/2
+   1  |  0    0    1
+  ------------------------
+      | 1/6  1/3  1/3  1/6
+]
+This method produces fast, though not too accurate solutions. Use it for quick
+preliminary results and then switch to error controlled methods like Cash-Karp
+for more reliable calculations.
+
+[endsect]
+
+[section stepper_rk5_ck]
+
+[*Concept:] [link boost_sandbox_numeric_odeint.stepper.concepts.error_stepper Error stepper]
+
+[*Accuracy:] The produced solution is accurate up to order 5 and the estimated 
+error is also of order 5.
+
+[*Complexity:] This method uses 6 function evaluation.
+
+[*Template Parameters:]
+
+[tpl_parameter_table_]
+
+The Runge-Kutta method of order 5 with Cash-Karp coefficients is a good trade-off
+between numerical effort and obtained accuracy with error estimation.
+It is the all-round method and suitable for most problems.
+See [@http://en.wikipedia.org/wiki/Cash%e2%80%93Karp_method wikipedia] for details and 
+the Butcher tableau.
+
+[endsect]
+
+[section stepper_rk78_fehlberg]
+
+[*Concept:] [link boost_sandbox_numeric_odeint.stepper.concepts.error_stepper Error Stepper]
+
+[*Accuracy:] The produced solution is accurate up to order 7 and the estimated 
+error is of order 8.
+
+[*Complexity:] This method uses 13 function evaluations.
+
+[*Template Parameters:]
+
+[tpl_parameter_table_]
+
+The Runge-Kutta 78 Fehlberg method is a high-order algorithm that produces very
+good accuracy but for the cost of high numerical effort.
+Whenever extra-ordinarily high precision is required, you can fall back to this
+method.
+
+[endsect]
+
+
+]
+
+[endsect]
+