w4kek/WSJT-X
1
0
Fork 0
mirror of https://github.com/saitohirga/WSJT-X.git synced 2026-06-04 23:14:57 -04:00
Code Issues Packages Projects Releases Wiki Activity

Squashed 'boost/' content from commit b4feb19f2

Browse Source 
git-subtree-dir: boost
git-subtree-split: b4feb19f287ee92d87a9624b5d36b7cf46aeadeb
This commit is contained in:
Bill Somerville
2018-06-09 21:48:32 +01:00
commit 4ebe6417a5
12444 changed files with 2327021 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libs/math/doc/html/math_toolkit/ellint/ellint_1.html
+268
View File
@@ -0,0 +1,268 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Elliptic Integrals of the First Kind - Legendre Form</title>
<link rel="stylesheet" href="../../math.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Math Toolkit 2.5.1">
<link rel="up" href="../ellint.html" title="Elliptic Integrals">
<link rel="prev" href="ellint_carlson.html" title="Elliptic Integrals - Carlson Form">
<link rel="next" href="ellint_2.html" title="Elliptic Integrals of the Second Kind - Legendre Form">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><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="ellint_carlson.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ellint.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="ellint_2.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="math_toolkit.ellint.ellint_1"></a><a class="link" href="ellint_1.html" title="Elliptic Integrals of the First Kind - Legendre Form">Elliptic Integrals of the
First Kind - Legendre Form</a>
</h3></div></div></div>
<h5>
<a name="math_toolkit.ellint.ellint_1.h0"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_1.synopsis"></a></span><a class="link" href="ellint_1.html#math_toolkit.ellint.ellint_1.synopsis">Synopsis</a>
</h5>
<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">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">ellint_1</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<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">math</span> <span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_1</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_1</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</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>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_1</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">k</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">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_1</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<h5>
<a name="math_toolkit.ellint.ellint_1.h1"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_1.description"></a></span><a class="link" href="ellint_1.html#math_toolkit.ellint.ellint_1.description">Description</a>
</h5>
<p>
These two functions evaluate the incomplete elliptic integral of the first
kind <span class="emphasis"><em>F(&#966;, k)</em></span> and its complete counterpart <span class="emphasis"><em>K(k)
= F(&#960;/2, k)</em></span>.
</p>
<p>
<span class="inlinemediaobject"><img src="../../../graphs/ellint_1.svg" align="middle"></span>
</p>
<p>
The return type of these functions is computed using the <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>result
type calculation rules</em></span></a> when T1 and T2 are different types:
when they are the same type then the result is the same type as the arguments.
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_1</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_1</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the incomplete elliptic integral of the first kind <span class="emphasis"><em>F(&#966;,
k)</em></span>:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint2.svg"></span>
</p>
<p>
Requires -1 &lt;= k &lt;= 1, otherwise returns the result of <a class="link" href="../error_handling.html#math_toolkit.error_handling.domain_error">domain_error</a>.
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can
be used to control the behaviour of the function: how it handles errors,
what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">policy
documentation for more details</a>.
</p>
<pre class="programlisting"><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>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_1</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">k</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>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_1</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the complete elliptic integral of the first kind <span class="emphasis"><em>K(k)</em></span>:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint6.svg"></span>
</p>
<p>
Requires -1 &lt;= k &lt;= 1, otherwise returns the result of <a class="link" href="../error_handling.html#math_toolkit.error_handling.domain_error">domain_error</a>.
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can
be used to control the behaviour of the function: how it handles errors,
what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">policy
documentation for more details</a>.
</p>
<h5>
<a name="math_toolkit.ellint.ellint_1.h2"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_1.accuracy"></a></span><a class="link" href="ellint_1.html#math_toolkit.ellint.ellint_1.accuracy">Accuracy</a>
</h5>
<p>
These functions are computed using only basic arithmetic operations, so there
isn't much variation in accuracy over differing platforms. Note that only
results for the widest floating point type on the system are given as narrower
types have <a class="link" href="../relative_error.html#math_toolkit.relative_error.zero_error">effectively
zero error</a>. All values are relative errors in units of epsilon.
</p>
<div class="table">
<a name="math_toolkit.ellint.ellint_1.table_ellint_1"></a><p class="title"><b>Table&#160;6.63.&#160;Error rates for ellint_1</b></p>
<div class="table-contents"><table class="table" summary="Error rates for ellint_1">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
</th>
<th>
<p>
Microsoft Visual C++ version 12.0<br> Win32<br> double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> long double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> double
</p>
</th>
<th>
<p>
Sun compiler version 0x5130<br> Sun Solaris<br> long double
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Elliptic Integral F: Mathworld Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.919&#949; (Mean = 0.542&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.94&#949; (Mean = 0.509&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> <span class="red">Max
= +INF&#949; (Mean = +INF&#949;) <a class="link" href="../logs_and_tables/logs.html#errors_GNU_C_version_5_1_0_linux_long_double_ellint_1__tr1_cmath__Elliptic_Integral_F_Mathworld_Data">And
other failures.</a>)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span><br> <br> (<span class="emphasis"><em>GSL
1.16:</em></span> Max = 0.919&#949; (Mean = 0.544&#949;))<br> (<span class="emphasis"><em>Cephes:</em></span>
<span class="red">Max = +INF&#949; (Mean = +INF&#949;) <a class="link" href="../logs_and_tables/logs.html#errors_GNU_C_version_5_1_0_linux_double_ellint_1_Cephes_Elliptic_Integral_F_Mathworld_Data">And
other failures.</a>)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.94&#949; (Mean = 0.509&#949;)</span>
</p>
</td>
</tr>
<tr>
<td>
<p>
Elliptic Integral F: Random Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.26&#949; (Mean = 0.631&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.57&#949; (Mean = 0.56&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> Max = 2.56&#949; (Mean = 0.816&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span><br> <br> (<span class="emphasis"><em>GSL
1.16:</em></span> Max = 2.99&#949; (Mean = 0.797&#949;))<br> (<span class="emphasis"><em>Cephes:</em></span>
Max = 2.18&#949; (Mean = 0.535&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.57&#949; (Mean = 0.561&#949;)</span>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><h5>
<a name="math_toolkit.ellint.ellint_1.h3"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_1.testing"></a></span><a class="link" href="ellint_1.html#math_toolkit.ellint.ellint_1.testing">Testing</a>
</h5>
<p>
The tests use a mixture of spot test values calculated using the online calculator
at <a href="http://functions.wolfram.com/" target="_top">functions.wolfram.com</a>,
and random test data generated using NTL::RR at 1000-bit precision and this
implementation.
</p>
<h5>
<a name="math_toolkit.ellint.ellint_1.h4"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_1.implementation"></a></span><a class="link" href="ellint_1.html#math_toolkit.ellint.ellint_1.implementation">Implementation</a>
</h5>
<p>
These functions are implemented in terms of Carlson's integrals using the
relations:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint19.svg"></span>
</p>
<p>
and
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint20.svg"></span>
</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; 2006-2010, 2012-2014 Nikhar Agrawal,
Anton Bikineev, Paul A. Bristow, Marco Guazzone, Christopher Kormanyos, Hubert
Holin, Bruno Lalande, John Maddock, Jeremy Murphy, Johan R&#229;de, Gautam Sewani,
Benjamin Sobotta, Thijs van den Berg, Daryle Walker and Xiaogang Zhang<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="ellint_carlson.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ellint.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="ellint_2.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
libs/math/doc/html/math_toolkit/ellint/ellint_2.html
+269
View File
@@ -0,0 +1,269 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Elliptic Integrals of the Second Kind - Legendre Form</title>
<link rel="stylesheet" href="../../math.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Math Toolkit 2.5.1">
<link rel="up" href="../ellint.html" title="Elliptic Integrals">
<link rel="prev" href="ellint_1.html" title="Elliptic Integrals of the First Kind - Legendre Form">
<link rel="next" href="ellint_3.html" title="Elliptic Integrals of the Third Kind - Legendre Form">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><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="ellint_1.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ellint.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="ellint_3.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="math_toolkit.ellint.ellint_2"></a><a class="link" href="ellint_2.html" title="Elliptic Integrals of the Second Kind - Legendre Form">Elliptic Integrals of the
Second Kind - Legendre Form</a>
</h3></div></div></div>
<h5>
<a name="math_toolkit.ellint.ellint_2.h0"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_2.synopsis"></a></span><a class="link" href="ellint_2.html#math_toolkit.ellint.ellint_2.synopsis">Synopsis</a>
</h5>
<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">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">ellint_2</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<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">math</span> <span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_2</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_2</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</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>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_2</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">k</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">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_2</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<h5>
<a name="math_toolkit.ellint.ellint_2.h1"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_2.description"></a></span><a class="link" href="ellint_2.html#math_toolkit.ellint.ellint_2.description">Description</a>
</h5>
<p>
These two functions evaluate the incomplete elliptic integral of the second
kind <span class="emphasis"><em>E(&#966;, k)</em></span> and its complete counterpart <span class="emphasis"><em>E(k)
= E(&#960;/2, k)</em></span>.
</p>
<p>
<span class="inlinemediaobject"><img src="../../../graphs/ellint_2.svg" align="middle"></span>
</p>
<p>
The return type of these functions is computed using the <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>result
type calculation rules</em></span></a> when T1 and T2 are different types:
when they are the same type then the result is the same type as the arguments.
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_2</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_2</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the incomplete elliptic integral of the second kind <span class="emphasis"><em>E(&#966;,
k)</em></span>:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint3.svg"></span>
</p>
<p>
Requires -1 &lt;= k &lt;= 1, otherwise returns the result of <a class="link" href="../error_handling.html#math_toolkit.error_handling.domain_error">domain_error</a>.
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can
be used to control the behaviour of the function: how it handles errors,
what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">policy
documentation for more details</a>.
</p>
<pre class="programlisting"><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>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_2</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">k</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>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_2</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the complete elliptic integral of the second kind <span class="emphasis"><em>E(k)</em></span>:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint7.svg"></span>
</p>
<p>
Requires -1 &lt;= k &lt;= 1, otherwise returns the result of <a class="link" href="../error_handling.html#math_toolkit.error_handling.domain_error">domain_error</a>.
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can
be used to control the behaviour of the function: how it handles errors,
what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">policy
documentation for more details</a>.
</p>
<h5>
<a name="math_toolkit.ellint.ellint_2.h2"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_2.accuracy"></a></span><a class="link" href="ellint_2.html#math_toolkit.ellint.ellint_2.accuracy">Accuracy</a>
</h5>
<p>
These functions are computed using only basic arithmetic operations, so there
isn't much variation in accuracy over differing platforms. Note that only
results for the widest floating point type on the system are given as narrower
types have <a class="link" href="../relative_error.html#math_toolkit.relative_error.zero_error">effectively
zero error</a>. All values are relative errors in units of epsilon.
</p>
<div class="table">
<a name="math_toolkit.ellint.ellint_2.table_ellint_2"></a><p class="title"><b>Table&#160;6.64.&#160;Error rates for ellint_2</b></p>
<div class="table-contents"><table class="table" summary="Error rates for ellint_2">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
</th>
<th>
<p>
Microsoft Visual C++ version 12.0<br> Win32<br> double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> long double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> double
</p>
</th>
<th>
<p>
Sun compiler version 0x5130<br> Sun Solaris<br> long double
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Elliptic Integral E: Mathworld Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.31&#949; (Mean = 0.727&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.656&#949; (Mean = 0.317&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> <span class="red">Max
= +INF&#949; (Mean = +INF&#949;) <a class="link" href="../logs_and_tables/logs.html#errors_GNU_C_version_5_1_0_linux_long_double_ellint_2__tr1_cmath__Elliptic_Integral_E_Mathworld_Data">And
other failures.</a>)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span><br> <br> (<span class="emphasis"><em>GSL
1.16:</em></span> Max = 0.63&#949; (Mean = 0.325&#949;))<br> (<span class="emphasis"><em>Cephes:</em></span>
<span class="red">Max = +INF&#949; (Mean = +INF&#949;) <a class="link" href="../logs_and_tables/logs.html#errors_GNU_C_version_5_1_0_linux_double_ellint_2_Cephes_Elliptic_Integral_E_Mathworld_Data">And
other failures.</a>)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.656&#949; (Mean = 0.317&#949;)</span>
</p>
</td>
</tr>
<tr>
<td>
<p>
Elliptic Integral E: Random Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.23&#949; (Mean = 0.639&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.05&#949; (Mean = 0.632&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> Max = 3.08e+04&#949; (Mean =
3.84e+03&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span><br> <br> (<span class="emphasis"><em>GSL
1.16:</em></span> Max = 4.4&#949; (Mean = 1.16&#949;))<br> (<span class="emphasis"><em>Cephes:</em></span>
Max = 8.92&#949; (Mean = 1.48&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.05&#949; (Mean = 0.632&#949;)</span>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><h5>
<a name="math_toolkit.ellint.ellint_2.h3"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_2.testing"></a></span><a class="link" href="ellint_2.html#math_toolkit.ellint.ellint_2.testing">Testing</a>
</h5>
<p>
The tests use a mixture of spot test values calculated using the online calculator
at <a href="http://functions.wolfram.com" target="_top">functions.wolfram.com</a>,
and random test data generated using NTL::RR at 1000-bit precision and this
implementation.
</p>
<h5>
<a name="math_toolkit.ellint.ellint_2.h4"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_2.implementation"></a></span><a class="link" href="ellint_2.html#math_toolkit.ellint.ellint_2.implementation">Implementation</a>
</h5>
<p>
These functions are implemented in terms of Carlson's integrals using the
relations:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint21.svg"></span>
</p>
<p>
and
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint22.svg"></span>
</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; 2006-2010, 2012-2014 Nikhar Agrawal,
Anton Bikineev, Paul A. Bristow, Marco Guazzone, Christopher Kormanyos, Hubert
Holin, Bruno Lalande, John Maddock, Jeremy Murphy, Johan R&#229;de, Gautam Sewani,
Benjamin Sobotta, Thijs van den Berg, Daryle Walker and Xiaogang Zhang<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="ellint_1.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ellint.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="ellint_3.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
libs/math/doc/html/math_toolkit/ellint/ellint_3.html
+352
View File
@@ -0,0 +1,352 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Elliptic Integrals of the Third Kind - Legendre Form</title>
<link rel="stylesheet" href="../../math.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Math Toolkit 2.5.1">
<link rel="up" href="../ellint.html" title="Elliptic Integrals">
<link rel="prev" href="ellint_2.html" title="Elliptic Integrals of the Second Kind - Legendre Form">
<link rel="next" href="ellint_d.html" title="Elliptic Integral D - Legendre Form">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><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="ellint_2.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ellint.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="ellint_d.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="math_toolkit.ellint.ellint_3"></a><a class="link" href="ellint_3.html" title="Elliptic Integrals of the Third Kind - Legendre Form">Elliptic Integrals of the
Third Kind - Legendre Form</a>
</h3></div></div></div>
<h5>
<a name="math_toolkit.ellint.ellint_3.h0"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_3.synopsis"></a></span><a class="link" href="ellint_3.html#math_toolkit.ellint.ellint_3.synopsis">Synopsis</a>
</h5>
<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">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">ellint_3</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<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">math</span> <span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_3</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_3</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">phi</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_3</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">n</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_3</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<h5>
<a name="math_toolkit.ellint.ellint_3.h1"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_3.description"></a></span><a class="link" href="ellint_3.html#math_toolkit.ellint.ellint_3.description">Description</a>
</h5>
<p>
These two functions evaluate the incomplete elliptic integral of the third
kind <span class="emphasis"><em>&#928;(n, &#966;, k)</em></span> and its complete counterpart <span class="emphasis"><em>&#928;(n,
k) = E(n, &#960;/2, k)</em></span>.
</p>
<p>
<span class="inlinemediaobject"><img src="../../../graphs/ellint_3.svg" align="middle"></span>
</p>
<p>
The return type of these functions is computed using the <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>result
type calculation rules</em></span></a> when the arguments are of different
types: when they are the same type then the result is the same type as the
arguments.
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_3</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T3</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_3</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">phi</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the incomplete elliptic integral of the third kind <span class="emphasis"><em>&#928;(n,
&#966;, k)</em></span>:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint4.svg"></span>
</p>
<p>
Requires <span class="emphasis"><em>-1 &lt;= k &lt;= 1</em></span> and <span class="emphasis"><em>n &lt; 1/sin<sup>2</sup>(&#966;)</em></span>,
otherwise returns the result of <a class="link" href="../error_handling.html#math_toolkit.error_handling.domain_error">domain_error</a>
(outside this range the result would be complex).
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can
be used to control the behaviour of the function: how it handles errors,
what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">policy
documentation for more details</a>.
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_3</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">n</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_3</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the complete elliptic integral of the first kind <span class="emphasis"><em>&#928;(n, k)</em></span>:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint8.svg"></span>
</p>
<p>
Requires <span class="emphasis"><em>-1 &lt;= k &lt;= 1</em></span> and <span class="emphasis"><em>n &lt; 1</em></span>,
otherwise returns the result of <a class="link" href="../error_handling.html#math_toolkit.error_handling.domain_error">domain_error</a>
(outside this range the result would be complex).
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can
be used to control the behaviour of the function: how it handles errors,
what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">policy
documentation for more details</a>.
</p>
<h5>
<a name="math_toolkit.ellint.ellint_3.h2"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_3.accuracy"></a></span><a class="link" href="ellint_3.html#math_toolkit.ellint.ellint_3.accuracy">Accuracy</a>
</h5>
<p>
These functions are computed using only basic arithmetic operations, so there
isn't much variation in accuracy over differing platforms. Note that only
results for the widest floating point type on the system are given as narrower
types have <a class="link" href="../relative_error.html#math_toolkit.relative_error.zero_error">effectively
zero error</a>. All values are relative errors in units of epsilon.
</p>
<div class="table">
<a name="math_toolkit.ellint.ellint_3.table_ellint_3"></a><p class="title"><b>Table&#160;6.65.&#160;Error rates for ellint_3</b></p>
<div class="table-contents"><table class="table" summary="Error rates for ellint_3">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
</th>
<th>
<p>
Microsoft Visual C++ version 12.0<br> Win32<br> double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> long double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> double
</p>
</th>
<th>
<p>
Sun compiler version 0x5130<br> Sun Solaris<br> long double
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Elliptic Integral PI: Mathworld Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 565&#949; (Mean = 102&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 475&#949; (Mean = 86.3&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> <span class="red">Max
= +INF&#949; (Mean = +INF&#949;) <a class="link" href="../logs_and_tables/logs.html#errors_GNU_C_version_5_1_0_linux_long_double_ellint_3__tr1_cmath__Elliptic_Integral_PI_Mathworld_Data">And
other failures.</a>)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span><br> <br> (<span class="emphasis"><em>GSL
1.16:</em></span> Max = 1.48e+05&#949; (Mean = 2.54e+04&#949;) <a class="link" href="../logs_and_tables/logs.html#errors_GNU_C_version_5_1_0_linux_double_ellint_3_GSL_1_16_Elliptic_Integral_PI_Mathworld_Data">And
other failures.</a>)
</p>
</td>
<td>
<p>
<span class="blue">Max = 475&#949; (Mean = 86.3&#949;)</span>
</p>
</td>
</tr>
<tr>
<td>
<p>
Elliptic Integral PI: Random Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 9.08&#949; (Mean = 0.99&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 4.54&#949; (Mean = 0.895&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> <span class="red">Max
= 3.37e+20&#949; (Mean = 3.47e+19&#949;) <a class="link" href="../logs_and_tables/logs.html#errors_GNU_C_version_5_1_0_linux_long_double_ellint_3__tr1_cmath__Elliptic_Integral_PI_Random_Data">And
other failures.</a>)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span><br> <br> (<span class="emphasis"><em>GSL
1.16:</em></span> Max = 633&#949; (Mean = 50.1&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 4.49&#949; (Mean = 0.891&#949;)</span>
</p>
</td>
</tr>
<tr>
<td>
<p>
Elliptic Integral PI: Large Random Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.86&#949; (Mean = 0.944&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 3.7&#949; (Mean = 0.893&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> <span class="red">Max
= 2.52e+18&#949; (Mean = 4.83e+17&#949;) <a class="link" href="../logs_and_tables/logs.html#errors_GNU_C_version_5_1_0_linux_long_double_ellint_3__tr1_cmath__Elliptic_Integral_PI_Large_Random_Data">And
other failures.</a>)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.557&#949; (Mean = 0.0389&#949;)</span><br>
<br> (<span class="emphasis"><em>GSL 1.16:</em></span> Max = 40.1&#949; (Mean = 7.77&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 3.7&#949; (Mean = 0.892&#949;)</span>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><h5>
<a name="math_toolkit.ellint.ellint_3.h3"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_3.testing"></a></span><a class="link" href="ellint_3.html#math_toolkit.ellint.ellint_3.testing">Testing</a>
</h5>
<p>
The tests use a mixture of spot test values calculated using the online calculator
at <a href="http://functions.wolfram.com" target="_top">functions.wolfram.com</a>,
and random test data generated using NTL::RR at 1000-bit precision and this
implementation.
</p>
<h5>
<a name="math_toolkit.ellint.ellint_3.h4"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_3.implementation"></a></span><a class="link" href="ellint_3.html#math_toolkit.ellint.ellint_3.implementation">Implementation</a>
</h5>
<p>
The implementation for &#928;(n, &#966;, k) first siphons off the special cases:
</p>
<p>
<span class="emphasis"><em>&#928;(0, &#966;, k) = F(&#966;, k)</em></span>
</p>
<p>
<span class="emphasis"><em>&#928;(n, &#960;/2, k) = &#928;(n, k)</em></span>
</p>
<p>
and
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint23.svg"></span>
</p>
<p>
Then if n &lt; 0 the relations (A&amp;S 17.7.15/16):
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint24.svg"></span>
</p>
<p>
are used to shift <span class="emphasis"><em>n</em></span> to the range [0, 1].
</p>
<p>
Then the relations:
</p>
<p>
<span class="emphasis"><em>&#928;(n, -&#966;, k) = -&#928;(n, &#966;, k)</em></span>
</p>
<p>
<span class="emphasis"><em>&#928;(n, &#966;+m&#960;, k) = &#928;(n, &#966;, k) + 2m&#928;(n, k) ; n &lt;= 1</em></span>
</p>
<p>
<span class="emphasis"><em>&#928;(n, &#966;+m&#960;, k) = &#928;(n, &#966;, k) ; n &gt; 1</em></span> <a href="#ftn.math_toolkit.ellint.ellint_3.f0" class="footnote" name="math_toolkit.ellint.ellint_3.f0"><sup class="footnote">[1]</sup></a>
</p>
<p>
are used to move &#966; &#160; to the range [0, &#960;/2].
</p>
<p>
The functions are then implemented in terms of Carlson's integrals using
the relations:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint25.svg"></span>
</p>
<p>
and
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint26.svg"></span>
</p>
<div class="footnotes">
<br><hr style="width:100; text-align:left;margin-left: 0">
<div id="ftn.math_toolkit.ellint.ellint_3.f0" class="footnote"><p><a href="#math_toolkit.ellint.ellint_3.f0" class="para"><sup class="para">[1] </sup></a>
I haven't been able to find a literature reference for this relation, but
it appears to be the convention used by Mathematica. Intuitively the first
<span class="emphasis"><em>2 * m * &#928;(n, k)</em></span> terms cancel out as the derivative
alternates between +&#8734; and -&#8734;.
</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; 2006-2010, 2012-2014 Nikhar Agrawal,
Anton Bikineev, Paul A. Bristow, Marco Guazzone, Christopher Kormanyos, Hubert
Holin, Bruno Lalande, John Maddock, Jeremy Murphy, Johan R&#229;de, Gautam Sewani,
Benjamin Sobotta, Thijs van den Berg, Daryle Walker and Xiaogang Zhang<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="ellint_2.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ellint.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="ellint_d.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
libs/math/doc/html/math_toolkit/ellint/ellint_carlson.html
+1128
View File
File diff suppressed because it is too large Load Diff
libs/math/doc/html/math_toolkit/ellint/ellint_d.html
+360
View File
@@ -0,0 +1,360 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Elliptic Integral D - Legendre Form</title>
<link rel="stylesheet" href="../../math.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Math Toolkit 2.5.1">
<link rel="up" href="../ellint.html" title="Elliptic Integrals">
<link rel="prev" href="ellint_3.html" title="Elliptic Integrals of the Third Kind - Legendre Form">
<link rel="next" href="jacobi_zeta.html" title="Jacobi Zeta Function">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><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="ellint_3.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ellint.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="jacobi_zeta.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="math_toolkit.ellint.ellint_d"></a><a class="link" href="ellint_d.html" title="Elliptic Integral D - Legendre Form">Elliptic Integral D - Legendre
Form</a>
</h3></div></div></div>
<h5>
<a name="math_toolkit.ellint.ellint_d.h0"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_d.synopsis"></a></span><a class="link" href="ellint_d.html#math_toolkit.ellint.ellint_d.synopsis">Synopsis</a>
</h5>
<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">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">ellint_d</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<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">math</span> <span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_d</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_d</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_d</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_d</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<h5>
<a name="math_toolkit.ellint.ellint_d.h1"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_d.description"></a></span><a class="link" href="ellint_d.html#math_toolkit.ellint.ellint_d.description">Description</a>
</h5>
<p>
These two functions evaluate the incomplete elliptic integral <span class="emphasis"><em>D(&#966;,
k)</em></span> and its complete counterpart <span class="emphasis"><em>D(k) = D(&#960;/2, k)</em></span>.
</p>
<p>
The return type of these functions is computed using the __arg_pomotion_rules
when the arguments are of different types: when they are the same type then
the result is the same type as the arguments.
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_d</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_3</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the incomplete elliptic integral:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint_d.svg"></span>
</p>
<p>
Requires <span class="emphasis"><em>-1 &lt;= k &lt;= 1</em></span>, otherwise returns the result
of <a class="link" href="../error_handling.html#math_toolkit.error_handling.domain_error">domain_error</a>
(outside this range the result would be complex).
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can
be used to control the behaviour of the function: how it handles errors,
what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">policy
documentation for more details</a>.
</p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_d</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">ellint_d</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the complete elliptic integral <span class="emphasis"><em>D(k) = D(&#960;/2, k)</em></span>
</p>
<p>
Requires <span class="emphasis"><em>-1 &lt;= k &lt;= 1</em></span> otherwise returns the result
of <a class="link" href="../error_handling.html#math_toolkit.error_handling.domain_error">domain_error</a>
(outside this range the result would be complex).
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can
be used to control the behaviour of the function: how it handles errors,
what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">policy
documentation for more details</a>.
</p>
<h5>
<a name="math_toolkit.ellint.ellint_d.h2"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_d.accuracy"></a></span><a class="link" href="ellint_d.html#math_toolkit.ellint.ellint_d.accuracy">Accuracy</a>
</h5>
<p>
These functions are trivially computed in terms of other elliptic integrals
and generally have very low error rates (a few epsilon) unless parameter
&#966;
is very large, in which case the usual trigonometric function argument-reduction
issues apply.
</p>
<div class="table">
<a name="math_toolkit.ellint.ellint_d.table_ellint_d_complete_"></a><p class="title"><b>Table&#160;6.66.&#160;Error rates for ellint_d (complete)</b></p>
<div class="table-contents"><table class="table" summary="Error rates for ellint_d (complete)">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
</th>
<th>
<p>
Microsoft Visual C++ version 12.0<br> Win32<br> double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> long double
</p>
</th>
<th>
<p>
Sun compiler version 0x5130<br> Sun Solaris<br> long double
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Elliptic Integral E: Mathworld Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.637&#949; (Mean = 0.368&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.637&#949; (Mean = 0.368&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.27&#949; (Mean = 0.735&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.27&#949; (Mean = 0.735&#949;)</span>
</p>
</td>
</tr>
<tr>
<td>
<p>
Elliptic Integral D: Random Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.27&#949; (Mean = 0.355&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.27&#949; (Mean = 0.334&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.27&#949; (Mean = 0.334&#949;)</span>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="math_toolkit.ellint.ellint_d.table_ellint_d"></a><p class="title"><b>Table&#160;6.67.&#160;Error rates for ellint_d</b></p>
<div class="table-contents"><table class="table" summary="Error rates for ellint_d">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
</th>
<th>
<p>
Microsoft Visual C++ version 12.0<br> Win32<br> double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> long double
</p>
</th>
<th>
<p>
Sun compiler version 0x5130<br> Sun Solaris<br> long double
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Elliptic Integral E: Mathworld Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.862&#949; (Mean = 0.457&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span><br> <br> (<span class="emphasis"><em>GSL
1.16:</em></span> Max = 0.862&#949; (Mean = 0.568&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.3&#949; (Mean = 0.813&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.3&#949; (Mean = 0.813&#949;)</span>
</p>
</td>
</tr>
<tr>
<td>
<p>
Elliptic Integral D: Random Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.87&#949; (Mean = 0.805&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span><br> <br> (<span class="emphasis"><em>GSL
1.16:</em></span> Max = 3.01&#949; (Mean = 0.928&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.51&#949; (Mean = 0.883&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.51&#949; (Mean = 0.883&#949;)</span>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><h5>
<a name="math_toolkit.ellint.ellint_d.h3"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_d.testing"></a></span><a class="link" href="ellint_d.html#math_toolkit.ellint.ellint_d.testing">Testing</a>
</h5>
<p>
The tests use a mixture of spot test values calculated using values calculated
at wolframalpha.com, and random test data generated using MPFR at 1000-bit
precision and a deliberately naive implementation in terms of the Legendre
integrals.
</p>
<h5>
<a name="math_toolkit.ellint.ellint_d.h4"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_d.implementation"></a></span><a class="link" href="ellint_d.html#math_toolkit.ellint.ellint_d.implementation">Implementation</a>
</h5>
<p>
The implementation for D(&#966;, k) first performs argument reduction using the
relations:
</p>
<p>
<span class="emphasis"><em>D(-&#966;, k) = -D(&#966;, k)</em></span>
</p>
<p>
and
</p>
<p>
<span class="emphasis"><em>D(n&#960;+&#966;, k) = 2nD(k) + D(&#966;, k)</em></span>
</p>
<p>
to move &#966; &#160; to the range [0, &#960;/2].
</p>
<p>
The functions are then implemented in terms of Carlson's integral R<sub>D</sub>
using
the relation:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint_d.svg"></span>
</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; 2006-2010, 2012-2014 Nikhar Agrawal,
Anton Bikineev, Paul A. Bristow, Marco Guazzone, Christopher Kormanyos, Hubert
Holin, Bruno Lalande, John Maddock, Jeremy Murphy, Johan R&#229;de, Gautam Sewani,
Benjamin Sobotta, Thijs van den Berg, Daryle Walker and Xiaogang Zhang<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="ellint_3.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ellint.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="jacobi_zeta.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
libs/math/doc/html/math_toolkit/ellint/ellint_intro.html
+451
View File
@@ -0,0 +1,451 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Elliptic Integral Overview</title>
<link rel="stylesheet" href="../../math.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Math Toolkit 2.5.1">
<link rel="up" href="../ellint.html" title="Elliptic Integrals">
<link rel="prev" href="../ellint.html" title="Elliptic Integrals">
<link rel="next" href="ellint_carlson.html" title="Elliptic Integrals - Carlson Form">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><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="../ellint.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ellint.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="ellint_carlson.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="math_toolkit.ellint.ellint_intro"></a><a class="link" href="ellint_intro.html" title="Elliptic Integral Overview">Elliptic Integral Overview</a>
</h3></div></div></div>
<p>
The main reference for the elliptic integrals is:
</p>
<div class="blockquote"><blockquote class="blockquote"><p>
M. Abramowitz and I. A. Stegun (Eds.) (1964) Handbook of Mathematical Functions
with Formulas, Graphs, and Mathematical Tables, National Bureau of Standards
Applied Mathematics Series, U.S. Government Printing Office, Washington,
D.C.
</p></blockquote></div>
<p>
Mathworld also contain a lot of useful background information:
</p>
<div class="blockquote"><blockquote class="blockquote"><p>
<a href="http://mathworld.wolfram.com/EllipticIntegral.html" target="_top">Weisstein,
Eric W. "Elliptic Integral." From MathWorld--A Wolfram Web Resource.</a>
</p></blockquote></div>
<p>
As does <a href="http://en.wikipedia.org/wiki/Elliptic_integral" target="_top">Wikipedia
Elliptic integral</a>.
</p>
<h5>
<a name="math_toolkit.ellint.ellint_intro.h0"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_intro.notation"></a></span><a class="link" href="ellint_intro.html#math_toolkit.ellint.ellint_intro.notation">Notation</a>
</h5>
<p>
All variables are real numbers unless otherwise noted.
</p>
<h5>
<a name="math_toolkit.ellint.ellint_intro.h1"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_intro.definition"></a></span><a class="link" href="ellint_intro.html#math_toolkit.ellint.ellint_intro.definition">Definition</a>
</h5>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint1.svg"></span>
</p>
<p>
is called elliptic integral if <span class="emphasis"><em>R(t, s)</em></span> is a rational
function of <span class="emphasis"><em>t</em></span> and <span class="emphasis"><em>s</em></span>, and <span class="emphasis"><em>s<sup>2</sup></em></span>
is a cubic or quartic polynomial in <span class="emphasis"><em>t</em></span>.
</p>
<p>
Elliptic integrals generally can not be expressed in terms of elementary
functions. However, Legendre showed that all elliptic integrals can be reduced
to the following three canonical forms:
</p>
<p>
Elliptic Integral of the First Kind (Legendre form)
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint2.svg"></span>
</p>
<p>
Elliptic Integral of the Second Kind (Legendre form)
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint3.svg"></span>
</p>
<p>
Elliptic Integral of the Third Kind (Legendre form)
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint4.svg"></span>
</p>
<p>
where
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint5.svg"></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>
<span class="emphasis"><em>&#966;</em></span> is called the amplitude.
</p>
<p>
<span class="emphasis"><em>k</em></span> is called the modulus.
</p>
<p>
<span class="emphasis"><em>&#945;</em></span> is called the modular angle.
</p>
<p>
<span class="emphasis"><em>n</em></span> is called the characteristic.
</p>
</td></tr>
</table></div>
<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>
Perhaps more than any other special functions the elliptic integrals are
expressed in a variety of different ways. In particular, the final parameter
<span class="emphasis"><em>k</em></span> (the modulus) may be expressed using a modular angle
&#945;, or a parameter <span class="emphasis"><em>m</em></span>. These are related by:
</p>
<p>
k = sin&#945;
</p>
<p>
m = k<sup>2</sup> = sin<sup>2</sup>&#945;
</p>
<p>
So that the integral of the third kind (for example) may be expressed as
either:
</p>
<p>
&#928;(n, &#966;, k)
</p>
<p>
&#928;(n, &#966; \ &#945;)
</p>
<p>
&#928;(n, &#966;| m)
</p>
<p>
To further complicate matters, some texts refer to the <span class="emphasis"><em>complement
of the parameter m</em></span>, or 1 - m, where:
</p>
<p>
1 - m = 1 - k<sup>2</sup> = cos<sup>2</sup>&#945;
</p>
<p>
This implementation uses <span class="emphasis"><em>k</em></span> throughout: this matches
the requirements of the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf" target="_top">Technical
Report on C++ Library Extensions</a>. However, you should be extra
careful when using these functions!
</p>
</td></tr>
</table></div>
<p>
When <span class="emphasis"><em>&#966;</em></span> = <span class="emphasis"><em>&#960;</em></span> / 2, the elliptic integrals
are called <span class="emphasis"><em>complete</em></span>.
</p>
<p>
Complete Elliptic Integral of the First Kind (Legendre form)
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint6.svg"></span>
</p>
<p>
Complete Elliptic Integral of the Second Kind (Legendre form)
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint7.svg"></span>
</p>
<p>
Complete Elliptic Integral of the Third Kind (Legendre form)
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint8.svg"></span>
</p>
<p>
Legendre also defined a forth integral D(&#966;,k) which is a combination of the
other three:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint_d.svg"></span>
</p>
<p>
Like the other Legendre integrals this comes in both complete and incomplete
forms.
</p>
<h5>
<a name="math_toolkit.ellint.ellint_intro.h2"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_intro.carlson_elliptic_integrals"></a></span><a class="link" href="ellint_intro.html#math_toolkit.ellint.ellint_intro.carlson_elliptic_integrals">Carlson
Elliptic Integrals</a>
</h5>
<p>
Carlson [<a class="link" href="ellint_intro.html#ellint_ref_carlson77">Carlson77</a>] [<a class="link" href="ellint_intro.html#ellint_ref_carlson78">Carlson78</a>]
gives an alternative definition of elliptic integral's canonical forms:
</p>
<p>
Carlson's Elliptic Integral of the First Kind
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint9.svg"></span>
</p>
<p>
where <span class="emphasis"><em>x</em></span>, <span class="emphasis"><em>y</em></span>, <span class="emphasis"><em>z</em></span>
are nonnegative and at most one of them may be zero.
</p>
<p>
Carlson's Elliptic Integral of the Second Kind
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint10.svg"></span>
</p>
<p>
where <span class="emphasis"><em>x</em></span>, <span class="emphasis"><em>y</em></span> are nonnegative, at
most one of them may be zero, and <span class="emphasis"><em>z</em></span> must be positive.
</p>
<p>
Carlson's Elliptic Integral of the Third Kind
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint11.svg"></span>
</p>
<p>
where <span class="emphasis"><em>x</em></span>, <span class="emphasis"><em>y</em></span>, <span class="emphasis"><em>z</em></span>
are nonnegative, at most one of them may be zero, and <span class="emphasis"><em>p</em></span>
must be nonzero.
</p>
<p>
Carlson's Degenerate Elliptic Integral
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint12.svg"></span>
</p>
<p>
where <span class="emphasis"><em>x</em></span> is nonnegative and <span class="emphasis"><em>y</em></span> is
nonzero.
</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>
<span class="emphasis"><em>R<sub>C</sub>(x, y) = R<sub>F</sub>(x, y, y)</em></span>
</p>
<p>
<span class="emphasis"><em>R<sub>D</sub>(x, y, z) = R<sub>J</sub>(x, y, z, z)</em></span>
</p>
</td></tr>
</table></div>
<p>
Carlson's Symmetric Integral
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint27.svg"></span>
</p>
<h5>
<a name="math_toolkit.ellint.ellint_intro.h3"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_intro.duplication_theorem"></a></span><a class="link" href="ellint_intro.html#math_toolkit.ellint.ellint_intro.duplication_theorem">Duplication
Theorem</a>
</h5>
<p>
Carlson proved in [<a class="link" href="ellint_intro.html#ellint_ref_carlson78">Carlson78</a>]
that
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint13.svg"></span>
</p>
<h5>
<a name="math_toolkit.ellint.ellint_intro.h4"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_intro.carlson_s_formulas"></a></span><a class="link" href="ellint_intro.html#math_toolkit.ellint.ellint_intro.carlson_s_formulas">Carlson's
Formulas</a>
</h5>
<p>
The Legendre form and Carlson form of elliptic integrals are related by equations:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint14.svg"></span>
</p>
<p>
In particular,
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/ellint15.svg"></span>
</p>
<h5>
<a name="math_toolkit.ellint.ellint_intro.h5"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_intro.miscellaneous_elliptic_integrals"></a></span><a class="link" href="ellint_intro.html#math_toolkit.ellint.ellint_intro.miscellaneous_elliptic_integrals">Miscellaneous
Elliptic Integrals</a>
</h5>
<p>
There are two functions related to the elliptic integrals which otherwise
defy categorisation, these are the Jacobi Zeta function:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/jacobi_zeta.svg"></span>
</p>
<p>
and the Heuman Lambda function:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/heuman_lambda.svg"></span>
</p>
<p>
Both of these functions are easily implemented in terms of Carlson's integrals,
and are provided in this library as <a class="link" href="jacobi_zeta.html" title="Jacobi Zeta Function">jacobi_zeta</a>
and <a class="link" href="heuman_lambda.html" title="Heuman Lambda Function">heuman_lambda</a>.
</p>
<h5>
<a name="math_toolkit.ellint.ellint_intro.h6"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_intro.numerical_algorithms"></a></span><a class="link" href="ellint_intro.html#math_toolkit.ellint.ellint_intro.numerical_algorithms">Numerical
Algorithms</a>
</h5>
<p>
The conventional methods for computing elliptic integrals are Gauss and Landen
transformations, which converge quadratically and work well for elliptic
integrals of the first and second kinds. Unfortunately they suffer from loss
of significant digits for the third kind. Carlson's algorithm [<a class="link" href="ellint_intro.html#ellint_ref_carlson79">Carlson79</a>]
[<a class="link" href="ellint_intro.html#ellint_ref_carlson78">Carlson78</a>], by contrast, provides
a unified method for all three kinds of elliptic integrals with satisfactory
precisions.
</p>
<h5>
<a name="math_toolkit.ellint.ellint_intro.h7"></a>
<span class="phrase"><a name="math_toolkit.ellint.ellint_intro.references"></a></span><a class="link" href="ellint_intro.html#math_toolkit.ellint.ellint_intro.references">References</a>
</h5>
<p>
Special mention goes to:
</p>
<div class="blockquote"><blockquote class="blockquote"><p>
A. M. Legendre, <span class="emphasis"><em>Traitd des Fonctions Elliptiques et des Integrales
Euleriennes</em></span>, Vol. 1. Paris (1825).
</p></blockquote></div>
<p>
However the main references are:
</p>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
<a name="ellint_ref_AS"></a>M. Abramowitz and I. A. Stegun (Eds.) (1964)
Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical
Tables, National Bureau of Standards Applied Mathematics Series, U.S.
Government Printing Office, Washington, D.C.
</li>
<li class="listitem">
<a name="ellint_ref_carlson79"></a>B.C. Carlson, <span class="emphasis"><em>Computing
elliptic integrals by duplication</em></span>, Numerische Mathematik,
vol 33, 1 (1979).
</li>
<li class="listitem">
<a name="ellint_ref_carlson77"></a>B.C. Carlson, <span class="emphasis"><em>Elliptic Integrals
of the First Kind</em></span>, SIAM Journal on Mathematical Analysis,
vol 8, 231 (1977).
</li>
<li class="listitem">
<a name="ellint_ref_carlson78"></a>B.C. Carlson, <span class="emphasis"><em>Short Proofs
of Three Theorems on Elliptic Integrals</em></span>, SIAM Journal on Mathematical
Analysis, vol 9, 524 (1978).
</li>
<li class="listitem">
<a name="ellint_ref_carlson81"></a>B.C. Carlson and E.M. Notis, <span class="emphasis"><em>ALGORITHM
577: Algorithms for Incomplete Elliptic Integrals</em></span>, ACM Transactions
on Mathematmal Software, vol 7, 398 (1981).
</li>
<li class="listitem">
B. C. Carlson, <span class="emphasis"><em>On computing elliptic integrals and functions</em></span>.
J. Math. and Phys., 44 (1965), pp. 36-51.
</li>
<li class="listitem">
B. C. Carlson, <span class="emphasis"><em>A table of elliptic integrals of the second
kind</em></span>. Math. Comp., 49 (1987), pp. 595-606. (Supplement, ibid.,
pp. S13-S17.)
</li>
<li class="listitem">
B. C. Carlson, <span class="emphasis"><em>A table of elliptic integrals of the third kind</em></span>.
Math. Comp., 51 (1988), pp. 267-280. (Supplement, ibid., pp. S1-S5.)
</li>
<li class="listitem">
B. C. Carlson, <span class="emphasis"><em>A table of elliptic integrals: cubic cases</em></span>.
Math. Comp., 53 (1989), pp. 327-333.
</li>
<li class="listitem">
B. C. Carlson, <span class="emphasis"><em>A table of elliptic integrals: one quadratic
factor</em></span>. Math. Comp., 56 (1991), pp. 267-280.
</li>
<li class="listitem">
B. C. Carlson, <span class="emphasis"><em>A table of elliptic integrals: two quadratic
factors</em></span>. Math. Comp., 59 (1992), pp. 165-180.
</li>
<li class="listitem">
B. C. Carlson, <span class="emphasis"><em><a href="http://arxiv.org/abs/math.CA/9409227" target="_top">Numerical
computation of real or complex elliptic integrals</a></em></span>.
Numerical Algorithms, Volume 10, Number 1 / March, 1995, p13-26.
</li>
<li class="listitem">
B. C. Carlson and John L. Gustafson, <span class="emphasis"><em><a href="http://arxiv.org/abs/math.CA/9310223" target="_top">Asymptotic
Approximations for Symmetric Elliptic Integrals</a></em></span>, SIAM
Journal on Mathematical Analysis, Volume 25, Issue 2 (March 1994), 288-303.
</li>
</ol></div>
<p>
The following references, while not directly relevent to our implementation,
may also be of interest:
</p>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
R. Burlisch, <span class="emphasis"><em>Numerical Compuation of Elliptic Integrals and
Elliptic Functions.</em></span> Numerical Mathematik 7, 78-90.
</li>
<li class="listitem">
R. Burlisch, <span class="emphasis"><em>An extension of the Bartky Transformation to Incomplete
Elliptic Integrals of the Third Kind</em></span>. Numerical Mathematik
13, 266-284.
</li>
<li class="listitem">
R. Burlisch, <span class="emphasis"><em>Numerical Compuation of Elliptic Integrals and
Elliptic Functions. III</em></span>. Numerical Mathematik 13, 305-315.
</li>
<li class="listitem">
T. Fukushima and H. Ishizaki, <span class="emphasis"><em><a href="http://adsabs.harvard.edu/abs/1994CeMDA..59..237F" target="_top">Numerical
Computation of Incomplete Elliptic Integrals of a General Form.</a></em></span>
Celestial Mechanics and Dynamical Astronomy, Volume 59, Number 3 / July,
1994, 237-251.
</li>
</ol></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; 2006-2010, 2012-2014 Nikhar Agrawal,
Anton Bikineev, Paul A. Bristow, Marco Guazzone, Christopher Kormanyos, Hubert
Holin, Bruno Lalande, John Maddock, Jeremy Murphy, Johan R&#229;de, Gautam Sewani,
Benjamin Sobotta, Thijs van den Berg, Daryle Walker and Xiaogang Zhang<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="../ellint.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ellint.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="ellint_carlson.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
libs/math/doc/html/math_toolkit/ellint/heuman_lambda.html
+221
View File
@@ -0,0 +1,221 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Heuman Lambda Function</title>
<link rel="stylesheet" href="../../math.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Math Toolkit 2.5.1">
<link rel="up" href="../ellint.html" title="Elliptic Integrals">
<link rel="prev" href="jacobi_zeta.html" title="Jacobi Zeta Function">
<link rel="next" href="../jacobi.html" title="Jacobi Elliptic Functions">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><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="jacobi_zeta.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ellint.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="../jacobi.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="math_toolkit.ellint.heuman_lambda"></a><a class="link" href="heuman_lambda.html" title="Heuman Lambda Function">Heuman Lambda Function</a>
</h3></div></div></div>
<h5>
<a name="math_toolkit.ellint.heuman_lambda.h0"></a>
<span class="phrase"><a name="math_toolkit.ellint.heuman_lambda.synopsis"></a></span><a class="link" href="heuman_lambda.html#math_toolkit.ellint.heuman_lambda.synopsis">Synopsis</a>
</h5>
<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">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">heuman_lambda</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<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">math</span> <span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">heuman_lambda</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">heuman_lambda</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<h5>
<a name="math_toolkit.ellint.heuman_lambda.h1"></a>
<span class="phrase"><a name="math_toolkit.ellint.heuman_lambda.description"></a></span><a class="link" href="heuman_lambda.html#math_toolkit.ellint.heuman_lambda.description">Description</a>
</h5>
<p>
This function evaluates the Heuman Lambda Function <span class="emphasis"><em>&#923;<sub>0</sub>(&#966;, k)</em></span>
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/heuman_lambda.svg"></span>
</p>
<p>
The return type of this function is computed using the __arg_pomotion_rules
when the arguments are of different types: when they are the same type then
the result is the same type as the arguments.
</p>
<p>
Requires <span class="emphasis"><em>-1 &lt;= k &lt;= 1</em></span>, otherwise returns the result
of <a class="link" href="../error_handling.html#math_toolkit.error_handling.domain_error">domain_error</a>
(outside this range the result would be complex).
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can
be used to control the behaviour of the function: how it handles errors,
what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">policy
documentation for more details</a>.
</p>
<p>
Note that there is no complete analogue of this function (where &#966; = &#960; / 2) as
this takes the value 1 for all <span class="emphasis"><em>k</em></span>.
</p>
<h5>
<a name="math_toolkit.ellint.heuman_lambda.h2"></a>
<span class="phrase"><a name="math_toolkit.ellint.heuman_lambda.accuracy"></a></span><a class="link" href="heuman_lambda.html#math_toolkit.ellint.heuman_lambda.accuracy">Accuracy</a>
</h5>
<p>
These functions are trivially computed in terms of other elliptic integrals
and generally have very low error rates (a few epsilon) unless parameter
&#966;
is very large, in which case the usual trigonometric function argument-reduction
issues apply.
</p>
<div class="table">
<a name="math_toolkit.ellint.heuman_lambda.table_heuman_lambda"></a><p class="title"><b>Table&#160;6.69.&#160;Error rates for heuman_lambda</b></p>
<div class="table-contents"><table class="table" summary="Error rates for heuman_lambda">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
</th>
<th>
<p>
Microsoft Visual C++ version 12.0<br> Win32<br> double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> long double
</p>
</th>
<th>
<p>
Sun compiler version 0x5130<br> Sun Solaris<br> long double
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Elliptic Integral Jacobi Zeta: Mathworld Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.08&#949; (Mean = 0.734&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.89&#949; (Mean = 0.887&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.89&#949; (Mean = 0.887&#949;)</span>
</p>
</td>
</tr>
<tr>
<td>
<p>
Elliptic Integral Heuman Lambda: Random Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.12&#949; (Mean = 0.59&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 3.82&#949; (Mean = 0.609&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 3.82&#949; (Mean = 0.608&#949;)</span>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><h5>
<a name="math_toolkit.ellint.heuman_lambda.h3"></a>
<span class="phrase"><a name="math_toolkit.ellint.heuman_lambda.testing"></a></span><a class="link" href="heuman_lambda.html#math_toolkit.ellint.heuman_lambda.testing">Testing</a>
</h5>
<p>
The tests use a mixture of spot test values calculated using values calculated
at wolframalpha.com, and random test data generated using MPFR at 1000-bit
precision and a deliberately naive implementation in terms of the Legendre
integrals.
</p>
<h5>
<a name="math_toolkit.ellint.heuman_lambda.h4"></a>
<span class="phrase"><a name="math_toolkit.ellint.heuman_lambda.implementation"></a></span><a class="link" href="heuman_lambda.html#math_toolkit.ellint.heuman_lambda.implementation">Implementation</a>
</h5>
<p>
The function is then implemented in terms of Carlson's integrals R<sub>J</sub> and R<sub>F</sub>
using
the relation:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/heuman_lambda.svg"></span>
</p>
<p>
This relation fails for <span class="emphasis"><em>|&#966;| &gt;= &#960;/2</em></span> in which case the
definition in terms of the Jacobi Zeta is used.
</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; 2006-2010, 2012-2014 Nikhar Agrawal,
Anton Bikineev, Paul A. Bristow, Marco Guazzone, Christopher Kormanyos, Hubert
Holin, Bruno Lalande, John Maddock, Jeremy Murphy, Johan R&#229;de, Gautam Sewani,
Benjamin Sobotta, Thijs van den Berg, Daryle Walker and Xiaogang Zhang<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="jacobi_zeta.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ellint.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="../jacobi.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
libs/math/doc/html/math_toolkit/ellint/jacobi_zeta.html
+257
View File
@@ -0,0 +1,257 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Jacobi Zeta Function</title>
<link rel="stylesheet" href="../../math.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Math Toolkit 2.5.1">
<link rel="up" href="../ellint.html" title="Elliptic Integrals">
<link rel="prev" href="ellint_d.html" title="Elliptic Integral D - Legendre Form">
<link rel="next" href="heuman_lambda.html" title="Heuman Lambda Function">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><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="ellint_d.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ellint.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="heuman_lambda.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="math_toolkit.ellint.jacobi_zeta"></a><a class="link" href="jacobi_zeta.html" title="Jacobi Zeta Function">Jacobi Zeta Function</a>
</h3></div></div></div>
<h5>
<a name="math_toolkit.ellint.jacobi_zeta.h0"></a>
<span class="phrase"><a name="math_toolkit.ellint.jacobi_zeta.synopsis"></a></span><a class="link" href="jacobi_zeta.html#math_toolkit.ellint.jacobi_zeta.synopsis">Synopsis</a>
</h5>
<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">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">jacobi_zeta</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<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">math</span> <span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">jacobi_zeta</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">jacobi_zeta</span><span class="special">(</span><span class="identifier">T1</span> <span class="identifier">k</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">phi</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<h5>
<a name="math_toolkit.ellint.jacobi_zeta.h1"></a>
<span class="phrase"><a name="math_toolkit.ellint.jacobi_zeta.description"></a></span><a class="link" href="jacobi_zeta.html#math_toolkit.ellint.jacobi_zeta.description">Description</a>
</h5>
<p>
This function evaluates the Jacobi Zeta Function <span class="emphasis"><em>Z(&#966;, k)</em></span>
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/jacobi_zeta.svg"></span>
</p>
<p>
The return type of this function is computed using the __arg_pomotion_rules
when the arguments are of different types: when they are the same type then
the result is the same type as the arguments.
</p>
<p>
Requires <span class="emphasis"><em>-1 &lt;= k &lt;= 1</em></span>, otherwise returns the result
of <a class="link" href="../error_handling.html#math_toolkit.error_handling.domain_error">domain_error</a>
(outside this range the result would be complex).
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can
be used to control the behaviour of the function: how it handles errors,
what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter&#160;15.&#160;Policies: Controlling Precision, Error Handling etc">policy
documentation for more details</a>.
</p>
<p>
Note that there is no complete analogue of this function (where &#966; = &#960; / 2) as
this takes the value 0 for all <span class="emphasis"><em>k</em></span>.
</p>
<h5>
<a name="math_toolkit.ellint.jacobi_zeta.h2"></a>
<span class="phrase"><a name="math_toolkit.ellint.jacobi_zeta.accuracy"></a></span><a class="link" href="jacobi_zeta.html#math_toolkit.ellint.jacobi_zeta.accuracy">Accuracy</a>
</h5>
<p>
These functions are trivially computed in terms of other elliptic integrals
and generally have very low error rates (a few epsilon) unless parameter
&#966;
is very large, in which case the usual trigonometric function argument-reduction
issues apply.
</p>
<div class="table">
<a name="math_toolkit.ellint.jacobi_zeta.table_jacobi_zeta"></a><p class="title"><b>Table&#160;6.68.&#160;Error rates for jacobi_zeta</b></p>
<div class="table-contents"><table class="table" summary="Error rates for jacobi_zeta">
<colgroup>
<col>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
</th>
<th>
<p>
Microsoft Visual C++ version 12.0<br> Win32<br> double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> long double
</p>
</th>
<th>
<p>
Sun compiler version 0x5130<br> Sun Solaris<br> long double
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Elliptic Integral Jacobi Zeta: Mathworld Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.505&#949; (Mean = 0.119&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.66&#949; (Mean = 0.48&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.66&#949; (Mean = 0.48&#949;)</span>
</p>
</td>
</tr>
<tr>
<td>
<p>
Elliptic Integral Jacobi Zeta: Random Data
</p>
</td>
<td>
<p>
<span class="blue">Max = 3.89&#949; (Mean = 0.818&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.99&#949; (Mean = 0.824&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 3.96&#949; (Mean = 1.06&#949;)</span>
</p>
</td>
</tr>
<tr>
<td>
<p>
Elliptic Integral Jacobi Zeta: Large Phi Values
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.92&#949; (Mean = 0.964&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.92&#949; (Mean = 0.951&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 3.05&#949; (Mean = 1.13&#949;)</span>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><h5>
<a name="math_toolkit.ellint.jacobi_zeta.h3"></a>
<span class="phrase"><a name="math_toolkit.ellint.jacobi_zeta.testing"></a></span><a class="link" href="jacobi_zeta.html#math_toolkit.ellint.jacobi_zeta.testing">Testing</a>
</h5>
<p>
The tests use a mixture of spot test values calculated using values calculated
at wolframalpha.com, and random test data generated using MPFR at 1000-bit
precision and a deliberately naive implementation in terms of the Legendre
integrals.
</p>
<h5>
<a name="math_toolkit.ellint.jacobi_zeta.h4"></a>
<span class="phrase"><a name="math_toolkit.ellint.jacobi_zeta.implementation"></a></span><a class="link" href="jacobi_zeta.html#math_toolkit.ellint.jacobi_zeta.implementation">Implementation</a>
</h5>
<p>
The implementation for Z(&#966;, k) first makes the argument &#966; positive using:
</p>
<p>
<span class="emphasis"><em>Z(-&#966;, k) = -Z(&#966;, k)</em></span>
</p>
<p>
The function is then implemented in terms of Carlson's integral R<sub>J</sub>
using the
relation:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/jacobi_zeta.svg"></span>
</p>
<p>
There is one special case where the above relation fails: when <span class="emphasis"><em>k
= 1</em></span>, in that case the function simplifies to
</p>
<p>
<span class="emphasis"><em>Z(&#966;, 1) = sign(cos(&#966;)) sin(&#966;)</em></span>
</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; 2006-2010, 2012-2014 Nikhar Agrawal,
Anton Bikineev, Paul A. Bristow, Marco Guazzone, Christopher Kormanyos, Hubert
Holin, Bruno Lalande, John Maddock, Jeremy Murphy, Johan R&#229;de, Gautam Sewani,
Benjamin Sobotta, Thijs van den Berg, Daryle Walker and Xiaogang Zhang<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="ellint_d.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../ellint.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="heuman_lambda.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>