Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r71914 - in sandbox/odeint/branches/karsten/libs/numeric/odeint/doc: . html html/boost_sandbox_numeric_odeint
From: karsten.ahnert_at_[hidden]
Date: 2011-05-13 06:21:58


Author: karsten
Date: 2011-05-13 06:21:57 EDT (Fri, 13 May 2011)
New Revision: 71914
URL: http://svn.boost.org/trac/boost/changeset/71914

Log:
chunk the first section
Removed:
   sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/getting_started.html
Text files modified:
   sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/Jamfile | 4
   sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/concepts.html | 450 ------------------
   sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/extend_odeint.html | 30
   sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/reference.html | 46 -
   sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/tutorial.html | 964 ---------------------------------------
   sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/index.html | 565 ++++++++++++++++++++++-
   sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/odeint.qbk | 3
   sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/reference.qbk | 1
   8 files changed, 575 insertions(+), 1488 deletions(-)

Modified: sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/Jamfile
==============================================================================
--- sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/Jamfile (original)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/Jamfile 2011-05-13 06:21:57 EDT (Fri, 13 May 2011)
@@ -18,8 +18,8 @@
         :
           <xsl:param>navig.graphics=1
           <xsl:param>boost.root=../../../..
- <xsl:param>chunk.section.depth=1
- <xsl:param>chunk.first.sections=1
+ <xsl:param>chunk.section.depth=2
+ <xsl:param>chunk.first.sections=0
           <xsl:param>toc.section.depth=2
           <xsl:param>toc.max.depth=2
           <xsl:param>generate.section.toc.level=3

Modified: sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/concepts.html
==============================================================================
--- sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/concepts.html (original)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/concepts.html 2011-05-13 06:21:57 EDT (Fri, 13 May 2011)
@@ -6,14 +6,14 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="../index.html" title="Chapter&#160;1.&#160;boost.sandbox.numeric.odeint">
 <link rel="up" href="../index.html" title="Chapter&#160;1.&#160;boost.sandbox.numeric.odeint">
-<link rel="prev" href="extend_odeint.html" title="Extend odeint">
-<link rel="next" href="reference.html" title="Reference">
+<link rel="prev" href="extend_odeint/adapt_your_own_operations.html" title="Adapt your own operations">
+<link rel="next" href="concepts/error_stepper.html" title="Error stepper">
 </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="extend_odeint.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="reference.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="extend_odeint/adapt_your_own_operations.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="concepts/error_stepper.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -22,15 +22,15 @@
 <div class="toc"><dl>
 <dt><span class="section"><a href="concepts.html#boost_sandbox_numeric_odeint.concepts.basic_stepper">Basic
       stepper</a></span></dt>
-<dt><span class="section"><a href="concepts.html#boost_sandbox_numeric_odeint.concepts.error_stepper">Error
+<dt><span class="section"><a href="concepts/error_stepper.html">Error
       stepper</a></span></dt>
-<dt><span class="section"><a href="concepts.html#boost_sandbox_numeric_odeint.concepts.controlled_stepper">Controlled
+<dt><span class="section"><a href="concepts/controlled_stepper.html">Controlled
       stepper</a></span></dt>
-<dt><span class="section"><a href="concepts.html#boost_sandbox_numeric_odeint.concepts.dense_ouput_stepper">Dense
+<dt><span class="section"><a href="concepts/dense_ouput_stepper.html">Dense
       ouput stepper</a></span></dt>
-<dt><span class="section"><a href="concepts.html#boost_sandbox_numeric_odeint.concepts.size_adjusting_stepper">Size
+<dt><span class="section"><a href="concepts/size_adjusting_stepper.html">Size
       adjusting stepper</a></span></dt>
-<dt><span class="section">CompositeStepper</span></dt>
+<dt><span class="section">CompositeStepper</span></dt>
 </dl></div>
 <p>
       The odeint library defines three concepts for stepping objects.
@@ -312,438 +312,6 @@
           </li>
 </ul></div>
 </div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.concepts.error_stepper"></a><a class="link" href="concepts.html#boost_sandbox_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. Like
