Subject: [Boost-commit] svn:boost r61607 - in sandbox/odeint/libs/numeric/odeint/doc: . html html/boost_numeric_odeint html/odeint
From: karsten.ahnert_at_[hidden]
Date: 2010-04-27 05:20:18
Author: karsten
Date: 2010-04-27 05:20:17 EDT (Tue, 27 Apr 2010)
New Revision: 61607
URL: http://svn.boost.org/trac/boost/changeset/61607
Log:
fixing dir structure
Added:
sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/
sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/container_traits.html (contents, props changed)
sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/integration_functions.html (contents, props changed)
sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/short_example.html (contents, props changed)
sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/stepper.html (contents, props changed)
sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/tutorial.html (contents, props changed)
Removed:
sandbox/odeint/libs/numeric/odeint/doc/html/odeint/
Text files modified:
sandbox/odeint/libs/numeric/odeint/doc/html/index.html | 56 ++++++++++++++++++++--------------------
sandbox/odeint/libs/numeric/odeint/doc/html/standalone_HTML.manifest | 10 +++---
sandbox/odeint/libs/numeric/odeint/doc/odeint.qbk | 16 +++-------
3 files changed, 38 insertions(+), 44 deletions(-)
Added: sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/container_traits.html
==============================================================================
--- (empty file)
+++ sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/container_traits.html 2010-04-27 05:20:17 EDT (Tue, 27 Apr 2010)
@@ -0,0 +1,51 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Container traits</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter 1. boost.numeric.odeint">
+<link rel="up" href="../index.html" title="Chapter 1. boost.numeric.odeint">
+<link rel="prev" href="integration_functions.html" title="Integration functions">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="integration_functions.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_numeric_odeint.container_traits"></a><a class="link" href="container_traits.html" title="Container traits">Container traits</a>
+</h2></div></div></div>
+<div class="toc"><dl><dt><span class="section"><a href="container_traits.html#boost_numeric_odeint.container_traits.define_your_own_traits">Define
+ your own traits</a></span></dt></dl></div>
+<p>
+ definitions
+ </p>
+<div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title">
+<a name="boost_numeric_odeint.container_traits.define_your_own_traits"></a><a class="link" href="container_traits.html#boost_numeric_odeint.container_traits.define_your_own_traits" title="Define your own traits">Define
+ your own traits</a>
+</h3></div></div></div></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2009 Karsten Ahnert and Mario Mulansky<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="integration_functions.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a>
+</div>
+</body>
+</html>
Added: sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/integration_functions.html
==============================================================================
--- (empty file)
+++ sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/integration_functions.html 2010-04-27 05:20:17 EDT (Tue, 27 Apr 2010)
@@ -0,0 +1,58 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Integration functions</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter 1. boost.numeric.odeint">
+<link rel="up" href="../index.html" title="Chapter 1. boost.numeric.odeint">
+<link rel="prev" href="stepper.html" title="Stepper">
+<link rel="next" href="container_traits.html" title="Container traits">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="stepper.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="container_traits.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_numeric_odeint.integration_functions"></a><a class="link" href="integration_functions.html" title="Integration functions">Integration
+ functions</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="integration_functions.html#boost_numeric_odeint.integration_functions.constant_step_size_functions">Constant
+ step-size functions</a></span></dt>
+<dt><span class="section"><a href="integration_functions.html#boost_numeric_odeint.integration_functions.adaptive_step_size_functions">Adaptive
+ step-size functions</a></span></dt>
+</dl></div>
+<div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title">
+<a name="boost_numeric_odeint.integration_functions.constant_step_size_functions"></a><a class="link" href="integration_functions.html#boost_numeric_odeint.integration_functions.constant_step_size_functions" title="Constant step-size functions">Constant
+ step-size functions</a>
+</h3></div></div></div></div>
+<div class="section" lang="en"><div class="titlepage"><div><div><h3 class="title">
+<a name="boost_numeric_odeint.integration_functions.adaptive_step_size_functions"></a><a class="link" href="integration_functions.html#boost_numeric_odeint.integration_functions.adaptive_step_size_functions" title="Adaptive step-size functions">Adaptive
+ step-size functions</a>
+</h3></div></div></div></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2009 Karsten Ahnert and Mario Mulansky<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="stepper.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="container_traits.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
Added: sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/short_example.html
==============================================================================
--- (empty file)
+++ sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/short_example.html 2010-04-27 05:20:17 EDT (Tue, 27 Apr 2010)
@@ -0,0 +1,160 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Short Example</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter 1. boost.numeric.odeint">
+<link rel="up" href="../index.html" title="Chapter 1. boost.numeric.odeint">
+<link rel="prev" href="../index.html" title="Chapter 1. boost.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"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="tutorial.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_numeric_odeint.short_example"></a><a class="link" href="short_example.html" title="Short Example">Short Example</a>
+</h2></div></div></div>
+<p>
+ This section gives a quick introduction to the most important features of the
+ library using a number of instructive examples. Image, for example, you want
+ to numerically integrate a harmonic oscillator with friction. The equations
+ of motion are given by x'' = -x + gamma x'. This can be transformed to a system
+ of two first-order differential equations design the right hand side of the
+ equation w' = f(w) where in this case with new variables x and p=x'. To apply
+ numerical integration one first has to w = (x,p):
+ </p>
+<p>
+ </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"><</span><span class="keyword">double</span><span class="special">></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">&</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&</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>
+ </p>
+<p>
+ Here we chose <span class="bold"><strong>vector<double></strong></span> as the
+ state type, but others are also possible, for example <span class="bold"><strong>tr1/array<double,2></strong></span>.
+ Odeint is designed in such a way that it works with basically any container
+ that can be accessed via iterators. The parameter structure of the function
+ is crucial: the integration methods will always call them in the form <span class="bold"><strong>f(x, dxdt, t)</strong></span>. So even if there is no explicit time
+ dependence, one has to define <span class="bold"><strong>t</strong></span> as a function
+ parameter.
+ </p>
+<p>
+ Now, we have to define the initial state from which the integration should
+ start:
+ </p>
+<p>
+ </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>
+ </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. The results are stored into
+ two InsertIterators (time and state) that must be provided.
+ </p>
+<p>
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><span class="identifier">vector</span><span class="special"><</span><span class="keyword">double</span><span class="special">></span> <span class="identifier">times</span><span class="special">;</span>
+<span class="identifier">vector</span><span class="special"><</span><span class="identifier">state_type</span><span class="special">></span> <span class="identifier">x_t_vec</span><span class="special">;</span>
+
+<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="identifier">back_inserter</span><span class="special">(</span> <span class="identifier">times</span> <span class="special">)</span> <span class="special">,</span>
+ <span class="identifier">back_inserter</span><span class="special">(</span> <span class="identifier">x_t_vec</span> <span class="special">)</span> <span class="special">);</span>
+</pre>
+<p>
+ </p>
+<p>
+ </p>
+<p>
+ The integrate function expects as parameters the rhs of the ode as defined
+ above, the initial state x, the start- and end-time of the integration and
+ two InsertIterators for the times and states where the current time and the
+ current state after each timestep is stored. 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. Note, that in total steps+1 elements will be inserted into times and
+ x_t_vec as the initial time and state are inserted before the first step.
+ </p>
+<p>
+ It is, of course, also possible to implement the ode system as a class. The
+ rhs must then be defined as the ()-operator:
+ </p>
+<p>
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><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">&</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&</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>
+ </p>
+</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 © 2009 Karsten Ahnert and Mario Mulansky<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="tutorial.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
Added: sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/stepper.html
==============================================================================
--- (empty file)
+++ sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/stepper.html 2010-04-27 05:20:17 EDT (Tue, 27 Apr 2010)
@@ -0,0 +1,1401 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Stepper</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter 1. boost.numeric.odeint">
+<link rel="up" href="../index.html" title="Chapter 1. boost.numeric.odeint">
+<link rel="prev" href="tutorial.html" title="Tutorial">
+<link rel="next" href="integration_functions.html" title="Integration functions">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tutorial.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="integration_functions.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_numeric_odeint.stepper"></a><a class="link" href="stepper.html" title="Stepper">Stepper</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section">Concepts</span></dt>
+<dt><span class="section"><a href="stepper.html#boost_numeric_odeint.stepper.stepper_classes">Stepper
+ classes</a></span></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_numeric_odeint.stepper.concepts"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.concepts" title="Concepts">Concepts</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="stepper.html#boost_numeric_odeint.stepper.concepts.dynamical_system">Dynamical
+ system</a></span></dt>
+<dt><span class="section"><a href="stepper.html#boost_numeric_odeint.stepper.concepts.basic_stepper">Basic
+ stepper</a></span></dt>
+<dt><span class="section"><a href="stepper.html#boost_numeric_odeint.stepper.concepts.error_stepper">Error
+ stepper</a></span></dt>
+<dt><span class="section"><a href="stepper.html#boost_numeric_odeint.stepper.concepts.controlled_stepper">Controlled
+ stepper</a></span></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.stepper.concepts.dynamical_system"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.concepts.dynamical_system" title="Dynamical system">Dynamical
+ system</a>
+</h4></div></div></div>
+<p>
+ The dynamical system represents the right hand side of the differential
+ equation:
+ </p>
+<p>
+ <span class="bold"><strong>x'(t) = f(x(t) , t)</strong></span>
+ </p>
+<p>
+ In this odeint library the dynamical system is realized by a callable object,
+ e.g. a function pointer, a functor or an instance of an object with an
+ appropriate <code class="computeroutput"><span class="special">()</span></code>-operator. The
+ parameter structure has to be the following:
+ </p>
+<p>
+ <code class="computeroutput"><span class="special">(</span><span class="keyword">const</span>
+ <span class="identifier">container_type</span> <span class="special">&</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">container_type</span>
+ <span class="special">&</span><span class="identifier">dxdt</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">time_type</span> <span class="identifier">t</span><span class="special">)</span></code>
+ </p>
+<p>
+ <code class="computeroutput"><span class="identifier">x</span></code> is the current state
+ of the system and <code class="computeroutput"><span class="identifier">t</span></code> is
+ the current time. The result <span class="bold"><strong>x' = f(x,t)</strong></span>
+ is then returned in <code class="computeroutput"><span class="identifier">dxdt</span></code>.
+ See the tutorial for examples on how to define the dynamical system.
+ </p>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.stepper.concepts.basic_stepper"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.concepts.basic_stepper" title="Basic stepper">Basic
+ stepper</a>
+</h4></div></div></div>
+<p>
+ Basic steppers execute one timestep of a specific order with a given stepsize.
+ They usually allocate internal memory to store intermediate function call
+ results. If state types with variable size are used (e.g. <code class="computeroutput"><span class="identifier">vector</span></code>), it has to be assured that the
+ stepper gets informed about any change of the state size by calling its
+ <code class="computeroutput"><span class="identifier">adjust_size</span></code> method.
+ </p>
+<p>
+ <span class="bold"><strong>Associated Types</strong></span>
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ </p>
+ </th>
+<th>
+ <p>
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Time
+ </p>
+ </td>
+<td>
+ <p>
+ Stepper::time_type
+ </p>
+ </td>
+<td>
+ <p>
+ Type of the time variable, e.g. <code class="computeroutput"><span class="keyword">double</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Container
+ </p>
+ </td>
+<td>
+ <p>
+ Stepper::container_type
+ </p>
+ </td>
+<td>
+ <p>
+ Type of the system state, e.g. <code class="computeroutput"><span class="identifier">vector</span><span class="special"><</span><span class="keyword">double</span><span class="special">></span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Value
+ </p>
+ </td>
+<td>
+ <p>
+ Stepper::value_type
+ </p>
+ </td>
+<td>
+ <p>
+ Value type of the state, e.g. <code class="computeroutput"><span class="keyword">double</span></code>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Order Type
+ </p>
+ </td>
+<td>
+ <p>
+ Stepper::order_type
+ </p>
+ </td>
+<td>
+ <p>
+ Type of the order parameter, usually <code class="computeroutput"><span class="keyword">unsigned</span>
+ <span class="keyword">short</span></code>
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+ <span class="bold"><strong>Methods</strong></span>
+ </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput"><span class="identifier">Stepper</span><span class="special">()</span></code>
+ Constructor.
+ </li>
+<li>
+<code class="computeroutput"><span class="identifier">Stepper</span><span class="special">(</span>
+ <span class="identifier">container_type</span> <span class="special">&</span><span class="identifier">x</span> <span class="special">)</span></code>
+ Constructor that allocates internal memory to store intermediate results
+ of the same size as <code class="computeroutput"><span class="identifier">x</span></code>.
+ </li>
+<li><code class="computeroutput"><span class="keyword">void</span> <span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">DynamicalSystem</span>
+ <span class="special">&</span><span class="identifier">system</span>
+ <span class="special">,</span> <span class="identifier">container_type</span>
+ <span class="special">&</span><span class="identifier">x</span>
+ <span class="special">,</span> <span class="identifier">time_type</span>
+ <span class="identifier">t</span> <span class="special">,</span>
+ <span class="identifier">time_type</span> <span class="identifier">dt</span>
+ <span class="special">)</span></code></li>
+</ul></div>
+<p>
+ Executes one timestep with the given parameters:
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Type
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ system
+ </p>
+ </td>
+<td>
+ <p>
+ DynamicalSystem
+ </p>
+ </td>
+<td>
+ <p>
+ Function (callable object) that computes the rhs of the ode
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ x
+ </p>
+ </td>
+<td>
+ <p>
+ container_type
+ </p>
+ </td>
+<td>
+ <p>
+ The current state of the system <span class="bold"><strong>x(t)</strong></span>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ t
+ </p>
+ </td>
+<td>
+ <p>
+ time_type
+ </p>
+ </td>
+<td>
+ <p>
+ The current time <span class="bold"><strong>t</strong></span>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ dt
+ </p>
+ </td>
+<td>
+ <p>
+ time_type
+ </p>
+ </td>
+<td>
+ <p>
+ Length of the timestep to be executed
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+ The result of this method is the (approximate) state of the system <span class="bold"><strong>x(t+dt)</strong></span> and is stored in the variable <code class="computeroutput"><span class="identifier">x</span></code> (in-place). Note, that the time <code class="computeroutput"><span class="identifier">t</span></code> is not automatically increased by this
+ method.
+ </p>
+<div class="itemizedlist"><ul type="disc"><li><code class="computeroutput"><span class="keyword">void</span> <span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">DynamicalSystem</span>
+ <span class="special">&</span><span class="identifier">system</span>
+ <span class="special">,</span> <span class="identifier">container_type</span>
+ <span class="special">&</span><span class="identifier">x</span>
+ <span class="special">,</span> <span class="keyword">const</span>
+ <span class="identifier">container_type</span> <span class="special">&</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">time_type</span> <span class="identifier">t</span>
+ <span class="special">,</span> <span class="identifier">time_type</span>
+ <span class="identifier">dt</span> <span class="special">)</span></code></li></ul></div>
+<p>
+ The same as above but with the additional parameter <code class="computeroutput"><span class="identifier">dxdt</span></code>
+ that represents the derivative <span class="bold"><strong>x'(t) = f(x,t)</strong></span>
+ at the time <span class="bold"><strong>t</strong></span>.
+ </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">adjust_size</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&</span><span class="identifier">x</span> <span class="special">)</span></code>
+ Adjusts the internal memory to store intermediate results of the same
+ size as <code class="computeroutput"><span class="identifier">x</span></code>. This function
+ <span class="emphasis"><em>must</em></span> be called whenever the system size changes
+ during the integration.
+ </li>
+<li>
+<code class="computeroutput"><span class="identifier">order_type</span> <span class="identifier">order_step</span><span class="special">()</span></code> Returns the order of the algorithm.
+ If <span class="bold"><strong>n</strong></span> is the order of a method, then
+ the result of one iteration with the timestep <span class="bold"><strong>dt</strong></span>
+ is accurate up to <span class="bold"><strong>dt^n</strong></span>. That means the
+ error made by the time discretization is of order <span class="bold"><strong>dt^(n+1)</strong></span>.
+ </li>
+</ul></div>
+<p>
+ <span class="bold"><strong>Stepper that model this concept</strong></span>
+ </p>
+<div class="itemizedlist"><ul type="disc">
+<li><code class="computeroutput"><span class="identifier">stepper_euler</span></code></li>
+<li><code class="computeroutput"><span class="identifier">stepper_rk4</span></code></li>
+<li><code class="computeroutput"><span class="identifier">stepper_rk78_fehlberg</span></code></li>
+</ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.stepper.concepts.error_stepper"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.concepts.error_stepper" title="Error stepper">Error
+ stepper</a>
+</h4></div></div></div>
+<p>
+ Error steppers execute one timestep of a specific order with a given stepsize.
+ Additionally, an error estimation of the obtained result is computed that
+ can be used to control the error introduced by the time discretization.
+ As the basic steppers, error steppers usually allocate internal memory
+ to store intermediate function call results. If state types with variable
+ size are used (e.g. <code class="computeroutput"><span class="identifier">vector</span></code>),
+ it has to be assured that the stepper gets informed about any change of
+ the state size by calling its <code class="computeroutput"><span class="identifier">adjust_size</span></code>
+ method.
+ </p>
+<p>
+ <span class="bold"><strong>Associated Types</strong></span>
+ </p>
+<p>
+ Same as for <span class="emphasis"><em>basic steppers</em></span> above.
+ </p>
+<p>
+ <span class="bold"><strong>Methods</strong></span>
+ </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput"><span class="identifier">Error_Stepper</span><span class="special">()</span></code>
+ Constructor.
+ </li>
+<li>
+<code class="computeroutput"><span class="identifier">Error_Stepper</span><span class="special">(</span>
+ <span class="identifier">container_type</span> <span class="special">&</span><span class="identifier">x</span> <span class="special">)</span></code>
+ Constructor that allocates internal memory to store intermediate results
+ of the same size as <code class="computeroutput"><span class="identifier">x</span></code>.
+ </li>
+<li><code class="computeroutput"><span class="keyword">void</span> <span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">DynamicalSystem</span>
+ <span class="special">&</span><span class="identifier">system</span>
+ <span class="special">,</span> <span class="identifier">container_type</span>
+ <span class="special">&</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">&</span><span class="identifier">xerr</span><span class="special">)</span></code></li>
+</ul></div>
+<p>
+ Executes one timestep with the given parameters:
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Type
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ system
+ </p>
+ </td>
+<td>
+ <p>
+ DynamicalSystem
+ </p>
+ </td>
+<td>
+ <p>
+ Function (callable object) that computes the rhs of the ode
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ x
+ </p>
+ </td>
+<td>
+ <p>
+ container_type
+ </p>
+ </td>
+<td>
+ <p>
+ The current state of the system <span class="bold"><strong>x(t)</strong></span>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ t
+ </p>
+ </td>
+<td>
+ <p>
+ time_type
+ </p>
+ </td>
+<td>
+ <p>
+ The current time <span class="bold"><strong>t</strong></span>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ dt
+ </p>
+ </td>
+<td>
+ <p>
+ time_type
+ </p>
+ </td>
+<td>
+ <p>
+ Length of the timestep to be executed
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ xerr
+ </p>
+ </td>
+<td>
+ <p>
+ container_type
+ </p>
+ </td>
+<td>
+ <p>
+ Used by the method to return the error estimation of this computation
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+ The result of this method is the (approximate) state of the system <span class="bold"><strong>x(t+dt)</strong></span>, which is returned in the variable <code class="computeroutput"><span class="identifier">x</span></code> (in-place), and the corresponding error
+ estimation returned in <code class="computeroutput"><span class="identifier">xerr</span></code>.
+ Note, that the time <code class="computeroutput"><span class="identifier">t</span></code> is
+ not automatically increased by this method.
+ </p>
+<div class="itemizedlist"><ul type="disc"><li><code class="computeroutput"><span class="keyword">void</span> <span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">DynamicalSystem</span>
+ <span class="special">&</span><span class="identifier">system</span>
+ <span class="special">,</span> <span class="identifier">container_type</span>
+ <span class="special">&</span><span class="identifier">x</span>
+ <span class="special">,</span> <span class="keyword">const</span>
+ <span class="identifier">container_type</span> <span class="special">&</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">&</span><span class="identifier">xerr</span><span class="special">)</span></code></li></ul></div>
+<p>
+ The same as above but with the additional parameter <code class="computeroutput"><span class="identifier">dxdt</span></code>
+ that represents the derivative <span class="bold"><strong>x'(t) = f(x,t)</strong></span>
+ at the time <span class="bold"><strong>t</strong></span>.
+ </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">adjust_size</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&</span><span class="identifier">x</span> <span class="special">)</span></code>
+ Adjusts the internal memory to store intermediate results of the same
+ size as <code class="computeroutput"><span class="identifier">x</span></code>. This function
+ <span class="emphasis"><em>must</em></span> be called whenever the system size changes
+ during the integration.
+ </li>
+<li>
+<code class="computeroutput"><span class="identifier">order_type</span> <span class="identifier">order_error_step</span><span class="special">()</span></code> Returns the order of the result <span class="bold"><strong>x(t+dt)</strong></span> of the algorithm.
+ </li>
+<li>
+<code class="computeroutput"><span class="identifier">order_type</span> <span class="identifier">order_error</span><span class="special">()</span></code> Returns the order of the error estimation
+ of the algorithm.
+ </li>
+</ul></div>
+<p>
+ <span class="bold"><strong>Stepper that model this concept</strong></span>
+ </p>
+<div class="itemizedlist"><ul type="disc">
+<li><code class="computeroutput"><span class="identifier">stepper_rk5_ck</span></code></li>
+<li><code class="computeroutput"><span class="identifier">stepper_rk78_fehlberg</span></code></li>
+<li><code class="computeroutput"><span class="identifier">stepper_half_step</span></code></li>
+</ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.stepper.concepts.controlled_stepper"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.concepts.controlled_stepper" title="Controlled stepper">Controlled
+ stepper</a>
+</h4></div></div></div>
+<p>
+ Controlled steppers try to execute a timestep with a given error threshold.
+ If the estimated error of the obtained solution is too big, the result
+ is rejected and a new stepsize is proposed. If the error is small enough
+ the timestep is accepted and possibly an increased stepsize is proposed.
+ </p>
+<p>
+ <span class="bold"><strong>Associated Types</strong></span>
+ </p>
+<p>
+ Same as for <span class="emphasis"><em>basic steppers</em></span> above.
+ </p>
+<p>
+ <span class="bold"><strong>Methods</strong></span>
+ </p>
+<div class="itemizedlist"><ul type="disc"><li><code class="computeroutput"><span class="identifier">Controlled_Stepper</span><span class="special">(</span>
+ <span class="identifier">time_type</span> <span class="identifier">abs_err</span><span class="special">,</span> <span class="identifier">time_type</span>
+ <span class="identifier">rel_err</span><span class="special">,</span>
+ <span class="identifier">time_type</span> <span class="identifier">factor_x</span><span class="special">,</span> <span class="identifier">time_type</span>
+ <span class="identifier">factor_dxdt</span> <span class="special">)</span></code></li></ul></div>
+<p>
+ Constructor that initializes the controlled stepper with several parameters
+ of the error control. The controlled stepper assures that the error done
+ by each individual timestep yields:
+ </p>
+<p>
+ <span class="bold"><strong>xerr < 1.1 ( eps_abs + eps_rel * (factor_x |x|
+ + factor_dxdt h |x'|) ) </strong></span>
+ </p>
+<p>
+ The factor 1.1 is for safety to avoid unnecessary many stepsize adjustings.
+ The above inequality should be understand to hold for <span class="emphasis"><em>all</em></span>
+ components of the possibly more dimensional vectors <span class="bold"><strong>x</strong></span>,
+ <span class="bold"><strong>x'</strong></span> and <span class="bold"><strong>xerr</strong></span>.
+ If the estimated error is too large, a reduced stepsize will be suggested.
+ If the estimated error is less than half of the desired error, an increased
+ stepsize will be suggested.
+ </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput"><span class="identifier">Controlled_Stepper</span><span class="special">(</span>
+ <span class="identifier">container_type</span> <span class="special">&</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">time_type</span> <span class="identifier">abs_err</span><span class="special">,</span> <span class="identifier">time_type</span>
+ <span class="identifier">rel_err</span><span class="special">,</span>
+ <span class="identifier">time_type</span> <span class="identifier">factor_x</span><span class="special">,</span> <span class="identifier">time_type</span>
+ <span class="identifier">factor_dxdt</span> <span class="special">)</span></code>
+ Same as above, but with additional allocation of the internal memory
+ to store intermediate results of the same size as <code class="computeroutput"><span class="identifier">x</span></code>.
+ </li>
+<li><code class="computeroutput"><span class="identifier">controlled_step_result</span> <span class="identifier">try_step</span><span class="special">(</span>
+ <span class="identifier">DynamicalSystem</span> <span class="special">&</span><span class="identifier">system</span><span class="special">,</span> <span class="identifier">container_type</span> <span class="special">&</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">time_type</span> <span class="special">&</span><span class="identifier">t</span><span class="special">,</span> <span class="identifier">time_type</span> <span class="special">&</span><span class="identifier">dt</span> <span class="special">)</span></code></li>
+</ul></div>
+<p>
+ Tries one timestep with the given parameters
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Type
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ system
+ </p>
+ </td>
+<td>
+ <p>
+ DynamicalSystem
+ </p>
+ </td>
+<td>
+ <p>
+ Function (callable object) that computes the rhs of the ode
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ x
+ </p>
+ </td>
+<td>
+ <p>
+ container_type
+ </p>
+ </td>
+<td>
+ <p>
+ The current state of the system <span class="bold"><strong>x(t)</strong></span>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ t
+ </p>
+ </td>
+<td>
+ <p>
+ time_type
+ </p>
+ </td>
+<td>
+ <p>
+ The current time <span class="bold"><strong>t</strong></span>
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ dt
+ </p>
+ </td>
+<td>
+ <p>
+ time_type
+ </p>
+ </td>
+<td>
+ <p>
+ Length of the timestep to be executed
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+ This method has three possible outcomes represented by the returned value
+ <code class="computeroutput"><span class="identifier">result</span></code>: If <code class="computeroutput"><span class="identifier">result</span> <span class="special">=</span> <span class="identifier">success</span></code> the step has been applied and
+ x contains the new state <span class="bold"><strong>x(t)</strong></span> where the
+ time has also been increased <span class="bold"><strong>t += dt</strong></span>.
+ If <code class="computeroutput"><span class="identifier">result</span> <span class="special">=</span>
+ <span class="identifier">step_size_increased</span></code> the step
+ has also been accomplished, but the estimated error was so small that a
+ new stepsize is proposed in the variable <code class="computeroutput"><span class="identifier">dt</span></code>.
+ If <code class="computeroutput"><span class="identifier">result</span> <span class="special">=</span>
+ <span class="identifier">step_size_decreased</span></code> the step
+ has been rejected due to a too big error. <code class="computeroutput"><span class="identifier">x</span></code>
+ and <code class="computeroutput"><span class="identifier">t</span></code> remain unchanged
+ and <code class="computeroutput"><span class="identifier">dt</span></code> now containes the
+ suggested reduced stepsize that should give an error below the desired
+ level.
+ </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput"><span class="identifier">controlled_step_result</span> <span class="identifier">try_step</span><span class="special">(</span>
+ <span class="identifier">DynamicalSystem</span> <span class="special">&</span><span class="identifier">system</span><span class="special">,</span> <span class="identifier">container_type</span> <span class="special">&</span><span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">container_type</span>
+ <span class="special">&</span><span class="identifier">dxdt</span><span class="special">,</span> <span class="identifier">time_type</span>
+ <span class="special">&</span><span class="identifier">t</span><span class="special">,</span> <span class="identifier">time_type</span>
+ <span class="special">&</span><span class="identifier">dt</span>
+ <span class="special">)</span></code> Same as above but with the additional
+ parameter <code class="computeroutput"><span class="identifier">dxdt</span></code> that that
+ represents the derivative <span class="bold"><strong>x'(t) = f(x,t)</strong></span>
+ at the time <span class="bold"><strong>t</strong></span>.
+ </li>
+<li>
+<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">adjust_size</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&</span><span class="identifier">x</span> <span class="special">)</span></code>
+ Adjusts the internal memory to store intermediate results of the same
+ size as <code class="computeroutput"><span class="identifier">x</span></code>. This function
+ <span class="emphasis"><em>must</em></span> be called whenever the system size changes
+ during the integration.
+ </li>
+<li>
+<code class="computeroutput"><span class="identifier">order_type</span> <span class="identifier">order_error_step</span><span class="special">()</span></code> Returns the order of the result <span class="bold"><strong>x(t+dt)</strong></span> of the algorithm.
+ </li>
+</ul></div>
+<p>
+ <span class="bold"><strong>Stepper that model this concept</strong></span>
+ </p>
+<div class="itemizedlist"><ul type="disc">
+<li><code class="computeroutput"><span class="identifier">controlled_stepper_standard</span></code></li>
+<li><code class="computeroutput"><span class="identifier">controlled_stepper_bs</span></code></li>
+</ul></div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_numeric_odeint.stepper.stepper_classes"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.stepper_classes" title="Stepper classes">Stepper
+ classes</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section">stepper_euler</span></dt>
+<dt><span class="section">stepper_rk4</span></dt>
+<dt><span class="section">stepper_rk5_ck</span></dt>
+<dt><span class="section">stepper_rk78_fehlberg</span></dt>
+</dl></div>
+<div class="table">
+<a name="boost_numeric_odeint.stepper.stepper_classes.stepper_algorithms"></a><p class="title"><b>Table 1.3. Stepper Algorithms</b></p>
+<div class="table-contents"><table class="table" summary="Stepper Algorithms">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Method
+ </p>
+ </th>
+<th>
+ <p>
+ Class
+ </p>
+ </th>
+<th>
+ <p>
+ Order
+ </p>
+ </th>
+<th>
+ <p>
+ Error Estimation
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Euler
+ </p>
+ </td>
+<td>
+ <p>
+ stepper_euler
+ </p>
+ </td>
+<td>
+ <p>
+ 1
+ </p>
+ </td>
+<td>
+ <p>
+ No
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Runge-Kutta 4
+ </p>
+ </td>
+<td>
+ <p>
+ stepper_rk4
+ </p>
+ </td>
+<td>
+ <p>
+ 4
+ </p>
+ </td>
+<td>
+ <p>
+ No
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Runge-Kutta Cash-Karp
+ </p>
+ </td>
+<td>
+ <p>
+ stepper_rk5_ck
+ </p>
+ </td>
+<td>
+ <p>
+ 5
+ </p>
+ </td>
+<td>
+ <p>
+ Yes (Order 4)
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Runge-Kutta Fehlberg
+ </p>
+ </td>
+<td>
+ <p>
+ stepper_rk78_fehlberg
+ </p>
+ </td>
+<td>
+ <p>
+ 7
+ </p>
+ </td>
+<td>
+ <p>
+ Yes (Order 8)
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Midpoint
+ </p>
+ </td>
+<td>
+ <p>
+ stepper_midpoint
+ </p>
+ </td>
+<td>
+ <p>
+ variable
+ </p>
+ </td>
+<td>
+ <p>
+ No
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Bulirsch-Stoer
+ </p>
+ </td>
+<td>
+ <p>
+ controlled_stepper_bs
+ </p>
+ </td>
+<td>
+ <p>
+ variable
+ </p>
+ </td>
+<td>
+ <p>
+ Controlled
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break"><div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.stepper.stepper_classes.stepper_euler"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.stepper_classes.stepper_euler" title="stepper_euler">stepper_euler</a>
+</h4></div></div></div>
+<p>
+ <span class="bold"><strong>Concept:</strong></span> <a class="link" href="../">Basic
+ stepper</a>
+ </p>
+<p>
+ <span class="bold"><strong>Accuracy:</strong></span> The produced solution is accurate
+ up to order 1.
+ </p>
+<p>
+ <span class="bold"><strong>Complexity:</strong></span> This method uses 1 function
+ evaluation.
+ </p>
+<p>
+ <span class="bold"><strong>Template Parameters:</strong></span>
+ </p>
+<p>
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Default Value
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ class Container
+ </p>
+ </td>
+<td>
+ <p>
+ no default value
+ </p>
+ </td>
+<td>
+ <p>
+ Type of container that stores the state of the system
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ class Time
+ </p>
+ </td>
+<td>
+ <p>
+ double
+ </p>
+ </td>
+<td>
+ <p>
+ Type of the time variable in the ode
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ class Traits
+ </p>
+ </td>
+<td>
+ <p>
+ container_traits< Container >
+ </p>
+ </td>
+<td>
+ <p>
+ container_traits used by the stepper
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+ </p>
+<p>
+ The Euler algorithm used in this class performs one integration step according
+ to the formula:
+ </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+ </p>
+<p>
+ x(t+dt) = x(t) + dt*f(x,t)
+ </p>
+<p>
+ </p>
+</blockquote></div>
+<p>
+ The Euler stepper is the most simple algorithm to integrate a differential
+ equation. It's only purpose in this library is for educational reasons
+ - use more sophisticated steppers for real life problems.
+ </p>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.stepper.stepper_classes.stepper_rk4"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.stepper_classes.stepper_rk4" title="stepper_rk4">stepper_rk4</a>
+</h4></div></div></div>
+<p>
+ <span class="bold"><strong>Concept:</strong></span> <a class="link" href="../">Basic
+ stepper</a>
+ </p>
+<p>
+ <span class="bold"><strong>Accuracy:</strong></span> The produced solution is accurate
+ up to order 4.
+ </p>
+<p>
+ <span class="bold"><strong>Complexity:</strong></span> This method uses 4 function
+ evaluations.
+ </p>
+<p>
+ <span class="bold"><strong>Template Parameters:</strong></span>
+ </p>
+<p>
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Default Value
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ class Container
+ </p>
+ </td>
+<td>
+ <p>
+ no default value
+ </p>
+ </td>
+<td>
+ <p>
+ Type of container that stores the state of the system
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ class Time
+ </p>
+ </td>
+<td>
+ <p>
+ double
+ </p>
+ </td>
+<td>
+ <p>
+ Type of the time variable in the ode
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ class Traits
+ </p>
+ </td>
+<td>
+ <p>
+ container_traits< Container >
+ </p>
+ </td>
+<td>
+ <p>
+ container_traits used by the stepper
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+ </p>
+<p>
+ The Runge-Kutta 4 algorithm is <span class="emphasis"><em>the</em></span> classical method
+ to integrate odes. The <a href="http://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods#Explicit_Runge.E2.80.93Kutta_methods" target="_top">Butcher
+ Tableau</a> for this method is as follows:
+ </p>
+<pre class="programlisting">Butcher Tableau for Runge-Kutta 4
+ 0 |
+ 1/2 | 1/2
+ 1/2 | 0 1/2
+ 1 | 0 0 1
+ ------------------------
+ | 1/6 1/3 1/3 1/6
+</pre>
+<p>
+ This method produces fast, though not too accurate solutions. Use it for
+ quick preliminary results and then switch to error controlled methods like
+ Cash-Karp for more reliable calculations.
+ </p>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.stepper.stepper_classes.stepper_rk5_ck"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.stepper_classes.stepper_rk5_ck" title="stepper_rk5_ck">stepper_rk5_ck</a>
+</h4></div></div></div>
+<p>
+ <span class="bold"><strong>Concept:</strong></span> <a class="link" href="../">Error
+ stepper</a>
+ </p>
+<p>
+ <span class="bold"><strong>Accuracy:</strong></span> The produced solution is accurate
+ up to order 5 and the estimated error is also of order 5.
+ </p>
+<p>
+ <span class="bold"><strong>Complexity:</strong></span> This method uses 6 function
+ evaluation.
+ </p>
+<p>
+ <span class="bold"><strong>Template Parameters:</strong></span>
+ </p>
+<p>
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Default Value
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ class Container
+ </p>
+ </td>
+<td>
+ <p>
+ no default value
+ </p>
+ </td>
+<td>
+ <p>
+ Type of container that stores the state of the system
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ class Time
+ </p>
+ </td>
+<td>
+ <p>
+ double
+ </p>
+ </td>
+<td>
+ <p>
+ Type of the time variable in the ode
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ class Traits
+ </p>
+ </td>
+<td>
+ <p>
+ container_traits< Container >
+ </p>
+ </td>
+<td>
+ <p>
+ container_traits used by the stepper
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+ </p>
+<p>
+ The Runge-Kutta method of order 5 with Cash-Karp coefficients is a good
+ trade-off between numerical effort and obtained accuracy with error estimation.
+ It is the all-round method and suitable for most problems. See wikipedia
+ for details and the Butcher tableau.
+ </p>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.stepper.stepper_classes.stepper_rk78_fehlberg"></a><a class="link" href="stepper.html#boost_numeric_odeint.stepper.stepper_classes.stepper_rk78_fehlberg" title="stepper_rk78_fehlberg">stepper_rk78_fehlberg</a>
+</h4></div></div></div>
+<p>
+ <span class="bold"><strong>Concept:</strong></span> <a class="link" href="../">Error
+ Stepper</a>
+ </p>
+<p>
+ <span class="bold"><strong>Accuracy:</strong></span> The produced solution is accurate
+ up to order 7 and the estimated error is of order 8.
+ </p>
+<p>
+ <span class="bold"><strong>Complexity:</strong></span> This method uses 13 function
+ evaluations.
+ </p>
+<p>
+ <span class="bold"><strong>Template Parameters:</strong></span>
+ </p>
+<p>
+ </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Parameter
+ </p>
+ </th>
+<th>
+ <p>
+ Default Value
+ </p>
+ </th>
+<th>
+ <p>
+ Description
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ class Container
+ </p>
+ </td>
+<td>
+ <p>
+ no default value
+ </p>
+ </td>
+<td>
+ <p>
+ Type of container that stores the state of the system
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ class Time
+ </p>
+ </td>
+<td>
+ <p>
+ double
+ </p>
+ </td>
+<td>
+ <p>
+ Type of the time variable in the ode
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ class Traits
+ </p>
+ </td>
+<td>
+ <p>
+ container_traits< Container >
+ </p>
+ </td>
+<td>
+ <p>
+ container_traits used by the stepper
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+<p>
+ </p>
+<p>
+ The Runge-Kutta 78 Fehlberg method is a high-order algorithm that produces
+ very good accuracy but for the cost of high numerical effort. Whenever
+ extra-ordinarily high precision is required, you can fall back to this
+ method.
+ </p>
+</div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2009 Karsten Ahnert and Mario Mulansky<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tutorial.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="integration_functions.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
Added: sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/tutorial.html
==============================================================================
--- (empty file)
+++ sandbox/odeint/libs/numeric/odeint/doc/html/boost_numeric_odeint/tutorial.html 2010-04-27 05:20:17 EDT (Tue, 27 Apr 2010)
@@ -0,0 +1,523 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Tutorial</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter 1. boost.numeric.odeint">
+<link rel="up" href="../index.html" title="Chapter 1. boost.numeric.odeint">
+<link rel="prev" href="short_example.html" title="Short Example">
+<link rel="next" href="stepper.html" title="Stepper">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="short_example.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="stepper.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_numeric_odeint.tutorial"></a><a class="link" href="tutorial.html" title="Tutorial">Tutorial</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="tutorial.html#boost_numeric_odeint.tutorial.harmonic_oscillator">Harmonic
+ oscillator</a></span></dt>
+<dt><span class="section">Solar system</span></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_numeric_odeint.tutorial.harmonic_oscillator"></a><a class="link" href="tutorial.html#boost_numeric_odeint.tutorial.harmonic_oscillator" title="Harmonic oscillator">Harmonic
+ oscillator</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="tutorial.html#boost_numeric_odeint.tutorial.harmonic_oscillator.define_the_ode">Define
+ the ODE</a></span></dt>
+<dt><span class="section"><a href="tutorial.html#boost_numeric_odeint.tutorial.harmonic_oscillator.stepper_types">Stepper
+ Types</a></span></dt>
+<dt><span class="section"><a href="tutorial.html#boost_numeric_odeint.tutorial.harmonic_oscillator.integration_with_constant_step_size">Integration
+ with Constant Step Size</a></span></dt>
+<dt><span class="section"><a href="tutorial.html#boost_numeric_odeint.tutorial.harmonic_oscillator.integration_with_adaptive_step_size">Integration
+ with Adaptive Step Size</a></span></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.tutorial.harmonic_oscillator.define_the_ode"></a><a class="link" href="tutorial.html#boost_numeric_odeint.tutorial.harmonic_oscillator.define_the_ode" title="Define the ODE">Define
+ the ODE</a>
+</h4></div></div></div>
+<p>
+ First of all, you have to specify the datatype that represents a state
+ of your system <span class="bold"><strong>x</strong></span>. Mathematically, this
+ usually is an n-dimensional vector with real numbers or complex numbers
+ as scalar objects. For odeint the most natural way is to use <code class="computeroutput"><span class="identifier">vector</span><span class="special"><</span>
+ <span class="keyword">double</span> <span class="special">></span></code>
+ or <code class="computeroutput"><span class="identifier">vector</span><span class="special"><</span>
+ <span class="identifier">complex</span><span class="special"><</span>
+ <span class="keyword">double</span> <span class="special">></span>
+ <span class="special">></span></code> to represent the system state.
+ However, odeint can deal with other container types than vector as well,
+ e.g. <code class="computeroutput"><span class="identifier">tr1</span><span class="special">/</span><span class="identifier">array</span><span class="special"><</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">N</span> <span class="special">></span></code>
+ as long as it is able to obtain a ForwardIterator going through all of
+ the container's elements. The scalar type must have several operators (
+ +, -, +<code class="literal">, -</code> ) and the <code class="computeroutput"><span class="identifier">abs</span><span class="special">()</span></code>-fcuntion defined . Furthermore, one can
+ choose the datatype of the time (that is, the parameter to which respect
+ the differentiation is done). The standard type for this is <code class="computeroutput"><span class="keyword">double</span></code>, but one might be able to choose,
+ for example, <code class="computeroutput"><span class="identifier">complex</span><span class="special"><</span>
+ <span class="keyword">double</span> <span class="special">></span></code>
+ as well (untested). It must be possible to multiply the time type and the
+ scalar type of the vector. For the most cases <code class="computeroutput"><span class="identifier">vector</span><span class="special"><</span> <span class="keyword">double</span> <span class="special">></span></code> as state type and the standard <code class="computeroutput"><span class="keyword">double</span></code> for the time type should be sufficient.
+ </p>
+<p>
+ To integrate a differential equation numerically, one has to define the
+ rhs of the equation <span class="emphasis"><em>x' = f(x)</em></span>. In odeint you supply
+ this function in terms of an object that implements the ()-operator with
+ a certain parameter structure. Hence, the straight forward way would be
+ to just define a function, e.g:
+ </p>
+<p>
+ </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"><</span><span class="keyword">double</span><span class="special">></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">&</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&</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>
+ </p>
+<p>
+ The parameters of the function must follow the example above where <span class="bold"><strong>x</strong></span> is the current state, <span class="bold"><strong>dxdt</strong></span>
+ is the derivative <span class="emphasis"><em>x'</em></span> and should be filled by the function
+ with <span class="emphasis"><em>f(x)</em></span> and <span class="bold"><strong>t</strong></span> is
+ the current time.
+ </p>
+<p>
+ A more sophisticated approach is to implement the system as a class where
+ the rhs function is defined as the ()-operator of the class with the same
+ parameter structure as above:
+ </p>
+<p>
+ </p>
+<p>
+
+</p>
+<pre class="programlisting"><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">&</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&</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>
+ </p>
+<p>
+ odeint can deal with instances of such classes instead of pure functions
+ which allows for cleaner code.
+ </p>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.tutorial.harmonic_oscillator.stepper_types"></a><a class="link" href="tutorial.html#boost_numeric_odeint.tutorial.harmonic_oscillator.stepper_types" title="Stepper Types">Stepper
+ Types</a>
+</h4></div></div></div>
+<p>
+ Numerical integration works iteratevly, that means you start at a state
+ <span class="emphasis"><em>x(t)</em></span> and performs a timestep of length <span class="emphasis"><em>dt</em></span>
+ to obtain the approximate state <span class="emphasis"><em>x(t+dt)</em></span>. There exist
+ many different methods to perform such a timestep each of which has a certain
+ order <span class="emphasis"><em>q</em></span>. If the order of a method is <span class="emphasis"><em>q</em></span>
+ than it is accurate up to term <span class="emphasis"><em>~dt^q</em></span> that means the
+ error in <span class="emphasis"><em>x</em></span> made by such a step is <span class="emphasis"><em>~dt^(q+1)</em></span>.
+ odeint provides several steppers of different orders from which you can
+ choose. There are three types of steppers: <span class="bold"><strong>Stepper</strong></span>,
+ <span class="bold"><strong>ErrorStepper</strong></span> and <span class="bold"><strong>ControlledStepper</strong></span>.
+ </p>
+<div class="table">
+<a name="boost_numeric_odeint.tutorial.harmonic_oscillator.stepper_types.stepper_algorithms"></a><p class="title"><b>Table 1.2. Stepper Algorithms</b></p>
+<div class="table-contents"><table class="table" summary="Stepper Algorithms">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ <p>
+ Method
+ </p>
+ </th>
+<th>
+ <p>
+ Class
+ </p>
+ </th>
+<th>
+ <p>
+ Order
+ </p>
+ </th>
+<th>
+ <p>
+ Error Estimation
+ </p>
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ <p>
+ Euler
+ </p>
+ </td>
+<td>
+ <p>
+ stepper_euler
+ </p>
+ </td>
+<td>
+ <p>
+ 1
+ </p>
+ </td>
+<td>
+ <p>
+ No
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Runge-Kutta 4
+ </p>
+ </td>
+<td>
+ <p>
+ stepper_rk4
+ </p>
+ </td>
+<td>
+ <p>
+ 4
+ </p>
+ </td>
+<td>
+ <p>
+ No
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Runge-Kutta Cash-Karp
+ </p>
+ </td>
+<td>
+ <p>
+ stepper_rk5_ck
+ </p>
+ </td>
+<td>
+ <p>
+ 5
+ </p>
+ </td>
+<td>
+ <p>
+ Yes (Order 4)
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Runge-Kutta Fehlberg
+ </p>
+ </td>
+<td>
+ <p>
+ stepper_rk78_fehlberg
+ </p>
+ </td>
+<td>
+ <p>
+ 7
+ </p>
+ </td>
+<td>
+ <p>
+ Yes (Order 8)
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Midpoint
+ </p>
+ </td>
+<td>
+ <p>
+ stepper_midpoint
+ </p>
+ </td>
+<td>
+ <p>
+ variable
+ </p>
+ </td>
+<td>
+ <p>
+ No
+ </p>
+ </td>
+</tr>
+<tr>
+<td>
+ <p>
+ Bulirsch-Stoer
+ </p>
+ </td>
+<td>
+ <p>
+ controlled_stepper_bs
+ </p>
+ </td>
+<td>
+ <p>
+ variable
+ </p>
+ </td>
+<td>
+ <p>
+ Controlled
+ </p>
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<br class="table-break">
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.tutorial.harmonic_oscillator.integration_with_constant_step_size"></a><a class="link" href="tutorial.html#boost_numeric_odeint.tutorial.harmonic_oscillator.integration_with_constant_step_size" title="Integration with Constant Step Size">Integration
+ with Constant Step Size</a>
+</h4></div></div></div>
+<p>
+ The basic stepper just performs one timestep and doesn't give you any information
+ about the error that was made (except that you know it is of order q+1).
+ Such steppers are used with constant step size that should be chosen small
+ enough to have reasonable small errors. However, you should apply some
+ sort of validity check of your results (such as observing conserved quantities)
+ becasue you have no other control of the error. The following example defines
+ a basic stepper based on the classical Runge-Kutta scheme of 4th order.
+ </p>
+<p>
+ [define_const_stepper]
+ </p>
+<p>
+ The declaration of the stepper requires the state type as template parameter.
+ The integration can now be done by using the <code class="computeroutput"><span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">Stepper</span><span class="special">,</span> <span class="identifier">System</span><span class="special">,</span> <span class="identifier">state</span><span class="special">,</span> <span class="identifier">start_time</span><span class="special">,</span> <span class="identifier">end_time</span><span class="special">,</span> <span class="identifier">step_size</span>
+ <span class="special">)</span></code> function from odeint:
+ </p>
+<p>
+ [integrate_const]
+ </p>
+<p>
+ This call integrates the system defined by <code class="computeroutput"><span class="identifier">harmonic_oscillator</span></code>
+ using the rk4 method from t=0 to 10 with a stepsize dt=0.01 and the initial
+ condition given in <code class="computeroutput"><span class="identifier">x</span></code>. The
+ result, <span class="emphasis"><em>x(t=10)</em></span> is stored in <code class="computeroutput"><span class="identifier">x</span></code>
+ (in-place).
+ </p>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.tutorial.harmonic_oscillator.integration_with_adaptive_step_size"></a><a class="link" href="tutorial.html#boost_numeric_odeint.tutorial.harmonic_oscillator.integration_with_adaptive_step_size" title="Integration with Adaptive Step Size">Integration
+ with Adaptive Step Size</a>
+</h4></div></div></div>
+<p>
+ To improve the numerical results and additionally minimize the computational
+ effort, the application of a step size control is advisable. Step size
+ control is realized via stepper algorithms that additionally provide an
+ error estimation of the applied step. Odeint provides a number of such
+ <span class="bold"><strong>ErrorSteppers</strong></span> and we will show their usage
+ on the example of stepper_rk5_ck -- a 5th order Runge-Kutta method with
+ 4th order error estimation and coefficients introduced by Cash-Karp.
+ </p>
+<p>
+ [define_adapt_stepper]
+ </p>
+<p>
+ Given the error stepper, one still needs an instance that checks the error
+ and adjusts the step size accordingly. In odeint, this is done by <span class="bold"><strong>ControlledSteppers</strong></span>. The usual way to create a controlled
+ stepper is via the <code class="computeroutput"><span class="identifier">make_controlled_stepper_standard</span><span class="special">(</span> <span class="identifier">ErrorStepper</span>
+ <span class="special">,</span> <span class="identifier">eps_abs</span>
+ <span class="special">,</span> <span class="identifier">eps_rel</span>
+ <span class="special">,</span> <span class="identifier">a_x</span>
+ <span class="special">,</span> <span class="identifier">a_dxdt</span>
+ <span class="special">)</span></code> function that takes an error stepper
+ as parameter and four values defining the maximal absolute and relative
+ error allowed for on integration step. The standard controlled stepper
+ created by this method ensures that the error <span class="emphasis"><em>err</em></span>
+ of the solution fulfills <span class="emphasis"><em>err < eps_abs + eps_rel * ( a_x *
+ |x| + a_dxdt * dt * |dxdt| ) </em></span> by decreasesing the step size.
+ Note, that the stepsize is also increased if the error gets too small compared
+ to the rhs of the above relation. Now we have everything needed to integrate
+ the harmonic oscillator using an adaptive step size method. Similar to
+ the case with constant step size above, there exists a <code class="computeroutput"><span class="identifier">integrate_adaptive</span></code>
+ function with a similar parameter structure, but it requires the controlled
+ stepper create by <code class="computeroutput"><span class="identifier">make_controlled_stepper_standard</span></code>.
+ </p>
+<p>
+ [integrate_adapt]
+ </p>
+<p>
+ As above, this integrates the system defined by <code class="computeroutput"><span class="identifier">harmonic_oscillator</span></code>
+ using an adaptive step size method based on the rk5_ck scheme from t=0
+ to 10 with an initial step size of dt=0.01 (will be adjusted) and the initial
+ condition given in x. The result, x(t=10), will also be stored in x (in-place).
+ </p>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_numeric_odeint.tutorial.solar_system"></a><a class="link" href="tutorial.html#boost_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_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_numeric_odeint.tutorial.solar_system.define_the_system_function">Define
+ the system function</a></span></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.tutorial.solar_system.gravitation_and_energy_conservation"></a><a class="link" href="tutorial.html#boost_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 solar system.
+ In the solar system each planet, and of course also the sun will be represented
+ by mass points. The interaction force between each object is the gravitational
+ force which can be written as Fij = - gamma m M / (qi-qj)3 * (qi-qj)
+ </p>
+<p>
+ where gamma is the gravitational constant, mi and mj are the masses and
+ qi and qj are the locations of the two objects.
+ </p>
+<p>
+ dqi = pi dpi = 1/m sum ji Fij
+ </p>
+<p>
+ where pi is the momenta of object i. The equations of motion can also be
+ derived from the Hamiltonian
+ </p>
+<p>
+ H = sum over i pi^2 / 2 + sum j V( qi , qj )
+ </p>
+<p>
+ via dqi = dH / dpi, dpi = - dH / dq1. V(qi,qj) is the interaction potential.
+ </p>
+<p>
+ In time independent Hamiltonian system the energy is conserved and special
+ integration methods have to be applied in order to ensure energy conservation.
+ The odeint library provides two stepper classes for Hamiltonian systems,
+ which are separable and can be written in the form H = sum pi^2/2 + Hq.
+ </p>
+<p>
+ hamiltonian_stepper_euler hamiltonian_stepper_rk
+ </p>
+<p>
+ 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 dqi=pi dpi=f(qi).
+ </p>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_numeric_odeint.tutorial.solar_system.define_the_system_function"></a><a class="link" href="tutorial.html#boost_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/operator.hpp>:
+ </p>
+<p>
+ show the code
+ </p>
+<p>
+ The next step is to define the state type and the system (derivative) function.
+ As state type we use std::tr1::array and a state type represents all space
+ coordinates q or all momenta coordinates p. As system function we have
+ to provide f(q)
+ </p>
+<p>
+ show the code
+ </p>
+<p>
+ Note, that we have allready define the masses of all planets in the solar
+ system.
+ </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.
+ </p>
+<p>
+ show the code
+ </p>
+<p>
+ Now, we use the rk stepper to integrate the solar system. To visualize
+ the motion we save the trajectory of each planet in a circular buffer.
+ The output can be piped directly into gnuplot and a very nice visualization
+ of the motion appears.
+ </p>
+</div>
+<p>
+ usage of the steppers
+ </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 © 2009 Karsten Ahnert and Mario Mulansky<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="short_example.html"><img src="../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="stepper.html"><img src="../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
Modified: sandbox/odeint/libs/numeric/odeint/doc/html/index.html
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/html/index.html (original)
+++ sandbox/odeint/libs/numeric/odeint/doc/html/index.html 2010-04-27 05:20:17 EDT (Tue, 27 Apr 2010)
@@ -1,11 +1,11 @@
<html>
<head>
-<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Chapter 1. boost.sandbox.numeric.odeint</title>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Chapter 1. boost.numeric.odeint</title>
<link rel="stylesheet" href="boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-<link rel="start" href="index.html" title="Chapter 1. boost.sandbox.numeric.odeint">
-<link rel="next" href="odeint/short_example.html" title="Short Example">
+<link rel="start" href="index.html" title="Chapter 1. boost.numeric.odeint">
+<link rel="next" href="boost_numeric_odeint/short_example.html" title="Short Example">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@@ -17,20 +17,20 @@
<td align="center">More</td>
</tr></table>
<hr>
-<div class="spirit-nav"><a accesskey="n" href="odeint/short_example.html"><img src="../../doc/html/images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="boost_numeric_odeint/short_example.html"><img src="../../doc/html/images/next.png" alt="Next"></a></div>
<div class="chapter" lang="en">
<div class="titlepage"><div>
<div><h2 class="title">
-<a name="odeint"></a>Chapter 1. boost.sandbox.numeric.odeint</h2></div>
+<a name="boost_numeric_odeint"></a>Chapter 1. boost.numeric.odeint</h2></div>
<div><div class="author"><h3 class="author">
<span class="firstname">Karsten</span> <span class="surname">Ahnert</span>
</h3></div></div>
<div><div class="author"><h3 class="author">
<span class="firstname">Mario</span> <span class="surname">Mulansky</span>
</h3></div></div>
-<div><p class="copyright">Copyright © 2009 Karsten Ahnert and Mario Mulansky</p></div>
+<div><p class="copyright">Copyright © 2009 Karsten Ahnert and Mario Mulansky</p></div>
<div><div class="legalnotice">
-<a name="id325363"></a><p>
+<a name="id325394"></a><p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</p>
@@ -39,38 +39,36 @@
<div class="toc">
<p><b>Table of Contents</b></p>
<dl>
-<dt><span class="section">Overview</span></dt>
-<dt><span class="section">Short Example</span></dt>
-<dt><span class="section">Tutorial</span></dt>
+<dt><span class="section">Overview</span></dt>
+<dt><span class="section">Short Example</span></dt>
+<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
+<dt><span class="section"><a href="boost_numeric_odeint/tutorial.html#boost_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
- system</a></span></dt>
+<dt><span class="section">Solar system</span></dt>
</dl></dd>
-<dt><span class="section">Stepper</span></dt>
+<dt><span class="section">Stepper</span></dt>
<dd><dl>
-<dt><span class="section">Concepts</span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/stepper.html#boost_sandbox_numeric_odeint.stepper.stepper_classes">Stepper
+<dt><span class="section">Concepts</span></dt>
+<dt><span class="section"><a href="boost_numeric_odeint/stepper.html#boost_numeric_odeint.stepper.stepper_classes">Stepper
classes</a></span></dt>
</dl></dd>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/integration_functions.html">Integration
+<dt><span class="section"><a href="boost_numeric_odeint/integration_functions.html">Integration
functions</a></span></dt>
<dd><dl>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/integration_functions.html#boost_sandbox_numeric_odeint.integration_functions.constant_step_size_functions">Constant
+<dt><span class="section"><a href="boost_numeric_odeint/integration_functions.html#boost_numeric_odeint.integration_functions.constant_step_size_functions">Constant
step-size functions</a></span></dt>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/integration_functions.html#boost_sandbox_numeric_odeint.integration_functions.adaptive_step_size_functions">Adaptive
+<dt><span class="section"><a href="boost_numeric_odeint/integration_functions.html#boost_numeric_odeint.integration_functions.adaptive_step_size_functions">Adaptive
step-size functions</a></span></dt>
</dl></dd>
-<dt><span class="section"><a href="boost_sandbox_numeric_odeint/container_traits.html">Container
- traits</a></span></dt>
-<dd><dl><dt><span class="section"><a href="boost_sandbox_numeric_odeint/container_traits.html#boost_sandbox_numeric_odeint.container_traits.define_your_own_traits">Define
+<dt><span class="section">Container traits</span></dt>
+<dd><dl><dt><span class="section"><a href="boost_numeric_odeint/container_traits.html#boost_numeric_odeint.container_traits.define_your_own_traits">Define
your own traits</a></span></dt></dl></dd>
</dl>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="odeint.overview"></a><a class="link" href="index.html#odeint.overview" title="Overview">Overview</a>
+<a name="boost_numeric_odeint.overview"></a><a class="link" href="index.html#boost_numeric_odeint.overview" title="Overview">Overview</a>
</h2></div></div></div>
<p>
Odeint is a library for solving initial value problems (IVP) of ordinary differential
@@ -86,8 +84,10 @@
for real life problems and serves just as illustrative example. In <span class="bold"><strong>odeint</strong></span>, the following algorithms are implemented:
</p>
<div class="table">
-<a name="id326850"></a><p class="title"><b>Table 1.1. Stepper Algorithms</b></p>
-<div class="table-contents"><table class="table" summary="Stepper Algorithms">
+<a name="boost_numeric_odeint.overview.stepper_algorithms"></a><p class="title"><b>Table 1.1. Stepper
+ Algorithms</b></p>
+<div class="table-contents"><table class="table" summary="Stepper
+ Algorithms">
<colgroup>
<col>
<col>
@@ -256,10 +256,10 @@
</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: April 20, 2010 at 18:00:35 GMT</small></p></td>
+<td align="left"><p><small>Last revised: April 27, 2010 at 09:26:26 GMT</small></p></td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>
-<div class="spirit-nav"><a accesskey="n" href="odeint/short_example.html"><img src="../../doc/html/images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="boost_numeric_odeint/short_example.html"><img src="../../doc/html/images/next.png" alt="Next"></a></div>
</body>
</html>
Modified: sandbox/odeint/libs/numeric/odeint/doc/html/standalone_HTML.manifest
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/html/standalone_HTML.manifest (original)
+++ sandbox/odeint/libs/numeric/odeint/doc/html/standalone_HTML.manifest 2010-04-27 05:20:17 EDT (Tue, 27 Apr 2010)
@@ -1,6 +1,6 @@
index.html
-odeint/short_example.html
-boost_sandbox_numeric_odeint/tutorial.html
-boost_sandbox_numeric_odeint/stepper.html
-boost_sandbox_numeric_odeint/integration_functions.html
-boost_sandbox_numeric_odeint/container_traits.html
+boost_numeric_odeint/short_example.html
+boost_numeric_odeint/tutorial.html
+boost_numeric_odeint/stepper.html
+boost_numeric_odeint/integration_functions.html
+boost_numeric_odeint/container_traits.html
Modified: sandbox/odeint/libs/numeric/odeint/doc/odeint.qbk
==============================================================================
--- sandbox/odeint/libs/numeric/odeint/doc/odeint.qbk (original)
+++ sandbox/odeint/libs/numeric/odeint/doc/odeint.qbk 2010-04-27 05:20:17 EDT (Tue, 27 Apr 2010)
@@ -1,13 +1,9 @@
-[library boost.sandbox.numeric.odeint
- [quickbook 1.3]
+[library boost.numeric.odeint
+ [quickbook 1.5]
[authors [Ahnert, Karsten], [Mulansky, Mario]]
[copyright 2009 Karsten Ahnert and Mario Mulansky]
- [category math]
- [id odeint]
- [dirname odeint]
- [purpose
- Numerical integration of ordinary differential equations.
- ]
+ [category numeric]
+ [purpose Numerical integration of ordinary differential equations]
[license
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
@@ -50,8 +46,8 @@
Image, for example, you want to numerically integrate a harmonic oscillator
with friction. The equations of motion are given by x'' = -x + gamma x'.
This can be transformed to a system of two first-order differential equations
-with new variables x and p=x'. To apply numerical integration one first has to
design the right hand side of the equation w' = f(w) where in this case
+with new variables x and p=x'. To apply numerical integration one first has to
w = (x,p):
[import ../examples/doc_harm_osc.cpp]
@@ -96,8 +92,6 @@
[endsect]
-[import ../examples/doc_integrate.cpp]
-
[include tutorial.qbk]
[include steppers.qbk]