[DEV] add v1.66.0

This commit is contained in:
2018-01-12 21:47:58 +01:00
parent 87059bb1af
commit a97e9ae7d4
49032 changed files with 7668950 additions and 0 deletions

View File

@@ -0,0 +1,41 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Acknowledgments</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="prev" href="literature.html" title="Literature">
<link rel="next" href="../odeint_reference.html" title="odeint Reference">
</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="../logo.jpg"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="literature.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../odeint_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_numeric_odeint.acknowledgments"></a><a class="link" href="acknowledgments.html" title="Acknowledgments">Acknowledgments</a>
</h2></div></div></div></div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="literature.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../odeint_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,64 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Concepts</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="prev" href="odeint_in_detail/binding_member_functions.html" title="Binding member functions">
<link rel="next" href="concepts/system.html" title="System">
</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="../logo.jpg"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="odeint_in_detail/binding_member_functions.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="concepts/system.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_numeric_odeint.concepts"></a><a class="link" href="concepts.html" title="Concepts">Concepts</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="concepts/system.html">System</a></span></dt>
<dt><span class="section"><a href="concepts/second_order_system.html">Second
Order System</a></span></dt>
<dt><span class="section"><a href="concepts/symplectic_system.html">Symplectic
System</a></span></dt>
<dt><span class="section"><a href="concepts/simple_symplectic_system.html">Simple
Symplectic System</a></span></dt>
<dt><span class="section"><a href="concepts/implicit_system.html">Implicit
System</a></span></dt>
<dt><span class="section"><a href="concepts/stepper.html">Stepper</a></span></dt>
<dt><span class="section"><a href="concepts/error_stepper.html">Error Stepper</a></span></dt>
<dt><span class="section"><a href="concepts/controlled_stepper.html">Controlled
Stepper</a></span></dt>
<dt><span class="section"><a href="concepts/dense_output_stepper.html">Dense
Output Stepper</a></span></dt>
<dt><span class="section"><a href="concepts/state_algebra_operations.html">State
Algebra Operations</a></span></dt>
<dt><span class="section"><a href="concepts/state_wrapper.html">State Wrapper</a></span></dt>
</dl></div>
<a name="odeint.concepts"></a>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="odeint_in_detail/binding_member_functions.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="concepts/system.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,235 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Controlled Stepper</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../concepts.html" title="Concepts">
<link rel="prev" href="error_stepper.html" title="Error Stepper">
<link rel="next" href="dense_output_stepper.html" title="Dense Output 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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="error_stepper.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="dense_output_stepper.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.concepts.controlled_stepper"></a><a class="link" href="controlled_stepper.html" title="Controlled Stepper">Controlled
Stepper</a>
</h3></div></div></div>
<p>
This concept specifies the interface a controlled stepper has to fulfill
to be used within <a class="link" href="../odeint_in_detail/integrate_functions.html" title="Integrate functions">integrate
functions</a>.
</p>
<h5>
<a name="boost_numeric_odeint.concepts.controlled_stepper.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.controlled_stepper.description"></a></span><a class="link" href="controlled_stepper.html#boost_numeric_odeint.concepts.controlled_stepper.description">Description</a>
</h5>
<p>
A controlled stepper following this Controlled Stepper concept provides the
possibility to perform one step of the solution <span class="emphasis"><em>x(t)</em></span>
of an ODE with step-size <span class="emphasis"><em>dt</em></span> to obtain <span class="emphasis"><em>x(t+dt)</em></span>
with a given step-size <span class="emphasis"><em>dt</em></span>. Depending on an error estimate
of the solution the step might be rejected and a smaller step-size is suggested.
</p>
<h5>
<a name="boost_numeric_odeint.concepts.controlled_stepper.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.controlled_stepper.associated_types"></a></span><a class="link" href="controlled_stepper.html#boost_numeric_odeint.concepts.controlled_stepper.associated_types">Associated
types</a>
</h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<p><span class="bold"><strong>state_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">state_type</span></code></p>
<p>The
type characterizing the state of the ODE, hence <span class="emphasis"><em>x</em></span>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>deriv_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">deriv_type</span></code></p>
<p>The
type characterizing the derivative of the ODE, hence <span class="emphasis"><em>d x/dt</em></span>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>time_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span></code></p>
<p>The
type characterizing the dependent variable of the ODE, hence the time
<span class="emphasis"><em>t</em></span>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>value_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">value_type</span></code></p>
<p>The
numerical data type which is used within the stepper, something like
<code class="computeroutput"><span class="keyword">float</span></code>, <code class="computeroutput"><span class="keyword">double</span></code>,
<code class="computeroutput"><span class="identifier">complex</span><span class="special">&amp;</span><span class="identifier">lt</span><span class="special">;</span> <span class="keyword">double</span> <span class="special">&amp;</span><span class="identifier">gt</span><span class="special">;</span></code>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>stepper_category</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">stepper_category</span></code></p>
<p>A
tag type characterizing the category of the stepper. This type must be
convertible to <code class="computeroutput"><span class="identifier">controlled_stepper_tag</span></code>.</p>
</li>
</ul></div>
<h5>
<a name="boost_numeric_odeint.concepts.controlled_stepper.h2"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.controlled_stepper.notation"></a></span><a class="link" href="controlled_stepper.html#boost_numeric_odeint.concepts.controlled_stepper.notation">Notation</a>
</h5>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term"><code class="computeroutput"><span class="identifier">ControlledStepper</span></code></span></dt>
<dd><p>
A type that is a model of Controlled Stepper
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">State</span></code></span></dt>
<dd><p>
A type representing the state <span class="emphasis"><em>x</em></span> of the ODE
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Time</span></code></span></dt>
<dd><p>
A type representing the time <span class="emphasis"><em>t</em></span> of the ODE
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">stepper</span></code></span></dt>
<dd><p>
An object of type <code class="computeroutput"><span class="identifier">ControlledStepper</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">x</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">State</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">t</span></code>, <code class="computeroutput"><span class="identifier">dt</span></code></span></dt>
<dd><p>
Objects of type <code class="computeroutput"><span class="identifier">Time</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">sys</span></code></span></dt>
<dd><p>
An object defining the ODE, should be a model of <a class="link" href="system.html" title="System">System</a>,
<a class="link" href="symplectic_system.html" title="Symplectic System">Symplectic
System</a>, <a class="link" href="simple_symplectic_system.html" title="Simple Symplectic System">Simple
Symplectic System</a> or <a class="link" href="implicit_system.html" title="Implicit System">Implicit
System</a>.
</p></dd>
</dl>
</div>
<h5>
<a name="boost_numeric_odeint.concepts.controlled_stepper.h3"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.controlled_stepper.valid_expressions"></a></span><a class="link" href="controlled_stepper.html#boost_numeric_odeint.concepts.controlled_stepper.valid_expressions">Valid
Expressions</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody><tr>
<td>
<p>
Do step
</p>
</td>
<td>
<p>
</p>
<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">try_step</span><span class="special">(</span> <span class="identifier">sys</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">)</span></pre>
<p>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">controlled_step_result</span></code>
</p>
</td>
<td>
<p>
Tries one step of step size <code class="computeroutput"><span class="identifier">dt</span></code>.
If the step was successful, <code class="computeroutput"><span class="identifier">success</span></code>
is returned, the resulting state is written to <code class="computeroutput"><span class="identifier">x</span></code>,
the new time is stored in <code class="computeroutput"><span class="identifier">t</span></code>
and <code class="computeroutput"><span class="identifier">dt</span></code> now contains
a new (possibly larger) step-size for the next step. If the error
was too big, <code class="computeroutput"><span class="identifier">rejected</span></code>
is returned and the results are neglected - <code class="computeroutput"><span class="identifier">x</span></code>
and <code class="computeroutput"><span class="identifier">t</span></code> are unchanged
and <code class="computeroutput"><span class="identifier">dt</span></code> now contains
a reduced step-size to be used for the next try.
</p>
</td>
</tr></tbody>
</table></div>
<h5>
<a name="boost_numeric_odeint.concepts.controlled_stepper.h4"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.controlled_stepper.models"></a></span><a class="link" href="controlled_stepper.html#boost_numeric_odeint.concepts.controlled_stepper.models">Models</a>
</h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">controlled_error_stepper</span><span class="special">&lt;</span> <span class="identifier">runge_kutta_cash_karp54</span>
<span class="special">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">controlled_error_stepper_fsal</span><span class="special">&lt;</span> <span class="identifier">runge_kutta_dopri5</span>
<span class="special">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">controlled_error_stepper</span><span class="special">&lt;</span> <span class="identifier">runge_kutta_fehlberg78</span>
<span class="special">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">rosenbrock4_controller</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">bulirsch_stoer</span></code>
</li>
</ul></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="error_stepper.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="dense_output_stepper.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,341 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Dense Output Stepper</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../concepts.html" title="Concepts">
<link rel="prev" href="controlled_stepper.html" title="Controlled Stepper">
<link rel="next" href="state_algebra_operations.html" title="State Algebra Operations">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="controlled_stepper.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="state_algebra_operations.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.concepts.dense_output_stepper"></a><a class="link" href="dense_output_stepper.html" title="Dense Output Stepper">Dense
Output Stepper</a>
</h3></div></div></div>
<p>
This concept specifies the interface a dense output stepper has to fulfill
to be used within <a class="link" href="../odeint_in_detail/integrate_functions.html" title="Integrate functions">integrate
functions</a>.
</p>
<h5>
<a name="boost_numeric_odeint.concepts.dense_output_stepper.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.dense_output_stepper.description"></a></span><a class="link" href="dense_output_stepper.html#boost_numeric_odeint.concepts.dense_output_stepper.description">Description</a>
</h5>
<p>
A dense output stepper following this Dense Output Stepper concept provides
the possibility to perform a single step of the solution <span class="emphasis"><em>x(t)</em></span>
of an ODE to obtain <span class="emphasis"><em>x(t+dt)</em></span>. The step-size <code class="computeroutput"><span class="identifier">dt</span></code> might be adjusted automatically due
to error control. Dense output steppers also can interpolate the solution
to calculate the state <span class="emphasis"><em>x(t')</em></span> at any point <span class="emphasis"><em>t
&lt;= t' &lt;= t+dt</em></span>.
</p>
<h5>
<a name="boost_numeric_odeint.concepts.dense_output_stepper.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.dense_output_stepper.associated_types"></a></span><a class="link" href="dense_output_stepper.html#boost_numeric_odeint.concepts.dense_output_stepper.associated_types">Associated
types</a>
</h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<p><span class="bold"><strong>state_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">state_type</span></code></p>
<p>The
type characterizing the state of the ODE, hence <span class="emphasis"><em>x</em></span>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>deriv_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">deriv_type</span></code></p>
<p>The
type characterizing the derivative of the ODE, hence <span class="emphasis"><em>d x/dt</em></span>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>time_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span></code></p>
<p>The
type characterizing the dependent variable of the ODE, hence the time
<span class="emphasis"><em>t</em></span>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>value_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">value_type</span></code></p>
<p>The
numerical data type which is used within the stepper, something like
<code class="computeroutput"><span class="keyword">float</span></code>, <code class="computeroutput"><span class="keyword">double</span></code>,
<code class="computeroutput"><span class="identifier">complex</span><span class="special">&amp;</span><span class="identifier">lt</span><span class="special">;</span> <span class="keyword">double</span> <span class="special">&amp;</span><span class="identifier">gt</span><span class="special">;</span></code>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>stepper_category</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">stepper_category</span></code></p>
<p>A
tag type characterizing the category of the stepper. This type must be
convertible to <code class="computeroutput"><span class="identifier">dense_output_stepper_tag</span></code>.</p>
</li>
</ul></div>
<h5>
<a name="boost_numeric_odeint.concepts.dense_output_stepper.h2"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.dense_output_stepper.notation"></a></span><a class="link" href="dense_output_stepper.html#boost_numeric_odeint.concepts.dense_output_stepper.notation">Notation</a>
</h5>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term"><code class="computeroutput"><span class="identifier">Stepper</span></code></span></dt>
<dd><p>
A type that is a model of Dense Output Stepper
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">State</span></code></span></dt>
<dd><p>
A type representing the state <span class="emphasis"><em>x</em></span> of the ODE
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">stepper</span></code></span></dt>
<dd><p>
An object of type <code class="computeroutput"><span class="identifier">Stepper</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">x0</span></code>, <code class="computeroutput"><span class="identifier">x</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">State</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">t0</span></code>, <code class="computeroutput"><span class="identifier">dt0</span></code>, <code class="computeroutput"><span class="identifier">t</span></code></span></dt>
<dd><p>
Objects of type <code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">sys</span></code></span></dt>
<dd><p>
An object defining the ODE, should be a model of <a class="link" href="system.html" title="System">System</a>,
<a class="link" href="symplectic_system.html" title="Symplectic System">Symplectic
System</a>, <a class="link" href="simple_symplectic_system.html" title="Simple Symplectic System">Simple
Symplectic System</a> or <a class="link" href="implicit_system.html" title="Implicit System">Implicit
System</a>.
</p></dd>
</dl>
</div>
<h5>
<a name="boost_numeric_odeint.concepts.dense_output_stepper.h3"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.dense_output_stepper.valid_expressions"></a></span><a class="link" href="dense_output_stepper.html#boost_numeric_odeint.concepts.dense_output_stepper.valid_expressions">Valid
Expressions</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Initialize integration
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">initialize</span><span class="special">(</span>
<span class="identifier">x0</span> <span class="special">,</span>
<span class="identifier">t0</span> <span class="special">,</span>
<span class="identifier">dt0</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
void
</p>
</td>
<td>
<p>
Initializes the stepper with initial values <code class="computeroutput"><span class="identifier">x0</span></code>,
<code class="computeroutput"><span class="identifier">t0</span></code> and <code class="computeroutput"><span class="identifier">dt0</span></code>.
</p>
</td>
</tr>
<tr>
<td>
<p>
Do step
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">do_step</span><span class="special">(</span>
<span class="identifier">sys</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span>
<span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span> <span class="special">,</span>
<span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span> <span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
Performs one step using the ODE defined by <code class="computeroutput"><span class="identifier">sys</span></code>.
The step-size might be changed internally due to error control.
This function returns a pair containing <code class="computeroutput"><span class="identifier">t</span></code>
and <code class="computeroutput"><span class="identifier">t</span><span class="special">+</span><span class="identifier">dt</span></code> representing the interval
for which interpolation can be performed.
</p>
</td>
</tr>
<tr>
<td>
<p>
Do interpolation
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">calc_state</span><span class="special">(</span>
<span class="identifier">t_inter</span> <span class="special">,</span>
<span class="identifier">x</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Performs the interpolation to calculate /x(t<sub>inter</sub>/) where /t &lt;=
t<sub>inter</sub> &lt;= t+dt/.
</p>
</td>
</tr>
<tr>
<td>
<p>
Get current time
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">current_time</span><span class="special">()</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">const</span> <span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span><span class="special">&amp;</span></code>
</p>
</td>
<td>
<p>
Returns the current time <span class="emphasis"><em>t+dt</em></span> of the stepper,
that is the end time of the last step and the starting time for
the next call of <code class="computeroutput"><span class="identifier">do_step</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Get current state
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">current_state</span><span class="special">()</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">const</span> <span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">state_type</span><span class="special">&amp;</span></code>
</p>
</td>
<td>
<p>
Returns the current state of the stepper, that is <span class="emphasis"><em>x(t+dt)</em></span>,
the state at the time returned by <code class="computeroutput"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">current_time</span><span class="special">()</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Get current time step
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">current_time_step</span><span class="special">()</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">const</span> <span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span><span class="special">&amp;</span></code>
</p>
</td>
<td>
<p>
Returns the current step size of the stepper, that is <span class="emphasis"><em>dt</em></span>
</p>
</td>
</tr>
</tbody>
</table></div>
<h5>
<a name="boost_numeric_odeint.concepts.dense_output_stepper.h4"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.dense_output_stepper.models"></a></span><a class="link" href="dense_output_stepper.html#boost_numeric_odeint.concepts.dense_output_stepper.models">Models</a>
</h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">dense_output_controlled_explicit_fsal</span><span class="special">&lt;</span> <span class="identifier">controlled_error_stepper_fsal</span><span class="special">&lt;</span> <span class="identifier">runge_kutta_dopri5</span>
<span class="special">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">bulirsch_stoer_dense_out</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">rosenbrock4_dense_output</span></code>
</li>
</ul></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="controlled_stepper.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="state_algebra_operations.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,369 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Error Stepper</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../concepts.html" title="Concepts">
<link rel="prev" href="stepper.html" title="Stepper">
<link rel="next" href="controlled_stepper.html" title="Controlled 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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="stepper.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="controlled_stepper.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.concepts.error_stepper"></a><a class="link" href="error_stepper.html" title="Error Stepper">Error Stepper</a>
</h3></div></div></div>
<p>
This concepts specifies the interface an error stepper has to fulfill to
be used within a ControlledErrorStepper. An error stepper must always fulfill
the stepper concept. This can trivially implemented by
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">System</span> <span class="special">&gt;</span>
<span class="identifier">error_stepper</span><span class="special">::</span><span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">System</span> <span class="identifier">sys</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">time_type</span> <span class="identifier">t</span> <span class="special">,</span> <span class="identifier">time_type</span> <span class="identifier">dt</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">state_type</span> <span class="identifier">xerr</span><span class="special">;</span>
<span class="comment">// allocate xerr</span>
<span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">sys</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">,</span> <span class="identifier">xerr</span> <span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
</p>
<h5>
<a name="boost_numeric_odeint.concepts.error_stepper.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.error_stepper.description"></a></span><a class="link" href="error_stepper.html#boost_numeric_odeint.concepts.error_stepper.description">Description</a>
</h5>
<p>
An error stepper following this Error Stepper concept is capable of doing
one step of the solution <span class="emphasis"><em>x(t)</em></span> of an ODE with step-size
<span class="emphasis"><em>dt</em></span> to obtain <span class="emphasis"><em>x(t+dt)</em></span> and also computing
an error estimate <span class="emphasis"><em>x<sub>err</sub></em></span> of the result. Error Steppers
can be Runge-Kutta steppers, symplectic steppers as well as implicit steppers.
Based on the stepper type, the ODE is defined as <a class="link" href="system.html" title="System">System</a>,
<a class="link" href="symplectic_system.html" title="Symplectic System">Symplectic
System</a>, <a class="link" href="simple_symplectic_system.html" title="Simple Symplectic System">Simple
Symplectic System</a> or <a class="link" href="implicit_system.html" title="Implicit System">Implicit
System</a>.
</p>
<h5>
<a name="boost_numeric_odeint.concepts.error_stepper.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.error_stepper.refinement_of"></a></span><a class="link" href="error_stepper.html#boost_numeric_odeint.concepts.error_stepper.refinement_of">Refinement
of</a>
</h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
DefaultConstructable
</li>
<li class="listitem">
CopyConstructable
</li>
<li class="listitem">
Stepper
</li>
</ul></div>
<h5>
<a name="boost_numeric_odeint.concepts.error_stepper.h2"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.error_stepper.associated_types"></a></span><a class="link" href="error_stepper.html#boost_numeric_odeint.concepts.error_stepper.associated_types">Associated
types</a>
</h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<p><span class="bold"><strong>state_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">state_type</span></code></p>
<p>The
type characterizing the state of the ODE, hence <span class="emphasis"><em>x</em></span>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>deriv_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">deriv_type</span></code></p>
<p>The
type characterizing the derivative of the ODE, hence <span class="emphasis"><em>d x/dt</em></span>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>time_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span></code></p>
<p>The
type characterizing the dependent variable of the ODE, hence the time
<span class="emphasis"><em>t</em></span>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>value_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">value_type</span></code></p>
<p>The
numerical data type which is used within the stepper, something like
<code class="computeroutput"><span class="keyword">float</span></code>, <code class="computeroutput"><span class="keyword">double</span></code>,
<code class="computeroutput"><span class="identifier">complex</span><span class="special">&amp;</span><span class="identifier">lt</span><span class="special">;</span> <span class="keyword">double</span> <span class="special">&amp;</span><span class="identifier">gt</span><span class="special">;</span></code>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>order_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">order_type</span></code></p>
<p>The
type characterizing the order of the ODE, typically <code class="computeroutput"><span class="keyword">unsigned</span>
<span class="keyword">short</span></code>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>stepper_category</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">stepper_category</span></code></p>
<p>A
tag type characterizing the category of the stepper. This type must be
convertible to <code class="computeroutput"><span class="identifier">error_stepper_tag</span></code>.</p>
</li>
</ul></div>
<h5>
<a name="boost_numeric_odeint.concepts.error_stepper.h3"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.error_stepper.notation"></a></span><a class="link" href="error_stepper.html#boost_numeric_odeint.concepts.error_stepper.notation">Notation</a>
</h5>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term"><code class="computeroutput"><span class="identifier">ErrorStepper</span></code></span></dt>
<dd><p>
A type that is a model of Error Stepper
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">State</span></code></span></dt>
<dd><p>
A type representing the state <span class="emphasis"><em>x</em></span> of the ODE
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Error</span></code></span></dt>
<dd><p>
A type representing the error calculated by the stepper, usually same
as <code class="computeroutput"><span class="identifier">State</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Time</span></code></span></dt>
<dd><p>
A type representing the time <span class="emphasis"><em>t</em></span> of the ODE
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">stepper</span></code></span></dt>
<dd><p>
An object of type <code class="computeroutput"><span class="identifier">ErrorStepper</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">x</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">State</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">xerr</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">Error</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">t</span></code>, <code class="computeroutput"><span class="identifier">dt</span></code></span></dt>
<dd><p>
Objects of type <code class="computeroutput"><span class="identifier">Time</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">sys</span></code></span></dt>
<dd><p>
An object defining the ODE, should be a model of either <a class="link" href="system.html" title="System">System</a>,
<a class="link" href="symplectic_system.html" title="Symplectic System">Symplectic
System</a>, <a class="link" href="simple_symplectic_system.html" title="Simple Symplectic System">Simple
Symplectic System</a> or <a class="link" href="implicit_system.html" title="Implicit System">Implicit
System</a>.
</p></dd>
</dl>
</div>
<h5>
<a name="boost_numeric_odeint.concepts.error_stepper.h4"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.error_stepper.valid_expressions"></a></span><a class="link" href="error_stepper.html#boost_numeric_odeint.concepts.error_stepper.valid_expressions">Valid
Expressions</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Get the stepper order
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">order</span><span class="special">()</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">order_type</span></code>
</p>
</td>
<td>
<p>
Returns the order of the stepper for one step without error estimation.
</p>
</td>
</tr>
<tr>
<td>
<p>
Get the stepper order
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">stepper_order</span><span class="special">()</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">order_type</span></code>
</p>
</td>
<td>
<p>
Returns the order of the stepper for one error estimation step
which is used for error calculation.
</p>
</td>
</tr>
<tr>
<td>
<p>
Get the error order
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">errorr_order</span><span class="special">()</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">order_type</span></code>
</p>
</td>
<td>
<p>
Returns the order of the error step which is used for error calculation.
</p>
</td>
</tr>
<tr>
<td>
<p>
Do step
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">do_step</span><span class="special">(</span>
<span class="identifier">sys</span> <span class="special">,</span>
<span class="identifier">x</span> <span class="special">,</span>
<span class="identifier">t</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Performs one step of step size <code class="computeroutput"><span class="identifier">dt</span></code>.
The newly obtained state is written in-place to <code class="computeroutput"><span class="identifier">x</span></code>.
</p>
</td>
</tr>
<tr>
<td>
<p>
Do step with error estimation
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">do_step</span><span class="special">(</span>
<span class="identifier">sys</span> <span class="special">,</span>
<span class="identifier">x</span> <span class="special">,</span>
<span class="identifier">t</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">,</span>
<span class="identifier">xerr</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Performs one step of step size <code class="computeroutput"><span class="identifier">dt</span></code>
with error estimation. The newly obtained state is written in-place
to <code class="computeroutput"><span class="identifier">x</span></code> and the estimated
error to <code class="computeroutput"><span class="identifier">xerr</span></code>.
</p>
</td>
</tr>
</tbody>
</table></div>
<h5>
<a name="boost_numeric_odeint.concepts.error_stepper.h5"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.error_stepper.models"></a></span><a class="link" href="error_stepper.html#boost_numeric_odeint.concepts.error_stepper.models">Models</a>
</h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">runge_kutta_cash_karp54</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">runge_kutta_dopri5</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">runge_kutta_fehlberg78</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">rosenbrock4</span></code>
</li>
</ul></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="stepper.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="controlled_stepper.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,184 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Implicit System</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../concepts.html" title="Concepts">
<link rel="prev" href="simple_symplectic_system.html" title="Simple Symplectic System">
<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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="simple_symplectic_system.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="stepper.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.concepts.implicit_system"></a><a class="link" href="implicit_system.html" title="Implicit System">Implicit
System</a>
</h3></div></div></div>
<h5>
<a name="boost_numeric_odeint.concepts.implicit_system.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.implicit_system.description"></a></span><a class="link" href="implicit_system.html#boost_numeric_odeint.concepts.implicit_system.description">Description</a>
</h5>
<p>
This concept describes how to define a ODE that can be solved by an implicit
routine. Implicit routines need not only the function <span class="emphasis"><em>f(x,t)</em></span>
but also the Jacobian <span class="emphasis"><em>df/dx = A(x,t)</em></span>. <span class="emphasis"><em>A</em></span>
is a matrix and implicit routines need to solve the linear problem <span class="emphasis"><em>Ax
= b</em></span>. In odeint this is implemented with use of <a href="http://www.boost.org/doc/libs/release/libs/numeric/ublas/index.html" target="_top">Boost.uBLAS</a>,
therefore, the <span class="emphasis"><em>state_type</em></span> implicit routines is <span class="emphasis"><em>ublas::vector</em></span>
and the matrix is defined as <span class="emphasis"><em>ublas::matrix</em></span>.
</p>
<h5>
<a name="boost_numeric_odeint.concepts.implicit_system.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.implicit_system.notation"></a></span><a class="link" href="implicit_system.html#boost_numeric_odeint.concepts.implicit_system.notation">Notation</a>
</h5>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term"><code class="computeroutput"><span class="identifier">System</span></code></span></dt>
<dd><p>
A type that is a model of <code class="computeroutput"><span class="identifier">Implicit</span>
<span class="identifier">System</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Time</span></code></span></dt>
<dd><p>
A type representing the time of the ODE
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">sys</span></code></span></dt>
<dd><p>
An object of type <code class="computeroutput"><span class="identifier">System</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">x</span></code></span></dt>
<dd><p>
Object of type ublas::vector
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">dxdt</span></code></span></dt>
<dd><p>
Object of type ublas::vector
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">jacobi</span></code></span></dt>
<dd><p>
Object of type ublas::matrix
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">t</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">Time</span></code>
</p></dd>
</dl>
</div>
<h5>
<a name="boost_numeric_odeint.concepts.implicit_system.h2"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.implicit_system.valid_expressions"></a></span><a class="link" href="implicit_system.html#boost_numeric_odeint.concepts.implicit_system.valid_expressions">Valid
Expressions</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Calculate <span class="emphasis"><em>dx/dt := f(x,t)</em></span>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">sys</span><span class="special">.</span><span class="identifier">first</span><span class="special">(</span>
<span class="identifier">x</span> <span class="special">,</span>
<span class="identifier">dxdt</span> <span class="special">,</span>
<span class="identifier">t</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Calculates <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">t</span><span class="special">)</span></code>,
the result is stored into dxdt
</p>
</td>
</tr>
<tr>
<td>
<p>
Calculate <span class="emphasis"><em>A := df/dx (x,t)</em></span>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">sys</span><span class="special">.</span><span class="identifier">second</span><span class="special">(</span>
<span class="identifier">x</span> <span class="special">,</span>
<span class="identifier">jacobi</span> <span class="special">,</span>
<span class="identifier">t</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Calculates the Jacobian of <span class="emphasis"><em>f</em></span> at <span class="emphasis"><em>x</em></span>,<span class="emphasis"><em>t</em></span>,
the result is stored into <code class="computeroutput"><span class="identifier">jacobi</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="simple_symplectic_system.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="stepper.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,168 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Second Order System</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../concepts.html" title="Concepts">
<link rel="prev" href="system.html" title="System">
<link rel="next" href="symplectic_system.html" title="Symplectic System">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="system.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="symplectic_system.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.concepts.second_order_system"></a><a class="link" href="second_order_system.html" title="Second Order System">Second
Order System</a>
</h3></div></div></div>
<h5>
<a name="boost_numeric_odeint.concepts.second_order_system.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.second_order_system.description"></a></span><a class="link" href="second_order_system.html#boost_numeric_odeint.concepts.second_order_system.description">Description</a>
</h5>
<p>
The Second Order System concept models the algorithmic implementation of
the rhs for steppers requirering the second order derivative, hence the r.h.s.
of the ODE <span class="emphasis"><em>x'' = f(x,x',t)</em></span>. The only requirement for
this concept is that it should be callable with a specific parameter syntax
(see below). A Second Order System is typically implemented as a function
or a functor. Systems fulfilling this concept are required by the Velocity
Verlet method.
</p>
<h5>
<a name="boost_numeric_odeint.concepts.second_order_system.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.second_order_system.notation"></a></span><a class="link" href="second_order_system.html#boost_numeric_odeint.concepts.second_order_system.notation">Notation</a>
</h5>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term"><code class="computeroutput"><span class="identifier">System</span></code></span></dt>
<dd><p>
A type that is a model of Second Order System
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Space</span></code></span></dt>
<dd><p>
A type representing the state <span class="emphasis"><em>x</em></span> of the ODE
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Velocity</span></code></span></dt>
<dd><p>
A type representing the derivative <span class="emphasis"><em>x'</em></span> of the ODE
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Acceleration</span></code></span></dt>
<dd><p>
A type representing the second order derivative <span class="emphasis"><em>x''</em></span>
of the ODE
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Time</span></code></span></dt>
<dd><p>
A type representing the time
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">sys</span></code></span></dt>
<dd><p>
An object of type <code class="computeroutput"><span class="identifier">System</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">x</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">Space</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">v</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">Velocity</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">a</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">Acceleration</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">t</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">Time</span></code>
</p></dd>
</dl>
</div>
<h5>
<a name="boost_numeric_odeint.concepts.second_order_system.h2"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.second_order_system.valid_expressions"></a></span><a class="link" href="second_order_system.html#boost_numeric_odeint.concepts.second_order_system.valid_expressions">Valid
expressions</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody><tr>
<td>
<p>
Calculate <span class="emphasis"><em>x'' := f(x,x',t)</em></span>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">sys</span><span class="special">(</span>
<span class="identifier">x</span> <span class="special">,</span>
<span class="identifier">v</span> <span class="special">,</span>
<span class="identifier">a</span> <span class="special">,</span>
<span class="identifier">t</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Calculates f(x,x',t), the result is stored into a.
</p>
</td>
</tr></tbody>
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="system.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="symplectic_system.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,187 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Simple Symplectic System</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../concepts.html" title="Concepts">
<link rel="prev" href="symplectic_system.html" title="Symplectic System">
<link rel="next" href="implicit_system.html" title="Implicit System">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="symplectic_system.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="implicit_system.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.concepts.simple_symplectic_system"></a><a class="link" href="simple_symplectic_system.html" title="Simple Symplectic System">Simple
Symplectic System</a>
</h3></div></div></div>
<h5>
<a name="boost_numeric_odeint.concepts.simple_symplectic_system.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.simple_symplectic_system.description"></a></span><a class="link" href="simple_symplectic_system.html#boost_numeric_odeint.concepts.simple_symplectic_system.description">Description</a>
</h5>
<p>
In most Hamiltonian systems the kinetic term is a quadratic term in the momentum
<span class="emphasis"><em>H<sub>kin</sub> = p^2 / 2m</em></span> and in many cases it is possible to rescale
coordinates and set <span class="emphasis"><em>m=1</em></span> which leads to a trivial equation
of motion:
</p>
<p>
<span class="emphasis"><em>q'(t) = f(p) = p. </em></span>
</p>
<p>
while for <span class="emphasis"><em>p'</em></span> we still have the general form
</p>
<p>
<span class="emphasis"><em>p'(t) = g(q) </em></span>
</p>
<p>
As this case is very frequent we introduced a concept where only the nontrivial
equation for <span class="emphasis"><em>p'</em></span> has to be provided to the symplectic
stepper. We call this concept <span class="emphasis"><em>SimpleSymplecticSystem</em></span>
</p>
<h5>
<a name="boost_numeric_odeint.concepts.simple_symplectic_system.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.simple_symplectic_system.notation"></a></span><a class="link" href="simple_symplectic_system.html#boost_numeric_odeint.concepts.simple_symplectic_system.notation">Notation</a>
</h5>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">System</span></dt>
<dd><p>
A type that is a model of SimpleSymplecticSystem
</p></dd>
<dt><span class="term">Coor</span></dt>
<dd><p>
The type of the coordinate <span class="emphasis"><em>q</em></span>
</p></dd>
<dt><span class="term">MomentumDeriv</span></dt>
<dd><p>
The type of the derivative of momentum <span class="emphasis"><em>p'</em></span>
</p></dd>
<dt><span class="term">sys</span></dt>
<dd><p>
An object that models System
</p></dd>
<dt><span class="term">q</span></dt>
<dd><p>
Object of type Coor
</p></dd>
<dt><span class="term">dpdt</span></dt>
<dd><p>
Object of type MomentumDeriv
</p></dd>
</dl>
</div>
<h5>
<a name="boost_numeric_odeint.concepts.simple_symplectic_system.h2"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.simple_symplectic_system.valid_expressions"></a></span><a class="link" href="simple_symplectic_system.html#boost_numeric_odeint.concepts.simple_symplectic_system.valid_expressions">Valid
Expressions</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Check for pair
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pair</span><span class="special">&lt;</span>
<span class="identifier">System</span> <span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span></code>
</p>
</td>
<td>
<p>
Check if System is a pair, should be evaluated to false in this
case.
</p>
</td>
</tr>
<tr>
<td>
<p>
Calculate <span class="emphasis"><em>dp/dt = g(q)</em></span>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">sys</span><span class="special">(</span>
<span class="identifier">q</span> <span class="special">,</span>
<span class="identifier">dpdt</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Calculates <span class="emphasis"><em>g(q)</em></span>, the result is stored into
<code class="computeroutput"><span class="identifier">dpdt</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="symplectic_system.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="implicit_system.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,882 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>State Algebra Operations</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../concepts.html" title="Concepts">
<link rel="prev" href="dense_output_stepper.html" title="Dense Output Stepper">
<link rel="next" href="state_wrapper.html" title="State Wrapper">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="dense_output_stepper.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="state_wrapper.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.concepts.state_algebra_operations"></a><a class="link" href="state_algebra_operations.html" title="State Algebra Operations">State
Algebra Operations</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="state_algebra_operations.html#boost_numeric_odeint.concepts.state_algebra_operations.operations">Operations</a></span></dt>
<dt><span class="section"><a href="state_algebra_operations.html#boost_numeric_odeint.concepts.state_algebra_operations.algebra">Algebra</a></span></dt>
<dt><span class="section"><a href="state_algebra_operations.html#boost_numeric_odeint.concepts.state_algebra_operations.pre_defined_implementations">Pre-Defined
implementations</a></span></dt>
<dt><span class="section"><a href="state_algebra_operations.html#boost_numeric_odeint.concepts.state_algebra_operations.example_expressions">Example
expressions</a></span></dt>
</dl></div>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
The following does not apply to implicit steppers like implicit_euler or
Rosenbrock 4 as there the <code class="computeroutput"><span class="identifier">state_type</span></code>
can not be changed from <code class="computeroutput"><span class="identifier">ublas</span><span class="special">::</span><span class="identifier">vector</span></code>
and no algebra/operations are used.
</p></td></tr>
</table></div>
<h5>
<a name="boost_numeric_odeint.concepts.state_algebra_operations.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.state_algebra_operations.description"></a></span><a class="link" href="state_algebra_operations.html#boost_numeric_odeint.concepts.state_algebra_operations.description">Description</a>
</h5>
<p>
The <code class="computeroutput"><span class="identifier">State</span></code>, <code class="computeroutput"><span class="identifier">Algebra</span></code> and <code class="computeroutput"><span class="identifier">Operations</span></code>
together define a concept describing how the mathematical vector operations
required for the stepper algorithms are performed. The typical vector operation
done within steppers is
</p>
<p>
<span class="emphasis"><em><span class="bold"><strong>y</strong></span> = &#931; &#945;<sub>i</sub> <span class="bold"><strong>x<sub>i</sub></strong></span></em></span>.
</p>
<p>
The <code class="computeroutput"><span class="identifier">State</span></code> represents the
state variable of an ODE, usually denoted with <span class="emphasis"><em>x</em></span>. Algorithmically,
the state is often realized as a <code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span></code> or <code class="computeroutput"><span class="identifier">array</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">N</span> <span class="special">&gt;</span></code>,
however, the genericity of odeint enables you to basically use anything as
a state type. The algorithmic counterpart of such mathematical expressions
is divided into two parts. First, the <code class="computeroutput"><span class="identifier">Algebra</span></code>
is used to account for the vector character of the equation. In the case
of a <code class="computeroutput"><span class="identifier">vector</span></code> as state type
this means the <code class="computeroutput"><span class="identifier">Algebra</span></code> is
responsible for iteration over all vector elements. Second, the <code class="computeroutput"><span class="identifier">Operations</span></code> are used to represent the actual
operation applied to each of the vector elements. So the <code class="computeroutput"><span class="identifier">Algebra</span></code>
iterates over all elements of the <code class="computeroutput"><span class="identifier">State</span></code>s
and calls an operation taken from the <code class="computeroutput"><span class="identifier">Operations</span></code>
for each element. This is where <code class="computeroutput"><span class="identifier">State</span></code>,
<code class="computeroutput"><span class="identifier">Algebra</span></code> and <code class="computeroutput"><span class="identifier">Operations</span></code> have to work together to make
odeint running. Please have a look at the <code class="computeroutput"><span class="identifier">range_algebra</span></code>
and <code class="computeroutput"><span class="identifier">default_operations</span></code> to
see an example how this is implemented.
</p>
<p>
In the following we describe how <code class="computeroutput"><span class="identifier">State</span></code>,
<code class="computeroutput"><span class="identifier">Algebra</span></code> and <code class="computeroutput"><span class="identifier">Operations</span></code> are used together within the
stepper implementations.
</p>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.concepts.state_algebra_operations.operations"></a><a class="link" href="state_algebra_operations.html#boost_numeric_odeint.concepts.state_algebra_operations.operations" title="Operations">Operations</a>
</h4></div></div></div>
<h6>
<a name="boost_numeric_odeint.concepts.state_algebra_operations.operations.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.state_algebra_operations.operations.notation"></a></span><a class="link" href="state_algebra_operations.html#boost_numeric_odeint.concepts.state_algebra_operations.operations.notation">Notation</a>
</h6>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term"><code class="computeroutput"><span class="identifier">Operations</span></code></span></dt>
<dd><p>
The operations type
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Value1</span></code>, ... ,
<code class="computeroutput"><span class="identifier">ValueN</span></code></span></dt>
<dd><p>
Types representing the value or time type of stepper
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Scale</span></code></span></dt>
<dd><p>
Type of the scale operation
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">scale</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">Scale</span></code>
</p></dd>
<dt><span class="term"><code class="literal">ScaleSum<span class="emphasis"><em>N</em></span></code></span></dt>
<dd><p>
Type that represents a general scale_sum operation, <code class="literal"><span class="emphasis"><em>N</em></span></code>
should be replaced by a number from 1 to 14.
</p></dd>
<dt><span class="term"><code class="literal">scale_sum<span class="emphasis"><em>N</em></span></code></span></dt>
<dd><p>
Object of type <code class="literal">ScaleSum<span class="emphasis"><em>N</em></span></code>,
<code class="literal"><span class="emphasis"><em>N</em></span></code> should be replaced by a
number from 1 to 14.
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">ScaleSumSwap2</span></code></span></dt>
<dd><p>
Type of the scale sum swap operation
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">scale_sum_swap2</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">ScaleSumSwap2</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">a1</span><span class="special">,</span>
<span class="identifier">a2</span><span class="special">,</span>
<span class="special">...</span></code></span></dt>
<dd><p>
Objects of type <code class="computeroutput"><span class="identifier">Value1</span></code>,
<code class="computeroutput"><span class="identifier">Value2</span></code>, ...
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">y</span><span class="special">,</span>
<span class="identifier">x1</span><span class="special">,</span>
<span class="identifier">x2</span><span class="special">,</span>
<span class="special">...</span></code></span></dt>
<dd><p>
Objects of <code class="computeroutput"><span class="identifier">State</span></code>'s
value type
</p></dd>
</dl>
</div>
<h6>
<a name="boost_numeric_odeint.concepts.state_algebra_operations.operations.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.state_algebra_operations.operations.valid_expressions"></a></span><a class="link" href="state_algebra_operations.html#boost_numeric_odeint.concepts.state_algebra_operations.operations.valid_expressions">Valid
Expressions</a>
</h6>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Get scale operation
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Operations</span><span class="special">::</span><span class="identifier">scale</span><span class="special">&lt;</span>
<span class="identifier">Value</span> <span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Scale</span></code>
</p>
</td>
<td>
<p>
Get <code class="computeroutput"><span class="identifier">Scale</span></code> from
<code class="computeroutput"><span class="identifier">Operations</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">Scale</span></code> constructor
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Scale</span><span class="special">&lt;</span>
<span class="identifier">Value</span> <span class="special">&gt;(</span>
<span class="identifier">a</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Scale</span></code>
</p>
</td>
<td>
<p>
Constructs a <code class="computeroutput"><span class="identifier">Scale</span></code>
object
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">Scale</span></code> operation
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">scale</span><span class="special">(</span>
<span class="identifier">x</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Calculates <code class="computeroutput"><span class="identifier">x</span> <span class="special">*=</span> <span class="identifier">a</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Get general <code class="computeroutput"><span class="identifier">scale_sum</span></code>
operation
</p>
</td>
<td>
<p>
<code class="literal">Operations::scale_sum<span class="emphasis"><em>N</em></span>&lt; Value1
, ... , ValueN &gt;</code>
</p>
</td>
<td>
<p>
<code class="literal">ScaleSum<span class="emphasis"><em>N</em></span></code>
</p>
</td>
<td>
<p>
Get the <code class="literal">ScaleSum<span class="emphasis"><em>N</em></span></code> type
from <code class="computeroutput"><span class="identifier">Operations</span></code>,
<code class="literal"><span class="emphasis"><em>N</em></span></code> should be replaced
by a number from 1 to 14.
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">scale_sum</span></code> constructor
</p>
</td>
<td>
<p>
<code class="literal">ScaleSum<span class="emphasis"><em>N</em></span>&lt; Value1 , ... , ValueN
&gt;( a1 , ... , aN )</code>
</p>
</td>
<td>
<p>
<code class="literal">ScaleSum<span class="emphasis"><em>N</em></span></code>
</p>
</td>
<td>
<p>
Constructs a <code class="computeroutput"><span class="identifier">scale_sum</span></code>
object given <code class="literal"><span class="emphasis"><em>N</em></span></code> parameter
values with <code class="literal"><span class="emphasis"><em>N</em></span></code> between
1 and 14.
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">scale_sum</span></code> operation
</p>
</td>
<td>
<p>
<code class="literal">scale_sum<span class="emphasis"><em>N</em></span>( y , x1 , ... , xN )</code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Calculates <code class="computeroutput"><span class="identifier">y</span> <span class="special">=</span> <span class="identifier">a1</span><span class="special">*</span><span class="identifier">x1</span>
<span class="special">+</span> <span class="identifier">a2</span><span class="special">*</span><span class="identifier">x2</span>
<span class="special">+</span> <span class="special">...</span>
<span class="special">+</span> <span class="identifier">aN</span><span class="special">*</span><span class="identifier">xN</span></code>.
Note that this is an <code class="literal"><span class="emphasis"><em>N</em></span>+1</code>-ary
function call.
</p>
</td>
</tr>
<tr>
<td>
<p>
Get scale sum swap operation
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Operations</span><span class="special">::</span><span class="identifier">scale_sum_swap2</span><span class="special">&lt;</span>
<span class="identifier">Value1</span> <span class="special">,</span>
<span class="identifier">Value2</span> <span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">ScaleSumSwap2</span></code>
</p>
</td>
<td>
<p>
Get scale sum swap from operations
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">ScaleSumSwap2</span></code>
constructor
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">ScaleSumSwap2</span><span class="special">&lt;</span> <span class="identifier">Value1</span>
<span class="special">,</span> <span class="identifier">Value2</span>
<span class="special">&gt;(</span> <span class="identifier">a1</span>
<span class="special">,</span> <span class="identifier">a2</span>
<span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">ScaleSumSwap2</span></code>
</p>
</td>
<td>
<p>
Constructor
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">ScaleSumSwap2</span></code>
operation
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">scale_sum_swap2</span><span class="special">(</span> <span class="identifier">x1</span>
<span class="special">,</span> <span class="identifier">x2</span>
<span class="special">,</span> <span class="identifier">x3</span>
<span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Calculates <code class="computeroutput"><span class="identifier">tmp</span> <span class="special">=</span> <span class="identifier">x1</span></code>,
<code class="computeroutput"><span class="identifier">x1</span> <span class="special">=</span>
<span class="identifier">a1</span><span class="special">*</span><span class="identifier">x2</span> <span class="special">+</span>
<span class="identifier">a2</span><span class="special">*</span><span class="identifier">x3</span></code> and <code class="computeroutput"><span class="identifier">x2</span>
<span class="special">=</span> <span class="identifier">tmp</span></code>.
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.concepts.state_algebra_operations.algebra"></a><a class="link" href="state_algebra_operations.html#boost_numeric_odeint.concepts.state_algebra_operations.algebra" title="Algebra">Algebra</a>
</h4></div></div></div>
<h6>
<a name="boost_numeric_odeint.concepts.state_algebra_operations.algebra.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.state_algebra_operations.algebra.notation"></a></span><a class="link" href="state_algebra_operations.html#boost_numeric_odeint.concepts.state_algebra_operations.algebra.notation">Notation</a>
</h6>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term"><code class="computeroutput"><span class="identifier">State</span></code></span></dt>
<dd><p>
The state type
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Algebra</span></code></span></dt>
<dd><p>
The algebra type
</p></dd>
<dt><span class="term"><code class="literal">Operation<span class="emphasis"><em>N</em></span></code></span></dt>
<dd><p>
An <code class="literal"><span class="emphasis"><em>N</em></span></code>-ary operation type,
<code class="literal"><span class="emphasis"><em>N</em></span></code> should be a number from
1 to 14.
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">algebra</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">Algebra</span></code>
</p></dd>
<dt><span class="term"><code class="literal">operation<span class="emphasis"><em>N</em></span></code></span></dt>
<dd><p>
Object of type <code class="literal">Operation<span class="emphasis"><em>N</em></span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">y</span><span class="special">,</span>
<span class="identifier">x1</span><span class="special">,</span>
<span class="identifier">x2</span><span class="special">,</span>
<span class="special">...</span></code></span></dt>
<dd><p>
Objects of type <code class="computeroutput"><span class="identifier">State</span></code>
</p></dd>
</dl>
</div>
<h6>
<a name="boost_numeric_odeint.concepts.state_algebra_operations.algebra.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.state_algebra_operations.algebra.valid_expressions"></a></span><a class="link" href="state_algebra_operations.html#boost_numeric_odeint.concepts.state_algebra_operations.algebra.valid_expressions">Valid
Expressions</a>
</h6>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Vector Operation with arity 2
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">algebra</span><span class="special">.</span><span class="identifier">for_each2</span><span class="special">(</span>
<span class="identifier">y</span> <span class="special">,</span>
<span class="identifier">x</span> <span class="special">,</span>
<span class="identifier">operation2</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
void
</p>
</td>
<td>
<p>
Calls <code class="computeroutput"><span class="identifier">operation2</span><span class="special">(</span> <span class="identifier">y_i</span>
<span class="special">,</span> <span class="identifier">x_i</span>
<span class="special">)</span></code> for each element <code class="computeroutput"><span class="identifier">y_i</span></code> of <code class="computeroutput"><span class="identifier">y</span></code>
and <code class="computeroutput"><span class="identifier">x_i</span></code> of <code class="computeroutput"><span class="identifier">x</span></code>.
</p>
</td>
</tr>
<tr>
<td>
<p>
Vector Operation with arity 3
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">algebra</span><span class="special">.</span><span class="identifier">for_each3</span><span class="special">(</span>
<span class="identifier">y</span> <span class="special">,</span>
<span class="identifier">x1</span> <span class="special">,</span>
<span class="identifier">x2</span> <span class="special">,</span>
<span class="identifier">operation3</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
void
</p>
</td>
<td>
<p>
Calls <code class="computeroutput"><span class="identifier">operation3</span><span class="special">(</span> <span class="identifier">y_i</span>
<span class="special">,</span> <span class="identifier">x1_i</span>
<span class="special">,</span> <span class="identifier">x2_i</span>
<span class="special">)</span></code> for each element <code class="computeroutput"><span class="identifier">y_i</span></code> of <code class="computeroutput"><span class="identifier">y</span></code>
and <code class="computeroutput"><span class="identifier">x1_i</span></code> of
<code class="computeroutput"><span class="identifier">x1</span></code> and <code class="computeroutput"><span class="identifier">x2_i</span></code> of <code class="computeroutput"><span class="identifier">x2</span></code>.
</p>
</td>
</tr>
<tr>
<td>
<p>
Vector Operation with arity <code class="literal"><span class="emphasis"><em>N</em></span></code>
</p>
</td>
<td>
<p>
<code class="literal">algebra.for_each<span class="emphasis"><em>N</em></span>( y , x1 , ...
, xN , operation<span class="emphasis"><em>N</em></span> )</code>
</p>
</td>
<td>
<p>
void
</p>
</td>
<td>
<p>
Calls <code class="literal">operation<span class="emphasis"><em>N</em></span>( y_i , x1_i ,
... , xN_i )</code> for each element <code class="computeroutput"><span class="identifier">y_i</span></code>
of <code class="computeroutput"><span class="identifier">y</span></code> and <code class="computeroutput"><span class="identifier">x1_i</span></code> of <code class="computeroutput"><span class="identifier">x1</span></code>
and so on. <code class="literal"><span class="emphasis"><em>N</em></span></code> should be
replaced by a number between 1 and 14.
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.concepts.state_algebra_operations.pre_defined_implementations"></a><a class="link" href="state_algebra_operations.html#boost_numeric_odeint.concepts.state_algebra_operations.pre_defined_implementations" title="Pre-Defined implementations">Pre-Defined
implementations</a>
</h4></div></div></div>
<p>
As standard configuration odeint uses the <code class="computeroutput"><span class="identifier">range_algebra</span></code>
and <code class="computeroutput"><span class="identifier">default_operations</span></code>
which suffices most situations. However, a few more possibilities exist
either to gain better performance or to ensure interoperability with other
libraries. In the following we list the existing <code class="computeroutput"><span class="identifier">Algebra</span></code>/<code class="computeroutput"><span class="identifier">Operations</span></code> configurations that can be
used in the steppers.
</p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
<code class="computeroutput"><span class="identifier">State</span></code>
</p>
</th>
<th>
<p>
<code class="computeroutput"><span class="identifier">Algebra</span></code>
</p>
</th>
<th>
<p>
<code class="computeroutput"><span class="identifier">Operations</span></code>
</p>
</th>
<th>
<p>
Remarks
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Anything supporting <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>,
like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span></code>, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span></code>,
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span></code>,... based on a <code class="computeroutput"><span class="identifier">value_type</span></code> that supports operators
+,* (typically <code class="computeroutput"><span class="keyword">double</span></code>)
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">range_algebra</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">default_operations</span></code>
</p>
</td>
<td>
<p>
Standard implementation, applicable for most typical situations.
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span></code> based on a <code class="computeroutput"><span class="identifier">value_type</span></code> that supports operators
+,*
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">array_algebra</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">default_operations</span></code>
</p>
</td>
<td>
<p>
Special implementation for boost::array with better performance
than <code class="computeroutput"><span class="identifier">range_algebra</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Anything that defines operators + within itself and * with scalar
(Mathematically spoken, anything that is a vector space).
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">vector_space_algebra</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">default_operations</span></code>
</p>
</td>
<td>
<p>
For the use of <a class="link" href="controlled_stepper.html" title="Controlled Stepper">Controlled
Stepper</a>, the template <code class="computeroutput"><span class="identifier">vector_space_reduce</span></code>
has to be instantiated.
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">thrust</span><span class="special">::</span><span class="identifier">device_vector</span></code>, <code class="computeroutput"><span class="identifier">thrust</span><span class="special">::</span><span class="identifier">host_vector</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">thrust_algebra</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">thrust_operations</span></code>
</p>
</td>
<td>
<p>
For running odeint on CUDA devices by using <a href="http://code.google.com/p/thrust/" target="_top">Thrust</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
Any RandomAccessRange
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">openmp_range_algebra</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">default_operations</span></code>
</p>
</td>
<td>
<p>
OpenMP-parallelised range algebra
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">openmp_state</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">openmp_algebra</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">default_operations</span></code>
</p>
</td>
<td>
<p>
OpenMP-parallelised algebra for split data
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span></code> or anything which allocates
the elements in a C-like manner
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">vector_space_algebra</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">mkl_operations</span></code>
</p>
</td>
<td>
<p>
Using the <a href="http://software.intel.com/en-us/articles/intel-mkl/" target="_top">Intel
Math Kernel Library</a> in odeint for maximum performance.
Currently, only the RK4 stepper is supported.
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.concepts.state_algebra_operations.example_expressions"></a><a class="link" href="state_algebra_operations.html#boost_numeric_odeint.concepts.state_algebra_operations.example_expressions" title="Example expressions">Example
expressions</a>
</h4></div></div></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody><tr>
<td>
<p>
Vector operation
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">algebra</span><span class="special">.</span><span class="identifier">for_each3</span><span class="special">(</span>
<span class="identifier">y</span> <span class="special">,</span>
<span class="identifier">x1</span> <span class="special">,</span>
<span class="identifier">x2</span> <span class="special">,</span>
<span class="identifier">Operations</span><span class="special">::</span><span class="identifier">scale_sum2</span><span class="special">&lt;</span>
<span class="identifier">Value1</span> <span class="special">,</span>
<span class="identifier">Value2</span> <span class="special">&gt;(</span>
<span class="identifier">a1</span> <span class="special">,</span>
<span class="identifier">a2</span> <span class="special">)</span>
<span class="special">)</span></code>
</p>
</td>
<td>
<p>
void
</p>
</td>
<td>
<p>
Calculates <span class="emphasis"><em><span class="bold"><strong>y</strong></span> = a1
<span class="bold"><strong>x1</strong></span> + a2 <span class="bold"><strong>x2</strong></span></em></span>
</p>
</td>
</tr></tbody>
</table></div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="dense_output_stepper.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="state_wrapper.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,233 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>State Wrapper</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../concepts.html" title="Concepts">
<link rel="prev" href="state_algebra_operations.html" title="State Algebra Operations">
<link rel="next" href="../literature.html" title="Literature">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="state_algebra_operations.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../literature.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.concepts.state_wrapper"></a><a class="link" href="state_wrapper.html" title="State Wrapper">State Wrapper</a>
</h3></div></div></div>
<h5>
<a name="boost_numeric_odeint.concepts.state_wrapper.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.state_wrapper.description"></a></span><a class="link" href="state_wrapper.html#boost_numeric_odeint.concepts.state_wrapper.description">Description</a>
</h5>
<p>
The <code class="computeroutput"><span class="identifier">State</span> <span class="identifier">Wrapper</span></code>
concept describes the way odeint creates temporary state objects to store
intermediate results within the stepper's <code class="computeroutput"><span class="identifier">do_step</span></code>
methods.
</p>
<h5>
<a name="boost_numeric_odeint.concepts.state_wrapper.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.state_wrapper.notation"></a></span><a class="link" href="state_wrapper.html#boost_numeric_odeint.concepts.state_wrapper.notation">Notation</a>
</h5>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term"><code class="computeroutput"><span class="identifier">State</span></code></span></dt>
<dd><p>
A type that is the <code class="computeroutput"><span class="identifier">state_type</span></code>
of the ODE
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">WrappedState</span></code></span></dt>
<dd><p>
A type that is a model of State Wrapper for the state type <code class="computeroutput"><span class="identifier">State</span></code>.
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">x</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">State</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">w</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">WrappedState</span></code>
</p></dd>
</dl>
</div>
<h5>
<a name="boost_numeric_odeint.concepts.state_wrapper.h2"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.state_wrapper.valid_expressions"></a></span><a class="link" href="state_wrapper.html#boost_numeric_odeint.concepts.state_wrapper.valid_expressions">Valid
Expressions</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Get resizeability
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">is_resizeable</span><span class="special">&lt;</span>
<span class="identifier">State</span> <span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">false_type</span></code> or <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">true_type</span></code>
</p>
</td>
<td>
<p>
Returns <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">true_type</span></code> if the <code class="computeroutput"><span class="identifier">State</span></code> is resizeable, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">false_type</span></code> otherwise.
</p>
</td>
</tr>
<tr>
<td>
<p>
Create <code class="computeroutput"><span class="identifier">WrappedState</span></code>
type
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">state_wrapper</span><span class="special">&lt;</span>
<span class="identifier">State</span> <span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">WrappedState</span></code>
</p>
</td>
<td>
<p>
Creates the type for a <code class="computeroutput"><span class="identifier">WrappedState</span></code>
for the state type <code class="computeroutput"><span class="identifier">State</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Constructor
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">WrappedState</span><span class="special">()</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">WrappedState</span></code>
</p>
</td>
<td>
<p>
Constructs a state wrapper with an empty state
</p>
</td>
</tr>
<tr>
<td>
<p>
Copy Constructor
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">WrappedState</span><span class="special">(</span>
<span class="identifier">w</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">WrappedState</span></code>
</p>
</td>
<td>
<p>
Constructs a state wrapper with a state of the same size as the
state in <code class="computeroutput"><span class="identifier">w</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Get state
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">w</span><span class="special">.</span><span class="identifier">m_v</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">State</span></code>
</p>
</td>
<td>
<p>
Returns the <code class="computeroutput"><span class="identifier">State</span></code>
object of this state wrapper.
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="state_algebra_operations.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../literature.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,279 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Stepper</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../concepts.html" title="Concepts">
<link rel="prev" href="implicit_system.html" title="Implicit System">
<link rel="next" href="error_stepper.html" title="Error Stepper">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="implicit_system.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="error_stepper.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.concepts.stepper"></a><a class="link" href="stepper.html" title="Stepper">Stepper</a>
</h3></div></div></div>
<p>
This concepts specifies the interface a simple stepper has to fulfill to
be used within the <a class="link" href="../odeint_in_detail/integrate_functions.html" title="Integrate functions">integrate
functions</a>.
</p>
<h5>
<a name="boost_numeric_odeint.concepts.stepper.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.stepper.description"></a></span><a class="link" href="stepper.html#boost_numeric_odeint.concepts.stepper.description">Description</a>
</h5>
<p>
The basic stepper concept. A basic stepper following this Stepper concept
is able to perform a single step of the solution <span class="emphasis"><em>x(t)</em></span>
of an ODE to obtain <span class="emphasis"><em>x(t+dt)</em></span> using a given step size
<span class="emphasis"><em>dt</em></span>. Basic steppers can be Runge-Kutta steppers, symplectic
steppers as well as implicit steppers. Depending on the actual stepper, the
ODE is defined as <a class="link" href="system.html" title="System">System</a>,
<a class="link" href="symplectic_system.html" title="Symplectic System">Symplectic
System</a>, <a class="link" href="simple_symplectic_system.html" title="Simple Symplectic System">Simple
Symplectic System</a> or <a class="link" href="implicit_system.html" title="Implicit System">Implicit
System</a>. Note that all error steppers are also basic steppers.
</p>
<h5>
<a name="boost_numeric_odeint.concepts.stepper.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.stepper.refinement_of"></a></span><a class="link" href="stepper.html#boost_numeric_odeint.concepts.stepper.refinement_of">Refinement
of</a>
</h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
DefaultConstructable
</li>
<li class="listitem">
CopyConstructable
</li>
</ul></div>
<h5>
<a name="boost_numeric_odeint.concepts.stepper.h2"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.stepper.associated_types"></a></span><a class="link" href="stepper.html#boost_numeric_odeint.concepts.stepper.associated_types">Associated
types</a>
</h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<p><span class="bold"><strong>state_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">state_type</span></code></p>
<p>The
type characterizing the state of the ODE, hence <span class="emphasis"><em>x</em></span>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>deriv_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">deriv_type</span></code></p>
<p>The
type characterizing the derivative of the ODE, hence <span class="emphasis"><em>d x/dt</em></span>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>time_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span></code></p>
<p>The
type characterizing the dependent variable of the ODE, hence the time
<span class="emphasis"><em>t</em></span>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>value_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">value_type</span></code></p>
<p>The
numerical data type which is used within the stepper, something like
<code class="computeroutput"><span class="keyword">float</span></code>, <code class="computeroutput"><span class="keyword">double</span></code>,
<code class="computeroutput"><span class="identifier">complex</span><span class="special">&amp;</span><span class="identifier">lt</span><span class="special">;</span> <span class="keyword">double</span> <span class="special">&amp;</span><span class="identifier">gt</span><span class="special">;</span></code>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>order_type</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">order_type</span></code></p>
<p>The
type characterizing the order of the ODE, typically <code class="computeroutput"><span class="keyword">unsigned</span>
<span class="keyword">short</span></code>.</p>
</li>
<li class="listitem">
<p><span class="bold"><strong>stepper_category</strong></span></p>
<p><code class="computeroutput"><span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">stepper_category</span></code></p>
<p>A
tag type characterizing the category of the stepper. This type must be
convertible to <code class="computeroutput"><span class="identifier">stepper_tag</span></code>.</p>
</li>
</ul></div>
<h5>
<a name="boost_numeric_odeint.concepts.stepper.h3"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.stepper.notation"></a></span><a class="link" href="stepper.html#boost_numeric_odeint.concepts.stepper.notation">Notation</a>
</h5>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term"><code class="computeroutput"><span class="identifier">Stepper</span></code></span></dt>
<dd><p>
A type that is a model of Stepper
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">State</span></code></span></dt>
<dd><p>
A type representing the state <span class="emphasis"><em>x</em></span> of the ODE
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Time</span></code></span></dt>
<dd><p>
A type representing the time <span class="emphasis"><em>t</em></span> of the ODE
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">stepper</span></code></span></dt>
<dd><p>
An object of type <code class="computeroutput"><span class="identifier">Stepper</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">x</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">State</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">t</span></code>, <code class="computeroutput"><span class="identifier">dt</span></code></span></dt>
<dd><p>
Objects of type <code class="computeroutput"><span class="identifier">Time</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">sys</span></code></span></dt>
<dd><p>
An object defining the ODE. Depending on the Stepper this might be
a model of <a class="link" href="system.html" title="System">System</a>,
<a class="link" href="symplectic_system.html" title="Symplectic System">Symplectic
System</a>, <a class="link" href="simple_symplectic_system.html" title="Simple Symplectic System">Simple
Symplectic System</a> or <a class="link" href="implicit_system.html" title="Implicit System">Implicit
System</a>
</p></dd>
</dl>
</div>
<h5>
<a name="boost_numeric_odeint.concepts.stepper.h4"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.stepper.valid_expressions"></a></span><a class="link" href="stepper.html#boost_numeric_odeint.concepts.stepper.valid_expressions">Valid Expressions</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Get the order
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">order</span><span class="special">()</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">order_type</span></code>
</p>
</td>
<td>
<p>
Returns the order of the stepper.
</p>
</td>
</tr>
<tr>
<td>
<p>
Do step
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">stepper</span><span class="special">.</span><span class="identifier">do_step</span><span class="special">(</span>
<span class="identifier">sys</span> <span class="special">,</span>
<span class="identifier">x</span> <span class="special">,</span>
<span class="identifier">t</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Performs one step of step size <code class="computeroutput"><span class="identifier">dt</span></code>.
The newly obtained state is written in place in <code class="computeroutput"><span class="identifier">x</span></code>.
</p>
</td>
</tr>
</tbody>
</table></div>
<h5>
<a name="boost_numeric_odeint.concepts.stepper.h5"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.stepper.models"></a></span><a class="link" href="stepper.html#boost_numeric_odeint.concepts.stepper.models">Models</a>
</h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">runge_kutta4</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">euler</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">runge_kutta_cash_karp54</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">runge_kutta_dopri5</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">runge_kutta_fehlberg78</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">modified_midpoint</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">rosenbrock4</span></code>
</li>
</ul></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="implicit_system.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="error_stepper.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,241 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Symplectic System</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../concepts.html" title="Concepts">
<link rel="prev" href="second_order_system.html" title="Second Order System">
<link rel="next" href="simple_symplectic_system.html" title="Simple Symplectic System">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="second_order_system.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="simple_symplectic_system.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.concepts.symplectic_system"></a><a class="link" href="symplectic_system.html" title="Symplectic System">Symplectic
System</a>
</h3></div></div></div>
<h5>
<a name="boost_numeric_odeint.concepts.symplectic_system.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.symplectic_system.description"></a></span><a class="link" href="symplectic_system.html#boost_numeric_odeint.concepts.symplectic_system.description">Description</a>
</h5>
<p>
This concept describes how to define a symplectic system written with generalized
coordinate <code class="computeroutput"><span class="identifier">q</span></code> and generalized
momentum <code class="computeroutput"><span class="identifier">p</span></code>:
</p>
<p>
<span class="emphasis"><em>q'(t) = f(p) </em></span>
</p>
<p>
<span class="emphasis"><em>p'(t) = g(q) </em></span>
</p>
<p>
Such a situation is typically found for Hamiltonian systems with a separable
Hamiltonian:
</p>
<p>
<span class="emphasis"><em>H(p,q) = H<sub>kin</sub>(p) + V(q) </em></span>
</p>
<p>
which gives the equations of motion:
</p>
<p>
<span class="emphasis"><em>q'(t) = dH<sub>kin</sub> / dp = f(p) </em></span>
</p>
<p>
<span class="emphasis"><em>p'(t) = dV / dq = g(q) </em></span>
</p>
<p>
The algorithmic implementation of this situation is described by a pair of
callable objects for <span class="emphasis"><em>f</em></span> and <span class="emphasis"><em>g</em></span> with
a specific parameter signature. Such a system should be implemented as a
std::pair of functions or a functors. Symplectic systems are used in symplectic
steppers like <code class="computeroutput"><span class="identifier">symplectic_rkn_sb3a_mclachlan</span></code>.
</p>
<h5>
<a name="boost_numeric_odeint.concepts.symplectic_system.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.symplectic_system.notation"></a></span><a class="link" href="symplectic_system.html#boost_numeric_odeint.concepts.symplectic_system.notation">Notation</a>
</h5>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term"><code class="computeroutput"><span class="identifier">System</span></code></span></dt>
<dd><p>
A type that is a model of SymplecticSystem
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Coor</span></code></span></dt>
<dd><p>
The type of the coordinate <span class="emphasis"><em>q</em></span>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Momentum</span></code></span></dt>
<dd><p>
The type of the momentum <span class="emphasis"><em>p</em></span>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">CoorDeriv</span></code></span></dt>
<dd><p>
The type of the derivative of coordinate <span class="emphasis"><em>q'</em></span>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">MomentumDeriv</span></code></span></dt>
<dd><p>
The type of the derivative of momentum <span class="emphasis"><em>p'</em></span>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">sys</span></code></span></dt>
<dd><p>
An object of the type <code class="computeroutput"><span class="identifier">System</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">q</span></code></span></dt>
<dd><p>
Object of type Coor
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">p</span></code></span></dt>
<dd><p>
Object of type Momentum
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">dqdt</span></code></span></dt>
<dd><p>
Object of type CoorDeriv
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">dpdt</span></code></span></dt>
<dd><p>
Object of type MomentumDeriv
</p></dd>
</dl>
</div>
<h5>
<a name="boost_numeric_odeint.concepts.symplectic_system.h2"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.symplectic_system.valid_expressions"></a></span><a class="link" href="symplectic_system.html#boost_numeric_odeint.concepts.symplectic_system.valid_expressions">Valid
expressions</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Check for pair
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pair</span><span class="special">&lt;</span>
<span class="identifier">System</span> <span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span></code>
</p>
</td>
<td>
<p>
Check if System is a pair
</p>
</td>
</tr>
<tr>
<td>
<p>
Calculate <span class="emphasis"><em>dq/dt = f(p)</em></span>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">sys</span><span class="special">.</span><span class="identifier">first</span><span class="special">(</span>
<span class="identifier">p</span> <span class="special">,</span>
<span class="identifier">dqdt</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Calculates <span class="emphasis"><em>f(p)</em></span>, the result is stored into
<code class="computeroutput"><span class="identifier">dqdt</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Calculate <span class="emphasis"><em>dp/dt = g(q)</em></span>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">sys</span><span class="special">.</span><span class="identifier">second</span><span class="special">(</span>
<span class="identifier">q</span> <span class="special">,</span>
<span class="identifier">dpdt</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Calculates <span class="emphasis"><em>g(q)</em></span>, the result is stored into
<code class="computeroutput"><span class="identifier">dpdt</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="second_order_system.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="simple_symplectic_system.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,158 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>System</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../concepts.html" title="Concepts">
<link rel="prev" href="../concepts.html" title="Concepts">
<link rel="next" href="second_order_system.html" title="Second Order System">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../concepts.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="second_order_system.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.concepts.system"></a><a class="link" href="system.html" title="System">System</a>
</h3></div></div></div>
<h5>
<a name="boost_numeric_odeint.concepts.system.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.system.description"></a></span><a class="link" href="system.html#boost_numeric_odeint.concepts.system.description">Description</a>
</h5>
<p>
The System concept models the algorithmic implementation of the rhs. of the
ODE <span class="emphasis"><em>x' = f(x,t)</em></span>. The only requirement for this concept
is that it should be callable with a specific parameter syntax (see below).
A System is typically implemented as a function or a functor. Systems fulfilling
this concept are required by all Runge-Kutta steppers as well as the Bulirsch-Stoer
steppers. However, symplectic and implicit steppers work with other system
concepts, see <a class="link" href="symplectic_system.html" title="Symplectic System">Symplectic
System</a> and <a class="link" href="implicit_system.html" title="Implicit System">Implicit
System</a>.
</p>
<h5>
<a name="boost_numeric_odeint.concepts.system.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.system.notation"></a></span><a class="link" href="system.html#boost_numeric_odeint.concepts.system.notation">Notation</a>
</h5>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term"><code class="computeroutput"><span class="identifier">System</span></code></span></dt>
<dd><p>
A type that is a model of System
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">State</span></code></span></dt>
<dd><p>
A type representing the state <span class="emphasis"><em>x</em></span> of the ODE
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Deriv</span></code></span></dt>
<dd><p>
A type representing the derivative <span class="emphasis"><em>x'</em></span> of the ODE
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Time</span></code></span></dt>
<dd><p>
A type representing the time
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">sys</span></code></span></dt>
<dd><p>
An object of type <code class="computeroutput"><span class="identifier">System</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">x</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">State</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">dxdt</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">Deriv</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">t</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">Time</span></code>
</p></dd>
</dl>
</div>
<h5>
<a name="boost_numeric_odeint.concepts.system.h2"></a>
<span class="phrase"><a name="boost_numeric_odeint.concepts.system.valid_expressions"></a></span><a class="link" href="system.html#boost_numeric_odeint.concepts.system.valid_expressions">Valid expressions</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody><tr>
<td>
<p>
Calculate <span class="emphasis"><em>dx/dt := f(x,t)</em></span>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">sys</span><span class="special">(</span>
<span class="identifier">x</span> <span class="special">,</span>
<span class="identifier">dxdt</span> <span class="special">,</span>
<span class="identifier">t</span> <span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Calculates f(x,t), the result is stored into dxdt
</p>
</td>
</tr></tbody>
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../concepts.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="second_order_system.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,50 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Getting started</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="prev" href="../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="next" href="getting_started/overview.html" title="Overview">
</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="../logo.jpg"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../index.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="getting_started/overview.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_numeric_odeint.getting_started"></a><a class="link" href="getting_started.html" title="Getting started">Getting started</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="getting_started/overview.html">Overview</a></span></dt>
<dt><span class="section"><a href="getting_started/usage__compilation__headers.html">Usage,
Compilation, Headers</a></span></dt>
<dt><span class="section"><a href="getting_started/short_example.html">Short
Example</a></span></dt>
</dl></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../index.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="getting_started/overview.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,207 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Short Example</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../getting_started.html" title="Getting started">
<link rel="prev" href="usage__compilation__headers.html" title="Usage, Compilation, Headers">
<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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="usage__compilation__headers.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../getting_started.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../tutorial.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.getting_started.short_example"></a><a class="link" href="short_example.html" title="Short Example">Short
Example</a>
</h3></div></div></div>
<p>
Imaging, you want to numerically integrate a harmonic oscillator with friction.
The equations of motion are given by <span class="emphasis"><em>x'' = -x + &#947; x'</em></span>.
Odeint only deals with first order ODEs that have no higher derivatives than
x' involved. However, any higher order ODE can be transformed to a system
of first order ODEs by introducing the new variables <span class="emphasis"><em>q=x</em></span>
and <span class="emphasis"><em>p=x'</em></span> such that <span class="emphasis"><em>w=(q,p)</em></span>. To
apply numerical integration one first has to design the right hand side of
the equation <span class="emphasis"><em>w' = f(w) = (p,-q+&#947; p)</em></span>:
</p>
<p>
</p>
<pre class="programlisting"><span class="comment">/* The type of container used to hold the state vector */</span>
<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">gam</span> <span class="special">=</span> <span class="number">0.15</span><span class="special">;</span>
<span class="comment">/* The rhs of x' = f(x) */</span>
<span class="keyword">void</span> <span class="identifier">harmonic_oscillator</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">const</span> <span class="keyword">double</span> <span class="comment">/* t */</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">gam</span><span class="special">*</span><span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
<span class="special">}</span>
</pre>
<p>
</p>
<p>
Here we chose <code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span></code>
as the state type, but others are also possible, for example <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span><span class="number">2</span><span class="special">&gt;</span></code>. odeint is designed in such a way that
you can easily use your own state types. Next, the ODE is defined which is
in this case a simple function calculating <span class="emphasis"><em>f(x)</em></span>. The
parameter signature of this function is crucial: the integration methods
will always call them in the form <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span>
<span class="identifier">dxdt</span><span class="special">,</span>
<span class="identifier">t</span><span class="special">)</span></code>
(there are exceptions for some special routines). So, even if there is no
explicit time dependence, one has to define <code class="computeroutput"><span class="identifier">t</span></code>
as a function parameter.
</p>
<p>
Now, we have to define the initial state from which the integration should
start:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">state_type</span> <span class="identifier">x</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
<span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="number">1.0</span><span class="special">;</span> <span class="comment">// start at x=1.0, p=0.0</span>
<span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
For the integration itself we'll use the <code class="computeroutput"><span class="identifier">integrate</span></code>
function, which is a convenient way to get quick results. It is based on
the error-controlled <code class="computeroutput"><span class="identifier">runge_kutta54_cash_karp</span></code>
stepper (5th order) and uses adaptive step-size.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">size_t</span> <span class="identifier">steps</span> <span class="special">=</span> <span class="identifier">integrate</span><span class="special">(</span> <span class="identifier">harmonic_oscillator</span> <span class="special">,</span>
<span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.1</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
The integrate function expects as parameters the rhs of the ode as defined
above, the initial state <code class="computeroutput"><span class="identifier">x</span></code>,
the start-and end-time of the integration as well as the initial time step=size.
Note, that <code class="computeroutput"><span class="identifier">integrate</span></code> uses
an adaptive step-size during the integration steps so the time points will
not be equally spaced. The integration returns the number of steps that were
applied and updates x which is set to the approximate solution of the ODE
at the end of integration.
</p>
<p>
It is also possible to represent the ode system as a class. The rhs must
then be implemented as a functor - a class with an overloaded function call
operator:
</p>
<p>
</p>
<pre class="programlisting"><span class="comment">/* The rhs of x' = f(x) defined as a class */</span>
<span class="keyword">class</span> <span class="identifier">harm_osc</span> <span class="special">{</span>
<span class="keyword">double</span> <span class="identifier">m_gam</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">harm_osc</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">gam</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_gam</span><span class="special">(</span><span class="identifier">gam</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">const</span> <span class="keyword">double</span> <span class="comment">/* t */</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">m_gam</span><span class="special">*</span><span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
which can be used via
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">harm_osc</span> <span class="identifier">ho</span><span class="special">(</span><span class="number">0.15</span><span class="special">);</span>
<span class="identifier">steps</span> <span class="special">=</span> <span class="identifier">integrate</span><span class="special">(</span> <span class="identifier">ho</span> <span class="special">,</span>
<span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.1</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
In order to observe the solution during the integration steps all you have
to do is to provide a reasonable observer. An example is
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">push_back_state_and_time</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;&amp;</span> <span class="identifier">m_states</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;&amp;</span> <span class="identifier">m_times</span><span class="special">;</span>
<span class="identifier">push_back_state_and_time</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">states</span> <span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">times</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">m_states</span><span class="special">(</span> <span class="identifier">states</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_times</span><span class="special">(</span> <span class="identifier">times</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">m_states</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">);</span>
<span class="identifier">m_times</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span> <span class="identifier">t</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
which stores the intermediate steps in a container. Note, the argument structure
of the ()-operator: odeint calls the observer exactly in this way, providing
the current state and time. Now, you only have to pass this container to
the integration function:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">state_type</span><span class="special">&gt;</span> <span class="identifier">x_vec</span><span class="special">;</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">times</span><span class="special">;</span>
<span class="identifier">steps</span> <span class="special">=</span> <span class="identifier">integrate</span><span class="special">(</span> <span class="identifier">harmonic_oscillator</span> <span class="special">,</span>
<span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.1</span> <span class="special">,</span>
<span class="identifier">push_back_state_and_time</span><span class="special">(</span> <span class="identifier">x_vec</span> <span class="special">,</span> <span class="identifier">times</span> <span class="special">)</span> <span class="special">);</span>
<span class="comment">/* output */</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span><span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;=</span><span class="identifier">steps</span><span class="special">;</span> <span class="identifier">i</span><span class="special">++</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">times</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="char">'\t'</span> <span class="special">&lt;&lt;</span> <span class="identifier">x_vec</span><span class="special">[</span><span class="identifier">i</span><span class="special">][</span><span class="number">0</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="char">'\t'</span> <span class="special">&lt;&lt;</span> <span class="identifier">x_vec</span><span class="special">[</span><span class="identifier">i</span><span class="special">][</span><span class="number">1</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="char">'\n'</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
<p>
That is all. You can use functional libraries like <a href="http://www.boost.org/doc/libs/release/libs/lambda/" target="_top">Boost.Lambda</a>
or <a href="http://www.boost.org/doc/libs/release/libs/phoenix/" target="_top">Boost.Phoenix</a>
to ease the creation of observer functions.
</p>
<p>
The full cpp file for this example can be found here: <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/harmonic_oscillator.cpp" target="_top">harmonic_oscillator.cpp</a>
</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 &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="usage__compilation__headers.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../getting_started.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../tutorial.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,95 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Usage, Compilation, Headers</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../getting_started.html" title="Getting started">
<link rel="prev" href="overview.html" title="Overview">
<link rel="next" href="short_example.html" title="Short Example">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="overview.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../getting_started.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="short_example.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.getting_started.usage__compilation__headers"></a><a class="link" href="usage__compilation__headers.html" title="Usage, Compilation, Headers">Usage,
Compilation, Headers</a>
</h3></div></div></div>
<p>
odeint is a header-only library, no linking against pre-compiled code is
required. It can be included by
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
</p>
<p>
which includes all headers of the library. All functions and classes from
odeint live in the namespace
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">odeint</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
It is also possible to include only parts of the library. This is the recommended
way since it saves a lot of compilation time.
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">/</span><span class="identifier">stepper</span><span class="special">/</span><span class="identifier">XYZ</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
- the include path for all steppers, XYZ is a placeholder for a stepper.
</li>
<li class="listitem">
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">/</span><span class="identifier">algebra</span><span class="special">/</span><span class="identifier">XYZ</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
- all algebras.
</li>
<li class="listitem">
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">/</span><span class="identifier">util</span><span class="special">/</span><span class="identifier">XYZ</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
- the utility functions like <code class="computeroutput"><span class="identifier">is_resizeable</span></code>,
<code class="computeroutput"><span class="identifier">same_size</span></code>, or <code class="computeroutput"><span class="identifier">resize</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">/</span><span class="identifier">integrate</span><span class="special">/</span><span class="identifier">XYZ</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
- the integrate routines.
</li>
<li class="listitem">
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">/</span><span class="identifier">iterator</span><span class="special">/</span><span class="identifier">XYZ</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
- the range and iterator functions.
</li>
<li class="listitem">
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">/</span><span class="identifier">external</span><span class="special">/</span><span class="identifier">XYZ</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
- any binders to external libraries.
</li>
</ul></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="overview.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../getting_started.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="short_example.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,102 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Literature</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="prev" href="concepts/state_wrapper.html" title="State Wrapper">
<link rel="next" href="acknowledgments.html" title="Acknowledgments">
</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="../logo.jpg"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="concepts/state_wrapper.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgments.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_numeric_odeint.literature"></a><a class="link" href="literature.html" title="Literature">Literature</a>
</h2></div></div></div>
<p>
<span class="bold"><strong>General information about numerical integration of ordinary
differential equations:</strong></span>
</p>
<p>
<a name="numerical_recipies"></a>[1] Press William H et al., Numerical Recipes
3rd Edition: The Art of Scientific Computing, 3rd ed. (Cambridge University
Press, 2007).
</p>
<p>
<a name="hairer_solving_odes_1"></a>[2] Ernst Hairer, Syvert P. N&#248;rsett, and
Gerhard Wanner, Solving Ordinary Differential Equations I: Nonstiff Problems,
2nd ed. (Springer, Berlin, 2009).
</p>
<p>
<a name="hairer_solving_odes_2"></a>[3] Ernst Hairer and Gerhard Wanner, Solving
Ordinary Differential Equations II: Stiff and Differential-Algebraic Problems,
2nd ed. (Springer, Berlin, 2010).
</p>
<p>
<span class="bold"><strong>Symplectic integration of numerical integration:</strong></span>
</p>
<p>
<a name="hairer_geometrical_numeric_integration"></a>[4] Ernst Hairer, Gerhard
Wanner, and Christian Lubich, Geometric Numerical Integration: Structure-Preserving
Algorithms for Ordinary Differential Equations, 2nd ed. (Springer-Verlag Gmbh,
2006).
</p>
<p>
<a name="leimkuhler_reich_simulating_hamiltonian_dynamics"></a>[5] Leimkuhler
Benedict and Reich Sebastian, Simulating Hamiltonian Dynamics (Cambridge University
Press, 2005).
</p>
<p>
<span class="bold"><strong>Special symplectic methods:</strong></span>
</p>
<p>
<a name="symplectic_yoshida_symplectic_integrators"></a>[6] Haruo Yoshida,
&#8220;Construction of higher order symplectic integrators,&#8221; Physics Letters
A 150, no. 5 (November 12, 1990): 262-268.
</p>
<p>
<a name="symplectic_mylachlan_symmetric_composition_mehtods"></a>[7] Robert
I. McLachlan, &#8220;On the numerical integration of ordinary differential equations
by symmetric composition methods,&#8221; SIAM J. Sci. Comput. 16, no. 1 (1995):
151-168.
</p>
<p>
<span class="bold"><strong>Special systems:</strong></span>
</p>
<p>
<a name="fpu_scholarpedia"></a>[8] <a href="http://www.scholarpedia.org/article/Fermi-Pasta-Ulam_nonlinear_lattice_oscillations" target="_top">Fermi-Pasta-Ulam
nonlinear lattice oscillations</a>
</p>
<p>
<a name="synchronization_pikovsky_rosenblum"></a>[9] Arkady Pikovsky, Michael
Rosemblum, and J&#252;rgen Kurths, Synchronization: A Universal Concept in Nonlinear
Sciences. (Cambridge University Press, 2001).
</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 &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="concepts/state_wrapper.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgments.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,60 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>odeint in detail</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="prev" href="tutorial/all_examples.html" title="All examples">
<link rel="next" href="odeint_in_detail/steppers.html" title="Steppers">
</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="../logo.jpg"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tutorial/all_examples.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="odeint_in_detail/steppers.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_numeric_odeint.odeint_in_detail"></a><a class="link" href="odeint_in_detail.html" title="odeint in detail">odeint in detail</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="odeint_in_detail/steppers.html">Steppers</a></span></dt>
<dt><span class="section"><a href="odeint_in_detail/generation_functions.html">Generation
functions</a></span></dt>
<dt><span class="section"><a href="odeint_in_detail/integrate_functions.html">Integrate
functions</a></span></dt>
<dt><span class="section"><a href="odeint_in_detail/iterators_and_ranges.html">Iterators
and Ranges</a></span></dt>
<dt><span class="section"><a href="odeint_in_detail/state_types__algebras_and_operations.html">State
types, algebras and operations</a></span></dt>
<dt><span class="section"><a href="odeint_in_detail/using_boost__ref.html">Using
boost::ref</a></span></dt>
<dt><span class="section"><a href="odeint_in_detail/using_boost__range.html">Using
boost::range</a></span></dt>
<dt><span class="section"><a href="odeint_in_detail/binding_member_functions.html">Binding
member functions</a></span></dt>
</dl></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tutorial/all_examples.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="odeint_in_detail/steppers.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,130 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Binding member functions</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../odeint_in_detail.html" title="odeint in detail">
<link rel="prev" href="using_boost__range.html" title="Using boost::range">
<link rel="next" href="../concepts.html" title="Concepts">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="using_boost__range.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../odeint_in_detail.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../concepts.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.binding_member_functions"></a><a class="link" href="binding_member_functions.html" title="Binding member functions">Binding
member functions</a>
</h3></div></div></div>
<div class="toc"><dl class="toc"><dt><span class="section"><a href="binding_member_functions.html#boost_numeric_odeint.odeint_in_detail.binding_member_functions.binding_member_functions_in_c__11">Binding
member functions in C++11</a></span></dt></dl></div>
<p>
Binding member functions to a function objects suitable for odeint system
function is not easy, at least in C++03. The usual way of using __boost_bind
does not work because of the forwarding problem. odeint provides two <code class="computeroutput"><span class="identifier">do_step</span></code> method which only differ in the
const specifiers of the arguments and __boost_bind binders only provide the
specializations up to two argument which is not enough for odeint.
</p>
<p>
But one can easily implement the according binders themself:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Obj</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Mem</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">ode_wrapper</span>
<span class="special">{</span>
<span class="identifier">Obj</span> <span class="identifier">m_obj</span><span class="special">;</span>
<span class="identifier">Mem</span> <span class="identifier">m_mem</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">ode_wrapper</span><span class="special">(</span> <span class="identifier">Obj</span> <span class="identifier">obj</span> <span class="special">,</span> <span class="identifier">Mem</span> <span class="identifier">mem</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_obj</span><span class="special">(</span> <span class="identifier">obj</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_mem</span><span class="special">(</span> <span class="identifier">mem</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Deriv</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Time</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">Deriv</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">Time</span> <span class="identifier">t</span> <span class="special">)</span>
<span class="special">{</span>
<span class="special">(</span><span class="identifier">m_obj</span><span class="special">.*</span><span class="identifier">m_mem</span><span class="special">)(</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Obj</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Mem</span> <span class="special">&gt;</span>
<span class="identifier">ode_wrapper</span><span class="special">&lt;</span> <span class="identifier">Obj</span> <span class="special">,</span> <span class="identifier">Mem</span> <span class="special">&gt;</span> <span class="identifier">make_ode_wrapper</span><span class="special">(</span> <span class="identifier">Obj</span> <span class="identifier">obj</span> <span class="special">,</span> <span class="identifier">Mem</span> <span class="identifier">mem</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">ode_wrapper</span><span class="special">&lt;</span> <span class="identifier">Obj</span> <span class="special">,</span> <span class="identifier">Mem</span> <span class="special">&gt;(</span> <span class="identifier">obj</span> <span class="special">,</span> <span class="identifier">mem</span> <span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
</p>
<p>
One can use this binder as follows
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">lorenz</span>
<span class="special">{</span>
<span class="keyword">void</span> <span class="identifier">ode</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</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="number">10.0</span> <span class="special">*</span> <span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">);</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="number">28.0</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">];</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="number">8.0</span> <span class="special">/</span> <span class="number">3.0</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span> <span class="keyword">int</span> <span class="identifier">argc</span> <span class="special">,</span> <span class="keyword">char</span> <span class="special">*</span><span class="identifier">argv</span><span class="special">[]</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">odeint</span><span class="special">;</span>
<span class="identifier">state_type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="special">{{</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">}};</span>
<span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;()</span> <span class="special">,</span> <span class="identifier">make_ode_wrapper</span><span class="special">(</span> <span class="identifier">lorenz</span><span class="special">()</span> <span class="special">,</span> <span class="special">&amp;</span><span class="identifier">lorenz</span><span class="special">::</span><span class="identifier">ode</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">);</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.binding_member_functions.binding_member_functions_in_c__11"></a><a class="link" href="binding_member_functions.html#boost_numeric_odeint.odeint_in_detail.binding_member_functions.binding_member_functions_in_c__11" title="Binding member functions in C++11">Binding
member functions in C++11</a>
</h4></div></div></div>
<p>
In C++11 one can use <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bind</span></code>
and one does not need to implement the bind themself:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">pl</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">placeholders</span><span class="special">;</span>
<span class="identifier">state_type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="special">{{</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">}};</span>
<span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;()</span> <span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span> <span class="special">&amp;</span><span class="identifier">lorenz</span><span class="special">::</span><span class="identifier">ode</span> <span class="special">,</span> <span class="identifier">lorenz</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">pl</span><span class="special">::</span><span class="identifier">_1</span> <span class="special">,</span> <span class="identifier">pl</span><span class="special">::</span><span class="identifier">_2</span> <span class="special">,</span> <span class="identifier">pl</span><span class="special">::</span><span class="identifier">_3</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">);</span>
</pre>
<p>
</p>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="using_boost__range.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../odeint_in_detail.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../concepts.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,323 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Generation functions</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../odeint_in_detail.html" title="odeint in detail">
<link rel="prev" href="steppers.html" title="Steppers">
<link rel="next" href="integrate_functions.html" title="Integrate 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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="steppers.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../odeint_in_detail.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="integrate_functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.generation_functions"></a><a class="link" href="generation_functions.html" title="Generation functions">Generation
functions</a>
</h3></div></div></div>
<p>
In the <a class="link" href="../tutorial.html" title="Tutorial">Tutorial</a> we have
learned how we can use the generation functions <code class="computeroutput"><span class="identifier">make_controlled</span></code>
and <code class="computeroutput"><span class="identifier">make_dense_output</span></code> to
create controlled and dense output stepper from a simple stepper or an error
stepper. The syntax of these two functions is very simple:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">auto</span> <span class="identifier">stepper1</span> <span class="special">=</span> <span class="identifier">make_controlled</span><span class="special">(</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="identifier">stepper_type</span><span class="special">()</span> <span class="special">);</span>
<span class="comment">// or with max step size limit:</span>
<span class="comment">// auto stepper1 = make_controlled( 1.0e-6 , 1.0e-6 , 0.01, stepper_type() );</span>
<span class="keyword">auto</span> <span class="identifier">stepper2</span> <span class="special">=</span> <span class="identifier">make_dense_output</span><span class="special">(</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="identifier">stepper_type</span><span class="special">()</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
The first two parameters are the absolute and the relative error tolerances
and the third parameter is the stepper. Additionally, a second version exists
where additionally a maximal step size is supplied which ensures the the
step size is not increased above this value. In C++03 you can infer the type
from the <code class="computeroutput"><span class="identifier">result_of</span></code> mechanism:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">odeint</span><span class="special">::</span><span class="identifier">result_of</span><span class="special">::</span><span class="identifier">make_controlled</span><span class="special">&lt;</span> <span class="identifier">stepper_type</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">stepper3</span> <span class="special">=</span> <span class="identifier">make_controlled</span><span class="special">(</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="identifier">stepper_type</span><span class="special">()</span> <span class="special">);</span>
<span class="special">(</span><span class="keyword">void</span><span class="special">)</span><span class="identifier">stepper3</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">odeint</span><span class="special">::</span><span class="identifier">result_of</span><span class="special">::</span><span class="identifier">make_dense_output</span><span class="special">&lt;</span> <span class="identifier">stepper_type</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">stepper4</span> <span class="special">=</span> <span class="identifier">make_dense_output</span><span class="special">(</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="identifier">stepper_type</span><span class="special">()</span> <span class="special">);</span>
<span class="special">(</span><span class="keyword">void</span><span class="special">)</span><span class="identifier">stepper4</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
To use your own steppers with the <code class="computeroutput"><span class="identifier">make_controlled</span></code>
or <code class="computeroutput"><span class="identifier">make_dense_output</span></code> you
need to specialize two class templates. Suppose your steppers are called
<code class="computeroutput"><span class="identifier">custom_stepper</span></code>, <code class="computeroutput"><span class="identifier">custom_controller</span></code> and <code class="computeroutput"><span class="identifier">custom_dense_output</span></code>.
Then, the first class you need to specialize is <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">get_controller</span></code>,
a meta function returning the type of the controller:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">numeric</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">odeint</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;&gt;</span>
<span class="keyword">struct</span> <span class="identifier">get_controller</span><span class="special">&lt;</span> <span class="identifier">custom_stepper</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="keyword">typedef</span> <span class="identifier">custom_controller</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>
<span class="special">}</span> <span class="special">}</span> <span class="special">}</span>
</pre>
<p>
</p>
<p>
The second one is a factory class <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">odeint</span><span class="special">::</span><span class="identifier">controller_factory</span></code>
which constructs the controller from the tolerances and the stepper. In our
dummy implementation this class is
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">numeric</span> <span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">odeint</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;&gt;</span>
<span class="keyword">struct</span> <span class="identifier">controller_factory</span><span class="special">&lt;</span> <span class="identifier">custom_stepper</span> <span class="special">,</span> <span class="identifier">custom_controller</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="identifier">custom_controller</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">double</span> <span class="identifier">abs_tol</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">rel_tol</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">custom_stepper</span> <span class="special">&amp;</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">custom_controller</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">custom_controller</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">double</span> <span class="identifier">abs_tol</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">rel_tol</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">max_dt</span> <span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">custom_stepper</span> <span class="special">&amp;</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="comment">// version with maximal allowed step size max_dt</span>
<span class="keyword">return</span> <span class="identifier">custom_controller</span><span class="special">();</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="special">}</span> <span class="special">}</span> <span class="special">}</span>
</pre>
<p>
</p>
<p>
This is all to use the <code class="computeroutput"><span class="identifier">make_controlled</span></code>
mechanism. Now you can use your controller via
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">auto</span> <span class="identifier">stepper5</span> <span class="special">=</span> <span class="identifier">make_controlled</span><span class="special">(</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="identifier">custom_stepper</span><span class="special">()</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
For the dense_output_stepper everything works similar. Here you have to specialize
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">odeint</span><span class="special">::</span><span class="identifier">get_dense_output</span></code> and <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">odeint</span><span class="special">::</span><span class="identifier">dense_output_factory</span></code>.
These two classes have the same syntax as their relatives <code class="computeroutput"><span class="identifier">get_controller</span></code>
and <code class="computeroutput"><span class="identifier">controller_factory</span></code>.
</p>
<p>
All controllers and dense-output steppers in odeint can be used with these
mechanisms. In the table below you will find, which steppers is constructed
from <code class="computeroutput"><span class="identifier">make_controlled</span></code> or
<code class="computeroutput"><span class="identifier">make_dense_output</span></code> if applied
on a stepper from odeint:
</p>
<div class="table">
<a name="boost_numeric_odeint.odeint_in_detail.generation_functions.generation_functions_make_controlled__abs_error___rel_error___stepper__"></a><p class="title"><b>Table&#160;1.7.&#160;Generation functions make_controlled( abs_error , rel_error , stepper
)</b></p>
<div class="table-contents"><table class="table" summary="Generation functions make_controlled( abs_error , rel_error , stepper
)">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Stepper
</p>
</th>
<th>
<p>
Result of make_controlled
</p>
</th>
<th>
<p>
Remarks
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">runge_kutta_cash_karp54</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">controlled_runge_kutta</span><span class="special">&lt;</span> <span class="identifier">runge_kutta_cash_karp54</span>
<span class="special">,</span> <span class="identifier">default_error_checker</span><span class="special">&lt;...&gt;</span> <span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>a<sub>x</sub>=1</em></span>, <span class="emphasis"><em>a<sub>dxdt</sub>=1</em></span>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">runge_kutta_fehlberg78</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">controlled_runge_kutta</span><span class="special">&lt;</span> <span class="identifier">runge_kutta_fehlberg78</span>
<span class="special">,</span> <span class="identifier">default_error_checker</span><span class="special">&lt;...&gt;</span> <span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>a<sub>x</sub>=1</em></span>, <span class="emphasis"><em>a<sub>dxdt</sub>=1</em></span>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">runge_kutta_dopri5</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">controlled_runge_kutta</span><span class="special">&lt;</span> <span class="identifier">runge_kutta_dopri5</span>
<span class="special">,</span> <span class="identifier">default_error_checker</span><span class="special">&lt;...&gt;</span> <span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>a <sub>x</sub>=1</em></span>, <span class="emphasis"><em>a<sub>dxdt</sub>=1</em></span>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">rosenbrock4</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rosenbrock4_controlled</span><span class="special">&lt;</span> <span class="identifier">rosenbrock4</span>
<span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_numeric_odeint.odeint_in_detail.generation_functions.generation_functions_make_dense_output__abs_error___rel_error___stepper__"></a><p class="title"><b>Table&#160;1.8.&#160;Generation functions make_dense_output( abs_error , rel_error , stepper
)</b></p>
<div class="table-contents"><table class="table" summary="Generation functions make_dense_output( abs_error , rel_error , stepper
)">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Stepper
</p>
</th>
<th>
<p>
Result of make_dense_output
</p>
</th>
<th>
<p>
Remarks
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">runge_kutta_dopri5</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">dense_output_runge_kutta</span><span class="special">&lt;</span> <span class="identifier">controlled_runge_kutta</span><span class="special">&lt;</span> <span class="identifier">runge_kutta_dopri5</span>
<span class="special">,</span> <span class="identifier">default_error_checker</span><span class="special">&lt;...&gt;</span> <span class="special">&gt;</span>
<span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>a <sub>x</sub>=1</em></span>, <span class="emphasis"><em>a<sub>dxdt</sub>=1</em></span>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">rosenbrock4</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rosenbrock4_dense_output</span><span class="special">&lt;</span> <span class="identifier">rosenbrock4_controller</span><span class="special">&lt;</span> <span class="identifier">rosenbrock4</span>
<span class="special">&gt;</span> <span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break">
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="steppers.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../odeint_in_detail.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="integrate_functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,409 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Integrate functions</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../odeint_in_detail.html" title="odeint in detail">
<link rel="prev" href="generation_functions.html" title="Generation functions">
<link rel="next" href="iterators_and_ranges.html" title="Iterators and Ranges">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="generation_functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../odeint_in_detail.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="iterators_and_ranges.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.integrate_functions"></a><a class="link" href="integrate_functions.html" title="Integrate functions">Integrate
functions</a>
</h3></div></div></div>
<p>
Integrate functions perform the time evolution of a given ODE from some starting
time <span class="emphasis"><em>t<sub>0</sub></em></span> to a given end time <span class="emphasis"><em>t<sub>1</sub></em></span>
and starting at state <span class="emphasis"><em>x<sub>0</sub></em></span> by subsequent calls of a given
stepper's <code class="computeroutput"><span class="identifier">do_step</span></code> function.
Additionally, the user can provide an __observer to analyze the state during
time evolution, and a <code class="computeroutput"><a class="link" href="../../boost/numeric/odeint/max_step_checker.html" title="Class max_step_checker">max_step_checker</a></code> to throw an
exception if too many steps are taken between observer calls (i.e. too small
step size). There are five different integrate functions which have different
strategies on when to call the observer function during integration. All
of the integrate functions except <code class="computeroutput"><span class="identifier">integrate_n_steps</span></code>
can be called with any stepper following one of the stepper concepts: <a class="link" href="../concepts/stepper.html" title="Stepper">Stepper</a> , <a class="link" href="../concepts/error_stepper.html" title="Error Stepper">Error
Stepper</a> , <a class="link" href="../concepts/controlled_stepper.html" title="Controlled Stepper">Controlled
Stepper</a> , <a class="link" href="../concepts/dense_output_stepper.html" title="Dense Output Stepper">Dense
Output Stepper</a>. Depending on the abilities of the stepper, the integrate
functions make use of step-size control or dense output.
</p>
<h5>
<a name="boost_numeric_odeint.odeint_in_detail.integrate_functions.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.odeint_in_detail.integrate_functions.equidistant_observer_calls"></a></span><a class="link" href="integrate_functions.html#boost_numeric_odeint.odeint_in_detail.integrate_functions.equidistant_observer_calls">Equidistant
observer calls</a>
</h5>
<p>
If observer calls at equidistant time intervals <span class="emphasis"><em>dt</em></span> are
needed, the <code class="computeroutput"><span class="identifier">integrate_const</span></code>
or <code class="computeroutput"><span class="identifier">integrate_n_steps</span></code> function
should be used. We start with explaining <code class="computeroutput"><span class="identifier">integrate_const</span></code>:
</p>
<p>
<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">x0</span> <span class="special">,</span>
<span class="identifier">t0</span> <span class="special">,</span>
<span class="identifier">t1</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">)</span></code>
</p>
<p>
<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">x0</span> <span class="special">,</span>
<span class="identifier">t0</span> <span class="special">,</span>
<span class="identifier">t1</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">,</span>
<span class="identifier">observer</span> <span class="special">)</span></code>
</p>
<p>
<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">x0</span> <span class="special">,</span>
<span class="identifier">t0</span> <span class="special">,</span>
<span class="identifier">t1</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">,</span>
<span class="identifier">observer</span> <span class="special">,</span>
<span class="identifier">max_step_checker</span> <span class="special">)</span></code>
</p>
<p>
These integrate the ODE given by <code class="computeroutput"><span class="identifier">system</span></code>
with subsequent steps from <code class="computeroutput"><span class="identifier">stepper</span></code>.
Integration start at <code class="computeroutput"><span class="identifier">t0</span></code> and
<code class="computeroutput"><span class="identifier">x0</span></code> and ends at some <span class="emphasis"><em>t'
= t<sub>0</sub> + n dt</em></span> with <span class="emphasis"><em>n</em></span> such that <span class="emphasis"><em>t<sub>1</sub> -
dt &lt; t' &lt;= t<sub>1</sub></em></span>. <code class="computeroutput"><span class="identifier">x0</span></code>
is changed to the approximative solution <span class="emphasis"><em>x(t')</em></span> at the
end of integration. If provided, the <code class="computeroutput"><span class="identifier">observer</span></code>
is invoked at times <span class="emphasis"><em>t<sub>0</sub></em></span>, <span class="emphasis"><em>t<sub>0</sub> + dt</em></span>,
<span class="emphasis"><em>t<sub>0</sub> + 2dt</em></span>, ... ,<span class="emphasis"><em>t'</em></span>. If provided,
the <code class="computeroutput"><span class="identifier">max_step_checker</span></code> counts
the number of steps between observer calls and throws a <code class="computeroutput"><span class="identifier">no_progress_error</span></code>
this exceeds some limit (default: 500). <code class="computeroutput"><span class="identifier">integrate_const</span></code>
returns the number of steps performed during the integration. Note that if
you are using a simple <a class="link" href="../concepts/stepper.html" title="Stepper">Stepper</a>
or <a class="link" href="../concepts/error_stepper.html" title="Error Stepper">Error Stepper</a>
and want to make exactly <code class="computeroutput"><span class="identifier">n</span></code>
steps you should prefer the <code class="computeroutput"><span class="identifier">integrate_n_steps</span></code>
function below.
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
If <code class="computeroutput"><span class="identifier">stepper</span></code> is a <a class="link" href="../concepts/stepper.html" title="Stepper">Stepper</a> or <a class="link" href="../concepts/error_stepper.html" title="Error Stepper">Error Stepper</a>
then <code class="computeroutput"><span class="identifier">dt</span></code> is also the step
size used for integration and the observer is called just after every
step.
</li>
<li class="listitem">
If <code class="computeroutput"><span class="identifier">stepper</span></code> is a <a class="link" href="../concepts/controlled_stepper.html" title="Controlled Stepper">Controlled
Stepper</a> then <code class="computeroutput"><span class="identifier">dt</span></code>
is the initial step size. The actual step size will change due to error
control during time evolution. However, if an observer is provided the
step size will be adjusted such that the algorithm always calculates
<span class="emphasis"><em>x(t)</em></span> at <span class="emphasis"><em>t = t<sub>0</sub> + n dt</em></span> and calls
the observer at that point. Note that the use of <a class="link" href="../concepts/controlled_stepper.html" title="Controlled Stepper">Controlled
Stepper</a> is reasonable here only if <code class="computeroutput"><span class="identifier">dt</span></code>
is considerably larger than typical step sizes used by the stepper.
</li>
<li class="listitem">
If <code class="computeroutput"><span class="identifier">stepper</span></code> is a <a class="link" href="../concepts/dense_output_stepper.html" title="Dense Output Stepper">Dense Output
Stepper</a> then <code class="computeroutput"><span class="identifier">dt</span></code>
is the initial step size. The actual step size will be adjusted during
integration due to error control. If an observer is provided dense output
is used to calculate <span class="emphasis"><em>x(t)</em></span> at <span class="emphasis"><em>t = t<sub>0</sub> + n
dt</em></span>.
</li>
</ul></div>
<h5>
<a name="boost_numeric_odeint.odeint_in_detail.integrate_functions.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.odeint_in_detail.integrate_functions.integrate_a_given_number_of_steps"></a></span><a class="link" href="integrate_functions.html#boost_numeric_odeint.odeint_in_detail.integrate_functions.integrate_a_given_number_of_steps">Integrate
a given number of steps</a>
</h5>
<p>
This function is very similar to <code class="computeroutput"><span class="identifier">integrate_const</span></code>
above. The only difference is that it does not take the end time as parameter,
but rather the number of steps. The integration is then performed until the
time <code class="computeroutput"><span class="identifier">t0</span><span class="special">+</span><span class="identifier">n</span><span class="special">*</span><span class="identifier">dt</span></code>.
</p>
<p>
<code class="computeroutput"><span class="identifier">integrate_n_steps</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">x0</span> <span class="special">,</span>
<span class="identifier">t0</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">,</span>
<span class="identifier">n</span> <span class="special">)</span></code>
</p>
<p>
<code class="computeroutput"><span class="identifier">integrate_n_steps</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">x0</span> <span class="special">,</span>
<span class="identifier">t0</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">,</span>
<span class="identifier">n</span> <span class="special">,</span> <span class="identifier">observer</span> <span class="special">)</span></code>
</p>
<p>
<code class="computeroutput"><span class="identifier">integrate_n_steps</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">x0</span> <span class="special">,</span>
<span class="identifier">t0</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">,</span>
<span class="identifier">n</span> <span class="special">,</span> <span class="identifier">observer</span> <span class="special">,</span> <span class="identifier">max_step_checker</span> <span class="special">)</span></code>
</p>
<p>
Integrates the ODE given by <code class="computeroutput"><span class="identifier">system</span></code>
with subsequent steps from <code class="computeroutput"><span class="identifier">stepper</span></code>
starting at <span class="emphasis"><em>x<sub>0</sub></em></span> and <span class="emphasis"><em>t<sub>0</sub></em></span>. If provided,
<code class="computeroutput"><span class="identifier">observer</span></code> is called after
every step and at the beginning with <code class="computeroutput"><span class="identifier">t0</span></code>,
similar as above. Again, providing a <code class="computeroutput"><span class="identifier">max_step_checker</span></code>
will throw a <code class="computeroutput"><span class="identifier">no_progress_error</span></code>
if too many steps are performed between observer calls. The approximate result
for <span class="emphasis"><em>x( t<sub>0</sub> + n dt )</em></span> is stored in <code class="computeroutput"><span class="identifier">x0</span></code>.
This function returns the end time <code class="computeroutput"><span class="identifier">t0</span>
<span class="special">+</span> <span class="identifier">n</span><span class="special">*</span><span class="identifier">dt</span></code>.
</p>
<h5>
<a name="boost_numeric_odeint.odeint_in_detail.integrate_functions.h2"></a>
<span class="phrase"><a name="boost_numeric_odeint.odeint_in_detail.integrate_functions.observer_calls_at_each_step"></a></span><a class="link" href="integrate_functions.html#boost_numeric_odeint.odeint_in_detail.integrate_functions.observer_calls_at_each_step">Observer
calls at each step</a>
</h5>
<p>
If the observer should be called at each time step then the <code class="computeroutput"><span class="identifier">integrate_adaptive</span></code> function should be used.
Note that in the case of <a class="link" href="../concepts/controlled_stepper.html" title="Controlled Stepper">Controlled
Stepper</a> or <a class="link" href="../concepts/dense_output_stepper.html" title="Dense Output Stepper">Dense
Output Stepper</a> this leads to non-equidistant observer calls as the
step size changes.
</p>
<p>
<code class="computeroutput"><span class="identifier">integrate_adaptive</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">x0</span> <span class="special">,</span>
<span class="identifier">t0</span> <span class="special">,</span>
<span class="identifier">t1</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">)</span></code>
</p>
<p>
<code class="computeroutput"><span class="identifier">integrate_adaptive</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">x0</span> <span class="special">,</span>
<span class="identifier">t0</span> <span class="special">,</span>
<span class="identifier">t1</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">,</span>
<span class="identifier">observer</span> <span class="special">)</span></code>
</p>
<p>
Integrates the ODE given by <code class="computeroutput"><span class="identifier">system</span></code>
with subsequent steps from <code class="computeroutput"><span class="identifier">stepper</span></code>.
Integration start at <code class="computeroutput"><span class="identifier">t0</span></code> and
<code class="computeroutput"><span class="identifier">x0</span></code> and ends at <span class="emphasis"><em>t<sub>1</sub></em></span>.
<code class="computeroutput"><span class="identifier">x0</span></code> is changed to the approximative
solution <span class="emphasis"><em>x(t<sub>1</sub>)</em></span> at the end of integration. If provided,
the <code class="computeroutput"><span class="identifier">observer</span></code> is called after
each step (and before the first step at <code class="computeroutput"><span class="identifier">t0</span></code>).
<code class="computeroutput"><span class="identifier">integrate_adaptive</span></code> returns
the number of steps performed during the integration.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
<code class="computeroutput"><span class="identifier">integrate_adaptive</span></code> by design
performs an observer call after each time step. Hence there is no need
for a <code class="computeroutput"><a class="link" href="../../boost/numeric/odeint/max_step_checker.html" title="Class max_step_checker">max_step_checker</a></code> as only
exactly one step is ever performed between observer calls.
</p></td></tr>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
If <code class="computeroutput"><span class="identifier">stepper</span></code> is a <a class="link" href="../concepts/stepper.html" title="Stepper">Stepper</a> or <a class="link" href="../concepts/error_stepper.html" title="Error Stepper">Error Stepper</a>
then <code class="computeroutput"><span class="identifier">dt</span></code> is the step size
used for integration and <code class="computeroutput"><span class="identifier">integrate_adaptive</span></code>
behaves like <code class="computeroutput"><span class="identifier">integrate_const</span></code>
except that for the last step the step size is reduced to ensure we end
exactly at <code class="computeroutput"><span class="identifier">t1</span></code>. If provided,
the observer is called at each step.
</li>
<li class="listitem">
If <code class="computeroutput"><span class="identifier">stepper</span></code> is a <a class="link" href="../concepts/controlled_stepper.html" title="Controlled Stepper">Controlled
Stepper</a> then <code class="computeroutput"><span class="identifier">dt</span></code>
is the initial step size. The actual step size is changed according to
error control of the stepper. For the last step, the step size will be
reduced to ensure we end exactly at <code class="computeroutput"><span class="identifier">t1</span></code>.
If provided, the observer is called after each time step (and before
the first step at <code class="computeroutput"><span class="identifier">t0</span></code>).
</li>
<li class="listitem">
If stepper is a <a class="link" href="../concepts/dense_output_stepper.html" title="Dense Output Stepper">Dense
Output Stepper</a> then <code class="computeroutput"><span class="identifier">dt</span></code>
is the initial step size and <code class="computeroutput"><span class="identifier">integrate_adaptive</span></code>
behaves just like for <a class="link" href="../concepts/controlled_stepper.html" title="Controlled Stepper">Controlled
Stepper</a> above. No dense output is used.
</li>
</ul></div>
<h5>
<a name="boost_numeric_odeint.odeint_in_detail.integrate_functions.h3"></a>
<span class="phrase"><a name="boost_numeric_odeint.odeint_in_detail.integrate_functions.observer_calls_at_given_time_points"></a></span><a class="link" href="integrate_functions.html#boost_numeric_odeint.odeint_in_detail.integrate_functions.observer_calls_at_given_time_points">Observer
calls at given time points</a>
</h5>
<p>
If the observer should be called at some user given time points the <code class="computeroutput"><span class="identifier">integrate_times</span></code> function should be used.
The times for observer calls are provided as a sequence of time values. The
sequence is either defined via two iterators pointing to begin and end of
the sequence or in terms of a <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>
object.
</p>
<p>
<code class="computeroutput"><span class="identifier">integrate_times</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">x0</span> <span class="special">,</span>
<span class="identifier">times_start</span> <span class="special">,</span>
<span class="identifier">times_end</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">,</span>
<span class="identifier">observer</span> <span class="special">)</span></code>
</p>
<p>
<code class="computeroutput"><span class="identifier">integrate_times</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">x0</span> <span class="special">,</span>
<span class="identifier">time_range</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">,</span>
<span class="identifier">observer</span> <span class="special">)</span></code>
</p>
<p>
Integrates the ODE given by <code class="computeroutput"><span class="identifier">system</span></code>
with subsequent steps from <code class="computeroutput"><span class="identifier">stepper</span></code>.
Integration starts at <code class="computeroutput"><span class="special">*</span><span class="identifier">times_start</span></code>
and ends exactly at <code class="computeroutput"><span class="special">*(</span><span class="identifier">times_end</span><span class="special">-</span><span class="number">1</span><span class="special">)</span></code>.
<code class="computeroutput"><span class="identifier">x0</span></code> contains the approximate
solution at the end point of integration. This function requires an observer
which is invoked at the subsequent times <code class="computeroutput"><span class="special">*</span><span class="identifier">times_start</span><span class="special">++</span></code>
until <code class="computeroutput"><span class="identifier">times_start</span> <span class="special">==</span>
<span class="identifier">times_end</span></code>. If called with a <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>
<code class="computeroutput"><span class="identifier">time_range</span></code> the function behaves
the same with <code class="computeroutput"><span class="identifier">times_start</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">time_range</span>
<span class="special">)</span></code> and <code class="computeroutput"><span class="identifier">times_end</span>
<span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span>
<span class="identifier">time_range</span> <span class="special">)</span></code>.
Additionally, a <code class="computeroutput"><a class="link" href="../../boost/numeric/odeint/max_step_checker.html" title="Class max_step_checker">max_step_checker</a></code> can be provided,
e.g.:
</p>
<p>
<code class="computeroutput"><span class="identifier">integrate_times</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">x0</span> <span class="special">,</span>
<span class="identifier">times_start</span> <span class="special">,</span>
<span class="identifier">times_end</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">,</span>
<span class="identifier">observer</span> <span class="special">,</span>
<span class="identifier">max_step_checker</span><span class="special">)</span></code>
</p>
<p>
As above, this will throw a <code class="computeroutput"><span class="identifier">no_progress_error</span></code>
if too many steps are performed between observer calls.
</p>
<p>
<code class="computeroutput"><span class="identifier">integrate_times</span></code> returns the
number of steps performed during the integration.
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
If <code class="computeroutput"><span class="identifier">stepper</span></code> is a <a class="link" href="../concepts/stepper.html" title="Stepper">Stepper</a> or <a class="link" href="../concepts/error_stepper.html" title="Error Stepper">Error Stepper</a>
<code class="computeroutput"><span class="identifier">dt</span></code> is the step size used
for integration. However, whenever a time point from the sequence is
approached the step size <code class="computeroutput"><span class="identifier">dt</span></code>
will be reduced to obtain the state <span class="emphasis"><em>x(t)</em></span> exactly
at the time point.
</li>
<li class="listitem">
If <code class="computeroutput"><span class="identifier">stepper</span></code> is a <a class="link" href="../concepts/controlled_stepper.html" title="Controlled Stepper">Controlled
Stepper</a> then <code class="computeroutput"><span class="identifier">dt</span></code>
is the initial step size. The actual step size is adjusted during integration
according to error control. However, if a time point from the sequence
is approached the step size is reduced to obtain the state <span class="emphasis"><em>x(t)</em></span>
exactly at the time point.
</li>
<li class="listitem">
If <code class="computeroutput"><span class="identifier">stepper</span></code> is a <a class="link" href="../concepts/dense_output_stepper.html" title="Dense Output Stepper">Dense Output
Stepper</a> then <code class="computeroutput"><span class="identifier">dt</span></code>
is the initial step size. The actual step size is adjusted during integration
according to error control. Dense output is used to obtain the states
<span class="emphasis"><em>x(t)</em></span> at the time points from the sequence.
</li>
</ul></div>
<h5>
<a name="boost_numeric_odeint.odeint_in_detail.integrate_functions.h4"></a>
<span class="phrase"><a name="boost_numeric_odeint.odeint_in_detail.integrate_functions.convenience_integrate_function"></a></span><a class="link" href="integrate_functions.html#boost_numeric_odeint.odeint_in_detail.integrate_functions.convenience_integrate_function">Convenience
integrate function</a>
</h5>
<p>
Additionally to the sophisticated integrate function above odeint also provides
a simple <code class="computeroutput"><span class="identifier">integrate</span></code> routine
which uses a dense output stepper based on <code class="computeroutput"><span class="identifier">runge_kutta_dopri5</span></code>
with standard error bounds <span class="emphasis"><em>10<sup>-6</sup></em></span> for the steps.
</p>
<p>
<code class="computeroutput"><span class="identifier">integrate</span><span class="special">(</span>
<span class="identifier">system</span> <span class="special">,</span>
<span class="identifier">x0</span> <span class="special">,</span>
<span class="identifier">t0</span> <span class="special">,</span>
<span class="identifier">t1</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">)</span></code>
</p>
<p>
<code class="computeroutput"><span class="identifier">integrate</span><span class="special">(</span>
<span class="identifier">system</span> <span class="special">,</span>
<span class="identifier">x0</span> <span class="special">,</span>
<span class="identifier">t0</span> <span class="special">,</span>
<span class="identifier">t1</span> <span class="special">,</span>
<span class="identifier">dt</span> <span class="special">,</span>
<span class="identifier">observer</span> <span class="special">)</span></code>
</p>
<p>
This function behaves exactly like <code class="computeroutput"><span class="identifier">integrate_adaptive</span></code>
above but no stepper has to be provided. It also returns the number of steps
performed during the integration.
</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 &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="generation_functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../odeint_in_detail.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="iterators_and_ranges.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,662 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Iterators and Ranges</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../odeint_in_detail.html" title="odeint in detail">
<link rel="prev" href="integrate_functions.html" title="Integrate functions">
<link rel="next" href="state_types__algebras_and_operations.html" title="State types, algebras and operations">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="integrate_functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../odeint_in_detail.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="state_types__algebras_and_operations.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.iterators_and_ranges"></a><a class="link" href="iterators_and_ranges.html" title="Iterators and Ranges">Iterators
and Ranges</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.examples">Examples</a></span></dt>
<dt><span class="section"><a href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.const_step_iterator">const_step_iterator</a></span></dt>
<dt><span class="section"><a href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.const_step_time_iterator">const_step_time_iterator</a></span></dt>
<dt><span class="section"><a href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.adaptive_step_iterator">adaptive_step_iterator</a></span></dt>
<dt><span class="section"><a href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.adaptive_step_time_iterator">adaptive_step_time_iterator</a></span></dt>
<dt><span class="section"><a href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.n_step_iterator">n_step_iterator</a></span></dt>
<dt><span class="section"><a href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.n_step_time_iterator">n_step_time_iterator</a></span></dt>
<dt><span class="section"><a href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.times_iterator">times_iterator</a></span></dt>
<dt><span class="section"><a href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.times_time_iterator">times_time_iterator</a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.examples"></a><a class="link" href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.examples" title="Examples">Examples</a>
</h4></div></div></div>
<p>
odeint supports iterators that iterate along an approximate solution of
an ordinary differential equation. Iterators offer you an alternative to
the integrate functions. Furthermore, many of the standard algorithms in
the C++ standard library and Boost.Range can be used with the odeint's
iterators.
</p>
<p>
Several iterator types are provided, in consistence with the <a class="link" href="integrate_functions.html" title="Integrate functions">integrate
functions</a>. Hence there are <code class="computeroutput"><span class="identifier">const_step_iterator</span></code>,
<code class="computeroutput"><span class="identifier">adaptive_step_iterator</span></code>,
<code class="computeroutput"><span class="identifier">n_step_iterator</span></code> and <code class="computeroutput"><span class="identifier">times_iterator</span></code> -- each of them in two
versions: either with only the <code class="computeroutput"><span class="identifier">state</span></code>
or with a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">state</span><span class="special">,</span><span class="identifier">time</span><span class="special">&gt;</span></code>
as value type. They are all single pass iterators. In the following, we
show a few examples of how to use those iterators together with std algorithms.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="identifier">stepper</span><span class="special">;</span>
<span class="identifier">state_type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="special">{{</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">}};</span>
<span class="keyword">double</span> <span class="identifier">res</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">accumulate</span><span class="special">(</span> <span class="identifier">make_const_step_iterator_begin</span><span class="special">(</span> <span class="identifier">stepper</span> <span class="special">,</span> <span class="identifier">lorenz</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">make_const_step_iterator_end</span><span class="special">(</span> <span class="identifier">stepper</span> <span class="special">,</span> <span class="identifier">lorenz</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">,</span>
<span class="number">0.0</span> <span class="special">,</span>
<span class="special">[](</span> <span class="keyword">double</span> <span class="identifier">sum</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">sum</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">];</span> <span class="special">}</span> <span class="special">);</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">res</span> <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
In this example all x-values of the solution are accumulated. Note, how
dereferencing the iterator gives the current state <code class="computeroutput"><span class="identifier">x</span></code>
of the ODE (the second argument of the accumulate lambda). The iterator
itself does not occur directly in this example but it is generated by the
factory functions <code class="computeroutput"><span class="identifier">make_const_step_iterator_begin</span></code>
and <code class="computeroutput"><span class="identifier">make_const_step_iterator_end</span></code>.
odeint also supports Boost.Range, that allows to write the above example
in a more compact form with the factory function <code class="computeroutput"><span class="identifier">make_const_step_range</span></code>,
but now using <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">accumulate</span></code> from __bost_range:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="identifier">stepper</span><span class="special">;</span>
<span class="identifier">state_type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="special">{{</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">}};</span>
<span class="keyword">double</span> <span class="identifier">res</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">accumulate</span><span class="special">(</span> <span class="identifier">make_const_step_range</span><span class="special">(</span> <span class="identifier">stepper</span> <span class="special">,</span> <span class="identifier">lorenz</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">)</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span>
<span class="special">[](</span> <span class="keyword">double</span> <span class="identifier">sum</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">sum</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">];</span> <span class="special">}</span> <span class="special">);</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">res</span> <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
The second iterator type is also a iterator with const step size. But the
value type of this iterator consists here of a pair of the time and the
state of the solution of the ODE. An example is
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="identifier">stepper</span><span class="special">;</span>
<span class="identifier">state_type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="special">{{</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">}};</span>
<span class="keyword">double</span> <span class="identifier">res</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">accumulate</span><span class="special">(</span> <span class="identifier">make_const_step_time_range</span><span class="special">(</span> <span class="identifier">stepper</span> <span class="special">,</span> <span class="identifier">lorenz</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">)</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span>
<span class="special">[](</span> <span class="keyword">double</span> <span class="identifier">sum</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;,</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">sum</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">first</span><span class="special">[</span><span class="number">0</span><span class="special">];</span> <span class="special">}</span> <span class="special">);</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">res</span> <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
The factory functions are now <code class="computeroutput"><span class="identifier">make_const_step_time_iterator_begin</span></code>,
<code class="computeroutput"><span class="identifier">make_const_step_time_iterator_end</span></code>
and <code class="computeroutput"><span class="identifier">make_const_step_time_range</span></code>.
Note, how the lambda now expects a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code>
as this is the value type of the <code class="computeroutput"><span class="identifier">const_step_time_iterator</span></code>'s.
</p>
<p>
Next, we discuss the adaptive iterators which are completely analogous
to the const step iterators, but are based on adaptive stepper routines
and thus adjust the step size during the iteration. Examples are
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">auto</span> <span class="identifier">stepper</span> <span class="special">=</span> <span class="identifier">make_controlled</span><span class="special">(</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="identifier">runge_kutta_cash_karp54</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;()</span> <span class="special">);</span>
<span class="identifier">state_type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="special">{{</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">}};</span>
<span class="keyword">double</span> <span class="identifier">res</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">accumulate</span><span class="special">(</span> <span class="identifier">make_adaptive_range</span><span class="special">(</span> <span class="identifier">stepper</span> <span class="special">,</span> <span class="identifier">lorenz</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">)</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span>
<span class="special">[](</span> <span class="keyword">double</span> <span class="identifier">sum</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">state_type</span><span class="special">&amp;</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">sum</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">];</span> <span class="special">}</span> <span class="special">);</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">res</span> <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">auto</span> <span class="identifier">stepper</span> <span class="special">=</span> <span class="identifier">make_controlled</span><span class="special">(</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="identifier">runge_kutta_cash_karp54</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;()</span> <span class="special">);</span>
<span class="identifier">state_type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="special">{{</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">}};</span>
<span class="keyword">double</span> <span class="identifier">res</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">accumulate</span><span class="special">(</span> <span class="identifier">make_adaptive_time_range</span><span class="special">(</span> <span class="identifier">stepper</span> <span class="special">,</span> <span class="identifier">lorenz</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">)</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span>
<span class="special">[](</span> <span class="keyword">double</span> <span class="identifier">sum</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">state_type</span><span class="special">&amp;</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">sum</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">first</span><span class="special">[</span><span class="number">0</span><span class="special">];</span> <span class="special">}</span> <span class="special">);</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">res</span> <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
'adaptive_iterator<code class="computeroutput"> <span class="keyword">and</span> </code>adaptive_time_iterator'
can only be used with <a class="link" href="../concepts/controlled_stepper.html" title="Controlled Stepper">Controlled
Stepper</a> or <a class="link" href="../concepts/dense_output_stepper.html" title="Dense Output Stepper">Dense
Output Stepper</a>.
</p></td></tr>
</table></div>
<p>
In general one can say that iterating over a range of a <code class="computeroutput"><span class="identifier">const_step_iterator</span></code>
behaves like an <code class="computeroutput"><span class="identifier">integrate_const</span></code>
function call, and similarly for <code class="computeroutput"><span class="identifier">adaptive_iterator</span></code>
and <code class="computeroutput"><span class="identifier">integrate_adaptive</span></code>,
<code class="computeroutput"><span class="identifier">n_step_iterator</span></code> and <code class="computeroutput"><span class="identifier">integrate_n_steps</span></code>, and finally <code class="computeroutput"><span class="identifier">times_iterator</span></code> and <code class="computeroutput"><span class="identifier">integrate_times</span></code>.
</p>
<p>
Below we list the most important properties of the exisiting iterators:
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.const_step_iterator"></a><a class="link" href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.const_step_iterator" title="const_step_iterator">const_step_iterator</a>
</h4></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Definition: <code class="computeroutput"><span class="identifier">const_step_iterator</span><span class="special">&lt;</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">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">value_type</span></code> is <code class="computeroutput"><span class="identifier">State</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">reference_type</span></code> is
<code class="computeroutput"><span class="identifier">State</span> <span class="keyword">const</span><span class="special">&amp;</span></code>
</li>
<li class="listitem">
Factory functions
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_const_step_iterator_begin</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">t_start</span>
<span class="special">,</span> <span class="identifier">t_end</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_const_step_iterator_end</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></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_const_step_range</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">t_start</span>
<span class="special">,</span> <span class="identifier">t_end</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">)</span></code>
</li>
</ul></div>
</li>
<li class="listitem">
This stepper works with all steppers fulfilling the Stepper concept
or the DenseOutputStepper concept.
</li>
<li class="listitem">
The value of <code class="computeroutput"><span class="identifier">state</span></code>
is the current state of the ODE during the iteration.
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.const_step_time_iterator"></a><a class="link" href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.const_step_time_iterator" title="const_step_time_iterator">const_step_time_iterator</a>
</h4></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Definition: <code class="computeroutput"><span class="identifier">const_step_time_iterator</span><span class="special">&lt;</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">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">value_type</span></code> is <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span>
<span class="identifier">State</span> <span class="special">,</span>
<span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span> <span class="special">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">reference_type</span></code> is
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span>
<span class="identifier">State</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">,</span> <span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span> <span class="special">&gt;</span>
<span class="keyword">const</span><span class="special">&amp;</span></code>
</li>
<li class="listitem">
Factory functions
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_const_step_time_iterator_begin</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">t_start</span>
<span class="special">,</span> <span class="identifier">t_end</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_const_step_time_iterator_end</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></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_const_step_time_range</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">t_start</span>
<span class="special">,</span> <span class="identifier">t_end</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">)</span></code>
</li>
</ul></div>
</li>
<li class="listitem">
This stepper works with all steppers fulfilling the Stepper concept
or the DenseOutputStepper concept.
</li>
<li class="listitem">
This stepper updates the value of <code class="computeroutput"><span class="identifier">state</span></code>.
The value of <code class="computeroutput"><span class="identifier">state</span></code>
is the current state of the ODE during the iteration.
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.adaptive_step_iterator"></a><a class="link" href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.adaptive_step_iterator" title="adaptive_step_iterator">adaptive_step_iterator</a>
</h4></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Definition: <code class="computeroutput"><span class="identifier">adaptive_iterator</span><span class="special">&lt;</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">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">value_type</span></code> is <code class="computeroutput"><span class="identifier">State</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">reference_type</span></code> is
<code class="computeroutput"><span class="identifier">State</span> <span class="keyword">const</span><span class="special">&amp;</span></code>
</li>
<li class="listitem">
Factory functions
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_adaptive_iterator_begin</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">t_start</span>
<span class="special">,</span> <span class="identifier">t_end</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_adaptive_iterator_end</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></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_adaptive_range</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">t_start</span>
<span class="special">,</span> <span class="identifier">t_end</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">)</span></code>
</li>
</ul></div>
</li>
<li class="listitem">
This stepper works with all steppers fulfilling the ControlledStepper
concept or the DenseOutputStepper concept.
</li>
<li class="listitem">
For steppers fulfilling the ControlledStepper concept <code class="computeroutput"><span class="identifier">state</span></code> is modified according to the
current state of the ODE. For DenseOutputStepper the state is not modified
due to performance optimizations, but the steppers itself.
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.adaptive_step_time_iterator"></a><a class="link" href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.adaptive_step_time_iterator" title="adaptive_step_time_iterator">adaptive_step_time_iterator</a>
</h4></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Definition: <code class="computeroutput"><span class="identifier">adaptive_iterator</span><span class="special">&lt;</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">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">value_type</span></code> is <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span>
<span class="identifier">State</span> <span class="special">,</span>
<span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span> <span class="special">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">reference_type</span></code> is
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span>
<span class="identifier">State</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">,</span> <span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span> <span class="special">&gt;</span>
<span class="keyword">const</span><span class="special">&amp;</span></code>
</li>
<li class="listitem">
Factory functions
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_adaptive_time_iterator_begin</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">t_start</span>
<span class="special">,</span> <span class="identifier">t_end</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_adaptive_time_iterator_end</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></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_adaptive_time_range</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">t_start</span>
<span class="special">,</span> <span class="identifier">t_end</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">)</span></code>
</li>
</ul></div>
</li>
<li class="listitem">
This stepper works with all steppers fulfilling the ControlledStepper
concept or the DenseOutputStepper concept.
</li>
<li class="listitem">
For steppers fulfilling the ControlledStepper concept <code class="computeroutput"><span class="identifier">state</span></code> is modified according to the
current state of the ODE. For DenseOutputStepper the state is not modified
due to performance optimizations, but the stepper itself.
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.n_step_iterator"></a><a class="link" href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.n_step_iterator" title="n_step_iterator">n_step_iterator</a>
</h4></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Definition: <code class="computeroutput"><span class="identifier">n_step_iterator</span><span class="special">&lt;</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">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">value_type</span></code> is <code class="computeroutput"><span class="identifier">State</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">reference_type</span></code> is
<code class="computeroutput"><span class="identifier">State</span> <span class="keyword">const</span><span class="special">&amp;</span></code>
</li>
<li class="listitem">
Factory functions
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_n_step_iterator_begin</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">t_start</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">,</span> <span class="identifier">num_of_steps</span>
<span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_n_step_iterator_end</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></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_n_step_range</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">t_start</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">,</span> <span class="identifier">num_of_steps</span>
<span class="special">)</span></code>
</li>
</ul></div>
</li>
<li class="listitem">
This stepper works with all steppers fulfilling the Stepper concept
or the DenseOutputStepper concept.
</li>
<li class="listitem">
The value of <code class="computeroutput"><span class="identifier">state</span></code>
is the current state of the ODE during the iteration.
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.n_step_time_iterator"></a><a class="link" href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.n_step_time_iterator" title="n_step_time_iterator">n_step_time_iterator</a>
</h4></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Definition: <code class="computeroutput"><span class="identifier">n_step_time_iterator</span><span class="special">&lt;</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">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">value_type</span></code> is <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span>
<span class="identifier">State</span> <span class="special">,</span>
<span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span> <span class="special">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">reference_type</span></code> is
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span>
<span class="identifier">State</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">,</span> <span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span> <span class="special">&gt;</span>
<span class="keyword">const</span><span class="special">&amp;</span></code>
</li>
<li class="listitem">
Factory functions
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_n_step_time_iterator_begin</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">t_start</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">,</span> <span class="identifier">num_of_steps</span>
<span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_n_step_time_iterator_end</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></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_n_step_time_range</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">t_start</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">,</span> <span class="identifier">num_of_steps</span>
<span class="special">)</span></code>
</li>
</ul></div>
</li>
<li class="listitem">
This stepper works with all steppers fulfilling the Stepper concept
or the DenseOutputStepper concept.
</li>
<li class="listitem">
This stepper updates the value of <code class="computeroutput"><span class="identifier">state</span></code>.
The value of <code class="computeroutput"><span class="identifier">state</span></code>
is the current state of the ODE during the iteration.
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.times_iterator"></a><a class="link" href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.times_iterator" title="times_iterator">times_iterator</a>
</h4></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Definition: <code class="computeroutput"><span class="identifier">times_iterator</span><span class="special">&lt;</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">TimeIterator</span>
<span class="special">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">value_type</span></code> is <code class="computeroutput"><span class="identifier">State</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">reference_type</span></code> is
<code class="computeroutput"><span class="identifier">State</span> <span class="keyword">const</span><span class="special">&amp;</span></code>
</li>
<li class="listitem">
Factory functions
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_times_iterator_begin</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">t_start</span>
<span class="special">,</span> <span class="identifier">t_end</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_times_iterator_end</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></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_times_range</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">t_start</span>
<span class="special">,</span> <span class="identifier">t_end</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">)</span></code>
</li>
</ul></div>
</li>
<li class="listitem">
This stepper works with all steppers fulfilling the Stepper concept,
the ControlledStepper concept or the DenseOutputStepper concept.
</li>
<li class="listitem">
The value of <code class="computeroutput"><span class="identifier">state</span></code>
is the current state of the ODE during the iteration.
</li>
</ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.times_time_iterator"></a><a class="link" href="iterators_and_ranges.html#boost_numeric_odeint.odeint_in_detail.iterators_and_ranges.times_time_iterator" title="times_time_iterator">times_time_iterator</a>
</h4></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Definition: <code class="computeroutput"><span class="identifier">times_time_iterator</span><span class="special">&lt;</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">TimeIterator</span><span class="special">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">value_type</span></code> is <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span>
<span class="identifier">State</span> <span class="special">,</span>
<span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span> <span class="special">&gt;</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">reference_type</span></code> is
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span>
<span class="identifier">State</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">,</span> <span class="identifier">Stepper</span><span class="special">::</span><span class="identifier">time_type</span> <span class="special">&gt;</span>
<span class="keyword">const</span><span class="special">&amp;</span></code>
</li>
<li class="listitem">
Factory functions
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_times_time_iterator_begin</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">t_start</span>
<span class="special">,</span> <span class="identifier">t_end</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_times_time_step_iterator_end</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></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">make_times_time_range</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">t_start</span>
<span class="special">,</span> <span class="identifier">t_end</span>
<span class="special">,</span> <span class="identifier">dt</span>
<span class="special">)</span></code>
</li>
</ul></div>
</li>
<li class="listitem">
This stepper works with all steppers fulfilling the Stepper concept,
the ControlledStepper concept or the DenseOutputStepper concept.
</li>
<li class="listitem">
This stepper updates the value of <code class="computeroutput"><span class="identifier">state</span></code>.
The value of <code class="computeroutput"><span class="identifier">state</span></code>
is the current state of the ODE during the iteration.
</li>
</ul></div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="integrate_functions.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../odeint_in_detail.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="state_types__algebras_and_operations.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,254 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Using boost::range</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../odeint_in_detail.html" title="odeint in detail">
<link rel="prev" href="using_boost__ref.html" title="Using boost::ref">
<link rel="next" href="binding_member_functions.html" title="Binding member 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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="using_boost__ref.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../odeint_in_detail.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="binding_member_functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.using_boost__range"></a><a class="link" href="using_boost__range.html" title="Using boost::range">Using
boost::range</a>
</h3></div></div></div>
<p>
Most steppers in odeint also accept the state give as a range. A range is
sequence of values modeled by a range concept. See <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>
for an overview over existing concepts and examples of ranges. This means
that the <code class="computeroutput"><span class="identifier">state_type</span></code> of the
stepper need not necessarily be used to call the <code class="computeroutput"><span class="identifier">do_step</span></code>
method.
</p>
<p>
One use-case for <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>
in odeint has been shown in <a class="link" href="../tutorial/chaotic_systems_and_lyapunov_exponents.html" title="Chaotic systems and Lyapunov exponents">Chaotic
System</a> where the state consists of two parts: one for the original
system and one for the perturbations. The ranges are used to initialize (solve)
only the system part where the perturbation part is not touched, that is
a range consisting only of the system part is used. After that the complete
state including the perturbations is solved.
</p>
<p>
Another use case is a system consisting of coupled units where you want to
initialize each unit separately with the ODE of the uncoupled unit. An example
is a chain of coupled van-der-Pol-oscillators which are initialized uniformly
from the uncoupled van-der-Pol-oscillator. Then you can use <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>
to solve only one individual oscillator in the chain.
</p>
<p>
In short, you can <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>
to use one state within two system functions which expect states with different
sizes.
</p>
<p>
An example was given in the <a class="link" href="../tutorial/chaotic_systems_and_lyapunov_exponents.html" title="Chaotic systems and Lyapunov exponents">Chaotic
System</a> tutorial. Using Boost.Range usually means that your system
function needs to adapt to the iterators of Boost.Range. That is, your function
is called with a range and you need to get the iterators from that range.
This can easily be done. You have to implement your system as a class or
a struct and you have to templatize the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>. Then you can use the <code class="computeroutput"><span class="identifier">range_iterator</span></code>-meta
function and <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span></code> and <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span></code> to
obtain the iterators of your range:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">sys</span>
<span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Deriv</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x_</span> <span class="special">,</span> <span class="identifier">Deriv</span> <span class="special">&amp;</span><span class="identifier">dxdt_</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">x_</span> <span class="special">);</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">Deriv</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">dxdt</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">dxdt_</span> <span class="special">);</span>
<span class="comment">// fill dxdt</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
If your range is a random access-range you can also apply the bracket operator
to the iterator to access the elements in the range:
</p>
<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">sys</span>
<span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Deriv</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x_</span> <span class="special">,</span> <span class="identifier">Deriv</span> <span class="special">&amp;</span><span class="identifier">dxdt_</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">x_</span> <span class="special">);</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">Deriv</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">dxdt</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">dxdt_</span> <span class="special">);</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">f1</span><span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">);</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">f2</span><span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
The following two tables show which steppers and which algebras are compatible
with <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>.
</p>
<div class="table">
<a name="boost_numeric_odeint.odeint_in_detail.using_boost__range.steppers_supporting_boost_range"></a><p class="title"><b>Table&#160;1.9.&#160;Steppers supporting Boost.Range</b></p>
<div class="table-contents"><table class="table" summary="Steppers supporting Boost.Range">
<colgroup><col></colgroup>
<thead><tr><th>
<p>
Stepper
</p>
</th></tr></thead>
<tbody>
<tr><td>
<p>
adams_bashforth_moulton
</p>
</td></tr>
<tr><td>
<p>
bulirsch_stoer_dense_out
</p>
</td></tr>
<tr><td>
<p>
bulirsch_stoer
</p>
</td></tr>
<tr><td>
<p>
controlled_runge_kutta
</p>
</td></tr>
<tr><td>
<p>
dense_output_runge_kutta
</p>
</td></tr>
<tr><td>
<p>
euler
</p>
</td></tr>
<tr><td>
<p>
explicit_error_generic_rk
</p>
</td></tr>
<tr><td>
<p>
explicit_generic_rk
</p>
</td></tr>
<tr><td>
<p>
rosenbrock4_controller
</p>
</td></tr>
<tr><td>
<p>
rosenbrock4_dense_output
</p>
</td></tr>
<tr><td>
<p>
rosenbrock4
</p>
</td></tr>
<tr><td>
<p>
runge_kutta4_classic
</p>
</td></tr>
<tr><td>
<p>
runge_kutta4
</p>
</td></tr>
<tr><td>
<p>
runge_kutta_cash_karp54_classic
</p>
</td></tr>
<tr><td>
<p>
runge_kutta_cash_karp54
</p>
</td></tr>
<tr><td>
<p>
runge_kutta_dopri5
</p>
</td></tr>
<tr><td>
<p>
runge_kutta_fehlberg78
</p>
</td></tr>
<tr><td>
<p>
symplectic_euler
</p>
</td></tr>
<tr><td>
<p>
symplectic_rkn_sb3a_mclachlan
</p>
</td></tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_numeric_odeint.odeint_in_detail.using_boost__range.algebras_supporting_boost_range"></a><p class="title"><b>Table&#160;1.10.&#160;Algebras supporting Boost.Range</b></p>
<div class="table-contents"><table class="table" summary="Algebras supporting Boost.Range">
<colgroup><col></colgroup>
<thead><tr><th>
<p>
algebra
</p>
</th></tr></thead>
<tbody>
<tr><td>
<p>
range_algebra
</p>
</td></tr>
<tr><td>
<p>
thrust_algebra
</p>
</td></tr>
</tbody>
</table></div>
</div>
<br class="table-break">
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="using_boost__ref.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../odeint_in_detail.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="binding_member_functions.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,87 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Using boost::ref</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../odeint_in_detail.html" title="odeint in detail">
<link rel="prev" href="state_types__algebras_and_operations.html" title="State types, algebras and operations">
<link rel="next" href="using_boost__range.html" title="Using boost::range">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="state_types__algebras_and_operations.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../odeint_in_detail.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="using_boost__range.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.odeint_in_detail.using_boost__ref"></a><a class="link" href="using_boost__ref.html" title="Using boost::ref">Using
boost::ref</a>
</h3></div></div></div>
<p>
In odeint all system functions and observers are passed by value. For example,
if you call a <code class="computeroutput"><span class="identifier">do_step</span></code> method
of a particular stepper or the integration functions, your system and your
stepper will be passed by value:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">rk4</span><span class="special">.</span><span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">sys</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">);</span> <span class="comment">// pass sys by value</span>
</pre>
<p>
</p>
<p>
This behavior is suitable for most systems, especially if your system does
not contain any data or only a few parameters. However, in some cases you
might contain some large amount of data with you system function and passing
them by value is not desired since the data would be copied.
</p>
<p>
In such cases you can easily use <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span></code> (and
its relative <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">cref</span></code>) which passes its argument by reference
(or constant reference). odeint will unpack the arguments and no copying
at all of your system object will take place:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">rk4</span><span class="special">.</span><span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span><span class="special">(</span> <span class="identifier">sys</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">);</span> <span class="comment">// pass sys as references</span>
</pre>
<p>
</p>
<p>
The same mechanism can be used for the observers in the integrate functions.
</p>
<div class="tip"><table border="0" summary="Tip">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../../../doc/src/images/tip.png"></td>
<th align="left">Tip</th>
</tr>
<tr><td align="left" valign="top"><p>
If you are using C++11 you can also use <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ref</span></code>
and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cref</span></code>
</p></td></tr>
</table></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="state_types__algebras_and_operations.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../odeint_in_detail.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="using_boost__range.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,72 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Tutorial</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="prev" href="getting_started/short_example.html" title="Short Example">
<link rel="next" href="tutorial/harmonic_oscillator.html" title="Harmonic oscillator">
</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="../logo.jpg"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="getting_started/short_example.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tutorial/harmonic_oscillator.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_numeric_odeint.tutorial"></a><a class="link" href="tutorial.html" title="Tutorial">Tutorial</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="tutorial/harmonic_oscillator.html">Harmonic
oscillator</a></span></dt>
<dt><span class="section"><a href="tutorial/solar_system.html">Solar system</a></span></dt>
<dt><span class="section"><a href="tutorial/chaotic_systems_and_lyapunov_exponents.html">Chaotic
systems and Lyapunov exponents</a></span></dt>
<dt><span class="section"><a href="tutorial/stiff_systems.html">Stiff systems</a></span></dt>
<dt><span class="section"><a href="tutorial/complex_state_types.html">Complex
state types</a></span></dt>
<dt><span class="section"><a href="tutorial/lattice_systems.html">Lattice
systems</a></span></dt>
<dt><span class="section"><a href="tutorial/ensembles_of_oscillators.html">Ensembles
of oscillators</a></span></dt>
<dt><span class="section"><a href="tutorial/using_boost__units.html">Using
boost::units</a></span></dt>
<dt><span class="section"><a href="tutorial/using_matrices_as_state_types.html">Using
matrices as state types</a></span></dt>
<dt><span class="section"><a href="tutorial/using_arbitrary_precision_floating_point_types.html">Using
arbitrary precision floating point types</a></span></dt>
<dt><span class="section"><a href="tutorial/self_expanding_lattices.html">Self
expanding lattices</a></span></dt>
<dt><span class="section"><a href="tutorial/using_cuda__or_openmp__tbb_______via_thrust.html">Using
CUDA (or OpenMP, TBB, ...) via Thrust</a></span></dt>
<dt><span class="section"><a href="tutorial/using_opencl_via_vexcl.html">Using
OpenCL via VexCL</a></span></dt>
<dt><span class="section"><a href="tutorial/parallel_computation_with_openmp_and_mpi.html">Parallel
computation with OpenMP and MPI</a></span></dt>
<dt><span class="section"><a href="tutorial/all_examples.html">All examples</a></span></dt>
</dl></div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="getting_started/short_example.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tutorial/harmonic_oscillator.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,601 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>All examples</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="parallel_computation_with_openmp_and_mpi.html" title="Parallel computation with OpenMP and MPI">
<link rel="next" href="../odeint_in_detail.html" title="odeint in detail">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="parallel_computation_with_openmp_and_mpi.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../odeint_in_detail.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.all_examples"></a><a class="link" href="all_examples.html" title="All examples">All examples</a>
</h3></div></div></div>
<p>
The following table gives an overview over all examples.
</p>
<div class="table">
<a name="boost_numeric_odeint.tutorial.all_examples.examples_overview"></a><p class="title"><b>Table&#160;1.4.&#160;Examples Overview</b></p>
<div class="table-contents"><table class="table" summary="Examples Overview">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
File
</p>
</th>
<th>
<p>
Brief Description
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/bind_member_functions.cpp" target="_top">bind_member_functions.cpp</a>
</p>
</td>
<td>
<p>
This examples shows how member functions can be used as system
functions in odeint.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/bind_member_functions.cpp" target="_top">bind_member_functions_cpp11.cpp</a>
</p>
</td>
<td>
<p>
This examples shows how member functions can be used as system
functions in odeint with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bind</span></code>
in C++11.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/bulirsch_stoer.cpp" target="_top">bulirsch_stoer.cpp</a>
</p>
</td>
<td>
<p>
Shows the usage of the Bulirsch-Stoer method.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/chaotic_system.cpp" target="_top">chaotic_system.cpp</a>
</p>
</td>
<td>
<p>
The chaotic system examples integrates the Lorenz system and calculates
the Lyapunov exponents.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/elliptic_functions.cpp" target="_top">elliptic_functions.cpp</a>
</p>
</td>
<td>
<p>
Example calculating the elliptic functions using Bulirsch-Stoer
and Runge-Kutta-Dopri5 Steppers with dense output.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/fpu.cpp" target="_top">fpu.cpp</a>
</p>
</td>
<td>
<p>
The Fermi-Pasta-Ulam (FPU) example shows how odeint can be used
to integrate lattice systems.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/generation_functions.cpp" target="_top">generation_functions.cpp</a>
</p>
</td>
<td>
<p>
Shows skeletal code on how to implement own factory functions.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/harmonic_oscillator.cpp" target="_top">harmonic_oscillator.cpp</a>
</p>
</td>
<td>
<p>
The harmonic oscillator examples gives a brief introduction to
odeint and shows the usage of the classical Runge-Kutta-solvers.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/harmonic_oscillator_units.cpp" target="_top">harmonic_oscillator_units.cpp</a>
</p>
</td>
<td>
<p>
This examples shows how <a href="http://www.boost.org/doc/libs/release/libs/units/" target="_top">Boost.Units</a>
can be used with odeint.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/heun.cpp" target="_top">heun.cpp</a>
</p>
</td>
<td>
<p>
The Heun example shows how an custom Runge-Kutta stepper can be
created with odeint generic Runge-Kutta method.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/list_lattice.cpp" target="_top">list_lattice.cpp</a>
</p>
</td>
<td>
<p>
Example of a phase lattice integration using <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span></code>
as state type.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/lorenz_point.cpp" target="_top">lorenz_point.cpp</a>
</p>
</td>
<td>
<p>
Alternative way of integrating lorenz by using a self defined point3d
data type as state type.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/my_vector.cpp" target="_top">my_vector.cpp</a>
</p>
</td>
<td>
<p>
Simple example showing how to get odeint to work with a self-defined
vector type.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/phase_oscillator_ensemble.cpp" target="_top">phase_oscillator_ensemble.cpp</a>
</p>
</td>
<td>
<p>
The phase oscillator ensemble example shows how globally coupled
oscillators can be analyzed and how statistical measures can be
computed during integration.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/resizing_lattice.cpp" target="_top">resizing_lattice.cpp</a>
</p>
</td>
<td>
<p>
Shows the strength of odeint's memory management by simulating
a Hamiltonian system on an expanding lattice.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/simple1d.cpp" target="_top">simple1d.cpp</a>
</p>
</td>
<td>
<p>
Integrating a simple, one-dimensional ODE showing the usage of
integrate- and generate-functions.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/solar_system.cpp" target="_top">solar_system.cpp</a>
</p>
</td>
<td>
<p>
The solar system example shows the usage of the symplectic solvers.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/stepper_details.cpp" target="_top">stepper_details.cpp</a>
</p>
</td>
<td>
<p>
Trivial example showing the usability of the several stepper classes.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/stiff_system.cpp" target="_top">stiff_system.cpp</a>
</p>
</td>
<td>
<p>
The stiff system example shows the usage of the stiff solvers using
the Jacobian of the system function.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/stochastic_euler.cpp" target="_top">stochastic_euler.cpp</a>
</p>
</td>
<td>
<p>
Implementation of a custom stepper - the stochastic euler - for
solving stochastic differential equations.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/stuart_landau.cpp" target="_top">stuart_landau.cpp</a>
</p>
</td>
<td>
<p>
The Stuart-Landau example shows how odeint can be used with complex
state types.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/two_dimensional_phase_lattice.cpp" target="_top">two_dimensional_phase_lattice.cpp</a>
</p>
</td>
<td>
<p>
The 2D phase oscillator example shows how a two-dimensional lattice
works with odeint and how matrix types can be used as state types
in odeint.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/van_der_pol_stiff.cpp" target="_top">van_der_pol_stiff.cpp</a>
</p>
</td>
<td>
<p>
This stiff system example again shows the usage of the stiff solvers
by integrating the van der Pol oscillator.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/gmpxx/lorenz_gmpxx.cpp" target="_top">gmpxx/lorenz_gmpxx.cpp</a>
</p>
</td>
<td>
<p>
This examples integrates the Lorenz system by means of an arbitrary
precision type.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/mtl/gauss_packet.cpp" target="_top">mtl/gauss_packet.cpp</a>
</p>
</td>
<td>
<p>
The MTL-Gauss-packet example shows how the MTL can be easily used
with odeint.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/mtl/implicit_euler_mtl.cpp" target="_top">mtl/implicit_euler_mtl.cpp</a>
</p>
</td>
<td>
<p>
This examples shows the usage of the MTL implicit Euler method
with a sparse matrix type.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/thrust/phase_oscillator_ensemble.cu" target="_top">thrust/phase_oscillator_ensemble.cu</a>
</p>
</td>
<td>
<p>
The Thrust phase oscillator ensemble example shows how globally
coupled oscillators can be analyzed with Thrust and CUDA, employing
the power of modern graphic devices.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/thrust/phase_oscillator_chain.cu" target="_top">thrust/phase_oscillator_chain.cu</a>
</p>
</td>
<td>
<p>
The Thrust phase oscillator chain example shows how chains of nearest
neighbor coupled oscillators can be integrated with Thrust and
odeint.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/thrust/lorenz_parameters.cu" target="_top">thrust/lorenz_parameters.cu</a>
</p>
</td>
<td>
<p>
The Lorenz parameters examples show how ensembles of ordinary differential
equations can be solved by means of Thrust to study the dependence
of an ODE on some parameters.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/thrust/relaxation.cu" target="_top">thrust/relaxation.cu</a>
</p>
</td>
<td>
<p>
Another examples for the usage of Thrust.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/ublas/lorenz_ublas.cpp" target="_top">ublas/lorenz_ublas.cpp</a>
</p>
</td>
<td>
<p>
This example shows how the ublas vector types can be used with
odeint.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/vexcl/lorenz_ensemble.cpp" target="_top">vexcl/lorenz_ensemble.cpp</a>
</p>
</td>
<td>
<p>
This example shows how the VexCL - a framework for OpenCL computation
- can be used with odeint.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/openmp/lorenz_ensemble_simple.cpp" target="_top">openmp/lorenz_ensemble_simple.cpp</a>
</p>
</td>
<td>
<p>
OpenMP Lorenz attractor parameter study with continuous data.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/openmp/lorenz_ensemble.cpp" target="_top">openmp/lorenz_ensemble.cpp</a>
</p>
</td>
<td>
<p>
OpenMP Lorenz attractor parameter study with split data.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/openmp/lorenz_ensemble.cpp" target="_top">openmp/lorenz_ensemble_nested.cpp</a>
</p>
</td>
<td>
<p>
OpenMP Lorenz attractor parameter study with nested <code class="computeroutput"><span class="identifier">vector_space_algebra</span></code>.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/openmp/phase_chain.cpp" target="_top">openmp/phase_chain.cpp</a>
</p>
</td>
<td>
<p>
OpenMP nearest neighbour coupled phase chain with continuous state.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/openmp/phase_chain_omp_state.cpp" target="_top">openmp/phase_chain_omp_state.cpp</a>
</p>
</td>
<td>
<p>
OpenMP nearest neighbour coupled phase chain with split state.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/mpi/phase_chain.cpp" target="_top">mpi/phase_chain.cpp</a>
</p>
</td>
<td>
<p>
MPI nearest neighbour coupled phase chain.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/2d_lattice/spreading.cpp" target="_top">2d_lattice/spreading.cpp</a>
</p>
</td>
<td>
<p>
This examples shows how a <code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">T</span>
<span class="special">&gt;</span> <span class="special">&gt;</span></code>
can be used a state type for odeint and how a resizing mechanism
of this state can be implemented.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/quadmath/black_hole.cpp" target="_top">quadmath/black_hole.cpp</a>
</p>
</td>
<td>
<p>
This examples shows how gcc libquadmath can be used with odeint.
It provides a high precision floating point type which is adapted
to odeint in this example.
</p>
</td>
</tr>
<tr>
<td>
<p>
<a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/molecular_dynamics.cpp" target="_top">molecular_dynamics.cpp</a>
</p>
</td>
<td>
<p>
A very basic molecular dynamics simulation with the Velocity-Verlet
method.
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break">
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="parallel_computation_with_openmp_and_mpi.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../odeint_in_detail.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,303 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Chaotic systems and Lyapunov exponents</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="solar_system.html" title="Solar system">
<link rel="next" href="stiff_systems.html" title="Stiff systems">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="solar_system.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="stiff_systems.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.chaotic_systems_and_lyapunov_exponents"></a><a class="link" href="chaotic_systems_and_lyapunov_exponents.html" title="Chaotic systems and Lyapunov exponents">Chaotic
systems and Lyapunov exponents</a>
</h3></div></div></div>
<p>
In this example we present application of odeint to investigation of the
properties of chaotic deterministic systems. In mathematical terms chaotic
refers to an exponential growth of perturbations <span class="emphasis"><em>&#948; x</em></span>.
In order to observe this exponential growth one usually solves the equations
for the tangential dynamics which is again an ordinary differential equation.
These equations are linear but time dependent and can be obtained via
</p>
<p>
<span class="emphasis"><em>d &#948; x / dt = J(x) &#948; x</em></span>
</p>
<p>
where <span class="emphasis"><em>J</em></span> is the Jacobian of the system under consideration.
<span class="emphasis"><em>&#948; x</em></span> can also be interpreted as a perturbation of the original
system. In principle <span class="emphasis"><em>n</em></span> of these perturbations exist,
they form a hypercube and evolve in the time. The Lyapunov exponents are
then defined as logarithmic growth rates of the perturbations. If one Lyapunov
exponent is larger then zero the nearby trajectories diverge exponentially
hence they are chaotic. If the largest Lyapunov exponent is zero one is usually
faced with periodic motion. In the case of a largest Lyapunov exponent smaller
then zero convergence to a fixed point is expected. More information's about
Lyapunov exponents and nonlinear dynamical systems can be found in many textbooks,
see for example: E. Ott "Chaos is Dynamical Systems", Cambridge.
</p>
<p>
To calculate the Lyapunov exponents numerically one usually solves the equations
of motion for <span class="emphasis"><em>n</em></span> perturbations and orthonormalizes them
every <span class="emphasis"><em>k</em></span> steps. The Lyapunov exponent is the average
of the logarithm of the stretching factor of each perturbation.
</p>
<p>
To demonstrate how one can use odeint to determine the Lyapunov exponents
we choose the Lorenz system. It is one of the most studied dynamical systems
in the nonlinear dynamics community. For the standard parameters it possesses
a strange attractor with non-integer dimension. The Lyapunov exponents take
values of approximately 0.9, 0 and -12.
</p>
<p>
The implementation of the Lorenz system is
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">sigma</span> <span class="special">=</span> <span class="number">10.0</span><span class="special">;</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">R</span> <span class="special">=</span> <span class="number">28.0</span><span class="special">;</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">8.0</span> <span class="special">/</span> <span class="number">3.0</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="number">3</span> <span class="special">&gt;</span> <span class="identifier">lorenz_state_type</span><span class="special">;</span>
<span class="keyword">void</span> <span class="identifier">lorenz</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">lorenz_state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">lorenz_state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">sigma</span> <span class="special">*</span> <span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">);</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">R</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">];</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">b</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
<span class="special">}</span>
</pre>
<p>
We need also to integrate the set of the perturbations. This is done in parallel
to the original system, hence within one system function. Of course, we want
to use the above definition of the Lorenz system, hence the definition of
the system function including the Lorenz system itself and the perturbation
could look like:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>
<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">num_of_lyap</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>
<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">=</span> <span class="identifier">n</span> <span class="special">+</span> <span class="identifier">n</span><span class="special">*</span><span class="identifier">num_of_lyap</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">N</span> <span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tr1</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">num_of_lyap</span> <span class="special">&gt;</span> <span class="identifier">lyap_type</span><span class="special">;</span>
<span class="keyword">void</span> <span class="identifier">lorenz_with_lyap</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">lorenz</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">);</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">l</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">l</span><span class="special">&lt;</span><span class="identifier">num_of_lyap</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">l</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="special">*</span><span class="identifier">pert</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="number">3</span> <span class="special">+</span> <span class="identifier">l</span> <span class="special">*</span> <span class="number">3</span><span class="special">;</span>
<span class="keyword">double</span> <span class="special">*</span><span class="identifier">dpert</span> <span class="special">=</span> <span class="identifier">dxdt</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="number">3</span> <span class="special">+</span> <span class="identifier">l</span> <span class="special">*</span> <span class="number">3</span><span class="special">;</span>
<span class="identifier">dpert</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span> <span class="identifier">sigma</span> <span class="special">*</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">+</span> <span class="number">10.0</span> <span class="special">*</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
<span class="identifier">dpert</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">R</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">)</span> <span class="special">*</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">2</span><span class="special">];</span>
<span class="identifier">dpert</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">b</span> <span class="special">*</span> <span class="identifier">pert</span><span class="special">[</span><span class="number">2</span><span class="special">];</span>
<span class="special">}</span>
<span class="special">}</span>
</pre>
<p>
</p>
<p>
The perturbations are stored linearly in the <code class="computeroutput"><span class="identifier">state_type</span></code>
behind the state of the Lorenz system. The problem of lorenz() and lorenz_with_lyap() having different
state types may be solved putting the Lorenz system inside a functor with
templatized arguments:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">lorenz</span>
<span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">StateIn</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">StateOut</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Value</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">StateIn</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">StateOut</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">Value</span> <span class="identifier">t</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">sigma</span> <span class="special">*</span> <span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">);</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">R</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">];</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">b</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="keyword">void</span> <span class="identifier">lorenz_with_lyap</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">lorenz</span><span class="special">()(</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">);</span>
<span class="special">...</span>
<span class="special">}</span>
</pre>
<p>
This works fine and <code class="computeroutput"><span class="identifier">lorenz_with_lyap</span></code>
can be used for example via
</p>
<pre class="programlisting"><span class="identifier">state_type</span> <span class="identifier">x</span><span class="special">;</span>
<span class="comment">// initialize x..</span>
<span class="identifier">explicit_rk4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="identifier">rk4</span><span class="special">;</span>
<span class="identifier">integrate_n_steps</span><span class="special">(</span> <span class="identifier">rk4</span> <span class="special">,</span> <span class="identifier">lorenz_with_lyap</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">,</span> <span class="number">1000</span> <span class="special">);</span>
</pre>
<p>
This code snippet performs 1000 steps with constant step size 0.01.
</p>
<p>
A real world use case for the calculation of the Lyapunov exponents of Lorenz
system would always include some transient steps, just to ensure that the
current state lies on the attractor, hence it would look like
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">state_type</span> <span class="identifier">x</span><span class="special">;</span>
<span class="comment">// initialize x</span>
<span class="identifier">explicit_rk4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="identifier">rk4</span><span class="special">;</span>
<span class="identifier">integrate_n_steps</span><span class="special">(</span> <span class="identifier">rk4</span> <span class="special">,</span> <span class="identifier">lorenz</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">,</span> <span class="number">1000</span> <span class="special">);</span>
</pre>
<p>
The problem is now, that <code class="computeroutput"><span class="identifier">x</span></code>
is the full state containing also the perturbations and <code class="computeroutput"><span class="identifier">integrate_n_steps</span></code>
does not know that it should only use 3 elements. In detail, odeint and its
steppers determine the length of the system under consideration by determining
the length of the state. In the classical solvers, e.g. from Numerical Recipes,
the problem was solved by pointer to the state and an appropriate length,
something similar to
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">lorenz</span><span class="special">(</span> <span class="keyword">double</span><span class="special">*</span> <span class="identifier">x</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">*</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">params</span> <span class="special">)</span>
<span class="special">{</span>
<span class="special">...</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">system_length</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>
<span class="identifier">rk4</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">system_length</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">,</span> <span class="identifier">lorenz</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
But odeint supports a similar and much more sophisticated concept: <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>.
To make the steppers and the system ready to work with <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>
the system has to be changed:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">lorenz</span>
<span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Deriv</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x_</span> <span class="special">,</span> <span class="identifier">Deriv</span> <span class="special">&amp;</span><span class="identifier">dxdt_</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">x_</span> <span class="special">);</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span> <span class="identifier">Deriv</span> <span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">dxdt</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">dxdt_</span> <span class="special">);</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">sigma</span> <span class="special">*</span> <span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">);</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">R</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">];</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">b</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
This is in principle all. Now, we only have to call <code class="computeroutput"><span class="identifier">integrate_n_steps</span></code>
with a range including only the first 3 components of <span class="emphasis"><em>x</em></span>:
</p>
<p>
</p>
<pre class="programlisting"><span class="comment">// explicitly choose range_algebra to override default choice of array_algebra</span>
<span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">state_type</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">double</span> <span class="special">,</span> <span class="identifier">range_algebra</span> <span class="special">&gt;</span> <span class="identifier">rk4</span><span class="special">;</span>
<span class="comment">// perform 10000 transient steps</span>
<span class="identifier">integrate_n_steps</span><span class="special">(</span> <span class="identifier">rk4</span> <span class="special">,</span> <span class="identifier">lorenz</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">make_pair</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">n</span> <span class="special">)</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">,</span> <span class="number">10000</span> <span class="special">);</span>
</pre>
<p>
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
Note that when using <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>,
we have to explicitly configure the stepper to use the <code class="computeroutput"><span class="identifier">range_algebra</span></code>
as otherwise odeint would automatically chose the <code class="computeroutput"><span class="identifier">array_algebra</span></code>,
which is incompatible with the usage of <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>,
because the original state_type is an <code class="computeroutput"><span class="identifier">array</span></code>.
</p></td></tr>
</table></div>
<p>
Having integrated a sufficient number of transients steps we are now able
to calculate the Lyapunov exponents:
</p>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
Initialize the perturbations. They are stored linearly behind the state
of the Lorenz system. The perturbations are initialized such that <span class="emphasis"><em>p
<sub>&#8203;ij</sub> = &#948; <sub>&#8203;ij</sub></em></span>, where <span class="emphasis"><em>p <sub>&#8203;ij</sub></em></span> is the <span class="emphasis"><em>j</em></span>-component
of the <span class="emphasis"><em>i</em></span>.-th perturbation and <span class="emphasis"><em>&#948; <sub>&#8203;ij</sub></em></span>
is the Kronecker symbol.
</li>
<li class="listitem">
Integrate 100 steps of the full system with perturbations
</li>
<li class="listitem">
Orthonormalize the perturbation using Gram-Schmidt orthonormalization
algorithm.
</li>
<li class="listitem">
Repeat step 2 and 3. Every 10000 steps write the current Lyapunov exponent.
</li>
</ol></div>
<p>
</p>
<pre class="programlisting"><span class="identifier">fill</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()+</span><span class="identifier">n</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">);</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">num_of_lyap</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">+</span><span class="identifier">n</span><span class="special">*</span><span class="identifier">i</span><span class="special">+</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="number">1.0</span><span class="special">;</span>
<span class="identifier">fill</span><span class="special">(</span> <span class="identifier">lyap</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">lyap</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">);</span>
<span class="keyword">double</span> <span class="identifier">t</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
<span class="identifier">size_t</span> <span class="identifier">count</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="keyword">while</span><span class="special">(</span> <span class="keyword">true</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">t</span> <span class="special">=</span> <span class="identifier">integrate_n_steps</span><span class="special">(</span> <span class="identifier">rk4</span> <span class="special">,</span> <span class="identifier">lorenz_with_lyap</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">,</span> <span class="number">100</span> <span class="special">);</span>
<span class="identifier">gram_schmidt</span><span class="special">&lt;</span> <span class="identifier">num_of_lyap</span> <span class="special">&gt;(</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">lyap</span> <span class="special">,</span> <span class="identifier">n</span> <span class="special">);</span>
<span class="special">++</span><span class="identifier">count</span><span class="special">;</span>
<span class="keyword">if</span><span class="special">(</span> <span class="special">!(</span><span class="identifier">count</span> <span class="special">%</span> <span class="number">100000</span><span class="special">)</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">t</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">num_of_lyap</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span> <span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\t"</span> <span class="special">&lt;&lt;</span> <span class="identifier">lyap</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">/</span> <span class="identifier">t</span> <span class="special">;</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
</pre>
<p>
</p>
<p>
The full code can be found here: <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/chaotic_system.cpp" target="_top">chaotic_system.cpp</a>
</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 &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="solar_system.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="stiff_systems.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,125 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Complex state types</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="stiff_systems.html" title="Stiff systems">
<link rel="next" href="lattice_systems.html" title="Lattice systems">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="stiff_systems.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="lattice_systems.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.complex_state_types"></a><a class="link" href="complex_state_types.html" title="Complex state types">Complex
state types</a>
</h3></div></div></div>
<p>
Thus far we have seen several examples defined for real values. odeint can
handle complex state types, hence ODEs which are defined on complex vector
spaces, as well. An example is the Stuart-Landau oscillator
</p>
<p>
<span class="emphasis"><em>d &#936; / dt = ( 1 + i &#951; ) &#936; + ( 1 + i &#945; ) | &#936; |<sup>2</sup> &#936; </em></span>
</p>
<p>
where <span class="emphasis"><em>&#936;</em></span> and <span class="emphasis"><em>i</em></span> is a complex variable.
The definition of this ODE in C++ using complex&lt; double &gt; as a state
type may look as follows
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">complex</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
<span class="keyword">struct</span> <span class="identifier">stuart_landau</span>
<span class="special">{</span>
<span class="keyword">double</span> <span class="identifier">m_eta</span><span class="special">;</span>
<span class="keyword">double</span> <span class="identifier">m_alpha</span><span class="special">;</span>
<span class="identifier">stuart_landau</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">eta</span> <span class="special">=</span> <span class="number">1.0</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">alpha</span> <span class="special">=</span> <span class="number">1.0</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">m_eta</span><span class="special">(</span> <span class="identifier">eta</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_alpha</span><span class="special">(</span> <span class="identifier">alpha</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="identifier">complex</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">I</span><span class="special">(</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">);</span>
<span class="identifier">dxdt</span> <span class="special">=</span> <span class="special">(</span> <span class="number">1.0</span> <span class="special">+</span> <span class="identifier">m_eta</span> <span class="special">*</span> <span class="identifier">I</span> <span class="special">)</span> <span class="special">*</span> <span class="identifier">x</span> <span class="special">-</span> <span class="special">(</span> <span class="number">1.0</span> <span class="special">+</span> <span class="identifier">m_alpha</span> <span class="special">*</span> <span class="identifier">I</span> <span class="special">)</span> <span class="special">*</span> <span class="identifier">norm</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
One can also use a function instead of a functor to implement it
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">eta</span> <span class="special">=</span> <span class="number">1.0</span><span class="special">;</span>
<span class="keyword">double</span> <span class="identifier">alpha</span> <span class="special">=</span> <span class="number">1.0</span><span class="special">;</span>
<span class="keyword">void</span> <span class="identifier">stuart_landau</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="identifier">complex</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">I</span><span class="special">(</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">);</span>
<span class="identifier">dxdt</span> <span class="special">=</span> <span class="special">(</span> <span class="number">1.0</span> <span class="special">+</span> <span class="identifier">m_eta</span> <span class="special">*</span> <span class="identifier">I</span> <span class="special">)</span> <span class="special">*</span> <span class="identifier">x</span> <span class="special">-</span> <span class="special">(</span> <span class="number">1.0</span> <span class="special">+</span> <span class="identifier">m_alpha</span> <span class="special">*</span> <span class="identifier">I</span> <span class="special">)</span> <span class="special">*</span> <span class="identifier">norm</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
<p>
We strongly recommend to use the first ansatz. In this case you have explicit
control over the parameters of the system and are not restricted to use global
variables to parametrize the oscillator.
</p>
<p>
When choosing the stepper type one has to account for the "unusual"
state type: it is a single <code class="computeroutput"><span class="identifier">complex</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span></code> opposed to the vector types used in the
previous examples. This means that no iterations over vector elements have
to be performed inside the stepper algorithm. Odeint already detects that
and automatically uses the <code class="computeroutput"><span class="identifier">vector_space_algebra</span></code>
for computation. You can enforce this by supplying additional template arguments
to the stepper including the <code class="computeroutput"><span class="identifier">vector_space_algebra</span></code>.
Details on the usage of algebras can be found in the section <a class="link" href="../odeint_in_detail/state_types__algebras_and_operations.html" title="State types, algebras and operations">Adapt
your own state types</a>.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">state_type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">complex</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;(</span> <span class="number">1.0</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">);</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">dt</span> <span class="special">=</span> <span class="number">0.1</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="identifier">stepper_type</span><span class="special">;</span>
<span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">stepper_type</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">stuart_landau</span><span class="special">(</span> <span class="number">2.0</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">,</span> <span class="identifier">streaming_observer</span><span class="special">(</span> <span class="identifier">cout</span> <span class="special">)</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
The full cpp file for the Stuart-Landau example can be found here <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/stuart_landau.cpp" target="_top">stuart_landau.cpp</a>
</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 &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="stiff_systems.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="lattice_systems.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,200 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Ensembles of oscillators</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="lattice_systems.html" title="Lattice systems">
<link rel="next" href="using_boost__units.html" title="Using boost::units">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="lattice_systems.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="using_boost__units.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.ensembles_of_oscillators"></a><a class="link" href="ensembles_of_oscillators.html" title="Ensembles of oscillators">Ensembles
of oscillators</a>
</h3></div></div></div>
<p>
Another important high dimensional system of coupled ordinary differential
equations is an ensemble of <span class="emphasis"><em>N</em></span> all-to-all coupled phase
oscillators <a class="link" href="../literature.html#synchronization_pikovsky_rosenblum">[9] </a>.
It is defined as
</p>
<p>
<span class="emphasis"><em>d&#966;<sub>&#8203;k</sub> / dt = &#969;<sub>&#8203;k</sub> + &#949; / N &#931;<sub>&#8203;j</sub> sin( &#966;<sub>&#8203;j</sub> - &#966;<sub>&#8203;k</sub> )</em></span>
</p>
<p>
The natural frequencies <span class="emphasis"><em>&#969;<sub>&#8203;i</sub></em></span> of each oscillator follow
some distribution and <span class="emphasis"><em>&#949;</em></span> is the coupling strength. We
choose here a Lorentzian distribution for <span class="emphasis"><em>&#969;<sub>&#8203;i</sub></em></span>. Interestingly
a phase transition can be observed if the coupling strength exceeds a critical
value. Above this value synchronization sets in and some of the oscillators
oscillate with the same frequency despite their different natural frequencies.
The transition is also called Kuramoto transition. Its behavior can be analyzed
by employing the mean field of the phase
</p>
<p>
<span class="emphasis"><em>Z = K e<sup>i &#920;</sup> = 1 / N &#931;<sub>&#8203;k</sub>e<sup>i &#966;<sub>&#8203;k</sub></sup></em></span>
</p>
<p>
The definition of the system function is now a bit more complex since we
also need to store the individual frequencies of each oscillator.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">container_type</span><span class="special">;</span>
<span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">calc_mean_field</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
<span class="keyword">double</span> <span class="identifier">cos_sum</span> <span class="special">=</span> <span class="number">0.0</span> <span class="special">,</span> <span class="identifier">sin_sum</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">n</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">cos_sum</span> <span class="special">+=</span> <span class="identifier">cos</span><span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">);</span>
<span class="identifier">sin_sum</span> <span class="special">+=</span> <span class="identifier">sin</span><span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">);</span>
<span class="special">}</span>
<span class="identifier">cos_sum</span> <span class="special">/=</span> <span class="keyword">double</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">);</span>
<span class="identifier">sin_sum</span> <span class="special">/=</span> <span class="keyword">double</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">);</span>
<span class="keyword">double</span> <span class="identifier">K</span> <span class="special">=</span> <span class="identifier">sqrt</span><span class="special">(</span> <span class="identifier">cos_sum</span> <span class="special">*</span> <span class="identifier">cos_sum</span> <span class="special">+</span> <span class="identifier">sin_sum</span> <span class="special">*</span> <span class="identifier">sin_sum</span> <span class="special">);</span>
<span class="keyword">double</span> <span class="identifier">Theta</span> <span class="special">=</span> <span class="identifier">atan2</span><span class="special">(</span> <span class="identifier">sin_sum</span> <span class="special">,</span> <span class="identifier">cos_sum</span> <span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">make_pair</span><span class="special">(</span> <span class="identifier">K</span> <span class="special">,</span> <span class="identifier">Theta</span> <span class="special">);</span>
<span class="special">}</span>
<span class="keyword">struct</span> <span class="identifier">phase_ensemble</span>
<span class="special">{</span>
<span class="identifier">container_type</span> <span class="identifier">m_omega</span><span class="special">;</span>
<span class="keyword">double</span> <span class="identifier">m_epsilon</span><span class="special">;</span>
<span class="identifier">phase_ensemble</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">g</span> <span class="special">=</span> <span class="number">1.0</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">epsilon</span> <span class="special">=</span> <span class="number">1.0</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">m_omega</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_epsilon</span><span class="special">(</span> <span class="identifier">epsilon</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">create_frequencies</span><span class="special">(</span> <span class="identifier">g</span> <span class="special">);</span>
<span class="special">}</span>
<span class="keyword">void</span> <span class="identifier">create_frequencies</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">g</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">mt19937</span> <span class="identifier">rng</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">cauchy_distribution</span><span class="special">&lt;&gt;</span> <span class="identifier">cauchy</span><span class="special">(</span> <span class="number">0.0</span> <span class="special">,</span> <span class="identifier">g</span> <span class="special">);</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">variate_generator</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mt19937</span><span class="special">&amp;,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">cauchy_distribution</span><span class="special">&lt;&gt;</span> <span class="special">&gt;</span> <span class="identifier">gen</span><span class="special">(</span> <span class="identifier">rng</span> <span class="special">,</span> <span class="identifier">cauchy</span> <span class="special">);</span>
<span class="identifier">generate</span><span class="special">(</span> <span class="identifier">m_omega</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">m_omega</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">gen</span> <span class="special">);</span>
<span class="special">}</span>
<span class="keyword">void</span> <span class="identifier">set_epsilon</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">epsilon</span> <span class="special">)</span> <span class="special">{</span> <span class="identifier">m_epsilon</span> <span class="special">=</span> <span class="identifier">epsilon</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">double</span> <span class="identifier">get_epsilon</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">m_epsilon</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="comment">/* t */</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">mean</span> <span class="special">=</span> <span class="identifier">calc_mean_field</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">);</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">m_omega</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">+</span> <span class="identifier">m_epsilon</span> <span class="special">*</span> <span class="identifier">mean</span><span class="special">.</span><span class="identifier">first</span> <span class="special">*</span> <span class="identifier">sin</span><span class="special">(</span> <span class="identifier">mean</span><span class="special">.</span><span class="identifier">second</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
Note, that we have used <span class="emphasis"><em>Z</em></span> to simplify the equations
of motion. Next, we create an observer which computes the value of <span class="emphasis"><em>Z</em></span>
and we record <span class="emphasis"><em>Z</em></span> for different values of <span class="emphasis"><em>&#949;</em></span>.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">statistics_observer</span>
<span class="special">{</span>
<span class="keyword">double</span> <span class="identifier">m_K_mean</span><span class="special">;</span>
<span class="identifier">size_t</span> <span class="identifier">m_count</span><span class="special">;</span>
<span class="identifier">statistics_observer</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">m_K_mean</span><span class="special">(</span> <span class="number">0.0</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_count</span><span class="special">(</span> <span class="number">0</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">mean</span> <span class="special">=</span> <span class="identifier">calc_mean_field</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">);</span>
<span class="identifier">m_K_mean</span> <span class="special">+=</span> <span class="identifier">mean</span><span class="special">.</span><span class="identifier">first</span><span class="special">;</span>
<span class="special">++</span><span class="identifier">m_count</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">double</span> <span class="identifier">get_K_mean</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="special">(</span> <span class="identifier">m_count</span> <span class="special">!=</span> <span class="number">0</span> <span class="special">)</span> <span class="special">?</span> <span class="identifier">m_K_mean</span> <span class="special">/</span> <span class="keyword">double</span><span class="special">(</span> <span class="identifier">m_count</span> <span class="special">)</span> <span class="special">:</span> <span class="number">0.0</span> <span class="special">;</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="identifier">reset</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="special">{</span> <span class="identifier">m_K_mean</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span> <span class="identifier">m_count</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
Now, we do several integrations for different values of <span class="emphasis"><em>&#949;</em></span>
and record <span class="emphasis"><em>Z</em></span>. The result nicely confirms the analytical
result of the phase transition, i.e. in our example the standard deviation
of the Lorentzian is 1 such that the transition will be observed at <span class="emphasis"><em>&#949; =
2</em></span>.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="number">16384</span><span class="special">;</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">dt</span> <span class="special">=</span> <span class="number">0.1</span><span class="special">;</span>
<span class="identifier">container_type</span> <span class="identifier">x</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">);</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">mt19937</span> <span class="identifier">rng</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">uniform_real</span><span class="special">&lt;&gt;</span> <span class="identifier">unif</span><span class="special">(</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">2.0</span> <span class="special">*</span> <span class="identifier">M_PI</span> <span class="special">);</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">variate_generator</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mt19937</span><span class="special">&amp;,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uniform_real</span><span class="special">&lt;&gt;</span> <span class="special">&gt;</span> <span class="identifier">gen</span><span class="special">(</span> <span class="identifier">rng</span> <span class="special">,</span> <span class="identifier">unif</span> <span class="special">);</span>
<span class="comment">// gamma = 1, the phase transition occurs at epsilon = 2</span>
<span class="identifier">phase_ensemble</span> <span class="identifier">ensemble</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">);</span>
<span class="identifier">statistics_observer</span> <span class="identifier">obs</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">epsilon</span> <span class="special">=</span> <span class="number">0.0</span> <span class="special">;</span> <span class="identifier">epsilon</span> <span class="special">&lt;</span> <span class="number">5.0</span> <span class="special">;</span> <span class="identifier">epsilon</span> <span class="special">+=</span> <span class="number">0.1</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">ensemble</span><span class="special">.</span><span class="identifier">set_epsilon</span><span class="special">(</span> <span class="identifier">epsilon</span> <span class="special">);</span>
<span class="identifier">obs</span><span class="special">.</span><span class="identifier">reset</span><span class="special">();</span>
<span class="comment">// start with random initial conditions</span>
<span class="identifier">generate</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">gen</span> <span class="special">);</span>
<span class="comment">// calculate some transients steps</span>
<span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">container_type</span> <span class="special">&gt;()</span> <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span><span class="special">(</span> <span class="identifier">ensemble</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">);</span>
<span class="comment">// integrate and compute the statistics</span>
<span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">container_type</span> <span class="special">&gt;()</span> <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span><span class="special">(</span> <span class="identifier">ensemble</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">100.0</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span><span class="special">(</span> <span class="identifier">obs</span> <span class="special">)</span> <span class="special">);</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">epsilon</span> <span class="special">&lt;&lt;</span> <span class="string">"\t"</span> <span class="special">&lt;&lt;</span> <span class="identifier">obs</span><span class="special">.</span><span class="identifier">get_K_mean</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
<p>
The full cpp file for this example can be found here <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/phase_oscillator_ensemble.cpp" target="_top">phase_oscillator_ensemble.cpp</a>
</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 &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="lattice_systems.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="using_boost__units.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,528 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Harmonic oscillator</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="../tutorial.html" title="Tutorial">
<link rel="next" href="solar_system.html" title="Solar system">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../tutorial.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="solar_system.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.harmonic_oscillator"></a><a class="link" href="harmonic_oscillator.html" title="Harmonic oscillator">Harmonic
oscillator</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="harmonic_oscillator.html#boost_numeric_odeint.tutorial.harmonic_oscillator.define_the_ode">Define
the ODE</a></span></dt>
<dt><span class="section"><a href="harmonic_oscillator.html#boost_numeric_odeint.tutorial.harmonic_oscillator.stepper_types">Stepper
Types</a></span></dt>
<dt><span class="section"><a href="harmonic_oscillator.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="harmonic_oscillator.html#boost_numeric_odeint.tutorial.harmonic_oscillator.integration_with_adaptive_step_size">Integration
with Adaptive Step Size</a></span></dt>
<dt><span class="section"><a href="harmonic_oscillator.html#boost_numeric_odeint.tutorial.harmonic_oscillator.using_iterators">Using
iterators</a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.tutorial.harmonic_oscillator.define_the_ode"></a><a class="link" href="harmonic_oscillator.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 data type that represents a state
<span class="emphasis"><em>x</em></span> of your system. 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">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span></code> or <code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">complex</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="special">&gt;</span></code>
to represent the system state. However, odeint can deal with other container
types as well, e.g. <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">N</span> <span class="special">&gt;</span></code>, as long as it fulfills some requirements
defined below.
</p>
<p>
To integrate a differential equation numerically, one also 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 straightforward way would be
to just define a function, e.g:
</p>
<p>
</p>
<pre class="programlisting"><span class="comment">/* The type of container used to hold the state vector */</span>
<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">gam</span> <span class="special">=</span> <span class="number">0.15</span><span class="special">;</span>
<span class="comment">/* The rhs of x' = f(x) */</span>
<span class="keyword">void</span> <span class="identifier">harmonic_oscillator</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">const</span> <span class="keyword">double</span> <span class="comment">/* 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>
The parameters of the function must follow the example above where <code class="computeroutput"><span class="identifier">x</span></code> is the current state, here a two-component
vector containing position <span class="emphasis"><em>q</em></span> and momentum <span class="emphasis"><em>p</em></span>
of the oscillator, <code class="computeroutput"><span class="identifier">dxdt</span></code>
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 <code class="computeroutput"><span class="identifier">t</span></code>
is the current time. Note that in this example <span class="emphasis"><em>t</em></span> is
not required to calculate <span class="emphasis"><em>f</em></span>, however odeint expects
the function signature to have exactly three parameters (there are exception,
discussed later).
</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>
<pre class="programlisting"><span class="comment">/* The rhs of x' = f(x) defined as a class */</span>
<span class="keyword">class</span> <span class="identifier">harm_osc</span> <span class="special">{</span>
<span class="keyword">double</span> <span class="identifier">m_gam</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">harm_osc</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">gam</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_gam</span><span class="special">(</span><span class="identifier">gam</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">const</span> <span class="keyword">double</span> <span class="comment">/* 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>
odeint can deal with instances of such classes instead of pure functions
which allows for cleaner code.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.tutorial.harmonic_oscillator.stepper_types"></a><a class="link" href="harmonic_oscillator.html#boost_numeric_odeint.tutorial.harmonic_oscillator.stepper_types" title="Stepper Types">Stepper
Types</a>
</h4></div></div></div>
<p>
Numerical integration works iteratively, that means you start at a state
<span class="emphasis"><em>x(t)</em></span> and perform a time-step 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 time-step 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<sup>q</sup></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<sup>q+1</sup></em></span>.
odeint provides several steppers of different orders, see <a class="link" href="../odeint_in_detail/steppers.html#boost_numeric_odeint.odeint_in_detail.steppers.stepper_overview" title="Stepper overview">Stepper
overview</a>.
</p>
<p>
Some of steppers in the table above are special: Some need the Jacobian
of the ODE, others are constructed for special ODE-systems like Hamiltonian
systems. We will show typical examples and use-cases in this tutorial and
which kind of steppers should be applied.
</p>
</div>
<div class="section">
<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="harmonic_oscillator.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 time-step and doesn't give you any
information about the error that was made (except that you know it is of
order <span class="emphasis"><em>q+1</em></span>). 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 (like
observing conserved quantities) because you have no other control of the
error. The following example defines a basic stepper based on the classical
Runge-Kutta scheme of 4th order. The declaration of the stepper requires
the state type as template parameter. The integration can now be done by
using the <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>
</p>
<pre class="programlisting"><span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="identifier">stepper</span><span class="special">;</span>
<span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">stepper</span> <span class="special">,</span> <span class="identifier">harmonic_oscillator</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
This call integrates the system defined by <code class="computeroutput"><span class="identifier">harmonic_oscillator</span></code>
using the RK4 method from <span class="emphasis"><em>t=0</em></span> to <span class="emphasis"><em>10</em></span>
with a step-size <span class="emphasis"><em>dt=0.01</em></span> 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). Each stepper defines a <code class="computeroutput"><span class="identifier">do_step</span></code>
method which can also be used directly. So, you write down the above example
as
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">dt</span> <span class="special">=</span> <span class="number">0.01</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">t</span><span class="special">=</span><span class="number">0.0</span> <span class="special">;</span> <span class="identifier">t</span><span class="special">&lt;</span><span class="number">10.0</span> <span class="special">;</span> <span class="identifier">t</span><span class="special">+=</span> <span class="identifier">dt</span> <span class="special">)</span>
<span class="identifier">stepper</span><span class="special">.</span><span class="identifier">do_step</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="identifier">t</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">);</span>
</pre>
<p>
</p>
<div class="tip"><table border="0" summary="Tip">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../../../doc/src/images/tip.png"></td>
<th align="left">Tip</th>
</tr>
<tr><td align="left" valign="top">
<p>
If you have a C++11 enabled compiler you can easily use lambdas to create
the system function :
</p>
<p>
</p>
<pre class="programlisting"><span class="special">{</span>
<span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="identifier">stepper</span><span class="special">;</span>
<span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">stepper</span> <span class="special">,</span> <span class="special">[](</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">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>
<span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
</p>
</td></tr>
</table></div>
</div>
<div class="section">
<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="harmonic_oscillator.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 <code class="computeroutput"><span class="identifier">explicit_error_rk54_ck</span></code>
- a 5th order Runge-Kutta method with 4th order error estimation and coefficients
introduced by Cash and Karp.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">runge_kutta_cash_karp54</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="identifier">error_stepper_type</span><span class="special">;</span>
</pre>
<p>
</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>. For the <code class="computeroutput"><span class="identifier">runge_kutta_cash_karp54</span></code>
stepper a <code class="computeroutput"><span class="identifier">controlled_runge_kutta</span></code>
stepper exists which can be used via
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">controlled_runge_kutta</span><span class="special">&lt;</span> <span class="identifier">error_stepper_type</span> <span class="special">&gt;</span> <span class="identifier">controlled_stepper_type</span><span class="special">;</span>
<span class="identifier">controlled_stepper_type</span> <span class="identifier">controlled_stepper</span><span class="special">;</span>
<span class="identifier">integrate_adaptive</span><span class="special">(</span> <span class="identifier">controlled_stepper</span> <span class="special">,</span> <span class="identifier">harmonic_oscillator</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
As above, this integrates the system defined by <code class="computeroutput"><span class="identifier">harmonic_oscillator</span></code>,
but now using an adaptive step size method based on the Runge-Kutta Cash-Karp
54 scheme from <span class="emphasis"><em>t=0</em></span> to <span class="emphasis"><em>10</em></span> with
an initial step size of <span class="emphasis"><em>dt=0.01</em></span> (will be adjusted)
and the initial condition given in x. The result, <span class="emphasis"><em>x(t=10)</em></span>,
will also be stored in x (in-place).
</p>
<p>
In the above example an error stepper is nested in a controlled stepper.
This is a nice technique; however one drawback is that one always needs
to define both steppers. One could also write the instantiation of the
controlled stepper into the call of the integrate function but a complete
knowledge of the underlying stepper types is still necessary. Another point
is, that the error tolerances for the step size control are not easily
included into the controlled stepper. Both issues can be solved by using
<code class="computeroutput"><span class="identifier">make_controlled</span></code>:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">integrate_adaptive</span><span class="special">(</span> <span class="identifier">make_controlled</span><span class="special">&lt;</span> <span class="identifier">error_stepper_type</span> <span class="special">&gt;(</span> <span class="number">1.0e-10</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">harmonic_oscillator</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
<code class="computeroutput"><span class="identifier">make_controlled</span></code> can be
used with many of the steppers of odeint. The first parameter is the absolute
error tolerance <span class="emphasis"><em>eps_abs</em></span> and the second is the relative
error tolerance <span class="emphasis"><em>eps_rel</em></span> which is used during the integration.
The template parameter determines from which error stepper a controlled
stepper should be instantiated. An alternative syntax of <code class="computeroutput"><span class="identifier">make_controlled</span></code> is
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">integrate_adaptive</span><span class="special">(</span> <span class="identifier">make_controlled</span><span class="special">(</span> <span class="number">1.0e-10</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="identifier">error_stepper_type</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">harmonic_oscillator</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
For the Runge-Kutta controller the error made during one step is compared
with <span class="emphasis"><em>eps_abs + eps_rel * ( a<sub>x</sub> * |x| + a<sub>dxdt</sub> * dt * |dxdt| )</em></span>.
If the error is smaller than this value the current step is accepted, otherwise
it is rejected and the step size is decreased. Note, that the step size
is also increased if the error gets too small compared to the rhs of the
above relation. The full instantiation of the <code class="computeroutput"><span class="identifier">controlled_runge_kutta</span></code>
with all parameters is therefore
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">abs_err</span> <span class="special">=</span> <span class="number">1.0e-10</span> <span class="special">,</span> <span class="identifier">rel_err</span> <span class="special">=</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="identifier">a_x</span> <span class="special">=</span> <span class="number">1.0</span> <span class="special">,</span> <span class="identifier">a_dxdt</span> <span class="special">=</span> <span class="number">1.0</span><span class="special">;</span>
<span class="identifier">controlled_stepper_type</span> <span class="identifier">controlled_stepper</span><span class="special">(</span>
<span class="identifier">default_error_checker</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">range_algebra</span> <span class="special">,</span> <span class="identifier">default_operations</span> <span class="special">&gt;(</span> <span class="identifier">abs_err</span> <span class="special">,</span> <span class="identifier">rel_err</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> <span class="special">);</span>
<span class="identifier">integrate_adaptive</span><span class="special">(</span> <span class="identifier">controlled_stepper</span> <span class="special">,</span> <span class="identifier">harmonic_oscillator</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
When using <code class="computeroutput"><span class="identifier">make_controlled</span></code>
the parameter <span class="emphasis"><em>a<sub>x</sub></em></span> and <span class="emphasis"><em>a<sub>dxdt</sub></em></span> are
used with their standard values of 1.
</p>
<p>
In the tables below, one can find all steppers which are working with
<code class="computeroutput"><span class="identifier">make_controlled</span></code> and <code class="computeroutput"><span class="identifier">make_dense_output</span></code> which is the analog
for the dense output steppers.
</p>
<div class="table">
<a name="boost_numeric_odeint.tutorial.harmonic_oscillator.integration_with_adaptive_step_size.generation_functions_make_controlled__abs_error___rel_error___stepper__"></a><p class="title"><b>Table&#160;1.2.&#160;Generation functions make_controlled( abs_error , rel_error , stepper
)</b></p>
<div class="table-contents"><table class="table" summary="Generation functions make_controlled( abs_error , rel_error , stepper
)">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Stepper
</p>
</th>
<th>
<p>
Result of make_controlled
</p>
</th>
<th>
<p>
Remarks
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">runge_kutta_cash_karp54</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">controlled_runge_kutta</span><span class="special">&lt;</span> <span class="identifier">runge_kutta_cash_karp54</span>
<span class="special">,</span> <span class="identifier">default_error_checker</span><span class="special">&lt;...&gt;</span> <span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>a<sub>x</sub>=1</em></span>, <span class="emphasis"><em>a<sub>dxdt</sub>=1</em></span>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">runge_kutta_fehlberg78</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">controlled_runge_kutta</span><span class="special">&lt;</span> <span class="identifier">runge_kutta_fehlberg78</span>
<span class="special">,</span> <span class="identifier">default_error_checker</span><span class="special">&lt;...&gt;</span> <span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>a<sub>x</sub>=1</em></span>, <span class="emphasis"><em>a<sub>dxdt</sub>=1</em></span>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">runge_kutta_dopri5</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">controlled_runge_kutta</span><span class="special">&lt;</span> <span class="identifier">runge_kutta_dopri5</span>
<span class="special">,</span> <span class="identifier">default_error_checker</span><span class="special">&lt;...&gt;</span> <span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>a <sub>x</sub>=1</em></span>, <span class="emphasis"><em>a<sub>dxdt</sub>=1</em></span>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">rosenbrock4</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rosenbrock4_controlled</span><span class="special">&lt;</span> <span class="identifier">rosenbrock4</span>
<span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="boost_numeric_odeint.tutorial.harmonic_oscillator.integration_with_adaptive_step_size.generation_functions_make_dense_output__abs_error___rel_error___stepper__"></a><p class="title"><b>Table&#160;1.3.&#160;Generation functions make_dense_output( abs_error , rel_error ,
stepper )</b></p>
<div class="table-contents"><table class="table" summary="Generation functions make_dense_output( abs_error , rel_error ,
stepper )">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Stepper
</p>
</th>
<th>
<p>
Result of make_dense_output
</p>
</th>
<th>
<p>
Remarks
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">runge_kutta_dopri5</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">dense_output_runge_kutta</span><span class="special">&lt;</span> <span class="identifier">controlled_runge_kutta</span><span class="special">&lt;</span> <span class="identifier">runge_kutta_dopri5</span>
<span class="special">,</span> <span class="identifier">default_error_checker</span><span class="special">&lt;...&gt;</span> <span class="special">&gt;</span>
<span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<span class="emphasis"><em>a <sub>x</sub>=1</em></span>, <span class="emphasis"><em>a<sub>dxdt</sub>=1</em></span>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">rosenbrock4</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rosenbrock4_dense_output</span><span class="special">&lt;</span> <span class="identifier">rosenbrock4_controller</span><span class="special">&lt;</span> <span class="identifier">rosenbrock4</span>
<span class="special">&gt;</span> <span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><p>
When using <code class="computeroutput"><span class="identifier">make_controlled</span></code>
or <code class="computeroutput"><span class="identifier">make_dense_output</span></code> one
should be aware which exact type is used and how the step size control
works.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.tutorial.harmonic_oscillator.using_iterators"></a><a class="link" href="harmonic_oscillator.html#boost_numeric_odeint.tutorial.harmonic_oscillator.using_iterators" title="Using iterators">Using
iterators</a>
</h4></div></div></div>
<p>
odeint supports iterators for solving ODEs. That is, you instantiate a
pair of iterators and instead of using the integrate routines with an appropriate
observer you put the iterators in one of the algorithm from the C++ standard
library or from Boost.Range. An example is
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">for_each</span><span class="special">(</span> <span class="identifier">make_const_step_time_iterator_begin</span><span class="special">(</span> <span class="identifier">stepper</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">0.1</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">make_const_step_time_iterator_end</span><span class="special">(</span> <span class="identifier">stepper</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="special">,</span>
<span class="special">[](</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span> <span class="special">,</span> <span class="keyword">const</span> <span class="keyword">double</span> <span class="special">&amp;</span> <span class="special">&gt;</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">{</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">second</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span> <span class="special">&lt;&lt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">first</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span> <span class="special">&lt;&lt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">first</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span> <span class="special">}</span> <span class="special">);</span>
</pre>
<p>
</p>
</div>
<p>
The full source file for this example can be found here: <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/harmonic_oscillator.cpp" target="_top">harmonic_oscillator.cpp</a>
</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 &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../tutorial.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="solar_system.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,183 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Lattice systems</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="complex_state_types.html" title="Complex state types">
<link rel="next" href="ensembles_of_oscillators.html" title="Ensembles of oscillators">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="complex_state_types.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="ensembles_of_oscillators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.lattice_systems"></a><a class="link" href="lattice_systems.html" title="Lattice systems">Lattice
systems</a>
</h3></div></div></div>
<p>
odeint can also be used to solve ordinary differential equations defined
on lattices. A prominent example is the Fermi-Pasta-Ulam system <a class="link" href="../literature.html#fpu_scholarpedia">[8]
</a>. It is a Hamiltonian system of nonlinear coupled harmonic oscillators.
The Hamiltonian is
</p>
<p>
<span class="emphasis"><em>H = &#931;<sub>&#8203;i</sub> p<sub>&#8203;i</sub><sup>2</sup>/2 + 1/2 ( q<sub>&#8203;i+1</sub> - q<sub>&#8203;i</sub> )^2 + &#946; / 4 ( q<sub>&#8203;i+1</sub> - q<sub>&#8203;i</sub> )^4 </em></span>
</p>
<p>
Remarkably, the Fermi-Pasta-Ulam system was the first numerical experiment
to be implemented on a computer. It was studied at Los Alamos in 1953 on
one of the first computers (a MANIAC I) and it triggered a whole new tree
of mathematical and physical science.
</p>
<p>
Like the <a class="link" href="solar_system.html" title="Solar system">Solar
System</a>, the FPU is solved again by a symplectic solver, but in this
case we can speed up the computation because the <span class="emphasis"><em>q</em></span> components
trivially reduce to <span class="emphasis"><em>dq<sub>&#8203;i</sub> / dt = p<sub>&#8203;i</sub></em></span>. odeint is capable
of doing this performance improvement. All you have to do is to call the
symplectic solver with an state function for the <span class="emphasis"><em>p</em></span> components.
Here is how this function looks like
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">container_type</span><span class="special">;</span>
<span class="keyword">struct</span> <span class="identifier">fpu</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">m_beta</span><span class="special">;</span>
<span class="identifier">fpu</span><span class="special">(</span> <span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">beta</span> <span class="special">=</span> <span class="number">1.0</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_beta</span><span class="special">(</span> <span class="identifier">beta</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="comment">// system function defining the ODE</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">q</span> <span class="special">,</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">dpdt</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
<span class="keyword">double</span> <span class="identifier">tmp</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="number">0.0</span><span class="special">;</span>
<span class="keyword">double</span> <span class="identifier">tmp2</span> <span class="special">=</span> <span class="identifier">tmp</span> <span class="special">+</span> <span class="identifier">m_beta</span> <span class="special">*</span> <span class="identifier">tmp</span> <span class="special">*</span> <span class="identifier">tmp</span> <span class="special">*</span> <span class="identifier">tmp</span><span class="special">;</span>
<span class="identifier">dpdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">tmp2</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">n</span><span class="special">-</span><span class="number">1</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">tmp</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">+</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="identifier">tmp2</span> <span class="special">=</span> <span class="identifier">tmp</span> <span class="special">+</span> <span class="identifier">m_beta</span> <span class="special">*</span> <span class="identifier">tmp</span> <span class="special">*</span> <span class="identifier">tmp</span> <span class="special">*</span> <span class="identifier">tmp</span><span class="special">;</span>
<span class="identifier">dpdt</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">+=</span> <span class="identifier">tmp2</span><span class="special">;</span>
<span class="identifier">dpdt</span><span class="special">[</span><span class="identifier">i</span><span class="special">+</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">tmp2</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">tmp</span> <span class="special">=</span> <span class="special">-</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">n</span><span class="special">-</span><span class="number">1</span><span class="special">];</span>
<span class="identifier">tmp2</span> <span class="special">=</span> <span class="identifier">tmp</span> <span class="special">+</span> <span class="identifier">m_beta</span> <span class="special">*</span> <span class="identifier">tmp</span> <span class="special">*</span> <span class="identifier">tmp</span> <span class="special">*</span> <span class="identifier">tmp</span><span class="special">;</span>
<span class="identifier">dpdt</span><span class="special">[</span><span class="identifier">n</span><span class="special">-</span><span class="number">1</span><span class="special">]</span> <span class="special">+=</span> <span class="identifier">tmp2</span><span class="special">;</span>
<span class="special">}</span>
<span class="comment">// calculates the energy of the system</span>
<span class="keyword">double</span> <span class="identifier">energy</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">q</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">p</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="comment">// ...</span>
<span class="special">}</span>
<span class="comment">// calculates the local energy of the system</span>
<span class="keyword">void</span> <span class="identifier">local_energy</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">q</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">p</span> <span class="special">,</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">e</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="comment">// ...</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
You can also use <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">N</span> <span class="special">&gt;</span></code>
for the state type.
</p>
<p>
Now, you have to define your initial values and perform the integration:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="number">64</span><span class="special">;</span>
<span class="identifier">container_type</span> <span class="identifier">q</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">p</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">);</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">n</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">p</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
<span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="number">32.0</span> <span class="special">*</span> <span class="identifier">sin</span><span class="special">(</span> <span class="keyword">double</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">+</span> <span class="number">1</span> <span class="special">)</span> <span class="special">/</span> <span class="keyword">double</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">+</span> <span class="number">1</span> <span class="special">)</span> <span class="special">*</span> <span class="identifier">M_PI</span> <span class="special">);</span>
<span class="special">}</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">dt</span> <span class="special">=</span> <span class="number">0.1</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">symplectic_rkn_sb3a_mclachlan</span><span class="special">&lt;</span> <span class="identifier">container_type</span> <span class="special">&gt;</span> <span class="identifier">stepper_type</span><span class="special">;</span>
<span class="identifier">fpu</span> <span class="identifier">fpu_instance</span><span class="special">(</span> <span class="number">8.0</span> <span class="special">);</span>
<span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">stepper_type</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">fpu_instance</span> <span class="special">,</span>
<span class="identifier">make_pair</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span><span class="special">(</span> <span class="identifier">q</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span><span class="special">(</span> <span class="identifier">p</span> <span class="special">)</span> <span class="special">)</span> <span class="special">,</span>
<span class="number">0.0</span> <span class="special">,</span> <span class="number">1000.0</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">,</span> <span class="identifier">streaming_observer</span><span class="special">(</span> <span class="identifier">cout</span> <span class="special">,</span> <span class="identifier">fpu_instance</span> <span class="special">,</span> <span class="number">10</span> <span class="special">)</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
The observer uses a reference to the system object to calculate the local
energies:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">streaming_observer</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="identifier">m_out</span><span class="special">;</span>
<span class="keyword">const</span> <span class="identifier">fpu</span> <span class="special">&amp;</span><span class="identifier">m_fpu</span><span class="special">;</span>
<span class="identifier">size_t</span> <span class="identifier">m_write_every</span><span class="special">;</span>
<span class="identifier">size_t</span> <span class="identifier">m_count</span><span class="special">;</span>
<span class="identifier">streaming_observer</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span> <span class="special">&amp;</span><span class="identifier">out</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">fpu</span> <span class="special">&amp;</span><span class="identifier">f</span> <span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">write_every</span> <span class="special">=</span> <span class="number">100</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">m_out</span><span class="special">(</span> <span class="identifier">out</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_fpu</span><span class="special">(</span> <span class="identifier">f</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_write_every</span><span class="special">(</span> <span class="identifier">write_every</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_count</span><span class="special">(</span> <span class="number">0</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span> <span class="special">(</span> <span class="identifier">m_count</span> <span class="special">%</span> <span class="identifier">m_write_every</span> <span class="special">)</span> <span class="special">==</span> <span class="number">0</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">q</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">first</span><span class="special">;</span>
<span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">p</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">second</span><span class="special">;</span>
<span class="identifier">container_type</span> <span class="identifier">energy</span><span class="special">(</span> <span class="identifier">q</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">);</span>
<span class="identifier">m_fpu</span><span class="special">.</span><span class="identifier">local_energy</span><span class="special">(</span> <span class="identifier">q</span> <span class="special">,</span> <span class="identifier">p</span> <span class="special">,</span> <span class="identifier">energy</span> <span class="special">);</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">q</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">m_out</span> <span class="special">&lt;&lt;</span> <span class="identifier">t</span> <span class="special">&lt;&lt;</span> <span class="string">"\t"</span> <span class="special">&lt;&lt;</span> <span class="identifier">i</span> <span class="special">&lt;&lt;</span> <span class="string">"\t"</span> <span class="special">&lt;&lt;</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="string">"\t"</span> <span class="special">&lt;&lt;</span> <span class="identifier">p</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="string">"\t"</span> <span class="special">&lt;&lt;</span> <span class="identifier">energy</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">m_out</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
<span class="identifier">clog</span> <span class="special">&lt;&lt;</span> <span class="identifier">t</span> <span class="special">&lt;&lt;</span> <span class="string">"\t"</span> <span class="special">&lt;&lt;</span> <span class="identifier">accumulate</span><span class="special">(</span> <span class="identifier">energy</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">energy</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">++</span><span class="identifier">m_count</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
The full cpp file for this FPU example can be found here <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/fpu.cpp" target="_top">fpu.cpp</a>
</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 &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="complex_state_types.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="ensembles_of_oscillators.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,938 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Parallel computation with OpenMP and MPI</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="using_opencl_via_vexcl.html" title="Using OpenCL via VexCL">
<link rel="next" href="all_examples.html" title="All examples">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="using_opencl_via_vexcl.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="all_examples.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi"></a><a class="link" href="parallel_computation_with_openmp_and_mpi.html" title="Parallel computation with OpenMP and MPI">Parallel
computation with OpenMP and MPI</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.openmp">OpenMP</a></span></dt>
<dt><span class="section"><a href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.mpi">MPI</a></span></dt>
<dt><span class="section"><a href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts">Concepts</a></span></dt>
</dl></div>
<p>
Parallelization is a key feature for modern numerical libraries due to the
vast availability of many cores nowadays, even on Laptops. odeint currently
supports parallelization with OpenMP and MPI, as described in the following
sections. However, it should be made clear from the beginning that the difficulty
of efficiently distributing ODE integration on many cores/machines lies in
the parallelization of the system function, which is still the user's responsibility.
Simply using a parallel odeint backend without parallelizing the system function
will bring you almost no performance gains.
</p>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.openmp"></a><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.openmp" title="OpenMP">OpenMP</a>
</h4></div></div></div>
<p>
odeint's OpenMP support is implemented as an external backend, which needs
to be manually included. Depending on the compiler some additional flags
may be needed, i.e. <code class="literal">-fopenmp</code> for GCC.
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">omp</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">/</span><span class="identifier">external</span><span class="special">/</span><span class="identifier">openmp</span><span class="special">/</span><span class="identifier">openmp</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
</p>
<p>
In the easiest parallelization approach with OpenMP we use a standard
<code class="computeroutput"><span class="identifier">vector</span></code> as the state type:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
We initialize the state with some random data:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">=</span> <span class="number">131101</span><span class="special">;</span>
<span class="identifier">state_type</span> <span class="identifier">x</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">);</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">random</span><span class="special">::</span><span class="identifier">uniform_real_distribution</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">distribution</span><span class="special">(</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">2.0</span><span class="special">*</span><span class="identifier">pi</span> <span class="special">);</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">random</span><span class="special">::</span><span class="identifier">mt19937</span> <span class="identifier">engine</span><span class="special">(</span> <span class="number">0</span> <span class="special">);</span>
<span class="identifier">generate</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span> <span class="identifier">distribution</span> <span class="special">,</span> <span class="identifier">engine</span> <span class="special">)</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
Now we have to configure the stepper to use the OpenMP backend. This is
done by explicitly providing the <code class="computeroutput"><span class="identifier">openmp_range_algebra</span></code>
as a template parameter to the stepper. This algebra requires the state
type to be a model of Random Access Range and will be used from multiple
threads by the algebra.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">runge_kutta4</span><span class="special">&lt;</span>
<span class="identifier">state_type</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">double</span> <span class="special">,</span>
<span class="identifier">openmp_range_algebra</span>
<span class="special">&gt;</span> <span class="identifier">stepper_type</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
Additional to providing the stepper with OpenMP parallelization we also
need a parallelized system function to exploit the available cores. Here
this is shown for a simple one-dimensional chain of phase oscillators with
nearest neighbor coupling:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">phase_chain</span>
<span class="special">{</span>
<span class="identifier">phase_chain</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">gamma</span> <span class="special">=</span> <span class="number">0.5</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">m_gamma</span><span class="special">(</span> <span class="identifier">gamma</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="comment">/* t */</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
<span class="preprocessor">#pragma</span> <span class="identifier">omp</span> <span class="identifier">parallel</span> <span class="keyword">for</span> <span class="identifier">schedule</span><span class="special">(</span><span class="identifier">runtime</span><span class="special">)</span>
<span class="keyword">for</span><span class="special">(</span><span class="identifier">size_t</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span> <span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">N</span> <span class="special">-</span> <span class="number">1</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">i</span><span class="special">+</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">)</span> <span class="special">+</span>
<span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">i</span><span class="special">-</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">);</span>
<span class="special">}</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span> <span class="special">]</span> <span class="special">=</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span> <span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span> <span class="special">]</span> <span class="special">);</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="identifier">N</span><span class="special">-</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">N</span><span class="special">-</span><span class="number">2</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">N</span><span class="special">-</span><span class="number">1</span><span class="special">]</span> <span class="special">);</span>
<span class="special">}</span>
<span class="keyword">double</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">x</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">sin</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">-</span> <span class="identifier">m_gamma</span> <span class="special">*</span> <span class="special">(</span> <span class="number">1.0</span> <span class="special">-</span> <span class="identifier">cos</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">);</span>
<span class="special">}</span>
<span class="keyword">double</span> <span class="identifier">m_gamma</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
In the OpenMP backends the system function will always be called sequentially
from the thread used to start the integration.
</p></td></tr>
</table></div>
<p>
Finally, we perform the integration by using one of the integrate functions
from odeint. As you can see, the parallelization is completely hidden in
the stepper and the system function. OpenMP will take care of distributing
the work among the threads and join them automatically.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">integrate_n_steps</span><span class="special">(</span> <span class="identifier">stepper_type</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">phase_chain</span><span class="special">(</span> <span class="number">1.2</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">,</span> <span class="number">100</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
After integrating, the data can be accessed immediately and be processed
further. Note, that you can specify the OpenMP scheduling by calling <code class="computeroutput"><span class="identifier">omp_set_schedule</span></code> in the beginning of
your program:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">chunk_size</span> <span class="special">=</span> <span class="identifier">N</span><span class="special">/</span><span class="identifier">omp_get_max_threads</span><span class="special">();</span>
<span class="identifier">omp_set_schedule</span><span class="special">(</span> <span class="identifier">omp_sched_static</span> <span class="special">,</span> <span class="identifier">chunk_size</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
See <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/openmp/phase_chain.cpp" target="_top">openmp/phase_chain.cpp</a> for the complete
example.
</p>
<h6>
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.openmp.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.openmp.split_state"></a></span><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.openmp.split_state">Split
state</a>
</h6>
<p>
For advanced cases odeint offers another approach to use OpenMP that allows
for a more exact control of the parallelization. For example, for odd-sized
data where OpenMP's thread boundaries don't match cache lines and hurt
performance it might be advisable to copy the data from the continuous
<code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
into separate, individually aligned, vectors. For this, odeint provides
the <code class="computeroutput"><span class="identifier">openmp_state</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
type, essentially an alias for <code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&gt;</span></code>.
</p>
<p>
Here, the initialization is done with a <code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span></code>, but then we use odeint's <code class="computeroutput"><span class="identifier">split</span></code> function to fill an <code class="computeroutput"><span class="identifier">openmp_state</span></code>. The splitting is done such
that the sizes of the individual regions differ at most by 1 to make the
computation as uniform as possible.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">=</span> <span class="number">131101</span><span class="special">;</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">x</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">);</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">random</span><span class="special">::</span><span class="identifier">uniform_real_distribution</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">distribution</span><span class="special">(</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">2.0</span><span class="special">*</span><span class="identifier">pi</span> <span class="special">);</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">random</span><span class="special">::</span><span class="identifier">mt19937</span> <span class="identifier">engine</span><span class="special">(</span> <span class="number">0</span> <span class="special">);</span>
<span class="identifier">generate</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span> <span class="identifier">distribution</span> <span class="special">,</span> <span class="identifier">engine</span> <span class="special">)</span> <span class="special">);</span>
<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">blocks</span> <span class="special">=</span> <span class="identifier">omp_get_max_threads</span><span class="special">();</span>
<span class="identifier">state_type</span> <span class="identifier">x_split</span><span class="special">(</span> <span class="identifier">blocks</span> <span class="special">);</span>
<span class="identifier">split</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">x_split</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
Of course, the system function has to be changed to deal with the <code class="computeroutput"><span class="identifier">openmp_state</span></code>. Note that each sub-region
of the state is computed in a single task, but at the borders read access
to the neighbouring regions is required.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">phase_chain_omp_state</span>
<span class="special">{</span>
<span class="identifier">phase_chain_omp_state</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">gamma</span> <span class="special">=</span> <span class="number">0.5</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">m_gamma</span><span class="special">(</span> <span class="identifier">gamma</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="comment">/* t */</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
<span class="preprocessor">#pragma</span> <span class="identifier">omp</span> <span class="identifier">parallel</span> <span class="keyword">for</span> <span class="identifier">schedule</span><span class="special">(</span><span class="identifier">runtime</span><span class="special">)</span>
<span class="keyword">for</span><span class="special">(</span><span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="number">0</span> <span class="special">;</span> <span class="identifier">n</span> <span class="special">&lt;</span> <span class="identifier">N</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">n</span><span class="special">)</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">M</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">].</span><span class="identifier">size</span><span class="special">();</span>
<span class="keyword">for</span><span class="special">(</span><span class="identifier">size_t</span> <span class="identifier">m</span> <span class="special">=</span> <span class="number">1</span> <span class="special">;</span> <span class="identifier">m</span> <span class="special">&lt;</span> <span class="identifier">M</span><span class="special">-</span><span class="number">1</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">m</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="identifier">n</span><span class="special">][</span><span class="identifier">m</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">][</span><span class="identifier">m</span><span class="special">+</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">][</span><span class="identifier">m</span><span class="special">]</span> <span class="special">)</span> <span class="special">+</span>
<span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">][</span><span class="identifier">m</span><span class="special">-</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">][</span><span class="identifier">m</span><span class="special">]</span> <span class="special">);</span>
<span class="special">}</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="identifier">n</span><span class="special">][</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">][</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">][</span><span class="number">0</span><span class="special">]</span> <span class="special">);</span>
<span class="keyword">if</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">&gt;</span> <span class="number">0</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="identifier">n</span><span class="special">][</span><span class="number">0</span><span class="special">]</span> <span class="special">+=</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">-</span><span class="number">1</span><span class="special">].</span><span class="identifier">back</span><span class="special">()</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">].</span><span class="identifier">front</span><span class="special">()</span> <span class="special">);</span>
<span class="special">}</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="identifier">n</span><span class="special">][</span><span class="identifier">M</span><span class="special">-</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">][</span><span class="identifier">M</span><span class="special">-</span><span class="number">2</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">][</span><span class="identifier">M</span><span class="special">-</span><span class="number">1</span><span class="special">]</span> <span class="special">);</span>
<span class="keyword">if</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">&lt;</span> <span class="identifier">N</span><span class="special">-</span><span class="number">1</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="identifier">n</span><span class="special">][</span><span class="identifier">M</span><span class="special">-</span><span class="number">1</span><span class="special">]</span> <span class="special">+=</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">+</span><span class="number">1</span><span class="special">].</span><span class="identifier">front</span><span class="special">()</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="identifier">n</span><span class="special">].</span><span class="identifier">back</span><span class="special">()</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="keyword">double</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">x</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">sin</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">-</span> <span class="identifier">m_gamma</span> <span class="special">*</span> <span class="special">(</span> <span class="number">1.0</span> <span class="special">-</span> <span class="identifier">cos</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">);</span>
<span class="special">}</span>
<span class="keyword">double</span> <span class="identifier">m_gamma</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
Using the <code class="computeroutput"><span class="identifier">openmp_state</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> state type automatically selects <code class="computeroutput"><span class="identifier">openmp_algebra</span></code> which executes odeint's
internal computations on parallel regions. Hence, no manual configuration
of the stepper is necessary. At the end of the integration, we use <code class="computeroutput"><span class="identifier">unsplit</span></code> to concatenate the sub-regions
back together into a single vector.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">integrate_n_steps</span><span class="special">(</span> <span class="identifier">runge_kutta4</span><span class="special">&lt;</span><span class="identifier">state_type</span><span class="special">&gt;()</span> <span class="special">,</span> <span class="identifier">phase_chain_omp_state</span><span class="special">(</span> <span class="number">1.2</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">x_split</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">,</span> <span class="number">100</span> <span class="special">);</span>
<span class="identifier">unsplit</span><span class="special">(</span> <span class="identifier">x_split</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">);</span>
</pre>
<p>
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
You don't actually need to use <code class="computeroutput"><span class="identifier">openmp_state</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> for advanced use cases, <code class="computeroutput"><span class="identifier">openmp_algebra</span></code> is simply an alias for
<code class="computeroutput"><span class="identifier">openmp_nested_algebra</span><span class="special">&lt;</span><span class="identifier">range_algebra</span><span class="special">&gt;</span></code> and supports any model of Random
Access Range as the outer, parallel state type, and will use the given
algebra on its elements.
</p></td></tr>
</table></div>
<p>
See <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/openmp/phase_chain_omp_state.cpp" target="_top">openmp/phase_chain_omp_state.cpp</a> for
the complete example.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.mpi"></a><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.mpi" title="MPI">MPI</a>
</h4></div></div></div>
<p>
To expand the parallel computation across multiple machines we can use
MPI.
</p>
<p>
The system function implementation is similar to the OpenMP variant with
split data, the main difference being that while OpenMP uses a spawn/join
model where everything not explicitly paralleled is only executed in the
main thread, in MPI's model each node enters the <code class="computeroutput"><span class="identifier">main</span><span class="special">()</span></code> method independently, diverging based
on its rank and synchronizing through message-passing and explicit barriers.
</p>
<p>
odeint's MPI support is implemented as an external backend, too. Depending
on the MPI implementation the code might need to be compiled with i.e.
<code class="literal">mpic++</code>.
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">/</span><span class="identifier">external</span><span class="special">/</span><span class="identifier">mpi</span><span class="special">/</span><span class="identifier">mpi</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
</p>
<p>
Instead of reading another thread's data, we asynchronously send and receive
the relevant data from neighbouring nodes, performing some computation
in the interim to hide the latency.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">phase_chain_mpi_state</span>
<span class="special">{</span>
<span class="identifier">phase_chain_mpi_state</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">gamma</span> <span class="special">=</span> <span class="number">0.5</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">m_gamma</span><span class="special">(</span> <span class="identifier">gamma</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="comment">/* t */</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">M</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">().</span><span class="identifier">size</span><span class="special">();</span>
<span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">have_left</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">world</span><span class="special">.</span><span class="identifier">rank</span><span class="special">()</span> <span class="special">&gt;</span> <span class="number">0</span><span class="special">,</span>
<span class="identifier">have_right</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">world</span><span class="special">.</span><span class="identifier">rank</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">world</span><span class="special">.</span><span class="identifier">size</span><span class="special">()-</span><span class="number">1</span><span class="special">;</span>
<span class="keyword">double</span> <span class="identifier">x_left</span><span class="special">,</span> <span class="identifier">x_right</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpi</span><span class="special">::</span><span class="identifier">request</span> <span class="identifier">r_left</span><span class="special">,</span> <span class="identifier">r_right</span><span class="special">;</span>
<span class="keyword">if</span><span class="special">(</span> <span class="identifier">have_left</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">x</span><span class="special">.</span><span class="identifier">world</span><span class="special">.</span><span class="identifier">isend</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">world</span><span class="special">.</span><span class="identifier">rank</span><span class="special">()-</span><span class="number">1</span> <span class="special">,</span> <span class="number">0</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">().</span><span class="identifier">front</span><span class="special">()</span> <span class="special">);</span> <span class="comment">// send to x_right</span>
<span class="identifier">r_left</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">world</span><span class="special">.</span><span class="identifier">irecv</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">world</span><span class="special">.</span><span class="identifier">rank</span><span class="special">()-</span><span class="number">1</span> <span class="special">,</span> <span class="number">0</span> <span class="special">,</span> <span class="identifier">x_left</span> <span class="special">);</span> <span class="comment">// receive from x().back()</span>
<span class="special">}</span>
<span class="keyword">if</span><span class="special">(</span> <span class="identifier">have_right</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">x</span><span class="special">.</span><span class="identifier">world</span><span class="special">.</span><span class="identifier">isend</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">world</span><span class="special">.</span><span class="identifier">rank</span><span class="special">()+</span><span class="number">1</span> <span class="special">,</span> <span class="number">0</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">().</span><span class="identifier">back</span><span class="special">()</span> <span class="special">);</span> <span class="comment">// send to x_left</span>
<span class="identifier">r_right</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">world</span><span class="special">.</span><span class="identifier">irecv</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">world</span><span class="special">.</span><span class="identifier">rank</span><span class="special">()+</span><span class="number">1</span> <span class="special">,</span> <span class="number">0</span> <span class="special">,</span> <span class="identifier">x_right</span> <span class="special">);</span> <span class="comment">// receive from x().front()</span>
<span class="special">}</span>
<span class="keyword">for</span><span class="special">(</span><span class="identifier">size_t</span> <span class="identifier">m</span> <span class="special">=</span> <span class="number">1</span> <span class="special">;</span> <span class="identifier">m</span> <span class="special">&lt;</span> <span class="identifier">M</span><span class="special">-</span><span class="number">1</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">m</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">dxdt</span><span class="special">()[</span><span class="identifier">m</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">()[</span><span class="identifier">m</span><span class="special">+</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">()[</span><span class="identifier">m</span><span class="special">]</span> <span class="special">)</span> <span class="special">+</span>
<span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">()[</span><span class="identifier">m</span><span class="special">-</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">()[</span><span class="identifier">m</span><span class="special">]</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">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">()[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">()[</span><span class="number">0</span><span class="special">]</span> <span class="special">);</span>
<span class="keyword">if</span><span class="special">(</span> <span class="identifier">have_left</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">r_left</span><span class="special">.</span><span class="identifier">wait</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">coupling_func</span><span class="special">(</span> <span class="identifier">x_left</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">().</span><span class="identifier">front</span><span class="special">()</span> <span class="special">);</span>
<span class="special">}</span>
<span class="identifier">dxdt</span><span class="special">()[</span><span class="identifier">M</span><span class="special">-</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">()[</span><span class="identifier">M</span><span class="special">-</span><span class="number">2</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">()[</span><span class="identifier">M</span><span class="special">-</span><span class="number">1</span><span class="special">]</span> <span class="special">);</span>
<span class="keyword">if</span><span class="special">(</span> <span class="identifier">have_right</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">r_right</span><span class="special">.</span><span class="identifier">wait</span><span class="special">();</span>
<span class="identifier">dxdt</span><span class="special">()[</span><span class="identifier">M</span><span class="special">-</span><span class="number">1</span><span class="special">]</span> <span class="special">+=</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x_right</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">().</span><span class="identifier">back</span><span class="special">()</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="keyword">double</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">x</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">sin</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">-</span> <span class="identifier">m_gamma</span> <span class="special">*</span> <span class="special">(</span> <span class="number">1.0</span> <span class="special">-</span> <span class="identifier">cos</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">);</span>
<span class="special">}</span>
<span class="keyword">double</span> <span class="identifier">m_gamma</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
Analogous to <code class="computeroutput"><span class="identifier">openmp_state</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> we use <code class="computeroutput"><span class="identifier">mpi_state</span><span class="special">&lt;</span> <span class="identifier">InnerState</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>,
which automatically selects <code class="computeroutput"><span class="identifier">mpi_nested_algebra</span></code>
and the appropriate MPI-oblivious inner algebra (since our inner state
is a <code class="computeroutput"><span class="identifier">vector</span></code>, the inner
algebra will be <code class="computeroutput"><span class="identifier">range_algebra</span></code>
as in the OpenMP example).
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">mpi_state</span><span class="special">&lt;</span> <span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
In the main program we construct a <code class="computeroutput"><span class="identifier">communicator</span></code>
which tells us the <code class="computeroutput"><span class="identifier">size</span></code>
of the cluster and the current node's <code class="computeroutput"><span class="identifier">rank</span></code>
within that. We generate the input data on the master node only, avoiding
unnecessary work on the other nodes. Instead of simply copying chunks,
<code class="computeroutput"><span class="identifier">split</span></code> acts as a MPI collective
function here and sends/receives regions from master to each slave. The
input argument is ignored on the slaves, but the master node receives a
region in its output and will participate in the computation.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpi</span><span class="special">::</span><span class="identifier">environment</span> <span class="identifier">env</span><span class="special">(</span> <span class="identifier">argc</span> <span class="special">,</span> <span class="identifier">argv</span> <span class="special">);</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpi</span><span class="special">::</span><span class="identifier">communicator</span> <span class="identifier">world</span><span class="special">;</span>
<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">=</span> <span class="number">131101</span><span class="special">;</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">x</span><span class="special">;</span>
<span class="keyword">if</span><span class="special">(</span> <span class="identifier">world</span><span class="special">.</span><span class="identifier">rank</span><span class="special">()</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="identifier">resize</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">);</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">random</span><span class="special">::</span><span class="identifier">uniform_real_distribution</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">distribution</span><span class="special">(</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">2.0</span><span class="special">*</span><span class="identifier">pi</span> <span class="special">);</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">random</span><span class="special">::</span><span class="identifier">mt19937</span> <span class="identifier">engine</span><span class="special">(</span> <span class="number">0</span> <span class="special">);</span>
<span class="identifier">generate</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span> <span class="identifier">distribution</span> <span class="special">,</span> <span class="identifier">engine</span> <span class="special">)</span> <span class="special">);</span>
<span class="special">}</span>
<span class="identifier">state_type</span> <span class="identifier">x_split</span><span class="special">(</span> <span class="identifier">world</span> <span class="special">);</span>
<span class="identifier">split</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">x_split</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
Now that <code class="computeroutput"><span class="identifier">x_split</span></code> contains
(only) the local chunk for each node, we start the integration.
</p>
<p>
To print the result on the master node, we send the processed data back
using <code class="computeroutput"><span class="identifier">unsplit</span></code>.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">integrate_n_steps</span><span class="special">(</span> <span class="identifier">runge_kutta4</span><span class="special">&lt;</span><span class="identifier">state_type</span><span class="special">&gt;()</span> <span class="special">,</span> <span class="identifier">phase_chain_mpi_state</span><span class="special">(</span> <span class="number">1.2</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">x_split</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">,</span> <span class="number">100</span> <span class="special">);</span>
<span class="identifier">unsplit</span><span class="special">(</span> <span class="identifier">x_split</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">);</span>
</pre>
<p>
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
<code class="computeroutput"><span class="identifier">mpi_nested_algebra</span><span class="special">::</span><span class="identifier">for_each</span></code><em class="replaceable"><code>N</code></em>
doesn't use any MPI constructs, it simply calls the inner algebra on
the local chunk and the system function is not guarded by any barriers
either, so if you don't manually place any (for example in parameter
studies cases where the elements are completely independent) you might
see the nodes diverging, returning from this call at different times.
</p></td></tr>
</table></div>
<p>
See <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/mpi/phase_chain.cpp" target="_top">mpi/phase_chain.cpp</a> for the complete example.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts"></a><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts" title="Concepts">Concepts</a>
</h4></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.mpi_state">MPI
State</a></span></dt>
<dt><span class="section"><a href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.openmp_split_state">OpenMP
Split State</a></span></dt>
<dt><span class="section"><a href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.splitter">Splitter</a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.mpi_state"></a><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.mpi_state" title="MPI State">MPI
State</a>
</h5></div></div></div>
<p>
As used by <code class="computeroutput"><span class="identifier">mpi_nested_algebra</span></code>.
</p>
<h6>
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.mpi_state.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.mpi_state.notation"></a></span><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.mpi_state.notation">Notation</a>
</h6>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term"><code class="computeroutput"><span class="identifier">InnerState</span></code></span></dt>
<dd><p>
The inner state type
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">State</span></code></span></dt>
<dd><p>
The MPI-state type
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">state</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">State</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">world</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpi</span><span class="special">::</span><span class="identifier">communicator</span></code>
</p></dd>
</dl>
</div>
<h6>
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.mpi_state.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.mpi_state.valid_expressions"></a></span><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.mpi_state.valid_expressions">Valid
Expressions</a>
</h6>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Construct a state with a communicator
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">State</span><span class="special">(</span><span class="identifier">world</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">State</span></code>
</p>
</td>
<td>
<p>
Constructs the State.
</p>
</td>
</tr>
<tr>
<td>
<p>
Construct a state with the default communicator
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">State</span><span class="special">()</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">State</span></code>
</p>
</td>
<td>
<p>
Constructs the State.
</p>
</td>
</tr>
<tr>
<td>
<p>
Get the current node's inner state
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">state</span><span class="special">()</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">InnerState</span></code>
</p>
</td>
<td>
<p>
Returns a (const) reference.
</p>
</td>
</tr>
<tr>
<td>
<p>
Get the communicator
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">state</span><span class="special">.</span><span class="identifier">world</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpi</span><span class="special">::</span><span class="identifier">communicator</span></code>
</p>
</td>
<td>
<p>
See <a href="http://www.boost.org/doc/libs/release/libs/mpi/" target="_top">Boost.MPI</a>.
</p>
</td>
</tr>
</tbody>
</table></div>
<h6>
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.mpi_state.h2"></a>
<span class="phrase"><a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.mpi_state.models"></a></span><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.mpi_state.models">Models</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
<code class="computeroutput"><span class="identifier">mpi_state</span><span class="special">&lt;</span><span class="identifier">InnerState</span><span class="special">&gt;</span></code>
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.openmp_split_state"></a><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.openmp_split_state" title="OpenMP Split State">OpenMP
Split State</a>
</h5></div></div></div>
<p>
As used by <code class="computeroutput"><span class="identifier">openmp_nested_algebra</span></code>,
essentially a Random Access Container with <code class="computeroutput"><span class="identifier">ValueType</span>
<span class="special">=</span> <span class="identifier">InnerState</span></code>.
</p>
<h6>
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.openmp_split_state.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.openmp_split_state.notation"></a></span><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.openmp_split_state.notation">Notation</a>
</h6>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term"><code class="computeroutput"><span class="identifier">InnerState</span></code></span></dt>
<dd><p>
The inner state type
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">State</span></code></span></dt>
<dd><p>
The split state type
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">state</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">State</span></code>
</p></dd>
</dl>
</div>
<h6>
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.openmp_split_state.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.openmp_split_state.valid_expressions"></a></span><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.openmp_split_state.valid_expressions">Valid
Expressions</a>
</h6>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Construct a state for <code class="computeroutput"><span class="identifier">n</span></code>
chunks
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">State</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">State</span></code>
</p>
</td>
<td>
<p>
Constructs underlying <code class="computeroutput"><span class="identifier">vector</span></code>.
</p>
</td>
</tr>
<tr>
<td>
<p>
Get a chunk
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">state</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">InnerState</span></code>
</p>
</td>
<td>
<p>
Accesses underlying <code class="computeroutput"><span class="identifier">vector</span></code>.
</p>
</td>
</tr>
<tr>
<td>
<p>
Get the number of chunks
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">state</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">size_type</span></code>
</p>
</td>
<td>
<p>
Returns size of underlying <code class="computeroutput"><span class="identifier">vector</span></code>.
</p>
</td>
</tr>
</tbody>
</table></div>
<h6>
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.openmp_split_state.h2"></a>
<span class="phrase"><a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.openmp_split_state.models"></a></span><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.openmp_split_state.models">Models</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
<code class="computeroutput"><span class="identifier">openmp_state</span><span class="special">&lt;</span><span class="identifier">ValueType</span><span class="special">&gt;</span></code>
with <code class="computeroutput"><span class="identifier">InnerState</span> <span class="special">=</span> <span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">ValueType</span><span class="special">&gt;</span></code>
</li></ul></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.splitter"></a><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.splitter" title="Splitter">Splitter</a>
</h5></div></div></div>
<h6>
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.splitter.h0"></a>
<span class="phrase"><a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.splitter.notation"></a></span><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.splitter.notation">Notation</a>
</h6>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term"><code class="computeroutput"><span class="identifier">Container1</span></code></span></dt>
<dd><p>
The continuous-data container type
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">x</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">Container1</span></code>
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">Container2</span></code></span></dt>
<dd><p>
The chunked-data container type
</p></dd>
<dt><span class="term"><code class="computeroutput"><span class="identifier">y</span></code></span></dt>
<dd><p>
Object of type <code class="computeroutput"><span class="identifier">Container2</span></code>
</p></dd>
</dl>
</div>
<h6>
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.splitter.h1"></a>
<span class="phrase"><a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.splitter.valid_expressions"></a></span><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.splitter.valid_expressions">Valid
Expressions</a>
</h6>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Copy chunks of input to output elements
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">split</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span>
<span class="identifier">y</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Calls <code class="computeroutput"><span class="identifier">split_impl</span><span class="special">&lt;</span><span class="identifier">Container1</span><span class="special">,</span> <span class="identifier">Container2</span><span class="special">&gt;::</span><span class="identifier">split</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">)</span></code>, splits <code class="computeroutput"><span class="identifier">x</span></code>
into <code class="computeroutput"><span class="identifier">y</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span></code>
chunks.
</p>
</td>
</tr>
<tr>
<td>
<p>
Join chunks of input elements to output
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">unsplit</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span>
<span class="identifier">x</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span></code>
</p>
</td>
<td>
<p>
Calls <code class="computeroutput"><span class="identifier">unsplit_impl</span><span class="special">&lt;</span><span class="identifier">Container2</span><span class="special">,</span> <span class="identifier">Container1</span><span class="special">&gt;::</span><span class="identifier">unsplit</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">x</span><span class="special">)</span></code>, assumes <code class="computeroutput"><span class="identifier">x</span></code>
is of the correct size <span class="emphasis"><em>&#963; <code class="computeroutput"><span class="identifier">y</span><span class="special">[</span><span class="identifier">i</span><span class="special">].</span><span class="identifier">size</span><span class="special">()</span></code></em></span>, does not resize
<code class="computeroutput"><span class="identifier">x</span></code>.
</p>
</td>
</tr>
</tbody>
</table></div>
<h6>
<a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.splitter.h2"></a>
<span class="phrase"><a name="boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.splitter.models"></a></span><a class="link" href="parallel_computation_with_openmp_and_mpi.html#boost_numeric_odeint.tutorial.parallel_computation_with_openmp_and_mpi.concepts.splitter.models">Models</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
defined for <code class="computeroutput"><span class="identifier">Container1</span></code>
= <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>
and <code class="computeroutput"><span class="identifier">Container2</span> <span class="special">=</span>
<span class="identifier">openmp_state</span></code>
</li>
<li class="listitem">
and <code class="computeroutput"><span class="identifier">Container2</span> <span class="special">=</span>
<span class="identifier">mpi_state</span></code>.
</li>
</ul></div>
<p>
To implement splitters for containers incompatible with <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>,
specialize the <code class="computeroutput"><span class="identifier">split_impl</span></code>
and <code class="computeroutput"><span class="identifier">unsplit_impl</span></code> types:
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Container1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Container2</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Enabler</span> <span class="special">=</span> <span class="keyword">void</span> <span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">split_impl</span> <span class="special">{</span>
<span class="keyword">static</span> <span class="keyword">void</span> <span class="identifier">split</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Container1</span> <span class="special">&amp;</span><span class="identifier">from</span> <span class="special">,</span> <span class="identifier">Container2</span> <span class="special">&amp;</span><span class="identifier">to</span> <span class="special">);</span>
<span class="special">};</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Container2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Container1</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Enabler</span> <span class="special">=</span> <span class="keyword">void</span> <span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">unsplit_impl</span> <span class="special">{</span>
<span class="keyword">static</span> <span class="keyword">void</span> <span class="identifier">unsplit</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Container2</span> <span class="special">&amp;</span><span class="identifier">from</span> <span class="special">,</span> <span class="identifier">Container1</span> <span class="special">&amp;</span><span class="identifier">to</span> <span class="special">);</span>
<span class="special">};</span>
</pre>
<p>
</p>
</div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="using_opencl_via_vexcl.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="all_examples.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,228 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Self expanding lattices</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="using_arbitrary_precision_floating_point_types.html" title="Using arbitrary precision floating point types">
<link rel="next" href="using_cuda__or_openmp__tbb_______via_thrust.html" title="Using CUDA (or OpenMP, TBB, ...) via Thrust">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="using_arbitrary_precision_floating_point_types.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="using_cuda__or_openmp__tbb_______via_thrust.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.self_expanding_lattices"></a><a class="link" href="self_expanding_lattices.html" title="Self expanding lattices">Self
expanding lattices</a>
</h3></div></div></div>
<p>
odeint supports changes of the state size during integration if a state_type
is used which can be resized, like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span></code>.
The adjustment of the state's size has to be done from outside and the stepper
has to be instantiated with <code class="computeroutput"><span class="identifier">always_resizer</span></code>
as the template argument for the <code class="computeroutput"><span class="identifier">resizer_type</span></code>.
In this configuration, the stepper checks for changes in the state size and
adjust it's internal storage accordingly.
</p>
<p>
We show this for a Hamiltonian system of nonlinear, disordered oscillators
with nonlinear nearest neighbor coupling.
</p>
<p>
The system function is implemented in terms of a class that also provides
functions for calculating the energy. Note, that this class stores the random
potential internally which is not resized, but rather a start index is kept
which should be changed whenever the states' size change.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">coord_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">coord_type</span> <span class="special">,</span> <span class="identifier">coord_type</span> <span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
<span class="keyword">struct</span> <span class="identifier">compacton_lattice</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">m_max_N</span><span class="special">;</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">m_beta</span><span class="special">;</span>
<span class="keyword">int</span> <span class="identifier">m_pot_start_index</span><span class="special">;</span>
<span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">m_pot</span><span class="special">;</span>
<span class="identifier">compacton_lattice</span><span class="special">(</span> <span class="keyword">int</span> <span class="identifier">max_N</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">beta</span> <span class="special">,</span> <span class="keyword">int</span> <span class="identifier">pot_start_index</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">m_max_N</span><span class="special">(</span> <span class="identifier">max_N</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_beta</span><span class="special">(</span> <span class="identifier">beta</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_pot_start_index</span><span class="special">(</span> <span class="identifier">pot_start_index</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_pot</span><span class="special">(</span> <span class="identifier">max_N</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">srand</span><span class="special">(</span> <span class="identifier">time</span><span class="special">(</span> <span class="identifier">NULL</span> <span class="special">)</span> <span class="special">);</span>
<span class="comment">// fill random potential with iid values from [0,1]</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">mt19937</span> <span class="identifier">rng</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">uniform_real</span><span class="special">&lt;&gt;</span> <span class="identifier">unif</span><span class="special">(</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">);</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">variate_generator</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mt19937</span><span class="special">&amp;,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uniform_real</span><span class="special">&lt;&gt;</span> <span class="special">&gt;</span> <span class="identifier">gen</span><span class="special">(</span> <span class="identifier">rng</span> <span class="special">,</span> <span class="identifier">unif</span> <span class="special">);</span>
<span class="identifier">generate</span><span class="special">(</span> <span class="identifier">m_pot</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">m_pot</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">gen</span> <span class="special">);</span>
<span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">coord_type</span> <span class="special">&amp;</span><span class="identifier">q</span> <span class="special">,</span> <span class="identifier">coord_type</span> <span class="special">&amp;</span><span class="identifier">dpdt</span> <span class="special">)</span>
<span class="special">{</span>
<span class="comment">// calculate dpdt = -dH/dq of this hamiltonian system</span>
<span class="comment">// dp_i/dt = - V_i * q_i^3 - beta*(q_i - q_{i-1})^3 + beta*(q_{i+1} - q_i)^3</span>
<span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">N</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
<span class="keyword">double</span> <span class="identifier">diff</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">N</span><span class="special">-</span><span class="number">1</span><span class="special">];</span>
<span class="keyword">for</span><span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">N</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">dpdt</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span> <span class="identifier">m_pot</span><span class="special">[</span><span class="identifier">m_pot_start_index</span><span class="special">+</span><span class="identifier">i</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">]*</span><span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">]*</span><span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">-</span>
<span class="identifier">m_beta</span> <span class="special">*</span> <span class="identifier">diff</span><span class="special">*</span><span class="identifier">diff</span><span class="special">*</span><span class="identifier">diff</span><span class="special">;</span>
<span class="identifier">diff</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">[(</span><span class="identifier">i</span><span class="special">+</span><span class="number">1</span><span class="special">)</span> <span class="special">%</span> <span class="identifier">N</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="identifier">dpdt</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">+=</span> <span class="identifier">m_beta</span> <span class="special">*</span> <span class="identifier">diff</span><span class="special">*</span><span class="identifier">diff</span><span class="special">*</span><span class="identifier">diff</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="keyword">void</span> <span class="identifier">energy_distribution</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">coord_type</span> <span class="special">&amp;</span><span class="identifier">q</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">coord_type</span> <span class="special">&amp;</span><span class="identifier">p</span> <span class="special">,</span> <span class="identifier">coord_type</span> <span class="special">&amp;</span><span class="identifier">energies</span> <span class="special">)</span>
<span class="special">{</span>
<span class="comment">// computes the energy per lattice site normalized by total energy</span>
<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
<span class="keyword">double</span> <span class="identifier">en</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">N</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">++</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">diff</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">[(</span><span class="identifier">i</span><span class="special">+</span><span class="number">1</span><span class="special">)</span> <span class="special">%</span> <span class="identifier">N</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="identifier">energies</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">p</span><span class="special">[</span><span class="identifier">i</span><span class="special">]*</span><span class="identifier">p</span><span class="special">[</span><span class="identifier">i</span><span class="special">]/</span><span class="number">2.0</span>
<span class="special">+</span> <span class="identifier">m_pot</span><span class="special">[</span><span class="identifier">m_pot_start_index</span><span class="special">+</span><span class="identifier">i</span><span class="special">]*</span><span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">]*</span><span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">]*</span><span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">]*</span><span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">]/</span><span class="number">4.0</span>
<span class="special">+</span> <span class="identifier">m_beta</span><span class="special">/</span><span class="number">4.0</span> <span class="special">*</span> <span class="identifier">diff</span><span class="special">*</span><span class="identifier">diff</span><span class="special">*</span><span class="identifier">diff</span><span class="special">*</span><span class="identifier">diff</span><span class="special">;</span>
<span class="identifier">en</span> <span class="special">+=</span> <span class="identifier">energies</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="special">}</span>
<span class="identifier">en</span> <span class="special">=</span> <span class="number">1.0</span><span class="special">/</span><span class="identifier">en</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">N</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">++</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">energies</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">*=</span> <span class="identifier">en</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="keyword">double</span> <span class="identifier">energy</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">coord_type</span> <span class="special">&amp;</span><span class="identifier">q</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">coord_type</span> <span class="special">&amp;</span><span class="identifier">p</span> <span class="special">)</span>
<span class="special">{</span>
<span class="comment">// calculates the total energy of the excitation</span>
<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
<span class="keyword">double</span> <span class="identifier">en</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">N</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">++</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">diff</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">[(</span><span class="identifier">i</span><span class="special">+</span><span class="number">1</span><span class="special">)</span> <span class="special">%</span> <span class="identifier">N</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="identifier">en</span> <span class="special">+=</span> <span class="identifier">p</span><span class="special">[</span><span class="identifier">i</span><span class="special">]*</span><span class="identifier">p</span><span class="special">[</span><span class="identifier">i</span><span class="special">]/</span><span class="number">2.0</span>
<span class="special">+</span> <span class="identifier">m_pot</span><span class="special">[</span><span class="identifier">m_pot_start_index</span><span class="special">+</span><span class="identifier">i</span><span class="special">]*</span><span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">]*</span><span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">]*</span><span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">]*</span><span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">/</span> <span class="number">4.0</span>
<span class="special">+</span> <span class="identifier">m_beta</span><span class="special">/</span><span class="number">4.0</span> <span class="special">*</span> <span class="identifier">diff</span><span class="special">*</span><span class="identifier">diff</span><span class="special">*</span><span class="identifier">diff</span><span class="special">*</span><span class="identifier">diff</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">return</span> <span class="identifier">en</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">void</span> <span class="identifier">change_pot_start</span><span class="special">(</span> <span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">delta</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">m_pot_start_index</span> <span class="special">+=</span> <span class="identifier">delta</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
The total size we allow is 1024 and we start with an initial state size of
60.
</p>
<p>
</p>
<pre class="programlisting"><span class="comment">//start with 60 sites</span>
<span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">N_start</span> <span class="special">=</span> <span class="number">60</span><span class="special">;</span>
<span class="identifier">coord_type</span> <span class="identifier">q</span><span class="special">(</span> <span class="identifier">N_start</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">);</span>
<span class="identifier">q</span><span class="special">.</span><span class="identifier">reserve</span><span class="special">(</span> <span class="identifier">max_N</span> <span class="special">);</span>
<span class="identifier">coord_type</span> <span class="identifier">p</span><span class="special">(</span> <span class="identifier">N_start</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">);</span>
<span class="identifier">p</span><span class="special">.</span><span class="identifier">reserve</span><span class="special">(</span> <span class="identifier">max_N</span> <span class="special">);</span>
<span class="comment">// start with uniform momentum distribution over 20 sites</span>
<span class="identifier">fill</span><span class="special">(</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()+</span><span class="number">20</span> <span class="special">,</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">end</span><span class="special">()-</span><span class="number">20</span> <span class="special">,</span> <span class="number">1.0</span><span class="special">/</span><span class="identifier">sqrt</span><span class="special">(</span><span class="number">20.0</span><span class="special">)</span> <span class="special">);</span>
<span class="identifier">coord_type</span> <span class="identifier">distr</span><span class="special">(</span> <span class="identifier">N_start</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">);</span>
<span class="identifier">distr</span><span class="special">.</span><span class="identifier">reserve</span><span class="special">(</span> <span class="identifier">max_N</span> <span class="special">);</span>
<span class="comment">// create the system</span>
<span class="identifier">compacton_lattice</span> <span class="identifier">lattice</span><span class="special">(</span> <span class="identifier">max_N</span> <span class="special">,</span> <span class="identifier">beta</span> <span class="special">,</span> <span class="special">(</span><span class="identifier">max_N</span><span class="special">-</span><span class="identifier">N_start</span><span class="special">)/</span><span class="number">2</span> <span class="special">);</span>
<span class="comment">//create the stepper, note that we use an always_resizer because state size might change during steps</span>
<span class="keyword">typedef</span> <span class="identifier">symplectic_rkn_sb3a_mclachlan</span><span class="special">&lt;</span> <span class="identifier">coord_type</span> <span class="special">,</span> <span class="identifier">coord_type</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">coord_type</span> <span class="special">,</span> <span class="identifier">coord_type</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">,</span>
<span class="identifier">range_algebra</span> <span class="special">,</span> <span class="identifier">default_operations</span> <span class="special">,</span> <span class="identifier">always_resizer</span> <span class="special">&gt;</span> <span class="identifier">hamiltonian_stepper</span><span class="special">;</span>
<span class="identifier">hamiltonian_stepper</span> <span class="identifier">stepper</span><span class="special">;</span>
<span class="identifier">hamiltonian_stepper</span><span class="special">::</span><span class="identifier">state_type</span> <span class="identifier">state</span> <span class="special">=</span> <span class="identifier">make_pair</span><span class="special">(</span> <span class="identifier">q</span> <span class="special">,</span> <span class="identifier">p</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
The lattice gets resized whenever the energy distribution comes close to
the borders <code class="computeroutput"><span class="identifier">distr</span><span class="special">[</span><span class="number">10</span><span class="special">]</span> <span class="special">&gt;</span>
<span class="number">1E-150</span></code>, <code class="computeroutput"><span class="identifier">distr</span><span class="special">[</span><span class="identifier">distr</span><span class="special">.</span><span class="identifier">size</span><span class="special">()-</span><span class="number">10</span><span class="special">]</span> <span class="special">&gt;</span>
<span class="number">1E-150</span></code>. If we increase to the left,
<code class="computeroutput"><span class="identifier">q</span></code> and <code class="computeroutput"><span class="identifier">p</span></code>
have to be rotated because their resize function always appends at the end.
Additionally, the start index of the potential changes in this case.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">t</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">dt</span> <span class="special">=</span> <span class="number">0.1</span><span class="special">;</span>
<span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">steps</span> <span class="special">=</span> <span class="number">10000</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span> <span class="keyword">int</span> <span class="identifier">step</span> <span class="special">=</span> <span class="number">0</span> <span class="special">;</span> <span class="identifier">step</span> <span class="special">&lt;</span> <span class="identifier">steps</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">step</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">stepper</span><span class="special">.</span><span class="identifier">do_step</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span><span class="special">(</span><span class="identifier">lattice</span><span class="special">)</span> <span class="special">,</span> <span class="identifier">state</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">);</span>
<span class="identifier">lattice</span><span class="special">.</span><span class="identifier">energy_distribution</span><span class="special">(</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">first</span> <span class="special">,</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">second</span> <span class="special">,</span> <span class="identifier">distr</span> <span class="special">);</span>
<span class="keyword">if</span><span class="special">(</span> <span class="identifier">distr</span><span class="special">[</span><span class="number">10</span><span class="special">]</span> <span class="special">&gt;</span> <span class="number">1E-150</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">do_resize</span><span class="special">(</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">first</span> <span class="special">,</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">second</span> <span class="special">,</span> <span class="identifier">distr</span> <span class="special">,</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">first</span><span class="special">.</span><span class="identifier">size</span><span class="special">()+</span><span class="number">20</span> <span class="special">);</span>
<span class="identifier">rotate</span><span class="special">(</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">first</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">first</span><span class="special">.</span><span class="identifier">end</span><span class="special">()-</span><span class="number">20</span> <span class="special">,</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">first</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">);</span>
<span class="identifier">rotate</span><span class="special">(</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">second</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">second</span><span class="special">.</span><span class="identifier">end</span><span class="special">()-</span><span class="number">20</span> <span class="special">,</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">second</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">);</span>
<span class="identifier">lattice</span><span class="special">.</span><span class="identifier">change_pot_start</span><span class="special">(</span> <span class="special">-</span><span class="number">20</span> <span class="special">);</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">t</span> <span class="special">&lt;&lt;</span> <span class="string">": resized left to "</span> <span class="special">&lt;&lt;</span> <span class="identifier">distr</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">", energy = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">lattice</span><span class="special">.</span><span class="identifier">energy</span><span class="special">(</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">first</span> <span class="special">,</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">second</span> <span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">if</span><span class="special">(</span> <span class="identifier">distr</span><span class="special">[</span><span class="identifier">distr</span><span class="special">.</span><span class="identifier">size</span><span class="special">()-</span><span class="number">10</span><span class="special">]</span> <span class="special">&gt;</span> <span class="number">1E-150</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">do_resize</span><span class="special">(</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">first</span> <span class="special">,</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">second</span> <span class="special">,</span> <span class="identifier">distr</span> <span class="special">,</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">first</span><span class="special">.</span><span class="identifier">size</span><span class="special">()+</span><span class="number">20</span> <span class="special">);</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">t</span> <span class="special">&lt;&lt;</span> <span class="string">": resized right to "</span> <span class="special">&lt;&lt;</span> <span class="identifier">distr</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">", energy = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">lattice</span><span class="special">.</span><span class="identifier">energy</span><span class="special">(</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">first</span> <span class="special">,</span> <span class="identifier">state</span><span class="special">.</span><span class="identifier">second</span> <span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">t</span> <span class="special">+=</span> <span class="identifier">dt</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
<p>
The <code class="computeroutput"><span class="identifier">do_resize</span></code> function simply
calls <code class="computeroutput"><span class="identifier">vector</span><span class="special">.</span><span class="identifier">resize</span></code> of <code class="computeroutput"><span class="identifier">q</span></code>
, <code class="computeroutput"><span class="identifier">p</span></code> and <code class="computeroutput"><span class="identifier">distr</span></code>.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">do_resize</span><span class="special">(</span> <span class="identifier">coord_type</span> <span class="special">&amp;</span><span class="identifier">q</span> <span class="special">,</span> <span class="identifier">coord_type</span> <span class="special">&amp;</span><span class="identifier">p</span> <span class="special">,</span> <span class="identifier">coord_type</span> <span class="special">&amp;</span><span class="identifier">distr</span> <span class="special">,</span> <span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">N</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">q</span><span class="special">.</span><span class="identifier">resize</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">);</span>
<span class="identifier">p</span><span class="special">.</span><span class="identifier">resize</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">);</span>
<span class="identifier">distr</span><span class="special">.</span><span class="identifier">resize</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">);</span>
<span class="special">}</span>
</pre>
<p>
</p>
<p>
The full example can be found in <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/resizing_lattice.cpp" target="_top">resizing_lattice.cpp</a>
</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 &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="using_arbitrary_precision_floating_point_types.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="using_cuda__or_openmp__tbb_______via_thrust.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,317 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Solar system</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="harmonic_oscillator.html" title="Harmonic oscillator">
<link rel="next" href="chaotic_systems_and_lyapunov_exponents.html" title="Chaotic systems and Lyapunov exponents">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="harmonic_oscillator.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="chaotic_systems_and_lyapunov_exponents.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.solar_system"></a><a class="link" href="solar_system.html" title="Solar system">Solar system</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="solar_system.html#boost_numeric_odeint.tutorial.solar_system.gravitation_and_energy_conservation">Gravitation
and energy conservation</a></span></dt>
<dt><span class="section"><a href="solar_system.html#boost_numeric_odeint.tutorial.solar_system.define_the_system_function">Define
the system function</a></span></dt>
</dl></div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.tutorial.solar_system.gravitation_and_energy_conservation"></a><a class="link" href="solar_system.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 outer solar system,
consisting of the sun, Jupiter, Saturn, Uranus, Neptune and Pluto.
</p>
<p>
<span class="inlinemediaobject"><img src="../../solar_system.jpg" alt="solar_system"></span>
</p>
<p>
Each planet and of course the sun will be represented by mass points. The
interaction force between each object is the gravitational force which
can be written as
</p>
<p>
<span class="emphasis"><em>F<sub>&#8203;ij</sub> = -&#947; m<sub>&#8203;i</sub> m<sub>&#8203;j</sub> ( q<sub>&#8203;i</sub> - q<sub>&#8203;j</sub> ) / | q<sub>&#8203;i</sub> - q<sub>&#8203;j</sub> | <sup>3</sup></em></span>
</p>
<p>
where <span class="emphasis"><em>&#947;</em></span> is the gravitational constant, <span class="emphasis"><em>m<sub>&#8203;i</sub></em></span>
and <span class="emphasis"><em>m<sub>&#8203;j</sub></em></span> are the masses and <span class="emphasis"><em>q<sub>&#8203;i</sub></em></span>
and <span class="emphasis"><em>q<sub>&#8203;j</sub></em></span> are the locations of the two objects. The equations
of motion are then
</p>
<p>
<span class="emphasis"><em>dq<sub>&#8203;i</sub> / dt = p<sub>&#8203;i</sub></em></span>
</p>
<p>
<span class="emphasis"><em>dp<sub>&#8203;i</sub> / dt = 1 / m<sub>&#8203;i</sub> &#931;<sub>&#8203;ji</sub> F<sub>&#8203;ij</sub></em></span>
</p>
<p>
where <span class="emphasis"><em>p<sub>&#8203;i</sub></em></span> is the momenta of object <span class="emphasis"><em>i</em></span>.
The equations of motion can also be derived from the Hamiltonian
</p>
<p>
<span class="emphasis"><em>H = &#931;<sub>&#8203;i</sub> p<sub>&#8203;i</sub><sup>2</sup> / ( 2 m<sub>&#8203;i</sub> ) + &#931;<sub>&#8203;j</sub> V( q<sub>&#8203;i</sub> , q<sub>&#8203;j</sub> )</em></span>
</p>
<p>
with the interaction potential <span class="emphasis"><em>V(q<sub>&#8203;i</sub>,q<sub>&#8203;j</sub>)</em></span>. The Hamiltonian
equations give the equations of motion
</p>
<p>
<span class="emphasis"><em>dq<sub>&#8203;i</sub> / dt = dH / dp<sub>&#8203;i</sub></em></span>
</p>
<p>
<span class="emphasis"><em>dp<sub>&#8203;i</sub> / dt = -dH / dq<sub>&#8203;i</sub></em></span>
</p>
<p>
In time independent Hamiltonian system the energy and the phase space volume
are conserved and special integration methods have to be applied in order
to ensure these conservation laws. The odeint library provides classes
for separable Hamiltonian systems, which can be written in the form <span class="emphasis"><em>H
= &#931;
p<sub>&#8203;i</sub><sup>2</sup> / (2m<sub>&#8203;i</sub>) + H<sub>&#8203;q</sub>(q)</em></span>, where <span class="emphasis"><em>H<sub>&#8203;q</sub>(q)</em></span> only
depends on the coordinates. Although this functional form might look a
bit arbitrary, it covers nearly all classical mechanical systems with inertia
and without dissipation, or where the equations of motion can be written
in the form <span class="emphasis"><em>dq<sub>&#8203;i</sub> / dt = p<sub>&#8203;i</sub></em></span> / m<sub>&#8203;i</sub> , <span class="emphasis"><em>dp<sub>&#8203;i</sub> / dt =
f( q<sub>&#8203;i</sub> )</em></span>.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
A short physical note: While the two-body-problem is known to be integrable,
that means it can be solved with purely analytic techniques, already
the three-body-problem is not solvable. This was found in the end of
the 19th century by H. Poincare which led to the whole new subject of
<a href="http://en.wikipedia.org/wiki/Chaos_theory" target="_top">Chaos Theory</a>.
</p></td></tr>
</table></div>
</div>
<div class="section">
<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="solar_system.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 3D point type which will represent
the space as well as the velocity. Therefore, we use the operators from
<a href="http://www.boost.org/doc/libs/release/libs/utility/operators.htm" target="_top">Boost.Operators</a>:
</p>
<p>
</p>
<pre class="programlisting"><span class="comment">/*the point type */</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">T</span> <span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">Dim</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">point</span> <span class="special">:</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">additive1</span><span class="special">&lt;</span> <span class="identifier">point</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">,</span> <span class="identifier">Dim</span> <span class="special">&gt;</span> <span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">additive2</span><span class="special">&lt;</span> <span class="identifier">point</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">,</span> <span class="identifier">Dim</span> <span class="special">&gt;</span> <span class="special">,</span> <span class="identifier">T</span> <span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiplicative2</span><span class="special">&lt;</span> <span class="identifier">point</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">,</span> <span class="identifier">Dim</span> <span class="special">&gt;</span> <span class="special">,</span> <span class="identifier">T</span>
<span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="keyword">const</span> <span class="keyword">static</span> <span class="identifier">size_t</span> <span class="identifier">dim</span> <span class="special">=</span> <span class="identifier">Dim</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">value_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">point</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">,</span> <span class="identifier">dim</span> <span class="special">&gt;</span> <span class="identifier">point_type</span><span class="special">;</span>
<span class="comment">// ...</span>
<span class="comment">// constructors</span>
<span class="comment">// ...</span>
<span class="comment">// operators</span>
<span class="keyword">private</span><span class="special">:</span>
<span class="identifier">T</span> <span class="identifier">m_val</span><span class="special">[</span><span class="identifier">dim</span><span class="special">];</span>
<span class="special">};</span>
<span class="comment">//...</span>
<span class="comment">// more operators</span>
</pre>
<p>
</p>
<p>
The next step is to define a container type storing the values of <span class="emphasis"><em>q</em></span>
and <span class="emphasis"><em>p</em></span> and to define system functions. As container
type we use <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span></code>
</p>
<p>
</p>
<pre class="programlisting"><span class="comment">// we simulate 5 planets and the sun</span>
<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="number">6</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">point</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="number">3</span> <span class="special">&gt;</span> <span class="identifier">point_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="identifier">point_type</span> <span class="special">,</span> <span class="identifier">n</span> <span class="special">&gt;</span> <span class="identifier">container_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">n</span> <span class="special">&gt;</span> <span class="identifier">mass_type</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
The <code class="computeroutput"><span class="identifier">container_type</span></code> is different
from the state type of the ODE. The state type of the ode is simply a
<code class="computeroutput"><span class="identifier">pair</span><span class="special">&lt;</span>
<span class="identifier">container_type</span> <span class="special">,</span>
<span class="identifier">container_type</span> <span class="special">&gt;</span></code>
since it needs the information about the coordinates and the momenta.
</p>
<p>
Next we define the system's equations. As we will use a stepper that accounts
for the Hamiltonian (energy-preserving) character of the system, we have
to define the rhs different from the usual case where it is just a single
function. The stepper will make use of the separable character, which means
the system will be defined by two objects representing <span class="emphasis"><em>f(p) =
-dH/dq</em></span> and <span class="emphasis"><em>g(q) = dH/dp</em></span>:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">gravitational_constant</span> <span class="special">=</span> <span class="number">2.95912208286e-4</span><span class="special">;</span>
<span class="keyword">struct</span> <span class="identifier">solar_system_coor</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="identifier">mass_type</span> <span class="special">&amp;</span><span class="identifier">m_masses</span><span class="special">;</span>
<span class="identifier">solar_system_coor</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">mass_type</span> <span class="special">&amp;</span><span class="identifier">masses</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_masses</span><span class="special">(</span> <span class="identifier">masses</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">p</span> <span class="special">,</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">dqdt</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">n</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
<span class="identifier">dqdt</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">p</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">/</span> <span class="identifier">m_masses</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">solar_system_momentum</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="identifier">mass_type</span> <span class="special">&amp;</span><span class="identifier">m_masses</span><span class="special">;</span>
<span class="identifier">solar_system_momentum</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">mass_type</span> <span class="special">&amp;</span><span class="identifier">masses</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_masses</span><span class="special">(</span> <span class="identifier">masses</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">q</span> <span class="special">,</span> <span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">dpdt</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">n</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">dpdt</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">j</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">j</span><span class="special">&lt;</span><span class="identifier">i</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">j</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">point_type</span> <span class="identifier">diff</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">j</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">abs</span><span class="special">(</span> <span class="identifier">diff</span> <span class="special">);</span>
<span class="identifier">diff</span> <span class="special">*=</span> <span class="special">(</span> <span class="identifier">gravitational_constant</span> <span class="special">*</span> <span class="identifier">m_masses</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">m_masses</span><span class="special">[</span><span class="identifier">j</span><span class="special">]</span> <span class="special">/</span> <span class="identifier">d</span> <span class="special">/</span> <span class="identifier">d</span> <span class="special">/</span> <span class="identifier">d</span> <span class="special">);</span>
<span class="identifier">dpdt</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">+=</span> <span class="identifier">diff</span><span class="special">;</span>
<span class="identifier">dpdt</span><span class="special">[</span><span class="identifier">j</span><span class="special">]</span> <span class="special">-=</span> <span class="identifier">diff</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
In general a three body-system is chaotic, hence we can not expect that
arbitrary initial conditions of the system will lead to a solution comparable
with the solar system dynamics. That is we have to define proper initial
conditions, which are taken from the book of Hairer, Wannier, Lubich <a class="link" href="../literature.html#hairer_geometrical_numeric_integration">[4] </a>.
</p>
<p>
As mentioned above, we need to use some special integrators in order to
conserve phase space volume. There is a well known family of such integrators,
the so-called Runge-Kutta-Nystroem solvers, which we apply here in terms
of a <code class="computeroutput"><span class="identifier">symplectic_rkn_sb3a_mclachlan</span></code>
stepper:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">symplectic_rkn_sb3a_mclachlan</span><span class="special">&lt;</span> <span class="identifier">container_type</span> <span class="special">&gt;</span> <span class="identifier">stepper_type</span><span class="special">;</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">dt</span> <span class="special">=</span> <span class="number">100.0</span><span class="special">;</span>
<span class="identifier">integrate_const</span><span class="special">(</span>
<span class="identifier">stepper_type</span><span class="special">()</span> <span class="special">,</span>
<span class="identifier">make_pair</span><span class="special">(</span> <span class="identifier">solar_system_coor</span><span class="special">(</span> <span class="identifier">masses</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">solar_system_momentum</span><span class="special">(</span> <span class="identifier">masses</span> <span class="special">)</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">make_pair</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span><span class="special">(</span> <span class="identifier">q</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span><span class="special">(</span> <span class="identifier">p</span> <span class="special">)</span> <span class="special">)</span> <span class="special">,</span>
<span class="number">0.0</span> <span class="special">,</span> <span class="number">200000.0</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">,</span> <span class="identifier">streaming_observer</span><span class="special">(</span> <span class="identifier">cout</span> <span class="special">)</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
These integration routine was used to produce the above sketch of the solar
system. Note, that there are two particularities in this example. First,
the state of the symplectic stepper is not <code class="computeroutput"><span class="identifier">container_type</span></code>
but a pair of <code class="computeroutput"><span class="identifier">container_type</span></code>.
Hence, we must pass such a pair to the integrate function. Since, we want
to pass them as references we can simply pack them into <a href="http://www.boost.org/doc/libs/release/libs/bind/ref.html" target="_top">Boost.Ref</a>.
The second point is the observer, which is called with a state type, hence
a pair of <code class="computeroutput"><span class="identifier">container_type</span></code>.
The reference wrapper is also passed, but this is not a problem at all:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">streaming_observer</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="identifier">m_out</span><span class="special">;</span>
<span class="identifier">streaming_observer</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span> <span class="special">&amp;</span><span class="identifier">out</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_out</span><span class="special">(</span> <span class="identifier">out</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">container_type</span> <span class="special">&amp;</span><span class="identifier">q</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">first</span><span class="special">;</span>
<span class="identifier">m_out</span> <span class="special">&lt;&lt;</span> <span class="identifier">t</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">q</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span> <span class="identifier">m_out</span> <span class="special">&lt;&lt;</span> <span class="string">"\t"</span> <span class="special">&lt;&lt;</span> <span class="identifier">q</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="identifier">m_out</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<div class="tip"><table border="0" summary="Tip">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../../../doc/src/images/tip.png"></td>
<th align="left">Tip</th>
</tr>
<tr><td align="left" valign="top"><p>
You can use C++11 lambda to create the observers
</p></td></tr>
</table></div>
<p>
The full example can be found here: <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/solar_system.cpp" target="_top">solar_system.cpp</a>
</p>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="harmonic_oscillator.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="chaotic_systems_and_lyapunov_exponents.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,171 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Stiff systems</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="chaotic_systems_and_lyapunov_exponents.html" title="Chaotic systems and Lyapunov exponents">
<link rel="next" href="complex_state_types.html" title="Complex state types">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="chaotic_systems_and_lyapunov_exponents.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="complex_state_types.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.stiff_systems"></a><a class="link" href="stiff_systems.html" title="Stiff systems">Stiff systems</a>
</h3></div></div></div>
<p>
An important class of ordinary differential equations are so called stiff
system which are characterized by two or more time scales of different order.
Examples of such systems are found in chemical systems where reaction rates
of individual sub-reaction might differ over large ranges, for example:
</p>
<p>
<span class="emphasis"><em>d S<sub>&#8203;1</sub> / dt = - 101 S<sub>&#8203;2</sub> - 100 S<sub>&#8203;1</sub></em></span>
</p>
<p>
<span class="emphasis"><em>d S<sub>&#8203;2</sub> / dt = S<sub>&#8203;1</sub></em></span>
</p>
<p>
In order to efficiently solve stiff systems numerically the Jacobian
</p>
<p>
<span class="emphasis"><em>J = d f<sub>&#8203;i</sub> / d x<sub>&#8203;j</sub></em></span>
</p>
<p>
is needed. Here is the definition of the above example
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">ublas</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">vector_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">ublas</span><span class="special">::</span><span class="identifier">matrix</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">matrix_type</span><span class="special">;</span>
<span class="keyword">struct</span> <span class="identifier">stiff_system</span>
<span class="special">{</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">vector_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">vector_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="comment">/* t */</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">dxdt</span><span class="special">[</span> <span class="number">0</span> <span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="number">101.0</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span> <span class="number">0</span> <span class="special">]</span> <span class="special">-</span> <span class="number">100.0</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span> <span class="number">1</span> <span class="special">];</span>
<span class="identifier">dxdt</span><span class="special">[</span> <span class="number">1</span> <span class="special">]</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">[</span> <span class="number">0</span> <span class="special">];</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="keyword">struct</span> <span class="identifier">stiff_system_jacobi</span>
<span class="special">{</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">vector_type</span> <span class="special">&amp;</span> <span class="comment">/* x */</span> <span class="special">,</span> <span class="identifier">matrix_type</span> <span class="special">&amp;</span><span class="identifier">J</span> <span class="special">,</span> <span class="keyword">const</span> <span class="keyword">double</span> <span class="special">&amp;</span> <span class="comment">/* t */</span> <span class="special">,</span> <span class="identifier">vector_type</span> <span class="special">&amp;</span><span class="identifier">dfdt</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">J</span><span class="special">(</span> <span class="number">0</span> <span class="special">,</span> <span class="number">0</span> <span class="special">)</span> <span class="special">=</span> <span class="special">-</span><span class="number">101.0</span><span class="special">;</span>
<span class="identifier">J</span><span class="special">(</span> <span class="number">0</span> <span class="special">,</span> <span class="number">1</span> <span class="special">)</span> <span class="special">=</span> <span class="special">-</span><span class="number">100.0</span><span class="special">;</span>
<span class="identifier">J</span><span class="special">(</span> <span class="number">1</span> <span class="special">,</span> <span class="number">0</span> <span class="special">)</span> <span class="special">=</span> <span class="number">1.0</span><span class="special">;</span>
<span class="identifier">J</span><span class="special">(</span> <span class="number">1</span> <span class="special">,</span> <span class="number">1</span> <span class="special">)</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
<span class="identifier">dfdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
<span class="identifier">dfdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
The state type has to be a <code class="computeroutput"><span class="identifier">ublas</span><span class="special">::</span><span class="identifier">vector</span></code>
and the matrix type must by a <code class="computeroutput"><span class="identifier">ublas</span><span class="special">::</span><span class="identifier">matrix</span></code>
since the stiff integrator only accepts these types. However, you might want
use non-stiff integrators on this system, too - we will do so later for demonstration.
Therefore we want to use the same function also with other state_types, realized
by templatizing the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">ublas</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">vector_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">ublas</span><span class="special">::</span><span class="identifier">matrix</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">matrix_type</span><span class="special">;</span>
<span class="keyword">struct</span> <span class="identifier">stiff_system</span>
<span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span>
<span class="special">{</span>
<span class="special">...</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="keyword">struct</span> <span class="identifier">stiff_system_jacobi</span>
<span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Matrix</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">Matrix</span> <span class="special">&amp;</span><span class="identifier">J</span> <span class="special">,</span> <span class="keyword">const</span> <span class="keyword">double</span> <span class="special">&amp;</span><span class="identifier">t</span> <span class="special">,</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">dfdt</span> <span class="special">)</span>
<span class="special">{</span>
<span class="special">...</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
Now you can use <code class="computeroutput"><span class="identifier">stiff_system</span></code>
in combination with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span></code> or <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span></code>.
In the example the explicit time derivative of <span class="emphasis"><em>f(x,t)</em></span>
is introduced separately in the Jacobian. If <span class="emphasis"><em>df / dt = 0</em></span>
simply fill <code class="computeroutput"><span class="identifier">dfdt</span></code> with zeros.
</p>
<p>
A well know solver for stiff systems is the Rosenbrock method. It has a step
size control and dense output facilities and can be used like all the other
steppers:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">vector_type</span> <span class="identifier">x</span><span class="special">(</span> <span class="number">2</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">);</span>
<span class="identifier">size_t</span> <span class="identifier">num_of_steps</span> <span class="special">=</span> <span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">make_dense_output</span><span class="special">&lt;</span> <span class="identifier">rosenbrock4</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="special">&gt;(</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">make_pair</span><span class="special">(</span> <span class="identifier">stiff_system</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">stiff_system_jacobi</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">50.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">,</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">arg_names</span><span class="special">::</span><span class="identifier">arg2</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span> <span class="special">&lt;&lt;</span> <span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">arg_names</span><span class="special">::</span><span class="identifier">arg1</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
During the integration 71 steps have been done. Comparing to a classical
Runge-Kutta solver this is a very good result. For example the Dormand-Prince
5 method with step size control and dense output yields 1531 steps.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">vector_type</span> <span class="identifier">x2</span><span class="special">(</span> <span class="number">2</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">);</span>
<span class="identifier">size_t</span> <span class="identifier">num_of_steps2</span> <span class="special">=</span> <span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">make_dense_output</span><span class="special">&lt;</span> <span class="identifier">runge_kutta_dopri5</span><span class="special">&lt;</span> <span class="identifier">vector_type</span> <span class="special">&gt;</span> <span class="special">&gt;(</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">stiff_system</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x2</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">50.0</span> <span class="special">,</span> <span class="number">0.01</span> <span class="special">,</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">arg_names</span><span class="special">::</span><span class="identifier">arg2</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span> <span class="special">&lt;&lt;</span> <span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">arg_names</span><span class="special">::</span><span class="identifier">arg1</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
Note, that we have used <a href="http://www.boost.org/doc/libs/release/libs/phoenix/" target="_top">Boost.Phoenix</a>,
a great functional programming library, to create and compose the observer.
</p>
<p>
The full example can be found here: <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/stiff_system.cpp" target="_top">stiff_system.cpp</a>
</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 &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="chaotic_systems_and_lyapunov_exponents.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="complex_state_types.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,118 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Using arbitrary precision floating point types</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="using_matrices_as_state_types.html" title="Using matrices as state types">
<link rel="next" href="self_expanding_lattices.html" title="Self expanding lattices">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="using_matrices_as_state_types.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="self_expanding_lattices.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.using_arbitrary_precision_floating_point_types"></a><a class="link" href="using_arbitrary_precision_floating_point_types.html" title="Using arbitrary precision floating point types">Using
arbitrary precision floating point types</a>
</h3></div></div></div>
<p>
Sometimes one needs results with higher precision than provided by the standard
floating point types. As odeint allows to configure the fundamental numerical
type, it is well suited to be run with arbitrary precision types. Therefore,
one only needs a library that provides a type representing values with arbitrary
precision and the fundamental operations for those values. <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/" target="_top">Boost.Multiprecision</a>
is a boost library that does exactly this. Making use of <a href="http://www.boost.org/doc/libs/release/libs/multiprecision/" target="_top">Boost.Multiprecision</a>
to solve odes with odeint is very simple, as the following example shows.
</p>
<p>
Here we use <code class="computeroutput"><span class="identifier">cpp_dec_float_50</span></code>
as the fundamental value type, which ensures exact computations up to 50
decimal digits.
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">cpp_dec_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">std</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">odeint</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span> <span class="identifier">value_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">,</span> <span class="number">3</span> <span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
As exemplary ODE again the lorenz system is chosen, but here we have to make
sure all constants are initialized as high precision values.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">lorenz</span>
<span class="special">{</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">sigma</span><span class="special">(</span> <span class="number">10</span> <span class="special">);</span>
<span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">R</span><span class="special">(</span> <span class="number">28</span> <span class="special">);</span>
<span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">b</span><span class="special">(</span> <span class="identifier">value_type</span><span class="special">(</span> <span class="number">8</span> <span class="special">)</span> <span class="special">/</span> <span class="identifier">value_type</span><span class="special">(</span> <span class="number">3</span> <span class="special">)</span> <span class="special">);</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">sigma</span> <span class="special">*</span> <span class="special">(</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">);</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">R</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">];</span>
<span class="identifier">dxdt</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">b</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">[</span><span class="number">1</span><span class="special">];</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
The actual integration then is straight forward:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">state_type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="special">{{</span> <span class="identifier">value_type</span><span class="special">(</span> <span class="number">10.0</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">value_type</span><span class="special">(</span> <span class="number">10.0</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">value_type</span><span class="special">(</span> <span class="number">10.0</span> <span class="special">)</span> <span class="special">}};</span>
<span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span> <span class="number">50</span> <span class="special">);</span>
<span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="special">&gt;()</span> <span class="special">,</span>
<span class="identifier">lorenz</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">value_type</span><span class="special">(</span> <span class="number">0.0</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">value_type</span><span class="special">(</span> <span class="number">10.0</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">value_type</span><span class="special">(</span> <span class="identifier">value_type</span><span class="special">(</span> <span class="number">1.0</span> <span class="special">)</span> <span class="special">/</span> <span class="identifier">value_type</span><span class="special">(</span> <span class="number">10.0</span> <span class="special">)</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">streaming_observer</span><span class="special">(</span> <span class="identifier">cout</span> <span class="special">)</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
The full example can be found at <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/multiprecision/lorenz_mp.cpp" target="_top">lorenz_mp.cpp</a>.
Another example that compares the accuracy of the high precision type with
standard double can be found at <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/multiprecision/cmp_precision.cpp" target="_top">cmp_precision.cpp</a>.
</p>
<p>
Furthermore, odeint can also be run with other multiprecision libraries,
e.g. <a href="http://gmplib.org/" target="_top">gmp</a>. An example for this is
given in <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/gmpxx/lorenz_gmpxx.cpp" target="_top">lorenz_gmpxx.cpp</a>.
</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 &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="using_matrices_as_state_types.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="self_expanding_lattices.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,211 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Using boost::units</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="ensembles_of_oscillators.html" title="Ensembles of oscillators">
<link rel="next" href="using_matrices_as_state_types.html" title="Using matrices as state types">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="ensembles_of_oscillators.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="using_matrices_as_state_types.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.using_boost__units"></a><a class="link" href="using_boost__units.html" title="Using boost::units">Using
boost::units</a>
</h3></div></div></div>
<p>
odeint also works well with <a href="http://www.boost.org/doc/libs/release/libs/units/" target="_top">Boost.Units</a>
- a library for compile time unit and dimension analysis. It works by decoding
unit information into the types of values. For a one-dimensional unit you
can just use the Boost.Unit types as state type, deriv type and time type
and hand the <code class="computeroutput"><span class="identifier">vector_space_algebra</span></code>
to the stepper definition and everything works just fine:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">units</span><span class="special">::</span><span class="identifier">quantity</span><span class="special">&lt;</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">time</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">time_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">units</span><span class="special">::</span><span class="identifier">quantity</span><span class="special">&lt;</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">length</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">length_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">units</span><span class="special">::</span><span class="identifier">quantity</span><span class="special">&lt;</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">velocity</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">velocity_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">length_type</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">velocity_type</span> <span class="special">,</span> <span class="identifier">time_type</span> <span class="special">,</span>
<span class="identifier">vector_space_algebra</span> <span class="special">&gt;</span> <span class="identifier">stepper_type</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
If you want to solve more-dimensional problems the individual entries typically
have different units. That means that the <code class="computeroutput"><span class="identifier">state_type</span></code>
is now possibly heterogeneous, meaning that every entry might have a different
type. To solve this problem, compile-time sequences from <a href="http://www.boost.org/doc/libs/release/libs/fusion/" target="_top">Boost.Fusion</a>
can be used.
</p>
<p>
To illustrate how odeint works with <a href="http://www.boost.org/doc/libs/release/libs/units/" target="_top">Boost.Units</a>
we use the harmonic oscillator as primary example. We start with defining
all quantities
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">/</span><span class="identifier">algebra</span><span class="special">/</span><span class="identifier">fusion_algebra</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">/</span><span class="identifier">algebra</span><span class="special">/</span><span class="identifier">fusion_algebra_dispatcher</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">units</span><span class="special">/</span><span class="identifier">systems</span><span class="special">/</span><span class="identifier">si</span><span class="special">/</span><span class="identifier">length</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">units</span><span class="special">/</span><span class="identifier">systems</span><span class="special">/</span><span class="identifier">si</span><span class="special">/</span><span class="identifier">time</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">units</span><span class="special">/</span><span class="identifier">systems</span><span class="special">/</span><span class="identifier">si</span><span class="special">/</span><span class="identifier">velocity</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">units</span><span class="special">/</span><span class="identifier">systems</span><span class="special">/</span><span class="identifier">si</span><span class="special">/</span><span class="identifier">acceleration</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">units</span><span class="special">/</span><span class="identifier">systems</span><span class="special">/</span><span class="identifier">si</span><span class="special">/</span><span class="identifier">io</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">fusion</span><span class="special">/</span><span class="identifier">container</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">std</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">odeint</span><span class="special">;</span>
<span class="keyword">namespace</span> <span class="identifier">fusion</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">fusion</span><span class="special">;</span>
<span class="keyword">namespace</span> <span class="identifier">units</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">units</span><span class="special">;</span>
<span class="keyword">namespace</span> <span class="identifier">si</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">units</span><span class="special">::</span><span class="identifier">si</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">units</span><span class="special">::</span><span class="identifier">quantity</span><span class="special">&lt;</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">time</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">time_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">units</span><span class="special">::</span><span class="identifier">quantity</span><span class="special">&lt;</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">length</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">length_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">units</span><span class="special">::</span><span class="identifier">quantity</span><span class="special">&lt;</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">velocity</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">velocity_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">units</span><span class="special">::</span><span class="identifier">quantity</span><span class="special">&lt;</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">acceleration</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">acceleration_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">units</span><span class="special">::</span><span class="identifier">quantity</span><span class="special">&lt;</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">frequency</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">frequency_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">fusion</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">length_type</span> <span class="special">,</span> <span class="identifier">velocity_type</span> <span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">fusion</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">velocity_type</span> <span class="special">,</span> <span class="identifier">acceleration_type</span> <span class="special">&gt;</span> <span class="identifier">deriv_type</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
Note, that the <code class="computeroutput"><span class="identifier">state_type</span></code>
and the <code class="computeroutput"><span class="identifier">deriv_type</span></code> are now
a compile-time fusion sequences. <code class="computeroutput"><span class="identifier">deriv_type</span></code>
represents <span class="emphasis"><em>x'</em></span> and is now different from the state type
as it has different unit definitions. Next, we define the ordinary differential
equation which is completely equivalent to the example in <a class="link" href="harmonic_oscillator.html" title="Harmonic oscillator">Harmonic
Oscillator</a>:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">oscillator</span>
<span class="special">{</span>
<span class="identifier">frequency_type</span> <span class="identifier">m_omega</span><span class="special">;</span>
<span class="identifier">oscillator</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">frequency_type</span> <span class="special">&amp;</span><span class="identifier">omega</span> <span class="special">=</span> <span class="number">1.0</span> <span class="special">*</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">hertz</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_omega</span><span class="special">(</span> <span class="identifier">omega</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">deriv_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">time_type</span> <span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">fusion</span><span class="special">::</span><span class="identifier">at_c</span><span class="special">&lt;</span> <span class="number">0</span> <span class="special">&gt;(</span> <span class="identifier">dxdt</span> <span class="special">)</span> <span class="special">=</span> <span class="identifier">fusion</span><span class="special">::</span><span class="identifier">at_c</span><span class="special">&lt;</span> <span class="number">1</span> <span class="special">&gt;(</span> <span class="identifier">x</span> <span class="special">);</span>
<span class="identifier">fusion</span><span class="special">::</span><span class="identifier">at_c</span><span class="special">&lt;</span> <span class="number">1</span> <span class="special">&gt;(</span> <span class="identifier">dxdt</span> <span class="special">)</span> <span class="special">=</span> <span class="special">-</span> <span class="identifier">m_omega</span> <span class="special">*</span> <span class="identifier">m_omega</span> <span class="special">*</span> <span class="identifier">fusion</span><span class="special">::</span><span class="identifier">at_c</span><span class="special">&lt;</span> <span class="number">0</span> <span class="special">&gt;(</span> <span class="identifier">x</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
Next, we instantiate an appropriate stepper. We must explicitly parametrize
the stepper with the <code class="computeroutput"><span class="identifier">state_type</span></code>,
<code class="computeroutput"><span class="identifier">deriv_type</span></code>, <code class="computeroutput"><span class="identifier">time_type</span></code>.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">runge_kutta_dopri5</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">deriv_type</span> <span class="special">,</span> <span class="identifier">time_type</span> <span class="special">&gt;</span> <span class="identifier">stepper_type</span><span class="special">;</span>
<span class="identifier">state_type</span> <span class="identifier">x</span><span class="special">(</span> <span class="number">1.0</span> <span class="special">*</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">meter</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">*</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">meter_per_second</span> <span class="special">);</span>
<span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">make_dense_output</span><span class="special">(</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="identifier">stepper_type</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">oscillator</span><span class="special">(</span> <span class="number">2.0</span> <span class="special">*</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">hertz</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">*</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">second</span> <span class="special">,</span> <span class="number">100.0</span> <span class="special">*</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">second</span> <span class="special">,</span> <span class="number">0.1</span> <span class="special">*</span> <span class="identifier">si</span><span class="special">::</span><span class="identifier">second</span> <span class="special">,</span> <span class="identifier">streaming_observer</span><span class="special">(</span> <span class="identifier">cout</span> <span class="special">)</span> <span class="special">);</span>
</pre>
<p>
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
When using compile-time sequences, the iteration over vector elements is
done by the <code class="computeroutput"><span class="identifier">fusion_algebra</span></code>,
which is automatically chosen by odeint. For more on the state types /
algebras see chapter <a class="link" href="../odeint_in_detail/state_types__algebras_and_operations.html" title="State types, algebras and operations">Adapt
your own state types</a>.
</p></td></tr>
</table></div>
<p>
It is quite easy but the compilation time might take very long. Furthermore,
the observer is defined a bit different
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">streaming_observer</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="identifier">m_out</span><span class="special">;</span>
<span class="identifier">streaming_observer</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span> <span class="special">&amp;</span><span class="identifier">out</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_out</span><span class="special">(</span> <span class="identifier">out</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">struct</span> <span class="identifier">write_element</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span> <span class="special">&amp;</span><span class="identifier">m_out</span><span class="special">;</span>
<span class="identifier">write_element</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span> <span class="special">&amp;</span><span class="identifier">out</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">m_out</span><span class="special">(</span> <span class="identifier">out</span> <span class="special">)</span> <span class="special">{</span> <span class="special">};</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="special">&amp;</span><span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">m_out</span> <span class="special">&lt;&lt;</span> <span class="string">"\t"</span> <span class="special">&lt;&lt;</span> <span class="identifier">t</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Time</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Time</span> <span class="special">&amp;</span><span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">m_out</span> <span class="special">&lt;&lt;</span> <span class="identifier">t</span><span class="special">;</span>
<span class="identifier">fusion</span><span class="special">::</span><span class="identifier">for_each</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">write_element</span><span class="special">(</span> <span class="identifier">m_out</span> <span class="special">)</span> <span class="special">);</span>
<span class="identifier">m_out</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<div class="caution"><table border="0" summary="Caution">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="../../../../../../../doc/src/images/caution.png"></td>
<th align="left">Caution</th>
</tr>
<tr><td align="left" valign="top"><p>
Using <a href="http://www.boost.org/doc/libs/release/libs/units/" target="_top">Boost.Units</a>
works nicely but compilation can be very time and memory consuming. For
example the unit test for the usage of <a href="http://www.boost.org/doc/libs/release/libs/units/" target="_top">Boost.Units</a>
in odeint take up to 4 GB of memory at compilation.
</p></td></tr>
</table></div>
<p>
The full cpp file for this example can be found here <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/harmonic_oscillator_units.cpp" target="_top">harmonic_oscillator_units.cpp</a>.
</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 &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="ensembles_of_oscillators.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="using_matrices_as_state_types.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,713 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Using CUDA (or OpenMP, TBB, ...) via Thrust</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="self_expanding_lattices.html" title="Self expanding lattices">
<link rel="next" href="using_opencl_via_vexcl.html" title="Using OpenCL via VexCL">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="self_expanding_lattices.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="using_opencl_via_vexcl.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.using_cuda__or_openmp__tbb_______via_thrust"></a><a class="link" href="using_cuda__or_openmp__tbb_______via_thrust.html" title="Using CUDA (or OpenMP, TBB, ...) via Thrust">Using
CUDA (or OpenMP, TBB, ...) via Thrust</a>
</h3></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="using_cuda__or_openmp__tbb_______via_thrust.html#boost_numeric_odeint.tutorial.using_cuda__or_openmp__tbb_______via_thrust.phase_oscillator_ensemble">Phase
oscillator ensemble</a></span></dt>
<dt><span class="section"><a href="using_cuda__or_openmp__tbb_______via_thrust.html#boost_numeric_odeint.tutorial.using_cuda__or_openmp__tbb_______via_thrust.large_oscillator_chains">Large
oscillator chains</a></span></dt>
<dt><span class="section"><a href="using_cuda__or_openmp__tbb_______via_thrust.html#boost_numeric_odeint.tutorial.using_cuda__or_openmp__tbb_______via_thrust.parameter_studies">Parameter
studies</a></span></dt>
</dl></div>
<p>
Modern graphic cards (graphic processing units - GPUs) can be used to speed
up the performance of time consuming algorithms by means of massive parallelization.
They are designed to execute many operations in parallel. odeint can utilize
the power of GPUs by means of CUDA and <a href="http://code.google.com/p/thrust/" target="_top">Thrust</a>,
which is a STL-like interface for the native CUDA API.
</p>
<div class="important"><table border="0" summary="Important">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../../../../../../doc/src/images/important.png"></td>
<th align="left">Important</th>
</tr>
<tr><td align="left" valign="top"><p>
Thrust also supports parallelization using OpenMP and Intel Threading Building
Blocks (TBB). You can switch between CUDA, OpenMP and TBB parallelizations
by a simple compiler switch. Hence, this also provides an easy way to get
basic OpenMP parallelization into odeint. The examples discussed below
are focused on GPU parallelization, though.
</p></td></tr>
</table></div>
<p>
To use odeint with CUDA a few points have to be taken into account. First
of all, the problem has to be well chosen. It makes absolutely no sense to
try to parallelize the code for a three dimensional system, it is simply
too small and not worth the effort. One single function call (kernel execution)
on the GPU is slow but you can do the operation on a huge set of data with
only one call. We have experienced that the vector size over which is parallelized
should be of the order of <span class="emphasis"><em>10<sup>6</sup></em></span> to make full use of the
GPU. Secondly, you have to use <a href="http://code.google.com/p/thrust/" target="_top">Thrust</a>'s
algorithms and functors when implementing the rhs the ODE. This might be
tricky since it involves some kind of functional programming knowledge.
</p>
<p>
Typical applications for CUDA and odeint are large systems, like lattices
or discretizations of PDE, and parameter studies. We introduce now three
examples which show how the power of GPUs can be used in combination with
odeint.
</p>
<div class="important"><table border="0" summary="Important">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../../../../../../doc/src/images/important.png"></td>
<th align="left">Important</th>
</tr>
<tr><td align="left" valign="top"><p>
The full power of CUDA is only available for really large systems where
the number of coupled ordinary differential equations is of order <span class="emphasis"><em>N=10<sup>6</sup></em></span>
or larger. For smaller systems the CPU is usually much faster. You can
also integrate an ensemble of different uncoupled ODEs in parallel as shown
in the last example.
</p></td></tr>
</table></div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.tutorial.using_cuda__or_openmp__tbb_______via_thrust.phase_oscillator_ensemble"></a><a class="link" href="using_cuda__or_openmp__tbb_______via_thrust.html#boost_numeric_odeint.tutorial.using_cuda__or_openmp__tbb_______via_thrust.phase_oscillator_ensemble" title="Phase oscillator ensemble">Phase
oscillator ensemble</a>
</h4></div></div></div>
<p>
The first example is the phase oscillator ensemble from the previous section:
</p>
<p>
<span class="emphasis"><em>d&#966;<sub>&#8203;k</sub> / dt = &#969;<sub>&#8203;k</sub> + &#949; / N &#931;<sub>&#8203;j</sub> sin( &#966;<sub>&#8203;j</sub> - &#966;<sub>&#8203;k</sub> ).</em></span>
</p>
<p>
It has a phase transition at <span class="emphasis"><em>&#949; = 2</em></span> in the limit of infinite
numbers of oscillators <span class="emphasis"><em>N</em></span>. In the case of finite <span class="emphasis"><em>N</em></span>
this transition is smeared out but still clearly visible.
</p>
<p>
<a href="http://code.google.com/p/thrust/" target="_top">Thrust</a> and CUDA are
perfectly suited for such kinds of problems where one needs a large number
of particles (oscillators). We start by defining the state type which is
a <code class="computeroutput"><span class="identifier">thrust</span><span class="special">::</span><span class="identifier">device_vector</span></code>. The content of this vector
lives on the GPU. If you are not familiar with this we recommend reading
the <span class="emphasis"><em>Getting started</em></span> section on the <a href="http://code.google.com/p/thrust/" target="_top">Thrust</a>
website.
</p>
<p>
</p>
<pre class="programlisting"><span class="comment">//change this to float if your device does not support double computation</span>
<span class="keyword">typedef</span> <span class="keyword">double</span> <span class="identifier">value_type</span><span class="special">;</span>
<span class="comment">//change this to host_vector&lt; ... &gt; of you want to run on CPU</span>
<span class="keyword">typedef</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">device_vector</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
<span class="comment">// typedef thrust::host_vector&lt; value_type &gt; state_type;</span>
</pre>
<p>
</p>
<p>
Thrust follows a functional programming approach. If you want to perform
a calculation on the GPU you usually have to call a global function like
<code class="computeroutput"><span class="identifier">thrust</span><span class="special">::</span><span class="identifier">for_each</span></code>, <code class="computeroutput"><span class="identifier">thrust</span><span class="special">::</span><span class="identifier">reduce</span></code>,
... with an appropriate local functor which performs the basic operation.
An example is
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">add_two</span>
<span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="identifier">__host__</span> <span class="identifier">__device__</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="identifier">T</span> <span class="special">&amp;</span><span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">t</span> <span class="special">+=</span> <span class="identifier">T</span><span class="special">(</span> <span class="number">2</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="comment">// ...</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">for_each</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">add_two</span><span class="special">()</span> <span class="special">);</span>
</pre>
<p>
This code generically adds two to every element in the container <code class="computeroutput"><span class="identifier">x</span></code>.
</p>
<p>
For the purpose of integrating the phase oscillator ensemble we need
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
to calculate the system function, hence the r.h.s. of the ODE.
</li>
<li class="listitem">
this involves computing the mean field of the oscillator example, i.e.
the values of <span class="emphasis"><em>R</em></span> and <span class="emphasis"><em>&#952;</em></span>
</li>
</ul></div>
<p>
The mean field is calculated in a class <code class="computeroutput"><span class="identifier">mean_field_calculator</span></code>
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">mean_field_calculator</span>
<span class="special">{</span>
<span class="keyword">struct</span> <span class="identifier">sin_functor</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">unary_function</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="identifier">__host__</span> <span class="identifier">__device__</span>
<span class="identifier">value_type</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="identifier">value_type</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">sin</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="keyword">struct</span> <span class="identifier">cos_functor</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">unary_function</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="identifier">__host__</span> <span class="identifier">__device__</span>
<span class="identifier">value_type</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="identifier">value_type</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">cos</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="keyword">static</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> <span class="identifier">get_mean</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">value_type</span> <span class="identifier">sin_sum</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">reduce</span><span class="special">(</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_transform_iterator</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">sin_functor</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_transform_iterator</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">sin_functor</span><span class="special">()</span> <span class="special">)</span> <span class="special">);</span>
<span class="identifier">value_type</span> <span class="identifier">cos_sum</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">reduce</span><span class="special">(</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_transform_iterator</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">cos_functor</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_transform_iterator</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">cos_functor</span><span class="special">()</span> <span class="special">)</span> <span class="special">);</span>
<span class="identifier">cos_sum</span> <span class="special">/=</span> <span class="identifier">value_type</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">);</span>
<span class="identifier">sin_sum</span> <span class="special">/=</span> <span class="identifier">value_type</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">);</span>
<span class="identifier">value_type</span> <span class="identifier">K</span> <span class="special">=</span> <span class="identifier">sqrt</span><span class="special">(</span> <span class="identifier">cos_sum</span> <span class="special">*</span> <span class="identifier">cos_sum</span> <span class="special">+</span> <span class="identifier">sin_sum</span> <span class="special">*</span> <span class="identifier">sin_sum</span> <span class="special">);</span>
<span class="identifier">value_type</span> <span class="identifier">Theta</span> <span class="special">=</span> <span class="identifier">atan2</span><span class="special">(</span> <span class="identifier">sin_sum</span> <span class="special">,</span> <span class="identifier">cos_sum</span> <span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">make_pair</span><span class="special">(</span> <span class="identifier">K</span> <span class="special">,</span> <span class="identifier">Theta</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
Inside this class two member structures <code class="computeroutput"><span class="identifier">sin_functor</span></code>
and <code class="computeroutput"><span class="identifier">cos_functor</span></code> are defined.
They compute the sine and the cosine of a value and they are used within
a transform iterator to calculate the sum of <span class="emphasis"><em>sin(&#966;<sub>&#8203;k</sub>)</em></span>
and <span class="emphasis"><em>cos(&#966;<sub>&#8203;k</sub>)</em></span>. The classifiers <code class="computeroutput"><span class="identifier">__host__</span></code>
and <code class="computeroutput"><span class="identifier">__device__</span></code> are CUDA
specific and define a function or operator which can be executed on the
GPU as well as on the CPU. The line
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">value_type</span> <span class="identifier">sin_sum</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">reduce</span><span class="special">(</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_transform_iterator</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">sin_functor</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_transform_iterator</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">sin_functor</span><span class="special">()</span> <span class="special">)</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
performs the calculation of this sine-sum on the GPU (or on the CPU, depending
on your thrust configuration).
</p>
<p>
The system function is defined via
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">phase_oscillator_ensemble</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="keyword">struct</span> <span class="identifier">sys_functor</span>
<span class="special">{</span>
<span class="identifier">value_type</span> <span class="identifier">m_K</span> <span class="special">,</span> <span class="identifier">m_Theta</span> <span class="special">,</span> <span class="identifier">m_epsilon</span><span class="special">;</span>
<span class="identifier">sys_functor</span><span class="special">(</span> <span class="identifier">value_type</span> <span class="identifier">K</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="identifier">Theta</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="identifier">epsilon</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">m_K</span><span class="special">(</span> <span class="identifier">K</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_Theta</span><span class="special">(</span> <span class="identifier">Theta</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_epsilon</span><span class="special">(</span> <span class="identifier">epsilon</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Tuple</span> <span class="special">&gt;</span>
<span class="identifier">__host__</span> <span class="identifier">__device__</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="identifier">Tuple</span> <span class="identifier">t</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span><span class="number">2</span><span class="special">&gt;(</span><span class="identifier">t</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span><span class="number">1</span><span class="special">&gt;(</span><span class="identifier">t</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">m_epsilon</span> <span class="special">*</span> <span class="identifier">m_K</span> <span class="special">*</span> <span class="identifier">sin</span><span class="special">(</span> <span class="identifier">m_Theta</span> <span class="special">-</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span><span class="number">0</span><span class="special">&gt;(</span><span class="identifier">t</span><span class="special">)</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="comment">// ...</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">dt</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> <span class="identifier">mean_field</span> <span class="special">=</span> <span class="identifier">mean_field_calculator</span><span class="special">::</span><span class="identifier">get_mean</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">);</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">for_each</span><span class="special">(</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_zip_iterator</span><span class="special">(</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_tuple</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">m_omega</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">dxdt</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">)</span> <span class="special">),</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_zip_iterator</span><span class="special">(</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_tuple</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">m_omega</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">dxdt</span><span class="special">.</span><span class="identifier">end</span><span class="special">())</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">sys_functor</span><span class="special">(</span> <span class="identifier">mean_field</span><span class="special">.</span><span class="identifier">first</span> <span class="special">,</span> <span class="identifier">mean_field</span><span class="special">.</span><span class="identifier">second</span> <span class="special">,</span> <span class="identifier">m_epsilon</span> <span class="special">)</span>
<span class="special">);</span>
<span class="special">}</span>
<span class="comment">// ...</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
This class is used within the <code class="computeroutput"><span class="identifier">do_step</span></code>
and <code class="computeroutput"><span class="identifier">integrate</span></code> method. It
defines a member structure <code class="computeroutput"><span class="identifier">sys_functor</span></code>
for the r.h.s. of each individual oscillator and the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> for the use in the steppers and integrators
of odeint. The functor computes first the mean field of <span class="emphasis"><em>&#966;<sub>&#8203;k</sub></em></span>
and secondly calculates the whole r.h.s. of the ODE using this mean field.
Note, how nicely <code class="computeroutput"><span class="identifier">thrust</span><span class="special">::</span><span class="identifier">tuple</span></code>
and <code class="computeroutput"><span class="identifier">thrust</span><span class="special">::</span><span class="identifier">zip_iterator</span></code> play together.
</p>
<p>
Now we are ready to put everything together. All we have to do for making
odeint ready for using the GPU is to parametrize the stepper with the
<code class="computeroutput"><span class="identifier">state_type</span></code> and <code class="computeroutput"><span class="identifier">value_type</span></code>:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> <span class="identifier">stepper_type</span><span class="special">;</span>
</pre>
<p>
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
We have specifically define four template parameters because we have
to override the default parameter value <code class="computeroutput"><span class="keyword">double</span></code>
with <code class="computeroutput"><span class="identifier">value_type</span></code> to ensure
our programs runs properly if we use <code class="computeroutput"><span class="keyword">float</span></code>
as fundamental data type.
</p></td></tr>
</table></div>
<p>
You can also use a controlled or dense output stepper, e.g.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">runge_kutta_dopri5</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> <span class="identifier">stepper_type</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
Then, it is straightforward to integrate the phase ensemble by creating
an instance of the rhs class and using an integration function:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">phase_oscillator_ensemble</span> <span class="identifier">ensemble</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">size_t</span> <span class="identifier">steps1</span> <span class="special">=</span> <span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">make_controlled</span><span class="special">(</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="identifier">stepper_type</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span><span class="special">(</span> <span class="identifier">ensemble</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="identifier">t_transients</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
We have to use <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span></code> here in order to pass the rhs class
as reference and not by value. This ensures that the natural frequencies
of each oscillator are not copied when calling <code class="computeroutput"><span class="identifier">integrate_const</span></code>.
In the full example the performance and results of the Runge-Kutta-4 and
the Dopri5 solver are compared.
</p>
<p>
The full example can be found at <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/thrust/phase_oscillator_ensemble.cu" target="_top">phase_oscillator_example.cu</a>.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.tutorial.using_cuda__or_openmp__tbb_______via_thrust.large_oscillator_chains"></a><a class="link" href="using_cuda__or_openmp__tbb_______via_thrust.html#boost_numeric_odeint.tutorial.using_cuda__or_openmp__tbb_______via_thrust.large_oscillator_chains" title="Large oscillator chains">Large
oscillator chains</a>
</h4></div></div></div>
<p>
The next example is a large, one-dimensional chain of nearest-neighbor
coupled phase oscillators with the following equations of motion:
</p>
<p>
<span class="emphasis"><em>d &#966;<sub>&#8203;k</sub> / dt = &#969;<sub>&#8203;k</sub> + sin( &#966;<sub>&#8203;k+1</sub> - &#966;<sub>&#8203;k</sub> ) + sin( &#966;<sub>&#8203;k</sub> - &#966;<sub>&#8203;k-1</sub>)</em></span>
</p>
<p>
In principle we can use all the techniques from the previous phase oscillator
ensemble example, but we have to take special care about the coupling of
the oscillators. To efficiently implement the coupling you can use a very
elegant way employing Thrust's permutation iterator. A permutation iterator
behaves like a normal iterator on a vector but it does not iterate along
the usual order of the elements. It rather iterates along some permutation
of the elements defined by some index map. To realize the nearest neighbor
coupling we create one permutation iterator which travels one step behind
a usual iterator and another permutation iterator which travels one step
in front. The full system class is:
</p>
<p>
</p>
<pre class="programlisting"><span class="comment">//change this to host_vector&lt; ... &gt; if you want to run on CPU</span>
<span class="keyword">typedef</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">device_vector</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">device_vector</span><span class="special">&lt;</span> <span class="identifier">size_t</span> <span class="special">&gt;</span> <span class="identifier">index_vector_type</span><span class="special">;</span>
<span class="comment">//typedef thrust::host_vector&lt; value_type &gt; state_type;</span>
<span class="comment">//typedef thrust::host_vector&lt; size_t &gt; index_vector_type;</span>
<span class="keyword">class</span> <span class="identifier">phase_oscillators</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="keyword">struct</span> <span class="identifier">sys_functor</span>
<span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Tuple</span> <span class="special">&gt;</span>
<span class="identifier">__host__</span> <span class="identifier">__device__</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="identifier">Tuple</span> <span class="identifier">t</span> <span class="special">)</span> <span class="comment">// this functor works on tuples of values</span>
<span class="special">{</span>
<span class="comment">// first, unpack the tuple into value, neighbors and omega</span>
<span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">phi</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span><span class="number">0</span><span class="special">&gt;(</span><span class="identifier">t</span><span class="special">);</span>
<span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">phi_left</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span><span class="number">1</span><span class="special">&gt;(</span><span class="identifier">t</span><span class="special">);</span> <span class="comment">// left neighbor</span>
<span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">phi_right</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span><span class="number">2</span><span class="special">&gt;(</span><span class="identifier">t</span><span class="special">);</span> <span class="comment">// right neighbor</span>
<span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">omega</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span><span class="number">3</span><span class="special">&gt;(</span><span class="identifier">t</span><span class="special">);</span>
<span class="comment">// the dynamical equation</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span><span class="number">4</span><span class="special">&gt;(</span><span class="identifier">t</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">omega</span> <span class="special">+</span> <span class="identifier">sin</span><span class="special">(</span> <span class="identifier">phi_right</span> <span class="special">-</span> <span class="identifier">phi</span> <span class="special">)</span> <span class="special">+</span> <span class="identifier">sin</span><span class="special">(</span> <span class="identifier">phi</span> <span class="special">-</span> <span class="identifier">phi_left</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="identifier">phase_oscillators</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">omega</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">m_omega</span><span class="special">(</span> <span class="identifier">omega</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_N</span><span class="special">(</span> <span class="identifier">omega</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_prev</span><span class="special">(</span> <span class="identifier">omega</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_next</span><span class="special">(</span> <span class="identifier">omega</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">)</span>
<span class="special">{</span>
<span class="comment">// build indices pointing to left and right neighbours</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">counting_iterator</span><span class="special">&lt;</span><span class="identifier">size_t</span><span class="special">&gt;</span> <span class="identifier">c</span><span class="special">(</span> <span class="number">0</span> <span class="special">);</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span> <span class="identifier">c</span> <span class="special">,</span> <span class="identifier">c</span><span class="special">+</span><span class="identifier">m_N</span><span class="special">-</span><span class="number">1</span> <span class="special">,</span> <span class="identifier">m_prev</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()+</span><span class="number">1</span> <span class="special">);</span>
<span class="identifier">m_prev</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="comment">// m_prev = { 0 , 0 , 1 , 2 , 3 , ... , N-1 }</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span> <span class="identifier">c</span><span class="special">+</span><span class="number">1</span> <span class="special">,</span> <span class="identifier">c</span><span class="special">+</span><span class="identifier">m_N</span> <span class="special">,</span> <span class="identifier">m_next</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">);</span>
<span class="identifier">m_next</span><span class="special">[</span><span class="identifier">m_N</span><span class="special">-</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">m_N</span><span class="special">-</span><span class="number">1</span><span class="special">;</span> <span class="comment">// m_next = { 1 , 2 , 3 , ... , N-1 , N-1 }</span>
<span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">dt</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">for_each</span><span class="special">(</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_zip_iterator</span><span class="special">(</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_tuple</span><span class="special">(</span>
<span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_permutation_iterator</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">m_prev</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_permutation_iterator</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">m_next</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">m_omega</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span>
<span class="identifier">dxdt</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span>
<span class="special">)</span> <span class="special">),</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_zip_iterator</span><span class="special">(</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_tuple</span><span class="special">(</span>
<span class="identifier">x</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_permutation_iterator</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">m_prev</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_permutation_iterator</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">m_next</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">m_omega</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span>
<span class="identifier">dxdt</span><span class="special">.</span><span class="identifier">end</span><span class="special">())</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">sys_functor</span><span class="special">()</span>
<span class="special">);</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span>
<span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">m_omega</span><span class="special">;</span>
<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">m_N</span><span class="special">;</span>
<span class="identifier">index_vector_type</span> <span class="identifier">m_prev</span><span class="special">;</span>
<span class="identifier">index_vector_type</span> <span class="identifier">m_next</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
Note, how easy you can obtain the value for the left and right neighboring
oscillator in the system functor using the permutation iterators. But,
the call of the <code class="computeroutput"><span class="identifier">thrust</span><span class="special">::</span><span class="identifier">for_each</span></code>
function looks relatively complicated. Every term of the r.h.s. of the
ODE is resembled by one iterator packed in exactly the same way as it is
unpacked in the functor above.
</p>
<p>
Now we put everything together. We create random initial conditions and
decreasing frequencies such that we should get synchronization. We copy
the frequencies and the initial conditions onto the device and finally
initialize and perform the integration. As result we simply write out the
current state, hence the phase of each oscillator.
</p>
<p>
</p>
<pre class="programlisting"><span class="comment">// create initial conditions and omegas on host:</span>
<span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> <span class="identifier">x_host</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">);</span>
<span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> <span class="identifier">omega_host</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">);</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">N</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">x_host</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="number">2.0</span> <span class="special">*</span> <span class="identifier">pi</span> <span class="special">*</span> <span class="identifier">drand48</span><span class="special">();</span>
<span class="identifier">omega_host</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">N</span> <span class="special">-</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">*</span> <span class="identifier">epsilon</span><span class="special">;</span> <span class="comment">// decreasing frequencies</span>
<span class="special">}</span>
<span class="comment">// copy to device</span>
<span class="identifier">state_type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">x_host</span><span class="special">;</span>
<span class="identifier">state_type</span> <span class="identifier">omega</span> <span class="special">=</span> <span class="identifier">omega_host</span><span class="special">;</span>
<span class="comment">// create stepper</span>
<span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> <span class="identifier">stepper</span><span class="special">;</span>
<span class="comment">// create phase oscillator system function</span>
<span class="identifier">phase_oscillators</span> <span class="identifier">sys</span><span class="special">(</span> <span class="identifier">omega</span> <span class="special">);</span>
<span class="comment">// integrate</span>
<span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">stepper</span> <span class="special">,</span> <span class="identifier">sys</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">dt</span> <span class="special">);</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">,</span> <span class="string">"\n"</span> <span class="special">)</span> <span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
The full example can be found at <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/thrust/phase_oscillator_chain.cu" target="_top">phase_oscillator_chain.cu</a>.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_numeric_odeint.tutorial.using_cuda__or_openmp__tbb_______via_thrust.parameter_studies"></a><a class="link" href="using_cuda__or_openmp__tbb_______via_thrust.html#boost_numeric_odeint.tutorial.using_cuda__or_openmp__tbb_______via_thrust.parameter_studies" title="Parameter studies">Parameter
studies</a>
</h4></div></div></div>
<p>
Another important use case for <a href="http://code.google.com/p/thrust/" target="_top">Thrust</a>
and CUDA are parameter studies of relatively small systems. Consider for
example the three-dimensional Lorenz system from the chaotic systems example
in the previous section which has three parameters. If you want to study
the behavior of this system for different parameters you usually have to
integrate the system for many parameter values. Using thrust and odeint
you can do this integration in parallel, hence you integrate a whole ensemble
of Lorenz systems where each individual realization has a different parameter
value.
</p>
<p>
In the following we will show how you can use <a href="http://code.google.com/p/thrust/" target="_top">Thrust</a>
to integrate the above mentioned ensemble of Lorenz systems. We will vary
only the parameter <span class="emphasis"><em>&#946;</em></span> but it is straightforward to vary
other parameters or even two or all three parameters. Furthermore, we will
use the largest Lyapunov exponent to quantify the behavior of the system
(chaoticity).
</p>
<p>
We start by defining the range of the parameters we want to study. The
state_type is again a <code class="computeroutput"><span class="identifier">thrust</span><span class="special">::</span><span class="identifier">device_vector</span><span class="special">&lt;</span> <span class="identifier">value_type</span>
<span class="special">&gt;</span></code>.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> <span class="identifier">beta_host</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">);</span>
<span class="keyword">const</span> <span class="identifier">value_type</span> <span class="identifier">beta_min</span> <span class="special">=</span> <span class="number">0.0</span> <span class="special">,</span> <span class="identifier">beta_max</span> <span class="special">=</span> <span class="number">56.0</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">N</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
<span class="identifier">beta_host</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">beta_min</span> <span class="special">+</span> <span class="identifier">value_type</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">*</span> <span class="special">(</span> <span class="identifier">beta_max</span> <span class="special">-</span> <span class="identifier">beta_min</span> <span class="special">)</span> <span class="special">/</span> <span class="identifier">value_type</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">-</span> <span class="number">1</span> <span class="special">);</span>
<span class="identifier">state_type</span> <span class="identifier">beta</span> <span class="special">=</span> <span class="identifier">beta_host</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
The next thing we have to implement is the Lorenz system without perturbations.
Later, a system with perturbations is also implemented in order to calculate
the Lyapunov exponent. We will use an ansatz where each device function
calculates one particular realization of the Lorenz ensemble
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">lorenz_system</span>
<span class="special">{</span>
<span class="keyword">struct</span> <span class="identifier">lorenz_functor</span>
<span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="identifier">__host__</span> <span class="identifier">__device__</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="identifier">T</span> <span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="comment">// unpack the parameter we want to vary and the Lorenz variables</span>
<span class="identifier">value_type</span> <span class="identifier">R</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span> <span class="number">3</span> <span class="special">&gt;(</span> <span class="identifier">t</span> <span class="special">);</span>
<span class="identifier">value_type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span> <span class="number">0</span> <span class="special">&gt;(</span> <span class="identifier">t</span> <span class="special">);</span>
<span class="identifier">value_type</span> <span class="identifier">y</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span> <span class="number">1</span> <span class="special">&gt;(</span> <span class="identifier">t</span> <span class="special">);</span>
<span class="identifier">value_type</span> <span class="identifier">z</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span> <span class="number">2</span> <span class="special">&gt;(</span> <span class="identifier">t</span> <span class="special">);</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span> <span class="number">4</span> <span class="special">&gt;(</span> <span class="identifier">t</span> <span class="special">)</span> <span class="special">=</span> <span class="identifier">sigma</span> <span class="special">*</span> <span class="special">(</span> <span class="identifier">y</span> <span class="special">-</span> <span class="identifier">x</span> <span class="special">);</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span> <span class="number">5</span> <span class="special">&gt;(</span> <span class="identifier">t</span> <span class="special">)</span> <span class="special">=</span> <span class="identifier">R</span> <span class="special">*</span> <span class="identifier">x</span> <span class="special">-</span> <span class="identifier">y</span> <span class="special">-</span> <span class="identifier">x</span> <span class="special">*</span> <span class="identifier">z</span><span class="special">;</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span> <span class="number">6</span> <span class="special">&gt;(</span> <span class="identifier">t</span> <span class="special">)</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">b</span> <span class="special">*</span> <span class="identifier">z</span> <span class="special">+</span> <span class="identifier">x</span> <span class="special">*</span> <span class="identifier">y</span> <span class="special">;</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="identifier">lorenz_system</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">,</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">beta</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">m_N</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">m_beta</span><span class="special">(</span> <span class="identifier">beta</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">State</span> <span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Deriv</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">State</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">Deriv</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">for_each</span><span class="special">(</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_zip_iterator</span><span class="special">(</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_tuple</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">+</span> <span class="identifier">m_N</span> <span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">+</span> <span class="number">2</span> <span class="special">*</span> <span class="identifier">m_N</span> <span class="special">,</span>
<span class="identifier">m_beta</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">dxdt</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">dxdt</span> <span class="special">)</span> <span class="special">+</span> <span class="identifier">m_N</span> <span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">dxdt</span> <span class="special">)</span> <span class="special">+</span> <span class="number">2</span> <span class="special">*</span> <span class="identifier">m_N</span> <span class="special">)</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_zip_iterator</span><span class="special">(</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">make_tuple</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">+</span> <span class="identifier">m_N</span> <span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">+</span> <span class="number">2</span> <span class="special">*</span> <span class="identifier">m_N</span> <span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">+</span> <span class="number">3</span> <span class="special">*</span> <span class="identifier">m_N</span> <span class="special">,</span>
<span class="identifier">m_beta</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">dxdt</span> <span class="special">)</span> <span class="special">+</span> <span class="identifier">m_N</span> <span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">dxdt</span> <span class="special">)</span> <span class="special">+</span> <span class="number">2</span> <span class="special">*</span> <span class="identifier">m_N</span> <span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span> <span class="identifier">dxdt</span> <span class="special">)</span> <span class="special">+</span> <span class="number">3</span> <span class="special">*</span> <span class="identifier">m_N</span> <span class="special">)</span> <span class="special">)</span> <span class="special">,</span>
<span class="identifier">lorenz_functor</span><span class="special">()</span> <span class="special">);</span>
<span class="special">}</span>
<span class="identifier">size_t</span> <span class="identifier">m_N</span><span class="special">;</span>
<span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">m_beta</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
As <code class="computeroutput"><span class="identifier">state_type</span></code> a <code class="computeroutput"><span class="identifier">thrust</span><span class="special">::</span><span class="identifier">device_vector</span></code> or a <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>
of a <code class="computeroutput"><span class="identifier">device_vector</span></code> is used.
The length of the state is <span class="emphasis"><em>3N</em></span> where <span class="emphasis"><em>N</em></span>
is the number of systems. The system is encoded into this vector such that
all <span class="emphasis"><em>x</em></span> components come first, then every <span class="emphasis"><em>y</em></span>
components and finally every <span class="emphasis"><em>z</em></span> components. Implementing
the device function is then a simple task, you only have to decompose the
tuple originating from the zip iterators.
</p>
<p>
Besides the system without perturbations we furthermore need to calculate
the system including linearized equations governing the time evolution
of small perturbations. Using the method from above this is straightforward,
with a small difficulty that Thrust's tuples have a maximal arity of 10.
But this is only a small problem since we can create a zip iterator packed
with zip iterators. So the top level zip iterator contains one zip iterator
for the state, one normal iterator for the parameter, and one zip iterator
for the derivative. Accessing the elements of this tuple in the system
function is then straightforward, you unpack the tuple with <code class="computeroutput"><span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;&gt;()</span></code>.
We will not show the code here, it is to large. It can be found <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/thrust/lorenz_parameters.cu" target="_top">here</a> and
is easy to understand.
</p>
<p>
Furthermore, we need an observer which determines the norm of the perturbations,
normalizes them and averages the logarithm of the norm. The device functor
which is used within this observer is defined
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">lyap_functor</span>
<span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="identifier">__host__</span> <span class="identifier">__device__</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="identifier">T</span> <span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">value_type</span> <span class="special">&amp;</span><span class="identifier">dx</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span> <span class="number">0</span> <span class="special">&gt;(</span> <span class="identifier">t</span> <span class="special">);</span>
<span class="identifier">value_type</span> <span class="special">&amp;</span><span class="identifier">dy</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span> <span class="number">1</span> <span class="special">&gt;(</span> <span class="identifier">t</span> <span class="special">);</span>
<span class="identifier">value_type</span> <span class="special">&amp;</span><span class="identifier">dz</span> <span class="special">=</span> <span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span> <span class="number">2</span> <span class="special">&gt;(</span> <span class="identifier">t</span> <span class="special">);</span>
<span class="identifier">value_type</span> <span class="identifier">norm</span> <span class="special">=</span> <span class="identifier">sqrt</span><span class="special">(</span> <span class="identifier">dx</span> <span class="special">*</span> <span class="identifier">dx</span> <span class="special">+</span> <span class="identifier">dy</span> <span class="special">*</span> <span class="identifier">dy</span> <span class="special">+</span> <span class="identifier">dz</span> <span class="special">*</span> <span class="identifier">dz</span> <span class="special">);</span>
<span class="identifier">dx</span> <span class="special">/=</span> <span class="identifier">norm</span><span class="special">;</span>
<span class="identifier">dy</span> <span class="special">/=</span> <span class="identifier">norm</span><span class="special">;</span>
<span class="identifier">dz</span> <span class="special">/=</span> <span class="identifier">norm</span><span class="special">;</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">get</span><span class="special">&lt;</span> <span class="number">3</span> <span class="special">&gt;(</span> <span class="identifier">t</span> <span class="special">)</span> <span class="special">+=</span> <span class="identifier">log</span><span class="special">(</span> <span class="identifier">norm</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
Note, that this functor manipulates the state, i.e. the perturbations.
</p>
<p>
Now we complete the whole code to calculate the Lyapunov exponents. First,
we have to define a state vector. This vector contains <span class="emphasis"><em>6N</em></span>
entries, the state <span class="emphasis"><em>x,y,z</em></span> and its perturbations <span class="emphasis"><em>dx,dy,dz</em></span>.
We initialize them such that <span class="emphasis"><em>x=y=z=10</em></span>, <span class="emphasis"><em>dx=1</em></span>,
and <span class="emphasis"><em>dy=dz=0</em></span>. We define a stepper type, a controlled
Runge-Kutta Dormand-Prince 5 stepper. We start with some integration to
overcome the transient behavior. For this, we do not involve the perturbation
and run the algorithm only on the state <span class="emphasis"><em>x,y,z</em></span> without
any observer. Note, how <a href="http://www.boost.org/doc/libs/release/libs/range/" target="_top">Boost.Range</a>
is used for partial integration of the state vector without perturbations
(the first half of the whole state). After the transient, the full system
with perturbations is integrated and the Lyapunov exponents are calculated
and written to <code class="computeroutput"><span class="identifier">stdout</span></code>.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">state_type</span> <span class="identifier">x</span><span class="special">(</span> <span class="number">6</span> <span class="special">*</span> <span class="identifier">N</span> <span class="special">);</span>
<span class="comment">// initialize x,y,z</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">fill</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="number">3</span> <span class="special">*</span> <span class="identifier">N</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">);</span>
<span class="comment">// initial dx</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">fill</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="number">3</span> <span class="special">*</span> <span class="identifier">N</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="number">4</span> <span class="special">*</span> <span class="identifier">N</span> <span class="special">,</span> <span class="number">1.0</span> <span class="special">);</span>
<span class="comment">// initialize dy,dz</span>
<span class="identifier">thrust</span><span class="special">::</span><span class="identifier">fill</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="number">4</span> <span class="special">*</span> <span class="identifier">N</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">);</span>
<span class="comment">// create error stepper, can be used with make_controlled or make_dense_output</span>
<span class="keyword">typedef</span> <span class="identifier">runge_kutta_dopri5</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">,</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> <span class="identifier">stepper_type</span><span class="special">;</span>
<span class="identifier">lorenz_system</span> <span class="identifier">lorenz</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">,</span> <span class="identifier">beta</span> <span class="special">);</span>
<span class="identifier">lorenz_perturbation_system</span> <span class="identifier">lorenz_perturbation</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">,</span> <span class="identifier">beta</span> <span class="special">);</span>
<span class="identifier">lyap_observer</span> <span class="identifier">obs</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">,</span> <span class="number">1</span> <span class="special">);</span>
<span class="comment">// calculate transients</span>
<span class="identifier">integrate_adaptive</span><span class="special">(</span> <span class="identifier">make_controlled</span><span class="special">(</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="identifier">stepper_type</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">lorenz</span> <span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">make_pair</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="number">3</span> <span class="special">*</span> <span class="identifier">N</span> <span class="special">)</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="number">10.0</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">);</span>
<span class="comment">// calculate the Lyapunov exponents -- the main loop</span>
<span class="keyword">double</span> <span class="identifier">t</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
<span class="keyword">while</span><span class="special">(</span> <span class="identifier">t</span> <span class="special">&lt;</span> <span class="number">10000.0</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">integrate_adaptive</span><span class="special">(</span> <span class="identifier">make_controlled</span><span class="special">(</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="number">1.0e-6</span> <span class="special">,</span> <span class="identifier">stepper_type</span><span class="special">()</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">lorenz_perturbation</span> <span class="special">,</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">+</span> <span class="number">1.0</span> <span class="special">,</span> <span class="number">0.1</span> <span class="special">);</span>
<span class="identifier">t</span> <span class="special">+=</span> <span class="number">1.0</span><span class="special">;</span>
<span class="identifier">obs</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">,</span> <span class="identifier">t</span> <span class="special">);</span>
<span class="special">}</span>
<span class="identifier">vector</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> <span class="identifier">lyap</span><span class="special">(</span> <span class="identifier">N</span> <span class="special">);</span>
<span class="identifier">obs</span><span class="special">.</span><span class="identifier">fill_lyap</span><span class="special">(</span> <span class="identifier">lyap</span> <span class="special">);</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">N</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
<span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">beta_host</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="string">"\t"</span> <span class="special">&lt;&lt;</span> <span class="identifier">lyap</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
The full example can be found at <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/thrust/lorenz_parameters.cu" target="_top">lorenz_parameters.cu</a>.
</p>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="self_expanding_lattices.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="using_opencl_via_vexcl.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,114 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Using matrices as state types</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="using_boost__units.html" title="Using boost::units">
<link rel="next" href="using_arbitrary_precision_floating_point_types.html" title="Using arbitrary precision floating point types">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="using_boost__units.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="using_arbitrary_precision_floating_point_types.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.using_matrices_as_state_types"></a><a class="link" href="using_matrices_as_state_types.html" title="Using matrices as state types">Using
matrices as state types</a>
</h3></div></div></div>
<p>
odeint works well with a variety of different state types. It is not restricted
to pure vector-wise types, like <code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span></code>, <code class="computeroutput"><span class="identifier">array</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="identifier">N</span> <span class="special">&gt;</span></code>,
<code class="computeroutput"><span class="identifier">fusion</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">,</span> <span class="keyword">double</span> <span class="special">&gt;</span></code>,
etc. but also works with types having a different topology then simple vectors.
Here, we show how odeint can be used with matrices as states type, in the
next section we will show how can be used to solve ODEs defined on complex
networks.
</p>
<p>
By default, odeint can be used with <code class="computeroutput"><span class="identifier">ublas</span><span class="special">::</span><span class="identifier">matrix</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span></code> as state type for matrices. A simple
example is a two-dimensional lattice of coupled phase oscillators. Other
matrix types like <code class="computeroutput"><span class="identifier">mtl</span><span class="special">::</span><span class="identifier">dense_matrix</span></code> or blitz arrays and matrices
can used as well but need some kind of activation in order to work with odeint.
This activation is described in following sections,
</p>
<p>
The definition of the system is
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">ublas</span><span class="special">::</span><span class="identifier">matrix</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
<span class="keyword">struct</span> <span class="identifier">two_dimensional_phase_lattice</span>
<span class="special">{</span>
<span class="identifier">two_dimensional_phase_lattice</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">gamma</span> <span class="special">=</span> <span class="number">0.5</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">m_gamma</span><span class="special">(</span> <span class="identifier">gamma</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="comment">/* t */</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">size_t</span> <span class="identifier">size1</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">size1</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">size2</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">size2</span><span class="special">();</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">1</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">size1</span><span class="special">-</span><span class="number">1</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">j</span><span class="special">=</span><span class="number">1</span> <span class="special">;</span> <span class="identifier">j</span><span class="special">&lt;</span><span class="identifier">size2</span><span class="special">-</span><span class="number">1</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">j</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">dxdt</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">,</span> <span class="identifier">j</span> <span class="special">)</span> <span class="special">=</span>
<span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">+</span> <span class="number">1</span> <span class="special">,</span> <span class="identifier">j</span> <span class="special">)</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">,</span> <span class="identifier">j</span> <span class="special">)</span> <span class="special">)</span> <span class="special">+</span>
<span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">-</span> <span class="number">1</span> <span class="special">,</span> <span class="identifier">j</span> <span class="special">)</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">,</span> <span class="identifier">j</span> <span class="special">)</span> <span class="special">)</span> <span class="special">+</span>
<span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">,</span> <span class="identifier">j</span> <span class="special">+</span> <span class="number">1</span> <span class="special">)</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">,</span> <span class="identifier">j</span> <span class="special">)</span> <span class="special">)</span> <span class="special">+</span>
<span class="identifier">coupling_func</span><span class="special">(</span> <span class="identifier">x</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">,</span> <span class="identifier">j</span> <span class="special">-</span> <span class="number">1</span> <span class="special">)</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">,</span> <span class="identifier">j</span> <span class="special">)</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">size1</span><span class="special">()</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span> <span class="identifier">dxdt</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">,</span> <span class="number">0</span> <span class="special">)</span> <span class="special">=</span> <span class="identifier">dxdt</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">size2</span><span class="special">()</span> <span class="special">-</span><span class="number">1</span> <span class="special">)</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">j</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">j</span><span class="special">&lt;</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">size2</span><span class="special">()</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">j</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="identifier">j</span> <span class="special">)</span> <span class="special">=</span> <span class="identifier">dxdt</span><span class="special">(</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">size1</span><span class="special">()</span> <span class="special">-</span><span class="number">1</span> <span class="special">,</span> <span class="identifier">j</span> <span class="special">)</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">double</span> <span class="identifier">coupling_func</span><span class="special">(</span> <span class="keyword">double</span> <span class="identifier">x</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">sin</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">-</span> <span class="identifier">m_gamma</span> <span class="special">*</span> <span class="special">(</span> <span class="number">1.0</span> <span class="special">-</span> <span class="identifier">cos</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="special">);</span>
<span class="special">}</span>
<span class="keyword">double</span> <span class="identifier">m_gamma</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
In principle this is all. Please note, that the above code is far from being
optimal. Better performance can be achieved if every interaction is only
calculated once and iterators for columns and rows are used. Below are some
visualizations of the evolution of this lattice equation.
</p>
<p>
<span class="inlinemediaobject"><img src="../../phase_lattice_2d_0000.jpg" alt="phase_lattice_2d_0000"></span> <span class="inlinemediaobject"><img src="../../phase_lattice_2d_0100.jpg" alt="phase_lattice_2d_0100"></span> <span class="inlinemediaobject"><img src="../../phase_lattice_2d_1000.jpg" alt="phase_lattice_2d_1000"></span>
</p>
<p>
The full cpp for this example can be found here <a href="https://github.com/headmyshoulder/odeint-v2/blob/master/examples/two_dimensional_phase_lattice.cpp" target="_top">two_dimensional_phase_lattice.cpp</a>.
</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 &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="using_boost__units.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="using_arbitrary_precision_floating_point_types.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,177 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Using OpenCL via VexCL</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Numeric.Odeint">
<link rel="up" href="../tutorial.html" title="Tutorial">
<link rel="prev" href="using_cuda__or_openmp__tbb_______via_thrust.html" title="Using CUDA (or OpenMP, TBB, ...) via Thrust">
<link rel="next" href="parallel_computation_with_openmp_and_mpi.html" title="Parallel computation with OpenMP and MPI">
</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="../../logo.jpg"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="using_cuda__or_openmp__tbb_______via_thrust.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="parallel_computation_with_openmp_and_mpi.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="boost_numeric_odeint.tutorial.using_opencl_via_vexcl"></a><a class="link" href="using_opencl_via_vexcl.html" title="Using OpenCL via VexCL">Using
OpenCL via VexCL</a>
</h3></div></div></div>
<p>
In the previous section the usage of odeint in combination with <a href="http://code.google.com/p/thrust/" target="_top">Thrust</a>
was shown. In this section we show how one can use OpenCL with odeint. The
point of odeint is not to implement its own low-level data structures and
algorithms, but to use high level libraries doing this task. Here, we will
use the <a href="https://github.com/ddemidov/vexcl" target="_top">VexCL</a> framework
to use OpenCL. <a href="https://github.com/ddemidov/vexcl" target="_top">VexCL</a>
is a nice library for general computations and it uses heavily expression
templates. With the help of <a href="https://github.com/ddemidov/vexcl" target="_top">VexCL</a>
it is possible to write very compact and expressive application.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
vexcl needs C++11 features! So you have to compile with C++11 support enabled.
</p></td></tr>
</table></div>
<p>
To use <a href="https://github.com/ddemidov/vexcl" target="_top">VexCL</a> one needs
to include one additional header which includes the data-types and algorithms
from vexcl and the adaption to odeint. Adaption to odeint means here only
to adapt the resizing functionality of <a href="https://github.com/ddemidov/vexcl" target="_top">VexCL</a>
to odeint.
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">numeric</span><span class="special">/</span><span class="identifier">odeint</span><span class="special">/</span><span class="identifier">external</span><span class="special">/</span><span class="identifier">vexcl</span><span class="special">/</span><span class="identifier">vexcl</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
</p>
<p>
To demonstrate the use of <a href="https://github.com/ddemidov/vexcl" target="_top">VexCL</a>
we integrate an ensemble of Lorenz system. The example is very similar to
the parameter study of the Lorenz system in the previous section except that
we do not compute the Lyapunov exponents. Again, we vary the parameter R
of the Lorenz system an solve a whole ensemble of Lorenz systems in parallel
(each with a different parameter R). First, we define the state type and
a vector type
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">vex</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span> <span class="keyword">double</span> <span class="special">&gt;</span> <span class="identifier">vector_type</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">vex</span><span class="special">::</span><span class="identifier">multivector</span><span class="special">&lt;</span> <span class="keyword">double</span><span class="special">,</span> <span class="number">3</span> <span class="special">&gt;</span> <span class="identifier">state_type</span><span class="special">;</span>
</pre>
<p>
</p>
<p>
The <code class="computeroutput"><span class="identifier">vector_type</span></code> is used to
represent the parameter R. The <code class="computeroutput"><span class="identifier">state_type</span></code>
is a multi-vector of three sub vectors and is used to represent. The first
component of this multi-vector represent all <code class="computeroutput"><span class="identifier">x</span></code>
components of the Lorenz system, while the second all <code class="computeroutput"><span class="identifier">y</span></code>
components and the third all <code class="computeroutput"><span class="identifier">z</span></code>
components. The components of this vector can be obtained via
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">auto</span> <span class="special">&amp;</span><span class="identifier">x</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="keyword">auto</span> <span class="special">&amp;</span><span class="identifier">y</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="keyword">auto</span> <span class="special">&amp;</span><span class="identifier">z</span> <span class="special">=</span> <span class="identifier">X</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
</pre>
<p>
</p>
<p>
As already mentioned <a href="https://github.com/ddemidov/vexcl" target="_top">VexCL</a>
supports expression templates and we will use them to implement the system
function for the Lorenz ensemble:
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">sigma</span> <span class="special">=</span> <span class="number">10.0</span><span class="special">;</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">8.0</span> <span class="special">/</span> <span class="number">3.0</span><span class="special">;</span>
<span class="keyword">struct</span> <span class="identifier">sys_func</span>
<span class="special">{</span>
<span class="keyword">const</span> <span class="identifier">vector_type</span> <span class="special">&amp;</span><span class="identifier">R</span><span class="special">;</span>
<span class="identifier">sys_func</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">vector_type</span> <span class="special">&amp;</span><span class="identifier">_R</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">R</span><span class="special">(</span> <span class="identifier">_R</span> <span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">const</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">x</span> <span class="special">,</span> <span class="identifier">state_type</span> <span class="special">&amp;</span><span class="identifier">dxdt</span> <span class="special">,</span> <span class="keyword">double</span> <span class="identifier">t</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">dxdt</span><span class="special">(</span><span class="number">0</span><span class="special">)</span> <span class="special">=</span> <span class="special">-</span><span class="identifier">sigma</span> <span class="special">*</span> <span class="special">(</span> <span class="identifier">x</span><span class="special">(</span><span class="number">0</span><span class="special">)</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">);</span>
<span class="identifier">dxdt</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">R</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">(</span><span class="number">0</span><span class="special">)</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">(</span><span class="number">0</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
<span class="identifier">dxdt</span><span class="special">(</span><span class="number">2</span><span class="special">)</span> <span class="special">=</span> <span class="special">-</span> <span class="identifier">b</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">(</span><span class="number">2</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">x</span><span class="special">(</span><span class="number">0</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
</p>
<p>
It's very easy, isn't it? These three little lines do all the computations
for you. There is no need to write your own OpenCL kernels. <a href="https://github.com/ddemidov/vexcl" target="_top">VexCL</a>
does everything for you. Next we have to write the main application. We initialize
the vector of parameters (R) and the initial state. Note that <a href="https://github.com/ddemidov/vexcl" target="_top">VexCL</a>
requires the <code class="computeroutput"><span class="identifier">vector_space_algebra</span></code>,
but that is automatically deduced and configured by odeint internally, so
we only have to specify the <code class="computeroutput"><span class="identifier">state_type</span></code>
when instantiating the stepper and we are done:
</p>
<p>
</p>
<pre class="programlisting"><span class="comment">// setup the opencl context</span>
<span class="identifier">vex</span><span class="special">::</span><span class="identifier">Context</span> <span class="identifier">ctx</span><span class="special">(</span> <span class="identifier">vex</span><span class="special">::</span><span class="identifier">Filter</span><span class="special">::</span><span class="identifier">Type</span><span class="special">(</span><span class="identifier">CL_DEVICE_TYPE_GPU</span><span class="special">)</span> <span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">ctx</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="comment">// set up number of system, time step and integration time</span>
<span class="keyword">const</span> <span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="number">1024</span> <span class="special">*</span> <span class="number">1024</span><span class="special">;</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">dt</span> <span class="special">=</span> <span class="number">0.01</span><span class="special">;</span>
<span class="keyword">const</span> <span class="keyword">double</span> <span class="identifier">t_max</span> <span class="special">=</span> <span class="number">1000.0</span><span class="special">;</span>
<span class="comment">// initialize R</span>
<span class="keyword">double</span> <span class="identifier">Rmin</span> <span class="special">=</span> <span class="number">0.1</span> <span class="special">,</span> <span class="identifier">Rmax</span> <span class="special">=</span> <span class="number">50.0</span> <span class="special">,</span> <span class="identifier">dR</span> <span class="special">=</span> <span class="special">(</span> <span class="identifier">Rmax</span> <span class="special">-</span> <span class="identifier">Rmin</span> <span class="special">)</span> <span class="special">/</span> <span class="keyword">double</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">-</span> <span class="number">1</span> <span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">x</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">*</span> <span class="number">3</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">r</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">);</span>
<span class="keyword">for</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span><span class="special">=</span><span class="number">0</span> <span class="special">;</span> <span class="identifier">i</span><span class="special">&lt;</span><span class="identifier">n</span> <span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span> <span class="identifier">r</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">Rmin</span> <span class="special">+</span> <span class="identifier">dR</span> <span class="special">*</span> <span class="keyword">double</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">);</span>
<span class="identifier">vector_type</span> <span class="identifier">R</span><span class="special">(</span> <span class="identifier">ctx</span><span class="special">.</span><span class="identifier">queue</span><span class="special">()</span> <span class="special">,</span> <span class="identifier">r</span> <span class="special">);</span>
<span class="comment">// initialize the state of the lorenz ensemble</span>
<span class="identifier">state_type</span> <span class="identifier">X</span><span class="special">(</span><span class="identifier">ctx</span><span class="special">.</span><span class="identifier">queue</span><span class="special">(),</span> <span class="identifier">n</span><span class="special">);</span>
<span class="identifier">X</span><span class="special">(</span><span class="number">0</span><span class="special">)</span> <span class="special">=</span> <span class="number">10.0</span><span class="special">;</span>
<span class="identifier">X</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">=</span> <span class="number">10.0</span><span class="special">;</span>
<span class="identifier">X</span><span class="special">(</span><span class="number">2</span><span class="special">)</span> <span class="special">=</span> <span class="number">10.0</span><span class="special">;</span>
<span class="comment">// create a stepper</span>
<span class="identifier">runge_kutta4</span><span class="special">&lt;</span> <span class="identifier">state_type</span> <span class="special">&gt;</span> <span class="identifier">stepper</span><span class="special">;</span>
<span class="comment">// solve the system</span>
<span class="identifier">integrate_const</span><span class="special">(</span> <span class="identifier">stepper</span> <span class="special">,</span> <span class="identifier">sys_func</span><span class="special">(</span> <span class="identifier">R</span> <span class="special">)</span> <span class="special">,</span> <span class="identifier">X</span> <span class="special">,</span> <span class="number">0.0</span> <span class="special">,</span> <span class="identifier">t_max</span> <span class="special">,</span> <span class="identifier">dt</span> <span class="special">);</span>
</pre>
<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 &#169; 2009-2015 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 <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="using_cuda__or_openmp__tbb_______via_thrust.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tutorial.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="parallel_computation_with_openmp_and_mpi.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>