- the basic steppers, error steppers usually allocate internal memory to store
- intermediate function call results. If state types with variable size are
- used (e.g. <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 class="itemizedlist" type="disc">
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">Error_Stepper</span><span class="special">()</span></code>
- Constructor.
- </li>
-<li class="listitem">
- <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 class="listitem">
- <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 class="itemizedlist" type="disc"><li class="listitem">
- <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 class="itemizedlist" type="disc">
-<li class="listitem">
- <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 class="listitem">
- <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 class="listitem">
- <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 class="itemizedlist" type="disc">
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">stepper_rk5_ck</span></code>
- </li>
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">stepper_rk78_fehlberg</span></code>
- </li>
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">stepper_half_step</span></code>
- </li>
-</ul></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.concepts.controlled_stepper"></a><a class="link" href="concepts.html#boost_sandbox_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 class="itemizedlist" type="disc"><li class="listitem">
- <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 class="itemizedlist" type="disc">
-<li class="listitem">
- <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 class="listitem">
- <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 class="itemizedlist" type="disc">
-<li class="listitem">
- <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 class="listitem">
- <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 class="listitem">
- <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 class="itemizedlist" type="disc">
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">controlled_stepper_standard</span></code>
- </li>
-<li class="listitem">
- <code class="computeroutput"><span class="identifier">controlled_stepper_bs</span></code>
- </li>
-</ul></div>
-</div>
-<div class="section"><div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.concepts.dense_ouput_stepper"></a><a class="link" href="concepts.html#boost_sandbox_numeric_odeint.concepts.dense_ouput_stepper" title="Dense ouput stepper">Dense
- ouput stepper</a>
-</h3></div></div></div></div>
-<div class="section"><div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.concepts.size_adjusting_stepper"></a><a class="link" href="concepts.html#boost_sandbox_numeric_odeint.concepts.size_adjusting_stepper" title="Size adjusting stepper">Size
- adjusting stepper</a>
-</h3></div></div></div></div>
-<div class="section"><div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.concepts.compositestepper"></a><a class="link" href="concepts.html#boost_sandbox_numeric_odeint.concepts.compositestepper" title="CompositeStepper">CompositeStepper</a>
-</h3></div></div></div></div>
 <p>
       see the wiki
     </p>
@@ -758,7 +326,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="extend_odeint.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="reference.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="extend_odeint/adapt_your_own_operations.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="concepts/error_stepper.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

Modified: sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/extend_odeint.html
==============================================================================
--- sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/extend_odeint.html (original)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/extend_odeint.html 2011-05-13 06:21:57 EDT (Fri, 13 May 2011)
@@ -6,14 +6,14 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="../index.html" title="Chapter&#160;1.&#160;boost.sandbox.numeric.odeint">
 <link rel="up" href="../index.html" title="Chapter&#160;1.&#160;boost.sandbox.numeric.odeint">
-<link rel="prev" href="tutorial.html" title="Tutorial">
-<link rel="next" href="concepts.html" title="Concepts">
+<link rel="prev" href="tutorial/references.html" title="References">
+<link rel="next" href="extend_odeint/adapt_your_own_containers.html" title="Adapt your own containers">
 </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="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="concepts.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="tutorial/references.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="extend_odeint/adapt_your_own_containers.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -22,33 +22,15 @@
 <div class="toc"><dl>
 <dt><span class="section"><a href="extend_odeint.html#boost_sandbox_numeric_odeint.extend_odeint.write_own_steppers">Write
       own steppers</a></span></dt>
-<dt><span class="section"><a href="extend_odeint.html#boost_sandbox_numeric_odeint.extend_odeint.adapt_your_own_containers">Adapt
+<dt><span class="section"><a href="extend_odeint/adapt_your_own_containers.html">Adapt
       your own containers</a></span></dt>
-<dt><span class="section"><a href="extend_odeint.html#boost_sandbox_numeric_odeint.extend_odeint.adapt_your_own_operations">Adapt
+<dt><span class="section"><a href="extend_odeint/adapt_your_own_operations.html">Adapt
       your own operations</a></span></dt>
 </dl></div>
 <div class="section"><div class="titlepage"><div><div><h3 class="title">
 <a name="boost_sandbox_numeric_odeint.extend_odeint.write_own_steppers"></a><a class="link" href="extend_odeint.html#boost_sandbox_numeric_odeint.extend_odeint.write_own_steppers" title="Write own steppers">Write
       own steppers</a>
 </h3></div></div></div></div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.extend_odeint.adapt_your_own_containers"></a><a class="link" href="extend_odeint.html#boost_sandbox_numeric_odeint.extend_odeint.adapt_your_own_containers" title="Adapt your own containers">Adapt
- your own containers</a>
-</h3></div></div></div>
-<p>
- gsl_vector, gsl_matrix, ublas::matrix, blitz::matrix, thrust
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.extend_odeint.adapt_your_own_operations"></a><a class="link" href="extend_odeint.html#boost_sandbox_numeric_odeint.extend_odeint.adapt_your_own_operations" title="Adapt your own operations">Adapt
- your own operations</a>
-</h3></div></div></div>
-<p>
- gsl_complex, complex, thrust
- </p>
-</div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
@@ -60,7 +42,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="tutorial.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="concepts.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="tutorial/references.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="extend_odeint/adapt_your_own_containers.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

Deleted: sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/getting_started.html
==============================================================================
--- sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/getting_started.html 2011-05-13 06:21:57 EDT (Fri, 13 May 2011)
+++ (empty file)
@@ -1,549 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Getting started</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;boost.sandbox.numeric.odeint">
-<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;boost.sandbox.numeric.odeint">
-<link rel="prev" href="../index.html" title="Chapter&#160;1.&#160;boost.sandbox.numeric.odeint">
-<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"></td></tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="tutorial.html"><img src="../images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_sandbox_numeric_odeint.getting_started"></a><a class="link" href="getting_started.html" title="Getting started">Getting started</a>
-</h2></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section">Overview</span></dt>
-<dt><span class="section"><a href="getting_started.html#boost_sandbox_numeric_odeint.getting_started.usage__compilation__headers">Usage,
- Compilation, Headers</a></span></dt>
-<dt><span class="section"><a href="getting_started.html#boost_sandbox_numeric_odeint.getting_started.short_example">Short
- Example</a></span></dt>
-</dl></div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.getting_started.overview"></a><a class="link" href="getting_started.html#boost_sandbox_numeric_odeint.getting_started.overview" title="Overview">Overview</a>
-</h3></div></div></div>
-<div class="caution"><table border="0" summary="Caution">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="../images/caution.png"></td>
-<th align="left">Caution</th>
-</tr>
-<tr><td align="left" valign="top"><p>
- Boost.Odeint is not an official boost library!
- </p></td></tr>
-</table></div>
-<p>
- Odeint is a library for solving initial value problems (IVP) of ordinary
- differential equations. Mathematically, these problems are formulated as
- follows: <span class="emphasis"><em>x'(t) = f(x,t)</em></span>, <span class="emphasis"><em>x(0) = x0</em></span>.
- <span class="emphasis"><em>x</em></span> and <span class="emphasis"><em>f</em></span> can be vectors and the
- solution is some function <span class="emphasis"><em>x(t)</em></span> fullfilling both equations
- above. In the following we will refer to <span class="emphasis"><em>x'(t)</em></span> also
- <code class="computeroutput"><span class="identifier">dxdt</span></code> which is also our notation
- for the derivative in the source code.
- </p>
-<p>
- Numerical approximations for the solution <span class="emphasis"><em>x(t)</em></span> are calculated
- iteratively. The easiest algorithm is the Euler-Scheme, where starting at
- <span class="emphasis"><em>x(0)</em></span> one finds <span class="emphasis"><em>x(dt) = x(0) + dt f(x(0),0)</em></span>.
- Now one can use <span class="emphasis"><em>x(dt)</em></span> and obtain <span class="emphasis"><em>x(2dt)</em></span>
- in a similar way and so on. The Euler method is of order 1, that means the
- error at each step is <span class="emphasis"><em>~ dt<sup>2</sup></em></span>. This is, of course, not
- very satisfying, which is why the Euler method is merely used for real life
- problems and serves just as illustrative example. In odeint, the following
- algorithms are implemented:
- </p>
-<div class="table">
-<a name="id532034"></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>
-<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>
-<th>
- <p>
- Dense Output
- </p>
- </th>
-<th>
- <p>
- Remarks
- </p>
- </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
- <p>
- Explicit Euler
- </p>
- </td>
-<td>
- <p>
- explicit_euler
- </p>
- </td>
-<td>
- <p>
- 1
- </p>
- </td>
-<td>
- <p>
- No
- </p>
- </td>
-<td>
- <p>
- Yes
- </p>
- </td>
-<td>
- <p>
- Very simple, only for demonstrating purposes
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- Runge-Kutta 4
- </p>
- </td>
-<td>
- <p>
- explicit_rkrk4
- </p>
- </td>
-<td>
- <p>
- 4
- </p>
- </td>
-<td>
- <p>
- No
- </p>
- </td>
-<td>
- <p>
- No
- </p>
- </td>
-<td>
- <p>
- Good default method
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- Runge-Kutta Cash-Karp
- </p>
- </td>
-<td>
- <p>
- explicit_error_rk54_ck
- </p>
- </td>
-<td>
- <p>
- 5
- </p>
- </td>
-<td>
- <p>
- Yes (Order 4)
- </p>
- </td>
-<td>
- <p>
- No
- </p>
- </td>
-<td>
- <p>
- ...
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- Dormand-Prince 5
- </p>
- </td>
-<td>
- <p>
- explicit_error_dopri5
- </p>
- </td>
-<td>
- <p>
- 5
- </p>
- </td>
-<td>
- <p>
- Yes (Order 4)
- </p>
- </td>
-<td>
- <p>
- Yes
- </p>
- </td>
-<td>
- <p>
- ...
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- Implicit Euler
- </p>
- </td>
-<td>
- <p>
- implicit_euler
- </p>
- </td>
-<td>
- <p>
- 1
- </p>
- </td>
-<td>
- <p>
- No
- </p>
- </td>
-<td>
- <p>
- No
- </p>
- </td>
-<td>
- <p>
- Needs the Jacobian
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- Rosenbrock 4
- </p>
- </td>
-<td>
- <p>
- rosenbrock4
- </p>
- </td>
-<td>
- <p>
- 4
- </p>
- </td>
-<td>
- <p>
- Yes
- </p>
- </td>
-<td>
- <p>
- Yes
- </p>
- </td>
-<td>
- <p>
- Good for stiff systems
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- Symplectic Euler
- </p>
- </td>
-<td>
- <p>
- symplectic_euler
- </p>
- </td>
-<td>
- <p>
- 1
- </p>
- </td>
-<td>
- <p>
- No
- </p>
- </td>
-<td>
- <p>
- No
- </p>
- </td>
-<td>
- <p>
- Symplectic solver for separable Hamiltonian system
- </p>
- </td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><p>
- Ordinary differential equations occur nearly everywhere in natural sciences.
- For example, the whole Newtonian mechanics are described by second order
- differential equations. Be sure, you will find them in every discipline.
- They also occur if partial differential equations (PDEs) are discretized
- in one coordinate. Then, a system of coupled ordinary differential occurs,
- sometimes also refered as lattices ODEs.
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.getting_started.usage__compilation__headers"></a><a class="link" href="getting_started.html#boost_sandbox_numeric_odeint.getting_started.usage__compilation__headers" title="Usage, Compilation, Headers">Usage,
- Compilation, Headers</a>
-</h3></div></div></div>
-<p>
- Odeint is completely header-only, meaning that you do not link against any
- library. It can be include by
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
-</pre>
-<p>
- which includes all headers in the library. All functions and classes from
- odeint live in the namespace
-</p>
-<pre class="programlisting"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">odeint</span><span class="special">;</span>
-</pre>
-<p>
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.getting_started.short_example"></a><a class="link" href="getting_started.html#boost_sandbox_numeric_odeint.getting_started.short_example" title="Short Example">Short
- Example</a>
-</h3></div></div></div>
-<p>
- Image, you want to numerically integrate a harmonic oscillator with friction.
- The equations of motion are given by <span class="emphasis"><em>x'' = -x + gamma x'</em></span>.
- This can be transformed to a system of two coupled first-order differential
- equations with new variables <span class="emphasis"><em>x</em></span> and <span class="emphasis"><em>p=x'</em></span>.
- To apply numerical integration one first has to design the right hand side
- of the equation <span class="emphasis"><em>w' = f(w)</em></span> where in this case <span class="emphasis"><em>w
- = (x,p)</em></span>:
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="comment">/* The type of container 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>
-
-<span class="comment">/* The rhs of x' = f(x) */</span>
-<span class="keyword">void</span> <span class="identifier">harmonic_oscillator</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
-<span class="special">{</span>
- <span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
- <span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">gam</span><span class="special">*</span><span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
-<span class="special">}</span>
-</pre>
-<p>
- </p>
-<p>
- Here we chose <code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span></code>
- as the state type, but others are also possible, for example <code class="computeroutput"><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span><span class="number">2</span><span class="special">&gt;</span></code>.
- Odeint is designed in such a way that you can easily use your own state types.
- Next, we define the ODE which is in this case a simple function. The parameter
- signature of this function is crucial: the integration methods will always
- call them in the form <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">dxdt</span><span class="special">,</span> <span class="identifier">t</span><span class="special">)</span></code>.
- So, even if there is no explicit time dependence, one has to define <code class="computeroutput"><span class="identifier">t</span></code> as a function parameter.
- </p>
-<p>
- Now, we have to define the initial state from which the integration should
- start:
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="identifier">state_type</span> <span class="identifier">x</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
-<span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="number">1.0</span><span class="special">;</span> <span class="comment">// start at x=1.0, p=0.0
-</span><span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
-</pre>
-<p>
- </p>
-<p>
- For the integration itself we'll use the <code class="computeroutput">integrate</code>
- function, which is a convenient way to get quick results. It is based on
- the error-controlled <code class="computeroutput">runge_kutta_rk5_ck</code>
- stepper (5th order) and uses adaptive stepsize.
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="identifier">size_t</span> <span class="identifier">steps</span> <span class="special">=</span> <span class="identifier">integrate</span><span class="special">(</span> <span class="identifier">harmonic_oscillator</span> <span class="special">,</span>
- <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.1</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<p>
- The integrate function expects as parameters the rhs of the ode as defined
- above, the initial state <code class="computeroutput"><span class="identifier">x</span></code>,
- the start-and end-time of the integration as well as the initial time step.
- Note, that <code class="computeroutput">integrate</code>
- uses an adaptive stepsize during the integration steps so the time points
- will not be equally spaced. The integration returns the number of steps that
- were applied.
- </p>
-<p>
- It is, of course, also possible to implement the ode system as a class. The
- rhs must then be implemented as a functor having defined the ()-operator:
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="comment">/* The rhs of x' = f(x) defined as a class */</span>
-<span class="keyword">class</span> <span class="identifier">harm_osc</span> <span class="special">{</span>
-
- <span class="keyword">double</span> <span class="identifier">m_gam</span><span class="special">;</span>
-
-<span class="keyword">public</span><span class="special">:</span>
- <span class="identifier">harm_osc</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">gam</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_gam</span><span class="special">(</span><span class="identifier">gam</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
-
- <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
- <span class="special">{</span>
- <span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
- <span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">m_gam</span><span class="special">*</span><span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
- <span class="special">}</span>
-<span class="special">};</span>
-</pre>
-<p>
- </p>
-<p>
- which can be used via
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="identifier">harm_osc</span> <span class="identifier">ho</span><span class="special">(</span><span class="number">0.15</span><span class="special">);</span>
-<span class="identifier">steps</span> <span class="special">=</span> <span class="identifier">integrate</span><span class="special">(</span> <span class="identifier">ho</span> <span class="special">,</span>
- <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.1</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<p>
- You surely have already noticed that during the integration a lot of steps
- have been done. You might wonder if you could access them do observe the
- solution during the iteration. Yes, you can do that. All you have to do is
- to provide a reasonable observer. An example is
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">push_back_state_and_time</span>
-<span class="special">{</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;&amp;</span> <span class="identifier">m_states</span><span class="special">;</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;&amp;</span> <span class="identifier">m_times</span><span class="special">;</span>
-
- <span class="identifier">push_back_state_and_time</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">states</span> <span class="special">,</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="special">&amp;</span><span class="identifier">times</span> <span class="special">)</span>
- <span class="special">:</span> <span class="identifier">m_states</span><span class="special">(</span> <span class="identifier">states</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_times</span><span class="special">(</span> <span class="identifier">times</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
-
- <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
- <span class="special">{</span>
- <span class="identifier">m_states</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">);</span>
- <span class="identifier">m_times</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span> <span class="identifier">t</span> <span class="special">);</span>
- <span class="special">}</span>
-<span class="special">};</span>
-</pre>
-<p>
- </p>
-<p>
- which stores the intermediate steps in a container. Now, you only have to
- pass this container to the integration function:
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">state_type</span><span class="special">&gt;</span> <span class="identifier">x_vec</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">times</span><span class="special">;</span>
-
-<span class="identifier">steps</span> <span class="special">=</span> <span class="identifier">integrate</span><span class="special">(</span> <span class="identifier">harmonic_oscillator</span> <span class="special">,</span>
- <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.1</span> <span class="special">,</span>
- <span class="identifier">push_back_state_and_time</span><span class="special">(</span> <span class="identifier">x_vec</span> <span class="special">,</span> <span class="identifier">times</span> <span class="special">)</span> <span class="special">);</span>
-
-<span class="comment">/* output */</span>
-<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span><span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;=</span><span class="identifier">steps</span><span class="special">;</span> <span class="identifier">i</span><span class="special">++</span> <span class="special">)</span>
-<span class="special">{</span>
- <span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">times</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="char">'\t'</span> <span class="special">&lt;&lt;</span> <span class="identifier">x_vec</span><span class="special">[</span><span class="identifier">i</span><span class="special">][</span><span class="number">0</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="char">'\t'</span> <span class="special">&lt;&lt;</span> <span class="identifier">x_vec</span><span class="special">[</span><span class="identifier">i</span><span class="special">][</span><span class="number">1</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="char">'\n'</span><span class="special">;</span>
-<span class="special">}</span>
-</pre>
-<p>
- </p>
-<p>
- That is all. Of course, you can use functional libraries like Boost.Lambda
- or Boost.Phoenix
- to ease the creation of observer functions.
- </p>
-<p>
- The full cpp file for this example can be found here: ../../examples/harmonic_oscillator.cpp
- </p>
-</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 -2011 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="../index.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="tutorial.html"><img src="../images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

Modified: sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/reference.html
==============================================================================
--- sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/reference.html (original)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/reference.html 2011-05-13 06:21:57 EDT (Fri, 13 May 2011)
@@ -6,13 +6,14 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="../index.html" title="Chapter&#160;1.&#160;boost.sandbox.numeric.odeint">
 <link rel="up" href="../index.html" title="Chapter&#160;1.&#160;boost.sandbox.numeric.odeint">
-<link rel="prev" href="concepts.html" title="Concepts">
+<link rel="prev" href="concepts/compositestepper.html" title="CompositeStepper">
+<link rel="next" href="reference/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"></td></tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="concepts.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a>
+<a accesskey="p" href="concepts/compositestepper.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="reference/integration_functions.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -21,11 +22,11 @@
 <div class="toc"><dl>
 <dt><span class="section"><a href="reference.html#boost_sandbox_numeric_odeint.reference.stepper_classes">Stepper
       classes</a></span></dt>
-<dt><span class="section"><a href="reference.html#boost_sandbox_numeric_odeint.reference.integration_functions">Integration
+<dt><span class="section"><a href="reference/integration_functions.html">Integration
       functions</a></span></dt>
-<dt><span class="section">Algebras</span></dt>
-<dt><span class="section">Operations</span></dt>
-<dt><span class="section">Resizing</span></dt>
+<dt><span class="section">Algebras</span></dt>
+<dt><span class="section">Operations</span></dt>
+<dt><span class="section">Resizing</span></dt>
 </dl></div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -33,7 +34,7 @@
       classes</a>
 </h3></div></div></div>
 <div class="table">
-<a name="id589875"></a><p class="title"><b>Table&#160;1.4.&#160;Stepper Algorithms</b></p>
+<a name="id589799"></a><p class="title"><b>Table&#160;1.4.&#160;Stepper Algorithms</b></p>
 <div class="table-contents"><table class="table" summary="Stepper Algorithms">
 <colgroup>
 <col>
@@ -201,35 +202,6 @@
 </div>
 <br class="table-break">
 </div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.reference.integration_functions"></a><a class="link" href="reference.html#boost_sandbox_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_sandbox_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_sandbox_numeric_odeint.reference.integration_functions.adaptive_step_size_functions">Adaptive
- step-size functions</a></span></dt>
-</dl></div>
-<div class="section"><div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.reference.integration_functions.constant_step_size_functions"></a><a class="link" href="reference.html#boost_sandbox_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"><div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.reference.integration_functions.adaptive_step_size_functions"></a><a class="link" href="reference.html#boost_sandbox_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 class="section"><div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.reference.algebras"></a><a class="link" href="reference.html#boost_sandbox_numeric_odeint.reference.algebras" title="Algebras">Algebras</a>
-</h3></div></div></div></div>
-<div class="section"><div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.reference.operations"></a><a class="link" href="reference.html#boost_sandbox_numeric_odeint.reference.operations" title="Operations">Operations</a>
-</h3></div></div></div></div>
-<div class="section"><div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.reference.resizing"></a><a class="link" href="reference.html#boost_sandbox_numeric_odeint.reference.resizing" title="Resizing">Resizing</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>
@@ -241,7 +213,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="concepts.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a>
+<a accesskey="p" href="concepts/compositestepper.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="reference/integration_functions.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

Modified: sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/tutorial.html
==============================================================================
--- sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/tutorial.html (original)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/boost_sandbox_numeric_odeint/tutorial.html 2011-05-13 06:21:57 EDT (Fri, 13 May 2011)
@@ -6,14 +6,14 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="../index.html" title="Chapter&#160;1.&#160;boost.sandbox.numeric.odeint">
 <link rel="up" href="../index.html" title="Chapter&#160;1.&#160;boost.sandbox.numeric.odeint">
-<link rel="prev" href="getting_started.html" title="Getting started">
-<link rel="next" href="extend_odeint.html" title="Extend odeint">
+<link rel="prev" href="../index.html" title="Chapter&#160;1.&#160;boost.sandbox.numeric.odeint">
+<link rel="next" href="tutorial/solar_system.html" title="Solar system">
 </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="getting_started.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="extend_odeint.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="../index.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="tutorial/solar_system.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -22,19 +22,19 @@
 <div class="toc"><dl>
 <dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.harmonic_oscillator">Harmonic
       oscillator</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.solar_system">Solar
+<dt><span class="section"><a href="tutorial/solar_system.html">Solar
       system</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.chaotic_systems_and_lyapunov_exponents">Chaotic
+<dt><span class="section"><a href="tutorial/chaotic_systems_and_lyapunov_exponents.html">Chaotic
       systems and Lyapunov exponents</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.stiff_systems">Stiff
+<dt><span class="section"><a href="tutorial/stiff_systems.html">Stiff
       systems</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.odeint_in_detail">Odeint
+<dt><span class="section"><a href="tutorial/odeint_in_detail.html">Odeint
       in detail</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics">Special
+<dt><span class="section"><a href="tutorial/special_topics.html">Special
       topics</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.all_examples">All
+<dt><span class="section"><a href="tutorial/all_examples.html">All
       examples</a></span></dt>
-<dt><span class="section">References</span></dt>
+<dt><span class="section">References</span></dt>
 </dl></div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -141,7 +141,7 @@
           choose:
         </p>
 <div class="table">
-<a name="id575784"></a><p class="title"><b>Table&#160;1.2.&#160;Stepper Algorithms</b></p>
+<a name="id575777"></a><p class="title"><b>Table&#160;1.2.&#160;Stepper Algorithms</b></p>
 <div class="table-contents"><table class="table" summary="Stepper Algorithms">
 <colgroup>
 <col>
@@ -535,946 +535,6 @@
         The full cpp file for this example can be found here: ../../examples/harmonic_oscillator.cpp
       </p>
 </div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.solar_system"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.solar_system" title="Solar system">Solar
- system</a>
-</h3></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.solar_system.gravitation_and_energy_conservation">Gravitation
- and energy conservation</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.solar_system.define_the_system_function">Define
- the system function</a></span></dt>
-</dl></div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.solar_system.gravitation_and_energy_conservation"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.solar_system.gravitation_and_energy_conservation" title="Gravitation and energy conservation">Gravitation
- and energy conservation</a>
-</h4></div></div></div>
-<p>
- The next example in this tutorial is a simulation of the outer solar system,
- consisting of the sun, Jupiter, Saturn, Uranus, Neptune and Pluto.
- </p>
-<p>
- <span class="inlinemediaobject"><img src="../solar_system.jpg" alt="solar_system"></span>
- </p>
-<p>
- Each planet and of course the sun will be represented by mass points. The
- interaction force between each object is the gravitational force which
- can be written as
- </p>
-<p>
- <span class="emphasis"><em>F<sub>&#8203;ij</sub> = -&#947; m<sub>&#8203;i</sub> m<sub>&#8203;j</sub> ( q<sub>&#8203;i</sub> - q<sub>&#8203;j</sub> ) / | q<sub>&#8203;i</sub> - q<sub>&#8203;j</sub> | <sup>3</sup></em></span>
- </p>
-<p>
- where <span class="emphasis"><em>&#947;</em></span> is the gravitational constant, <span class="emphasis"><em>m<sub>&#8203;i</sub></em></span>
- and <span class="emphasis"><em>m<sub>&#8203;j</sub></em></span> are the masses and <span class="emphasis"><em>q<sub>&#8203;i</sub></em></span>
- and <span class="emphasis"><em>q<sub>&#8203;j</sub></em></span> are the locations of the two objects. The equations
- of motion are then
- </p>
-<p>
- <span class="emphasis"><em>dq<sub>&#8203;i</sub> / dt = p<sub>&#8203;i</sub></em></span>
- </p>
-<p>
- <span class="emphasis"><em>dpboost_1_46_1.tar<sub>&#8203;i</sub> / dt = 1 / m<sub>&#8203;i</sub> &#931;<sub>&#8203;ji</sub> F<sub>&#8203;ij</sub></em></span>
- </p>
-<p>
- where <span class="emphasis"><em>p<sub>&#8203;i</sub></em></span> is the momenta of object <span class="emphasis"><em>i</em></span>.
- The equations of motion can also be derived from the Hamiltonian
- </p>
-<p>
- <span class="emphasis"><em>H = &#931;<sub>&#8203;i</sub> p<sub>&#8203;i</sub><sup>2</sup> / ( 2 m<sub>&#8203;i</sub> ) + &#931;<sub>&#8203;j</sub> V( q<sub>&#8203;i</sub> , q<sub>&#8203;j</sub> )</em></span>
- </p>
-<p>
- with the interaction potential <span class="emphasis"><em>V(q<sub>&#8203;i</sub>,q<sub>&#8203;j</sub>)</em></span>. The Hamiltonian
- equations give the equations of motion
- </p>
-<p>
- <span class="emphasis"><em>dq<sub>&#8203;i</sub> / dt = dH / dp<sub>&#8203;i</sub></em></span>
- </p>
-<p>
- <span class="emphasis"><em>dp<sub>&#8203;i</sub> = -dH / dq<sub>&#8203;i</sub></em></span>
- </p>
-<p>
- In time independent Hamiltonian system the energy and the phase space volume
- are conserved and special integration methods have to be applied in order
- to ensure these conservation laws. The odeint library provides classes
- for separable Hamiltonian systems, which can be written in the form <span class="emphasis"><em>H
- = &#931; p<sub>&#8203;i</sub><sup>2</sup> / (2m<sub>&#8203;i</sub>) + H<sub>&#8203;q</sub>(q)</em></span>, where <span class="emphasis"><em>H<sub>&#8203;q</sub>(q)</em></span> only
- depends on the coordinates. Alltough this functional form might look a
- bit arbitrary it covers nearly all classical mechanical systems with inertia
- and without dissipation, or where the equations of motion can be written
- in the form <span class="emphasis"><em>dq<sub>&#8203;i</sub> / dt = p<sub>&#8203;i</sub></em></span> / m<sub>&#8203;i</sub> , <span class="emphasis"><em>dp<sub>&#8203;i</sub> / dt =
- f( q<sub>&#8203;i</sub> )</em></span>.
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.solar_system.define_the_system_function"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.solar_system.define_the_system_function" title="Define the system function">Define
- the system function</a>
-</h4></div></div></div>
-<p>
- To implement this system we define a point type which will represent the
- space as well as the velocity. Therefore, we use the operators from Boost.Operators:
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="comment">/*the point type */</span>
-<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">T</span> <span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">Dim</span> <span class="special">&gt;</span>
-<span class="keyword">class</span> <span class="identifier">point</span> <span class="special">:</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">additive1</span><span class="special">&lt;</span> <span class="identifier">point</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">,</span> <span class="identifier">Dim</span> <span class="special">&gt;</span> <span class="special">,</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">additive2</span><span class="special">&lt;</span> <span class="identifier">point</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">,</span> <span class="identifier">Dim</span> <span class="special">&gt;</span> <span class="special">,</span> <span class="identifier">T</span> <span class="special">,</span>
-<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiplicative2</span><span class="special">&lt;</span> <span class="identifier">point</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">,</span> <span class="identifier">Dim</span> <span class="special">&gt;</span> <span class="special">,</span> <span class="identifier">T</span>
-<span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span>
-<span class="special">{</span>
-<span class="keyword">public</span><span class="special">:</span>
-
- <span class="keyword">const</span> <span class="keyword">static</span> <span class="identifier">size_t</span> <span class="identifier">dim</span> <span class="special">=</span> <span class="identifier">Dim</span><span class="special">;</span>
- <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">value_type</span><span class="special">;</span>
- <span class="keyword">typedef</span> <span class="identifier">point</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">,</span> <span class="identifier">dim</span> <span class="special">&gt;</span> <span class="identifier">point_type</span><span class="special">;</span>
-
- <span class="comment">// ...
-</span> <span class="comment">// constructors
-</span>
- <span class="comment">// ...
-</span> <span class="comment">// operators
-</span>
-<span class="keyword">private</span><span class="special">:</span>
-
- <span class="identifier">T</span> <span class="identifier">m_val</span><span class="special">[</span><span class="identifier">dim</span><span class="special">];</span>
-<span class="special">};</span>
-
-<span class="comment">//...
-</span><span class="comment">// more operators
-</span></pre>
-<p>
- </p>
-<p>
- The next step is to define a container type storing the values of <span class="emphasis"><em>q</em></span>
- and <span class="emphasis"><em>p</em></span> and to define system functions. As container
- type we use <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">array</span></code>
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="comment">// we simulate 5 planets and the sun
-</span><span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="number">6</span><span class="special">;</span>
-
-<span class="keyword">typedef</span> <span class="identifier">point</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="number">3</span> <span class="special">&gt;</span> <span class="identifier">point_type</span><span class="special">;</span>
-<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="identifier">point_type</span> <span class="special">,</span> <span class="identifier">n</span> <span class="special">&gt;</span> <span class="identifier">container_type</span><span class="special">;</span>
-<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">n</span> <span class="special">&gt;</span> <span class="identifier">mass_type</span><span class="special">;</span>
-</pre>
-<p>
- </p>
-<p>
- The <code class="computeroutput"><span class="identifier">container_type</span></code> is different
- from the state type of the ODE. The state type of the ode is simply a
- <code class="computeroutput"><span class="identifier">pair</span><span class="special">&lt;</span>
- <span class="identifier">container_type</span> <span class="special">,</span>
- <span class="identifier">container_type</span> <span class="special">&gt;</span></code>
- since it needs the informations about the coordinates and the momenta.
- </p>
-<p>
- As system function we have to provide <span class="emphasis"><em>f(p)</em></span> and <span class="emphasis"><em>f(q)</em></span>:
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">gravitational_constant</span> <span class="special">=</span> <span class="number">2.95912208286e-4</span><span class="special">;</span>
-
-<span class="keyword">struct</span> <span class="identifier">solar_system_coor</span>
-<span class="special">{</span>
- <span class="keyword">const</span> <span class="identifier">mass_type</span> <span class="special">&amp;</span><span class="identifier">m_masses</span><span class="special">;</span>
-
- <span class="identifier">solar_system_coor</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">mass_type</span> <span class="special">&amp;</span><span class="identifier">masses</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_masses</span><span class="special">(</span> <span class="identifier">masses</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
-
- <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">p</span> <span class="special">,</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">dqdt</span> <span class="special">)</span> <span class="keyword">const</span>
- <span class="special">{</span>
- <span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">n</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
- <span class="identifier">dqdt</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">p</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">/</span> <span class="identifier">m_masses</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
- <span class="special">}</span>
-<span class="special">};</span>
-</pre>
-<p>
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">solar_system_momentum</span>
-<span class="special">{</span>
- <span class="keyword">const</span> <span class="identifier">mass_type</span> <span class="special">&amp;</span><span class="identifier">m_masses</span><span class="special">;</span>
-
- <span class="identifier">solar_system_momentum</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">mass_type</span> <span class="special">&amp;</span><span class="identifier">masses</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_masses</span><span class="special">(</span> <span class="identifier">masses</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
-
- <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">q</span> <span class="special">,</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">dpdt</span> <span class="special">)</span> <span class="keyword">const</span>
- <span class="special">{</span>
- <span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
- <span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">n</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
- <span class="special">{</span>
- <span class="identifier">dpdt</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
- <span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">j</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">j</span><span class="special">&lt;</span><span class="identifier">i</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">j</span> <span class="special">)</span>
- <span class="special">{</span>
- <span class="identifier">point_type</span> <span class="identifier">diff</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">j</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
- <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">abs</span><span class="special">(</span> <span class="identifier">diff</span> <span class="special">);</span>
- <span class="identifier">diff</span> <span class="special">*=</span> <span class="special">(</span> <span class="identifier">gravitational_constant</span> <span class="special">*</span> <span class="identifier">m_masses</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">m_masses</span><span class="special">[</span><span class="identifier">j</span><span class="special">]</span> <span class="special">/</span> <span class="identifier">d</span> <span class="special">/</span> <span class="identifier">d</span> <span class="special">/</span> <span class="identifier">d</span> <span class="special">);</span>
- <span class="identifier">dpdt</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">+=</span> <span class="identifier">diff</span><span class="special">;</span>
- <span class="identifier">dpdt</span><span class="special">[</span><span class="identifier">j</span><span class="special">]</span> <span class="special">-=</span> <span class="identifier">diff</span><span class="special">;</span>
-
- <span class="special">}</span>
- <span class="special">}</span>
- <span class="special">}</span>
-<span class="special">};</span>
-</pre>
-<p>
- </p>
-<p>
- In general a three body-system is chaotic, hence we can not expect that
- arbitray initial conditions of the system will lead to a dynamic which
- is comparable with the solar system. That is we have to define proper initial
- conditions, which are taken from the book of Hairer, Wannier, Lubich.
- </p>
-<p>
- As mentioned above, we need to use some special integrators in order to
- conserve phase space volume and energy. There is a well known family of
- such integrators, the so-called Runge-Kutta-Nystroem solvers, which we
- apply here:
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">symplectic_rkn_sb3a_mclachlan</span><span class="special">&lt;</span> <span class="identifier">container_type</span> <span class="special">&gt;</span> <span class="identifier">stepper_type</span><span class="special">;</span>
-<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">dt</span> <span class="special">=</span> <span class="number">100.0</span><span class="special">;</span>
-
-<span class="identifier">integrate_const</span><span class="special">(</span>
- <span class="identifier">stepper_type</span><span class="special">()</span> <span class="special">,</span>
- <span class="identifier">make_pair</span><span class="special">(</span> <span class="identifier">solar_system_coor</span><span class="special">(</span> <span class="identifier">masses</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">solar_system_momentum</span><span class="special">(</span> <span class="identifier">masses</span> <span class="special">)</span> <span class="special">)</span> <span class="special">,</span>
- <span class="identifier">make_pair</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span><span class="special">(</span> <span class="identifier">q</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span><span class="special">(</span> <span class="identifier">p</span> <span class="special">)</span> <span class="special">)</span> <span class="special">,</span>
- <span class="number">0.0</span> <span class="special">,</span> <span class="number">200000.0</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">,</span> <span class="identifier">streaming_observer</span><span class="special">(</span> <span class="identifier">cout</span> <span class="special">)</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<p>
- These integration routine was used to produce the above sketch of the solar
- system. Note, that there are two particularities in this example. First,
- the state of the symplectic stepper is not <code class="computeroutput"><span class="identifier">container_type</span></code>
- but a pair of <code class="computeroutput"><span class="identifier">container_type</span></code>.
- Hence, we must pass such a pair to the integrate function. Since, we want
- to pass them as references we can simply pack them into boost::ref. The second point is the
- observer, which is called with a state type, hence a pair of <code class="computeroutput"><span class="identifier">container_type</span></code>. The reference wrapper
- is also passed, but this is not a problem at all:
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">streaming_observer</span>
-<span class="special">{</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="identifier">m_out</span><span class="special">;</span>
-
- <span class="identifier">streaming_observer</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span> <span class="special">&amp;</span><span class="identifier">out</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_out</span><span class="special">(</span> <span class="identifier">out</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
-
- <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">&gt;</span>
- <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
- <span class="special">{</span>
- <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">q</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">first</span><span class="special">;</span>
- <span class="identifier">m_out</span> <span class="special">&lt;&lt;</span> <span class="identifier">t</span><span class="special">;</span>
- <span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">q</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span> <span class="identifier">m_out</span> <span class="special">&lt;&lt;</span> <span class="string">"\t"</span> <span class="special">&lt;&lt;</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
- <span class="identifier">m_out</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">};</span>
-</pre>
-<p>
- </p>
-<p>
- The full example can be found here: ../../examples/solar_system.cpp
- </p>
-</div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.chaotic_systems_and_lyapunov_exponents"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.chaotic_systems_and_lyapunov_exponents" title="Chaotic systems and Lyapunov exponents">Chaotic
- systems and Lyapunov exponents</a>
-</h3></div></div></div>
-<p>
- Odeint can easily be used to investigate the properties of chaotic deterministic
- systems. In mathematical terms chaotic refers to an exponential growth of
- perturbations. In order to observe this exponential growth one usually solves
- the equations for the tangential dynamics which is again an ordinary differential
- equation. These equations are linear but time dependent and can be obtained
- via
- </p>
-<p>
- <span class="emphasis"><em>d &#948; x / dt = J(x) &#948; x</em></span>
- </p>
-<p>
- where <span class="emphasis"><em>J</em></span> is the Jacobian of the system under consideration.
- <span class="emphasis"><em>&#948; x</em></span> cam also be interpreted as a perturbation of the original
- system. In principle <span class="emphasis"><em>n</em></span> of these perturbations exit,
- they form a hypercube and evolve in the time. The Lyapunov exponents are
- then defined as logarithmic growth rates of the perturbations. If one Lyapunov
- exponent is larger then zero nearby trajectories divergy exponentially hence
- they are chaotic. If the largest Lyapunov exponent is zero one is usually
- faced with periodic motion. In the case of a largest Lyapunov exponent smaller
- then zero the converges the a fixed point. More informations about Lyapunov
- exponents and nonlinear dynamical systems can be found in many textbooks,
- see for example .
- </p>
-<p>
- To calculate the Lyapunov exponents numerically one usually solves the equations
- of motion for <span class="emphasis"><em>n</em></span> perturbations und orthonormalized them
- every <span class="emphasis"><em>k</em></span> steps. The Lyapunov exponent is the average
- the logarithm of the stretching factor of each perturbation.
- </p>
-<p>
- To demonstrate how one can use odeint to determine the Lyapunov exponents
- we choose the Lorenz system. It is one of the most studied dynamical systems
- in the nonlinear dynamics community. For the standard parameters is possesses
- a strange attractor with non-integer dimension. The Lyapunov exponents take
- values of approximately 0.9, 0 and -12.
- </p>
-<p>
- The implementation of the Lorenz system is
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">sigma</span> <span class="special">=</span> <span class="number">10.0</span><span class="special">;</span>
-<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">R</span> <span class="special">=</span> <span class="number">28.0</span><span class="special">;</span>
-<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">8.0</span> <span class="special">/</span> <span class="number">3.0</span><span class="special">;</span>
-
-<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="number">3</span> <span class="special">&gt;</span> <span class="identifier">lorenz_state_type</span><span class="special">;</span>
-
-<span class="keyword">void</span> <span class="identifier">lorenz</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">lorenz_state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">lorenz_state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
-<span class="special">{</span>
- <span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">sigma</span> <span class="special">*</span> <span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">);</span>
- <span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">R</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">];</span>
- <span class="identifier">dxdt</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">b</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
-<span class="special">}</span>
-</pre>
-<p>
- We need also need to integrate the set of the perturbations. This is done
- in parallel to the original system, hence within one system function. Of
- course, we want to use the above defintion of the Lorenz system, hence the
- definition of the system function including the Lorenz system itself and
- the perturbation could look like:
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>
-<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">num_of_lyap</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>
-<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">=</span> <span class="identifier">n</span> <span class="special">+</span> <span class="identifier">n</span><span class="special">*</span><span class="identifier">num_of_lyap</span><span class="special">;</span>
-
-<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">N</span> <span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
-<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">num_of_lyap</span> <span class="special">&gt;</span> <span class="identifier">lyap_type</span><span class="special">;</span>
-
-<span class="keyword">void</span> <span class="identifier">lorenz_with_lyap</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
-<span class="special">{</span>
- <span class="identifier">lorenz</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">);</span>
-
- <span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">l</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">l</span><span class="special">&lt;</span><span class="identifier">num_of_lyap</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">l</span> <span class="special">)</span>
- <span class="special">{</span>
- <span class="keyword">const</span> <span class="keyword">double</span> <span class="special">*</span><span class="identifier">pert</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="number">3</span> <span class="special">+</span> <span class="identifier">l</span> <span class="special">*</span> <span class="number">3</span><span class="special">;</span>
- <span class="keyword">double</span> <span class="special">*</span><span class="identifier">dpert</span> <span class="special">=</span> <span class="identifier">dxdt</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="number">3</span> <span class="special">+</span> <span class="identifier">l</span> <span class="special">*</span> <span class="number">3</span><span class="special">;</span>
- <span class="identifier">dpert</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span> <span class="identifier">sigma</span> <span class="special">*</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">+</span> <span class="number">10.0</span> <span class="special">*</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
- <span class="identifier">dpert</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">R</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">)</span> <span class="special">*</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">2</span><span class=
"special">];</span>
- <span class="identifier">dpert</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">b</span> <span class="special">*</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">2</span><span class="special">];</span>
- <span class="special">}</span>
-<span class="special">}</span>
-</pre>
-<p>
- </p>
-<p>
- The perturbations are stored linearly in the <code class="computeroutput"><span class="identifier">state_type</span></code>
- behind the state of the Lorenz system. The problem that lorenz() and lorenz_with_lyap() have different
- state types. A simple trick to over come this problem is put the Lorenz system
- inside a functor with templatized arguments:
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">lorenz</span>
-<span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">StateIn</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">StateOut</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Value</span> <span class="special">&gt;</span>
- <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">StateIn</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">StateOut</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">Value</span> <span class="identifier">t</span> <span class="special">)</span>
- <span class="special">{</span>
- <span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">sigma</span> <span class="special">*</span> <span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">);</span>
- <span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">R</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">];</span>
- <span class="identifier">dxdt</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">b</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
- <span class="special">}</span>
-<span class="special">};</span>
-
-<span class="keyword">void</span> <span class="identifier">lorenz_with_lyap</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
-<span class="special">{</span>
- <span class="identifier">lorenz</span><span class="special">()(</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">);</span>
- <span class="special">...</span>
-<span class="special">}</span>
-
-</pre>
-<p>
- This works fine and <code class="computeroutput"><span class="identifier">lorenz_with_lyap</span></code>
- can be used for example via
-</p>
-<pre class="programlisting"><span class="identifier">state_type</span> <span class="identifier">x</span><span class="special">;</span>
-<span class="comment">// initialize x
-</span><span class="identifier">explicit_rk4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="identifier">rk4</span><span class="special">;</span>
-<span class="identifier">integrate_n_steps</span><span class="special">(</span> <span class="identifier">rk4</span> <span class="special">,</span> <span class="identifier">lorenz_with_lyap</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">,</span> <span class="number">1000</span> <span class="special">);</span>
-</pre>
-<p>
- This code snippet performs 1000 steps with constant step size 0.01.
- </p>
-<p>
- A real world use case for the calculation of the Lyapunov exponents of Lorenz
- system would always include some transient steps, just to ensure that the
- current state lies on the attractor, hence it would look like
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="identifier">state_type</span> <span class="identifier">x</span><span class="special">;</span>
-<span class="comment">// initialize x
-</span><span class="identifier">explicit_rk4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="identifier">rk4</span><span class="special">;</span>
-<span class="identifier">integrate_n_steps</span><span class="special">(</span> <span class="identifier">rk4</span> <span class="special">,</span> <span class="identifier">lorenz</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">,</span> <span class="number">1000</span> <span class="special">);</span>
-</pre>
-<p>
- The problem is now, that <code class="computeroutput"><span class="identifier">x</span></code>
- is the full state containing also the perturbations and <code class="computeroutput"><span class="identifier">integrate_n_steps</span></code>
- does not know that it should only use 3 element. In detail, odeint and its
- steppers determine the length of the system under consideration be determing
- the length of the state. In the classical solvers from the problem was solved
- by pointer to the state and an appropriate length, something similar to
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">lorenz</span><span class="special">(</span> <span class="keyword">double</span><span class="special">*</span> <span class="identifier">x</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">*</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">params</span> <span class="special">)</span>
-<span class="special">{</span>
- <span class="special">...</span>
-<span class="special">}</span>
-
-<span class="keyword">int</span> <span class="identifier">system_length</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>
-<span class="identifier">rk4</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">system_length</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">,</span> <span class="identifier">lorenz</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<p>
- But odeint supports a similar and much more sophisticated concept: Boost.Range. To make the steppers and
- the system ready to work with Boost.Range the system has to by changed:
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">lorenz</span>
-<span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Deriv</span> <span class="special">&gt;</span>
- <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x_</span> <span class="special">,</span> <span class="identifier">Deriv</span> <span class="special">&amp;</span><span class="identifier">dxdt_</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
- <span class="special">{</span>
- <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">x_</span> <span class="special">);</span>
- <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">Deriv</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">dxdt</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">dxdt_</span> <span class="special">);</span>
-
- <span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">sigma</span> <span class="special">*</span> <span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">);</span>
- <span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">R</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">];</span>
- <span class="identifier">dxdt</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">b</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
- <span class="special">}</span>
-<span class="special">};</span>
-</pre>
-<p>
- </p>
-<p>
- This is in principle all. Now, we only have to call <code class="computeroutput"><span class="identifier">integrate_n_steps</span></code>
- with an suited range:
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="comment">// perform 10000 transient steps
-</span><span class="identifier">integrate_n_steps</span><span class="special">(</span> <span class="identifier">rk4</span> <span class="special">,</span> <span class="identifier">lorenz</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">make_pair</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">n</span> <span class="special">)</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">,</span> <span class="number">10000</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<p>
- Having integrated a sufficient number of transients steps we are now able
- to calculate the Lyapunov exponents:
- </p>
-<div class="orderedlist"><ol class="orderedlist" type="1">
-<li class="listitem">
- We initialize the perturbations. They are stored linearly behind the
- state of the Lorenz system. The perturbation are initialized such that
- they fullfill <span class="emphasis"><em>&lt; p <sub>&#8203;i</sub> , p<sub>&#8203;j</sub> &gt; = &#948; <sub>&#8203;ij</sub> </em></span> where <span class="emphasis"><em>&lt;,&gt;</em></span>
- is the classical scalar product and <span class="emphasis"><em>&#948; <sub>&#8203;ij</sub></em></span> is the Kronecker
- symbol.
- </li>
-<li class="listitem">
- Integrate 100 steps of the full system with perturbations
- </li>
-<li class="listitem">
- Orthonormalize the perturbation using Gram-Schmidt orthonormalization
- algorithm.
- </li>
-<li class="listitem">
- Repeat step 2 and 3. Every 10000 steps write the current Lyapunov exponent.
- </li>
-</ol></div>
-<p>
-
-</p>
-<pre class="programlisting"><span class="identifier">fill</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()+</span><span class="identifier">n</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">);</span>
-<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">num_of_lyap</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">+</span><span class="identifier">n</span><span class="special">*</span><span class="identifier">i</span><span class="special">+</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="number">1.0</span><span class="special">;</span>
-<span class="identifier">fill</span><span class="special">(</span> <span class="identifier">lyap</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">lyap</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">);</span>
-
-<span class="keyword">double</span> <span class="identifier">t</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
-<span class="identifier">size_t</span> <span class="identifier">count</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
-<span class="keyword">while</span><span class="special">(</span> <span class="keyword">true</span> <span class="special">)</span>
-<span class="special">{</span>
- <span class="identifier">t</span> <span class="special">=</span> <span class="identifier">integrate_n_steps</span><span class="special">(</span> <span class="identifier">rk4</span> <span class="special">,</span> <span class="identifier">lorenz_with_lyap</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">,</span> <span class="number">100</span> <span class="special">);</span>
- <span class="identifier">gram_schmidt</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">lyap</span> <span class="special">,</span> <span class="identifier">n</span> <span class="special">,</span> <span class="identifier">num_of_lyap</span> <span class="special">);</span>
- <span class="special">++</span><span class="identifier">count</span><span class="special">;</span>
-
- <span class="keyword">if</span><span class="special">(</span> <span class="special">!(</span><span class="identifier">count</span> <span class="special">%</span> <span class="number">100000</span><span class="special">)</span> <span class="special">)</span>
- <span class="special">{</span>
- <span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">t</span><span class="special">;</span>
- <span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">num_of_lyap</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span> <span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\t"</span> <span class="special">&lt;&lt;</span> <span class="identifier">lyap</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">/</span> <span class="identifier">t</span> <span class="special">;</span>
- <span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">}</span>
-</pre>
-<p>
- </p>
-<p>
- The full code can be found here: ../../examples/chaotic_system.cpp
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.stiff_systems"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.stiff_systems" title="Stiff systems">Stiff
- systems</a>
-</h3></div></div></div>
-<p>
- An important class of ordinary differential equations are so called stiff
- system which are characterized by two or more time scales of different order.
- </p>
-<p>
- what are stiff systems?
- </p>
-<p>
- examples
- </p>
-<p>
- applications
- </p>
-<p>
- To solve stiff systems numerically the Jacobian
- </p>
-<p>
- <span class="emphasis"><em>J = d f<sub>&#8203;i</sub> / d x<sub>&#8203;j</sub></em></span>
- </p>
-<p>
- is needed. Here is the definition of the above example
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">ublas</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">vector_type</span><span class="special">;</span>
-<span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">ublas</span><span class="special">::</span><span class="identifier">matrix</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">matrix_type</span><span class="special">;</span>
-
-<span class="keyword">struct</span> <span class="identifier">stiff_system</span>
-<span class="special">{</span>
- <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">vector_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">vector_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
- <span class="special">{</span>
- <span class="identifier">dxdt</span><span class="special">[</span> <span class="number">0</span> <span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="number">101.0</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span> <span class="number">0</span> <span class="special">]</span> <span class="special">-</span> <span class="number">100.0</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span> <span class="number">1</span> <span class="special">];</span>
- <span class="identifier">dxdt</span><span class="special">[</span> <span class="number">1</span> <span class="special">]</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">[</span> <span class="number">0</span> <span class="special">];</span>
- <span class="special">}</span>
-<span class="special">};</span>
-
-<span class="keyword">struct</span> <span class="identifier">stiff_system_jacobi</span>
-<span class="special">{</span>
- <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">vector_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">matrix_type</span> <span class="special">&amp;</span><span class="identifier">J</span> <span class="special">,</span> <span class="keyword">const</span> <span class="keyword">double</span> <span class="special">&amp;</span><span class="identifier">t</span> <span class="special">,</span> <span class="identifier">vector_type</span> <span class="special">&amp;</span><span class="identifier">dfdt</span> <span class="special">)</span>
- <span class="special">{</span>
- <span class="identifier">J</span><span class="special">(</span> <span class="number">0</span> <span class="special">,</span> <span class="number">0</span> <span class="special">)</span> <span class="special">=</span> <span class="special">-</span><span class="number">101.0</span><span class="special">;</span>
- <span class="identifier">J</span><span class="special">(</span> <span class="number">0</span> <span class="special">,</span> <span class="number">1</span> <span class="special">)</span> <span class="special">=</span> <span class="special">-</span><span class="number">100.0</span><span class="special">;</span>
- <span class="identifier">J</span><span class="special">(</span> <span class="number">1</span> <span class="special">,</span> <span class="number">0</span> <span class="special">)</span> <span class="special">=</span> <span class="number">1.0</span><span class="special">;</span>
- <span class="identifier">J</span><span class="special">(</span> <span class="number">1</span> <span class="special">,</span> <span class="number">1</span> <span class="special">)</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
- <span class="identifier">dfdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
- <span class="identifier">dfdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
- <span class="special">}</span>
-<span class="special">};</span>
-</pre>
-<p>
- </p>
-<p>
- The state type has to be a <code class="computeroutput"><span class="identifier">ublas</span><span class="special">::</span><span class="identifier">vector</span></code>
- and the matrix type must by a <code class="computeroutput"><span class="identifier">ublas</span><span class="special">::</span><span class="identifier">matrix</span></code>
- since the stiff integrator only accepts these types. With a little trick
- you can simply make this functions valid for other state and matrix types,
- just templatize the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>:
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">ublas</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">vector_type</span><span class="special">;</span>
-<span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">ublas</span><span class="special">::</span><span class="identifier">matrix</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">matrix_type</span><span class="special">;</span>
-
-<span class="keyword">struct</span> <span class="identifier">stiff_system</span>
-<span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">&gt;</span>
- <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
- <span class="special">{</span>
- <span class="special">}</span>
-<span class="special">};</span>
-
-<span class="keyword">struct</span> <span class="identifier">stiff_system_jacobi</span>
-<span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Matrix</span> <span class="special">&gt;</span>
- <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">Matrix</span> <span class="special">&amp;</span><span class="identifier">J</span> <span class="special">,</span> <span class="keyword">const</span> <span class="keyword">double</span> <span class="special">&amp;</span><span class="identifier">t</span> <span class="special">,</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">dfdt</span> <span class="special">)</span>
- <span class="special">{</span>
- <span class="special">}</span>
-<span class="special">};</span>
-</pre>
-<p>
- </p>
-<p>
- Now you can use <code class="computeroutput"><span class="identifier">stiff_system</span></code>
- in combination with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span></code> or <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">array</span></code>. In the example the explicit time
- derivative of <span class="emphasis"><em>f(x,t)</em></span> is introduced separately in the
- Jacobian. If <span class="emphasis"><em>df / dt = 0</em></span> simply fill <code class="computeroutput"><span class="identifier">dfdt</span></code>
- with zeros.
- </p>
-<p>
- A well know solver for stiff systems is the so called Rosenbrock method.
- It has a step size control and dense output facilities and can be used like
- all the other stepper:
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">rosenbrock4</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">stepper_type</span><span class="special">;</span>
-<span class="keyword">typedef</span> <span class="identifier">rosenbrock4_controller</span><span class="special">&lt;</span> <span class="identifier">stepper_type</span> <span class="special">&gt;</span> <span class="identifier">controlled_stepper_type</span><span class="special">;</span>
-<span class="keyword">typedef</span> <span class="identifier">rosenbrock4_dense_output</span><span class="special">&lt;</span> <span class="identifier">controlled_stepper_type</span> <span class="special">&gt;</span> <span class="identifier">dense_output_type</span><span class="special">;</span>
-
-<span class="identifier">vector_type</span> <span class="identifier">x</span><span class="special">(</span> <span class="number">3</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">);</span>
-
-<span class="identifier">size_t</span> <span class="identifier">num_of_steps</span> <span class="special">=</span> <span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">dense_output_type</span><span class="special">()</span> <span class="special">,</span>
- <span class="identifier">make_pair</span><span class="special">(</span> <span class="identifier">stiff_system</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">stiff_system_jacobi</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span>
- <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">50.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">,</span>
- <span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">arg_names</span><span class="special">::</span><span class="identifier">arg2</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span> <span class="special">&lt;&lt;</span> <span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">arg_names</span><span class="special">::</span><span class="identifier">arg1</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<p>
- During the integration 71 steps have been done. Comparing to a classical
- Runge-Kutta solver this is a very good result. For example the Dormand-Prince
- 5 method with step size control and dense output yields 1531 steps.
- </p>
-<p>
-
-</p>
-<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">explicit_error_dopri5</span><span class="special">&lt;</span> <span class="identifier">vector_type</span> <span class="special">&gt;</span> <span class="identifier">dopri5_type</span><span class="special">;</span>
-<span class="keyword">typedef</span> <span class="identifier">controlled_error_stepper</span><span class="special">&lt;</span> <span class="identifier">dopri5_type</span> <span class="special">&gt;</span> <span class="identifier">controlled_dopri5_type</span><span class="special">;</span>
-<span class="keyword">typedef</span> <span class="identifier">dense_output_controlled_explicit_fsal</span><span class="special">&lt;</span> <span class="identifier">controlled_dopri5_type</span> <span class="special">&gt;</span> <span class="identifier">dense_output_dopri5_type</span><span class="special">;</span>
-
-<span class="identifier">vector_type</span> <span class="identifier">x2</span><span class="special">(</span> <span class="number">3</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">);</span>
-
-<span class="identifier">size_t</span> <span class="identifier">num_of_steps2</span> <span class="special">=</span> <span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">dense_output_dopri5_type</span><span class="special">()</span> <span class="special">,</span>
- <span class="identifier">stiff_system</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x2</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">50.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">,</span>
- <span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">arg_names</span><span class="special">::</span><span class="identifier">arg2</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span> <span class="special">&lt;&lt;</span> <span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">arg_names</span><span class="special">::</span><span class="identifier">arg1</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span> <span class="special">);</span>
-</pre>
-<p>
- </p>
-<p>
- Note, that we have used Boost.Phoenix
- a great functional programming library to create and compose the observer.
- </p>
-<p>
- The full example can be found here: ../../examples/stiff_system.cpp
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.odeint_in_detail"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.odeint_in_detail" title="Odeint in detail">Odeint
- in detail</a>
-</h3></div></div></div>
-<p>
- Different steppers
- </p>
-<p>
- Explicit steppers
- </p>
-<p>
- Implicit steppers
- </p>
-<p>
- Step size controll
- </p>
-<p>
- dense output
- </p>
-<p>
- Algebras and operations
- </p>
-<p>
- Overview and table
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.special_topics"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics" title="Special topics">Special
- topics</a>
-</h3></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.complex_state_types">Complex
- state types</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.lattice_systems">Lattice
- systems</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.partial_differential_equations">Partial
- differential equations</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.using_boost__units">Using
- boost::units</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.using_cuda_and_thrust">Using
- Cuda and Thrust</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.using_matrices_as_state_types">Using
- matrices as state types</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.ordinary_differential_equations_on_networks">Ordinary
- differential equations on networks</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.pass_by_value_or_by_reference">Pass
- by value or by reference</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.using_boost__range">Using
- boost::range</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.using_arbitrary_precision_floating_point_types">Using
- arbitrary precision floating point types</a></span></dt>
-<dt><span class="section"><a href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.self_expanding_lattices">Self
- expanding lattices</a></span></dt>
-</dl></div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.special_topics.complex_state_types"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.complex_state_types" title="Complex state types">Complex
- state types</a>
-</h4></div></div></div>
-<p>
- typedef vector&lt; complex&lt; double &gt; &gt; state_type;
- </p>
-<p>
- Stuart landau
- </p>
-<p>
- DNLS
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.special_topics.lattice_systems"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.lattice_systems" title="Lattice systems">Lattice
- systems</a>
-</h4></div></div></div>
-<p>
- Fermi-Pasta-Ulam system
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.special_topics.partial_differential_equations"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.partial_differential_equations" title="Partial differential equations">Partial
- differential equations</a>
-</h4></div></div></div>
-<p>
- Wave equation
- </p>
-<p>
- KdV
- </p>
-<p>
- Ginzburg-Landau
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.special_topics.using_boost__units"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.using_boost__units" title="Using boost::units">Using
- boost::units</a>
-</h4></div></div></div>
-<p>
- blah blah
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.special_topics.using_cuda_and_thrust"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.using_cuda_and_thrust" title="Using Cuda and Thrust">Using
- Cuda and Thrust</a>
-</h4></div></div></div>
-<p>
- blah blah
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.special_topics.using_matrices_as_state_types"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.using_matrices_as_state_types" title="Using matrices as state types">Using
- matrices as state types</a>
-</h4></div></div></div>
-<p>
- Expanding resizing
- </p>
-</div>
-<div class="section"><div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.special_topics.ordinary_differential_equations_on_networks"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.ordinary_differential_equations_on_networks" title="Ordinary differential equations on networks">Ordinary
- differential equations on networks</a>
-</h4></div></div></div></div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.special_topics.pass_by_value_or_by_reference"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.pass_by_value_or_by_reference" title="Pass by value or by reference">Pass
- by value or by reference</a>
-</h4></div></div></div>
-<p>
- blah blah
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.special_topics.using_boost__range"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.using_boost__range" title="Using boost::range">Using
- boost::range</a>
-</h4></div></div></div>
-<p>
- blah blah
- </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.special_topics.using_arbitrary_precision_floating_point_types"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.using_arbitrary_precision_floating_point_types" title="Using arbitrary precision floating point types">Using
- arbitrary precision floating point types</a>
-</h4></div></div></div>
-<p>
- GMP
- </p>
-</div>
-<div class="section"><div class="titlepage"><div><div><h4 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.special_topics.self_expanding_lattices"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics.self_expanding_lattices" title="Self expanding lattices">Self
- expanding lattices</a>
-</h4></div></div></div></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.all_examples"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.all_examples" title="All examples">All
- examples</a>
-</h3></div></div></div>
-<p>
- The following table gives an overview over all examples.
- </p>
-<div class="table">
-<a name="id586646"></a><p class="title"><b>Table&#160;1.3.&#160;Examples Overview</b></p>
-<div class="table-contents"><table class="table" summary="Examples Overview">
-<colgroup>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
- <p>
- File
- </p>
- </th>
-<th>
- <p>
- Brief Description
- </p>
- </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
- <p>
- ../../examples/harmonic_oscillator.cpp
- </p>
- </td>
-<td>
- <p>
- The harmonic oscillator examples gives a brief introduction to
- odeint and shows the usage of the classical Runge-Kutta-solvers.
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- ../../examples/solar_system.cpp
- </p>
- </td>
-<td>
- <p>
- The solar system example shows the usage of the symplectic solvers.
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- ../../examples/stiff_system.cpp
- </p>
- </td>
-<td>
- <p>
- The stiff system example shows the usage of the stiff solvers using
- the Jacobian of the system function.
- </p>
- </td>
-</tr>
-<tr>
-<td>
- <p>
- ../../examples/thrust/phase_osc_chain.cu
- </p>
- </td>
-<td>
- <p>
- tba.
- </p>
- </td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break">
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_sandbox_numeric_odeint.tutorial.references"></a><a class="link" href="tutorial.html#boost_sandbox_numeric_odeint.tutorial.references" title="References">References</a>
-</h3></div></div></div>
-<p>
- <span class="bold"><strong>General informations about numerical integration of
- ordinary differential equations:</strong></span>
- </p>
-<p>
- [1] Press William H et al., Numerical Recipes 3rd Edition: The Art of Scientific
- Computing, 3rd ed. (Cambridge University Press, 2007).
- </p>
-<p>
- [2] Ernst Hairer, Syvert P. N&#248;rsett, and Gerhard Wanner, Solving Ordinary
- Differential Equations I: Nonstiff Problems, 2nd ed. (Springer, Berlin, 2009).
- </p>
-<p>
- [3] Ernst Hairer and Gerhard Wanner, Solving Ordinary Differential Equations
- II: Stiff and Differential-Algebraic Problems, 2nd ed. (Springer, Berlin,
- 2010).
- </p>
-<p>
- <span class="bold"><strong>Symplectic integration of numerical integration:</strong></span>
- </p>
-<p>
- [4] Ernst Hairer, Gerhard Wanner, and Christian Lubich, Geometric Numerical
- Integration: Structure-Preserving Algorithms for Ordinary Differential Equations,
- 2nd ed. (Springer-Verlag Gmbh, 2006).
- </p>
-<p>
- [5] Leimkuhler Benedict and Reich Sebastian, Simulating Hamiltonian Dynamics
- (Cambridge University Press, 2005).
- </p>
-<p>
- <span class="bold"><strong>Special symplectic methods:</strong></span>
- </p>
-<p>
- [6] Haruo Yoshida, &#8220;Construction of higher order symplectic integrators,&#8221;
- Physics Letters A 150, no. 5 (November 12, 1990): 262-268.
- </p>
-<p>
- [7] Robert I. McLachlan, &#8220;On the numerical integration of ordinary differential
- equations by symmetric composition methods,&#8221; SIAM J. Sci. Comput. 16, no.
- 1 (1995): 151-168.
- </p>
-</div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 <td align="left"></td>
@@ -1486,7 +546,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="getting_started.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="extend_odeint.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="../index.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="tutorial/solar_system.html"><img src="../images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

Modified: sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/index.html
==============================================================================
--- sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/index.html (original)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/html/index.html 2011-05-13 06:21:57 EDT (Fri, 13 May 2011)
@@ -5,12 +5,12 @@
 <link rel="stylesheet" href="boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
 <link rel="home" href="index.html" title="Chapter&#160;1.&#160;boost.sandbox.numeric.odeint">
-<link rel="next" href="boost_sandbox_numeric_odeint/getting_started.html" title="Getting started">
+<link rel="next" href="boost_sandbox_numeric_odeint/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"></td></tr></table>
 <hr>
-<div class="spirit-nav"><a accesskey="n" href="boost_sandbox_numeric_odeint/getting_started.html"><img src="images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="boost_sandbox_numeric_odeint/tutorial.html"><img src="images/next.png" alt="Next"></a></div>
 <div class="chapter">
 <div class="titlepage"><div>
 <div><h2 class="title">
@@ -32,82 +32,591 @@
 <div class="toc">
 <p><b>Table of Contents</b></p>
 <dl>
-<dt><span class="section">Getting started</span></dt>
+<dt><span class="section">Getting started</span></dt>
 <dd><dl>
-<dt><span class="section">Overview</span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/getting_started.html#boost_sandbox_numeric_odeint.getting_started.usage__compilation__headers">Usage,
+<dt><span class="section">Overview</span></dt>
+<dt><span class="section"><a href="index.html#boost_sandbox_numeric_odeint.getting_started.usage__compilation__headers">Usage,
       Compilation, Headers</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/getting_started.html#boost_sandbox_numeric_odeint.getting_started.short_example">Short
+<dt><span class="section"><a href="index.html#boost_sandbox_numeric_odeint.getting_started.short_example">Short
       Example</a></span></dt>
 </dl></dd>
 <dt><span class="section">Tutorial</span></dt>
 <dd><dl>
 <dt><span class="section"><a href="boost_sandbox_numeric_odeint/tutorial.html#boost_sandbox_numeric_odeint.tutorial.harmonic_oscillator">Harmonic
       oscillator</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/tutorial.html#boost_sandbox_numeric_odeint.tutorial.solar_system">Solar
+<dt><span class="section"><a href="boost_sandbox_numeric_odeint/tutorial/solar_system.html">Solar
       system</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/tutorial.html#boost_sandbox_numeric_odeint.tutorial.chaotic_systems_and_lyapunov_exponents">Chaotic
+<dt><span class="section"><a href="boost_sandbox_numeric_odeint/tutorial/chaotic_systems_and_lyapunov_exponents.html">Chaotic
       systems and Lyapunov exponents</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/tutorial.html#boost_sandbox_numeric_odeint.tutorial.stiff_systems">Stiff
+<dt><span class="section"><a href="boost_sandbox_numeric_odeint/tutorial/stiff_systems.html">Stiff
       systems</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/tutorial.html#boost_sandbox_numeric_odeint.tutorial.odeint_in_detail">Odeint
+<dt><span class="section"><a href="boost_sandbox_numeric_odeint/tutorial/odeint_in_detail.html">Odeint
       in detail</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/tutorial.html#boost_sandbox_numeric_odeint.tutorial.special_topics">Special
+<dt><span class="section"><a href="boost_sandbox_numeric_odeint/tutorial/special_topics.html">Special
       topics</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/tutorial.html#boost_sandbox_numeric_odeint.tutorial.all_examples">All
+<dt><span class="section"><a href="boost_sandbox_numeric_odeint/tutorial/all_examples.html">All
       examples</a></span></dt>
-<dt><span class="section">References</span></dt>
+<dt><span class="section">References</span></dt>
 </dl></dd>
 <dt><span class="section">Extend odeint</span></dt>
 <dd><dl>
 <dt><span class="section"><a href="boost_sandbox_numeric_odeint/extend_odeint.html#boost_sandbox_numeric_odeint.extend_odeint.write_own_steppers">Write
       own steppers</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/extend_odeint.html#boost_sandbox_numeric_odeint.extend_odeint.adapt_your_own_containers">Adapt
+<dt><span class="section"><a href="boost_sandbox_numeric_odeint/extend_odeint/adapt_your_own_containers.html">Adapt
       your own containers</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/extend_odeint.html#boost_sandbox_numeric_odeint.extend_odeint.adapt_your_own_operations">Adapt
+<dt><span class="section"><a href="boost_sandbox_numeric_odeint/extend_odeint/adapt_your_own_operations.html">Adapt
       your own operations</a></span></dt>
 </dl></dd>
 <dt><span class="section">Concepts</span></dt>
 <dd><dl>
 <dt><span class="section"><a href="boost_sandbox_numeric_odeint/concepts.html#boost_sandbox_numeric_odeint.concepts.basic_stepper">Basic
       stepper</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/concepts.html#boost_sandbox_numeric_odeint.concepts.error_stepper">Error
+<dt><span class="section"><a href="boost_sandbox_numeric_odeint/concepts/error_stepper.html">Error
       stepper</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/concepts.html#boost_sandbox_numeric_odeint.concepts.controlled_stepper">Controlled
+<dt><span class="section"><a href="boost_sandbox_numeric_odeint/concepts/controlled_stepper.html">Controlled
       stepper</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/concepts.html#boost_sandbox_numeric_odeint.concepts.dense_ouput_stepper">Dense
+<dt><span class="section"><a href="boost_sandbox_numeric_odeint/concepts/dense_ouput_stepper.html">Dense
       ouput stepper</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/concepts.html#boost_sandbox_numeric_odeint.concepts.size_adjusting_stepper">Size
+<dt><span class="section"><a href="boost_sandbox_numeric_odeint/concepts/size_adjusting_stepper.html">Size
       adjusting stepper</a></span></dt>
-<dt><span class="section">CompositeStepper</span></dt>
+<dt><span class="section">CompositeStepper</span></dt>
 </dl></dd>
 <dt><span class="section">Reference</span></dt>
 <dd><dl>
 <dt><span class="section"><a href="boost_sandbox_numeric_odeint/reference.html#boost_sandbox_numeric_odeint.reference.stepper_classes">Stepper
       classes</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/reference.html#boost_sandbox_numeric_odeint.reference.integration_functions">Integration
+<dt><span class="section"><a href="boost_sandbox_numeric_odeint/reference/integration_functions.html">Integration
       functions</a></span></dt>
-<dt><span class="section">Algebras</span></dt>
-<dt><span class="section">Operations</span></dt>
-<dt><span class="section">Resizing</span></dt>
+<dt><span class="section">Algebras</span></dt>
+<dt><span class="section">Operations</span></dt>
+<dt><span class="section">Resizing</span></dt>
 </dl></dd>
 </dl>
 </div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_sandbox_numeric_odeint.getting_started"></a><a class="link" href="index.html#boost_sandbox_numeric_odeint.getting_started" title="Getting started">Getting started</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section">Overview</span></dt>
+<dt><span class="section"><a href="index.html#boost_sandbox_numeric_odeint.getting_started.usage__compilation__headers">Usage,
+ Compilation, Headers</a></span></dt>
+<dt><span class="section"><a href="index.html#boost_sandbox_numeric_odeint.getting_started.short_example">Short
+ Example</a></span></dt>
+</dl></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_sandbox_numeric_odeint.getting_started.overview"></a><a class="link" href="index.html#boost_sandbox_numeric_odeint.getting_started.overview" title="Overview">Overview</a>
+</h3></div></div></div>
 <div class="caution"><table border="0" summary="Caution">
 <tr>
 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="images/caution.png"></td>
 <th align="left">Caution</th>
 </tr>
 <tr><td align="left" valign="top"><p>
- Boost.Odeint is not an official boost library!
- </p></td></tr>
+ Boost.Odeint is not an official boost library!
+ </p></td></tr>
 </table></div>
+<p>
+ Odeint is a library for solving initial value problems (IVP) of ordinary
+ differential equations. Mathematically, these problems are formulated as
+ follows: <span class="emphasis"><em>x'(t) = f(x,t)</em></span>, <span class="emphasis"><em>x(0) = x0</em></span>.
+ <span class="emphasis"><em>x</em></span> and <span class="emphasis"><em>f</em></span> can be vectors and the
+ solution is some function <span class="emphasis"><em>x(t)</em></span> fullfilling both equations
+ above. In the following we will refer to <span class="emphasis"><em>x'(t)</em></span> also
+ <code class="computeroutput"><span class="identifier">dxdt</span></code> which is also our notation
+ for the derivative in the source code.
+ </p>
+<p>
+ Numerical approximations for the solution <span class="emphasis"><em>x(t)</em></span> are calculated
+ iteratively. The easiest algorithm is the Euler-Scheme, where starting at
+ <span class="emphasis"><em>x(0)</em></span> one finds <span class="emphasis"><em>x(dt) = x(0) + dt f(x(0),0)</em></span>.
+ Now one can use <span class="emphasis"><em>x(dt)</em></span> and obtain <span class="emphasis"><em>x(2dt)</em></span>
+ in a similar way and so on. The Euler method is of order 1, that means the
+ error at each step is <span class="emphasis"><em>~ dt<sup>2</sup></em></span>. This is, of course, not
+ very satisfying, which is why the Euler method is merely used for real life
+ problems and serves just as illustrative example. In odeint, the following
+ algorithms are implemented:
+ </p>
+<div class="table">
+<a name="id533122"></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>
+<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>
+<th>
+ <p>
+ Dense Output
+ </p>
+ </th>
+<th>
+ <p>
+ Remarks
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Explicit Euler
+ </p>
+ </td>
+<td>
+ <p>
+ explicit_euler
+ </p>
+ </td>
+<td>
+ <p>
+ 1
+ </p>
+ </td>
+<td>
+ <p>
+ No
+ </p>
+ </td>
+<td>
+ <p>
+ Yes
+ </p>
+ </td>
+<td>
+ <p>
+ Very simple, only for demonstrating purposes
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Runge-Kutta 4
+ </p>
+ </td>
+<td>
+ <p>
+ explicit_rkrk4
+ </p>
+ </td>
+<td>
+ <p>
+ 4
+ </p>
+ </td>
+<td>
+ <p>
+ No
+ </p>
+ </td>
+<td>
+ <p>
+ No
+ </p>
+ </td>
+<td>
+ <p>
+ Good default method
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Runge-Kutta Cash-Karp
+ </p>
+ </td>
+<td>
+ <p>
+ explicit_error_rk54_ck
+ </p>
+ </td>
+<td>
+ <p>
+ 5
+ </p>
+ </td>
+<td>
+ <p>
+ Yes (Order 4)
+ </p>
+ </td>
+<td>
+ <p>
+ No
+ </p>
+ </td>
+<td>
+ <p>
+ ...
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Dormand-Prince 5
+ </p>
+ </td>
+<td>
+ <p>
+ explicit_error_dopri5
+ </p>
+ </td>
+<td>
+ <p>
+ 5
+ </p>
+ </td>
+<td>
+ <p>
+ Yes (Order 4)
+ </p>
+ </td>
+<td>
+ <p>
+ Yes
+ </p>
+ </td>
+<td>
+ <p>
+ ...
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Implicit Euler
+ </p>
+ </td>
+<td>
+ <p>
+ implicit_euler
+ </p>
+ </td>
+<td>
+ <p>
+ 1
+ </p>
+ </td>
+<td>
+ <p>
+ No
+ </p>
+ </td>
+<td>
+ <p>
+ No
+ </p>
+ </td>
+<td>
+ <p>
+ Needs the Jacobian
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Rosenbrock 4
+ </p>
+ </td>
+<td>
+ <p>
+ rosenbrock4
+ </p>
+ </td>
+<td>
+ <p>
+ 4
+ </p>
+ </td>
+<td>
+ <p>
+ Yes
+ </p>
+ </td>
+<td>
+ <p>
+ Yes
+ </p>
+ </td>
+<td>
+ <p>
+ Good for stiff systems
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Symplectic Euler
+ </p>
+ </td>
+<td>
+ <p>
+ symplectic_euler
+ </p>
+ </td>
+<td>
+ <p>
+ 1
+ </p>
+ </td>
+<td>
+ <p>
+ No
+ </p>
+ </td>
+<td>
+ <p>
+ No
+ </p>
+ </td>
+<td>
+ <p>
+ Symplectic solver for separable Hamiltonian system
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break"><p>
+ Ordinary differential equations occur nearly everywhere in natural sciences.
+ For example, the whole Newtonian mechanics are described by second order
+ differential equations. Be sure, you will find them in every discipline.
+ They also occur if partial differential equations (PDEs) are discretized
+ in one coordinate. Then, a system of coupled ordinary differential occurs,
+ sometimes also refered as lattices ODEs.
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_sandbox_numeric_odeint.getting_started.usage__compilation__headers"></a><a class="link" href="index.html#boost_sandbox_numeric_odeint.getting_started.usage__compilation__headers" title="Usage, Compilation, Headers">Usage,
+ Compilation, Headers</a>
+</h3></div></div></div>
+<p>
+ Odeint is completely header-only, meaning that you do not link against any
+ library. It can be include by
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+</pre>
+<p>
+ which includes all headers in the library. All functions and classes from
+ odeint live in the namespace
+</p>
+<pre class="programlisting"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">odeint</span><span class="special">;</span>
+</pre>
+<p>
+ </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_sandbox_numeric_odeint.getting_started.short_example"></a><a class="link" href="index.html#boost_sandbox_numeric_odeint.getting_started.short_example" title="Short Example">Short
+ Example</a>
+</h3></div></div></div>
+<p>
+ Image, you want to numerically integrate a harmonic oscillator with friction.
+ The equations of motion are given by <span class="emphasis"><em>x'' = -x + gamma x'</em></span>.
+ This can be transformed to a system of two coupled first-order differential
+ equations with new variables <span class="emphasis"><em>x</em></span> and <span class="emphasis"><em>p=x'</em></span>.
+ To apply numerical integration one first has to design the right hand side
+ of the equation <span class="emphasis"><em>w' = f(w)</em></span> where in this case <span class="emphasis"><em>w
+ = (x,p)</em></span>:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="comment">/* The type of container 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>
+
+<span class="comment">/* The rhs of x' = f(x) */</span>
+<span class="keyword">void</span> <span class="identifier">harmonic_oscillator</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
+<span class="special">{</span>
+ <span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
+ <span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">gam</span><span class="special">*</span><span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
+<span class="special">}</span>
+</pre>
+<p>
+ </p>
+<p>
+ Here we chose <code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span></code>
+ as the state type, but others are also possible, for example <code class="computeroutput"><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span><span class="number">2</span><span class="special">&gt;</span></code>.
+ Odeint is designed in such a way that you can easily use your own state types.
+ Next, we define the ODE which is in this case a simple function. The parameter
+ signature of this function is crucial: the integration methods will always
+ call them in the form <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">dxdt</span><span class="special">,</span> <span class="identifier">t</span><span class="special">)</span></code>.
+ So, even if there is no explicit time dependence, one has to define <code class="computeroutput"><span class="identifier">t</span></code> as a function parameter.
+ </p>
+<p>
+ Now, we have to define the initial state from which the integration should
+ start:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">state_type</span> <span class="identifier">x</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
+<span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="number">1.0</span><span class="special">;</span> <span class="comment">// start at x=1.0, p=0.0
+</span><span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
+</pre>
+<p>
+ </p>
+<p>
+ For the integration itself we'll use the <code class="computeroutput">integrate</code>
+ function, which is a convenient way to get quick results. It is based on
+ the error-controlled <code class="computeroutput">runge_kutta_rk5_ck</code>
+ stepper (5th order) and uses adaptive stepsize.
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">size_t</span> <span class="identifier">steps</span> <span class="special">=</span> <span class="identifier">integrate</span><span class="special">(</span> <span class="identifier">harmonic_oscillator</span> <span class="special">,</span>
+ <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.1</span> <span class="special">);</span>
+</pre>
+<p>
+ </p>
+<p>
+ The integrate function expects as parameters the rhs of the ode as defined
+ above, the initial state <code class="computeroutput"><span class="identifier">x</span></code>,
+ the start-and end-time of the integration as well as the initial time step.
+ Note, that <code class="computeroutput">integrate</code>
+ uses an adaptive stepsize during the integration steps so the time points
+ will not be equally spaced. The integration returns the number of steps that
+ were applied.
+ </p>
+<p>
+ It is, of course, also possible to implement the ode system as a class. The
+ rhs must then be implemented as a functor having defined the ()-operator:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="comment">/* The rhs of x' = f(x) defined as a class */</span>
+<span class="keyword">class</span> <span class="identifier">harm_osc</span> <span class="special">{</span>
+
+ <span class="keyword">double</span> <span class="identifier">m_gam</span><span class="special">;</span>
+
+<span class="keyword">public</span><span class="special">:</span>
+ <span class="identifier">harm_osc</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">gam</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_gam</span><span class="special">(</span><span class="identifier">gam</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
+
+ <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
+ <span class="special">{</span>
+ <span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
+ <span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">m_gam</span><span class="special">*</span><span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
+ <span class="special">}</span>
+<span class="special">};</span>
+</pre>
+<p>
+ </p>
+<p>
+ which can be used via
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">harm_osc</span> <span class="identifier">ho</span><span class="special">(</span><span class="number">0.15</span><span class="special">);</span>
+<span class="identifier">steps</span> <span class="special">=</span> <span class="identifier">integrate</span><span class="special">(</span> <span class="identifier">ho</span> <span class="special">,</span>
+ <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.1</span> <span class="special">);</span>
+</pre>
+<p>
+ </p>
+<p>
+ You surely have already noticed that during the integration a lot of steps
+ have been done. You might wonder if you could access them do observe the
+ solution during the iteration. Yes, you can do that. All you have to do is
+ to provide a reasonable observer. An example is
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">push_back_state_and_time</span>
+<span class="special">{</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;&amp;</span> <span class="identifier">m_states</span><span class="special">;</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;&amp;</span> <span class="identifier">m_times</span><span class="special">;</span>
+
+ <span class="identifier">push_back_state_and_time</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">states</span> <span class="special">,</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="special">&amp;</span><span class="identifier">times</span> <span class="special">)</span>
+ <span class="special">:</span> <span class="identifier">m_states</span><span class="special">(</span> <span class="identifier">states</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_times</span><span class="special">(</span> <span class="identifier">times</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
+
+ <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
+ <span class="special">{</span>
+ <span class="identifier">m_states</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">);</span>
+ <span class="identifier">m_times</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span> <span class="identifier">t</span> <span class="special">);</span>
+ <span class="special">}</span>
+<span class="special">};</span>
+</pre>
+<p>
+ </p>
+<p>
+ which stores the intermediate steps in a container. Now, you only have to
+ pass this container to the integration function:
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">state_type</span><span class="special">&gt;</span> <span class="identifier">x_vec</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">times</span><span class="special">;</span>
+
+<span class="identifier">steps</span> <span class="special">=</span> <span class="identifier">integrate</span><span class="special">(</span> <span class="identifier">harmonic_oscillator</span> <span class="special">,</span>
+ <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.1</span> <span class="special">,</span>
+ <span class="identifier">push_back_state_and_time</span><span class="special">(</span> <span class="identifier">x_vec</span> <span class="special">,</span> <span class="identifier">times</span> <span class="special">)</span> <span class="special">);</span>
+
+<span class="comment">/* output */</span>
+<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span><span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;=</span><span class="identifier">steps</span><span class="special">;</span> <span class="identifier">i</span><span class="special">++</span> <span class="special">)</span>
+<span class="special">{</span>
+ <span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">times</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="char">'\t'</span> <span class="special">&lt;&lt;</span> <span class="identifier">x_vec</span><span class="special">[</span><span class="identifier">i</span><span class="special">][</span><span class="number">0</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="char">'\t'</span> <span class="special">&lt;&lt;</span> <span class="identifier">x_vec</span><span class="special">[</span><span class="identifier">i</span><span class="special">][</span><span class="number">1</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="char">'\n'</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+ </p>
+<p>
+ That is all. Of course, you can use functional libraries like Boost.Lambda
+ or Boost.Phoenix
+ to ease the creation of observer functions.
+ </p>
+<p>
+ The full cpp file for this example can be found here: ../../examples/harmonic_oscillator.cpp
+ </p>
+</div>
+</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 13, 2011 at 10:39:06 GMT</small></p></td>
+<td align="left"><p><small>Last revised: May 13, 2011 at 11:19:54 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
-<div class="spirit-nav"><a accesskey="n" href="boost_sandbox_numeric_odeint/getting_started.html"><img src="images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="boost_sandbox_numeric_odeint/tutorial.html"><img src="images/next.png" alt="Next"></a></div>
 </body>
 </html>

Modified: sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/odeint.qbk
==============================================================================
--- sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/odeint.qbk (original)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/odeint.qbk 2011-05-13 06:21:57 EDT (Fri, 13 May 2011)
@@ -44,9 +44,6 @@
 [template sub[x]'''<subscript>'''[x]'''</subscript>''']
 [template subl[x]'''<subscript>'''__space[x]'''</subscript>''']
 
-[caution Boost.Odeint is not an official boost library!]
-
-
 [include getting_started.qbk]
 
 [include tutorial.qbk]

Modified: sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/reference.qbk
==============================================================================
--- sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/reference.qbk (original)
+++ sandbox/odeint/branches/karsten/libs/numeric/odeint/doc/reference.qbk 2011-05-13 06:21:57 EDT (Fri, 13 May 2011)
@@ -1,6 +1,5 @@
 [section Reference]
 
-
 [include reference_steppers.qbk]
 
 [include reference_integrate_functions.qbk]


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk