w4kek/WSJT-X
1
0
Fork 0
mirror of https://github.com/saitohirga/WSJT-X.git synced 2026-06-05 07:24:38 -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/sf_erf/error_function.html
+492
View File
@@ -0,0 +1,492 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Error Functions</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="../sf_erf.html" title="Error Functions">
<link rel="prev" href="../sf_erf.html" title="Error Functions">
<link rel="next" href="error_inv.html" title="Error Function Inverses">
</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="../sf_erf.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_erf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="error_inv.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.sf_erf.error_function"></a><a class="link" href="error_function.html" title="Error Functions">Error Functions</a>
</h3></div></div></div>
<h5>
<a name="math_toolkit.sf_erf.error_function.h0"></a>
<span class="phrase"><a name="math_toolkit.sf_erf.error_function.synopsis"></a></span><a class="link" href="error_function.html#math_toolkit.sf_erf.error_function.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">erf</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">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">erf</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">z</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">erf</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">z</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">erfc</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">z</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">erfc</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">z</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>
<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>: the return type is <code class="computeroutput"><span class="keyword">double</span></code> if T is an integer type, and T otherwise.
</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.sf_erf.error_function.h1"></a>
<span class="phrase"><a name="math_toolkit.sf_erf.error_function.description"></a></span><a class="link" href="error_function.html#math_toolkit.sf_erf.error_function.description">Description</a>
</h5>
<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">erf</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">z</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">erf</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">z</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 <a href="http://en.wikipedia.org/wiki/Error_function" target="_top">error
function</a> <a href="http://functions.wolfram.com/GammaBetaErf/Erf/" target="_top">erf</a>
of z:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/erf1.svg"></span>
</p>
<p>
<span class="inlinemediaobject"><img src="../../../graphs/erf.svg" align="middle"></span>
</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">erfc</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">z</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">erfc</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">z</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 complement of the <a href="http://functions.wolfram.com/GammaBetaErf/Erfc/" target="_top">error
function</a> of z:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/erf2.svg"></span>
</p>
<p>
<span class="inlinemediaobject"><img src="../../../graphs/erfc.svg" align="middle"></span>
</p>
<h5>
<a name="math_toolkit.sf_erf.error_function.h2"></a>
<span class="phrase"><a name="math_toolkit.sf_erf.error_function.accuracy"></a></span><a class="link" href="error_function.html#math_toolkit.sf_erf.error_function.accuracy">Accuracy</a>
</h5>
<p>
The following table shows the peak errors (in units of epsilon) found on
various platforms with various floating point types, along with comparisons
to the <a href="http://www.gnu.org/software/gsl/" target="_top">GSL-1.9</a>, <a href="http://www.gnu.org/software/libc/" target="_top">GNU C Lib</a>, <a href="http://docs.hp.com/en/B9106-90010/index.html" target="_top">HP-UX
C Library</a> and <a href="http://www.netlib.org/cephes/" target="_top">Cephes</a>
libraries. Unless otherwise specified any floating point type that is narrower
than the one shown will have <a class="link" href="../relative_error.html#math_toolkit.relative_error.zero_error">effectively
zero error</a>.
</p>
<div class="table">
<a name="math_toolkit.sf_erf.error_function.table_erf"></a><p class="title"><b>Table&#160;6.28.&#160;Error rates for erf</b></p>
<div class="table-contents"><table class="table" summary="Error rates for erf">
<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>
Erf Function: Small Values
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.996&#949; (Mean = 0.182&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 1.57&#949; (Mean = 0.317&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.925&#949; (Mean = 0.193&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> Max = 0.944&#949; (Mean = 0.191&#949;))<br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 0.944&#949; (Mean = 0.191&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.841&#949; (Mean = 0.0687&#949;)</span><br>
<br> (<span class="emphasis"><em>GSL 1.16:</em></span> Max = 2.06&#949; (Mean = 0.319&#949;))<br>
(<span class="emphasis"><em>Cephes:</em></span> Max = 1.13&#949; (Mean = 0.442&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.925&#949; (Mean = 0.193&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 0.944&#949; (Mean = 0.194&#949;))
</p>
</td>
</tr>
<tr>
<td>
<p>
Erf Function: Medium Values
</p>
</td>
<td>
<p>
<span class="blue">Max = 1&#949; (Mean = 0.169&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 1.19&#949; (Mean = 0.244&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.5&#949; (Mean = 0.193&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> Max = 0.921&#949; (Mean = 0.0723&#949;))<br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 0.921&#949; (Mean = 0.0723&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 1&#949; (Mean = 0.119&#949;)</span><br> <br>
(<span class="emphasis"><em>GSL 1.16:</em></span> Max = 2.31&#949; (Mean = 0.368&#949;))<br>
(<span class="emphasis"><em>Cephes:</em></span> Max = 1.34&#949; (Mean = 0.279&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.5&#949; (Mean = 0.202&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 0.921&#949; (Mean = 0.071&#949;))
</p>
</td>
</tr>
<tr>
<td>
<p>
Erf Function: Large Values
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span><br> <br> (<span class="emphasis"><em>&lt;math.h&gt;:</em></span>
Max = 0&#949; (Mean = 0&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span><br> <br> (<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span>
Max = 0&#949; (Mean = 0&#949;))<br> (<span class="emphasis"><em>&lt;math.h&gt;:</em></span>
Max = 0&#949; (Mean = 0&#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 = 0&#949; (Mean = 0&#949;))<br> (<span class="emphasis"><em>Cephes:</em></span>
Max = 0&#949; (Mean = 0&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span><br> <br> (<span class="emphasis"><em>&lt;math.h&gt;:</em></span>
Max = 0&#949; (Mean = 0&#949;))
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="math_toolkit.sf_erf.error_function.table_erfc"></a><p class="title"><b>Table&#160;6.29.&#160;Error rates for erfc</b></p>
<div class="table-contents"><table class="table" summary="Error rates for erfc">
<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>
Erf Function: Small Values
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span><br> <br> (<span class="emphasis"><em>&lt;math.h&gt;:</em></span>
Max = 0&#949; (Mean = 0&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span><br> <br> (<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span>
Max = 0&#949; (Mean = 0&#949;))<br> (<span class="emphasis"><em>&lt;math.h&gt;:</em></span>
Max = 0&#949; (Mean = 0&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.658&#949; (Mean = 0.0537&#949;)</span><br>
<br> (<span class="emphasis"><em>GSL 1.16:</em></span> Max = 1.01&#949; (Mean = 0.485&#949;))<br>
(<span class="emphasis"><em>Cephes:</em></span> Max = 0.786&#949; (Mean = 0.0642&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span><br> <br> (<span class="emphasis"><em>&lt;math.h&gt;:</em></span>
Max = 0&#949; (Mean = 0&#949;))
</p>
</td>
</tr>
<tr>
<td>
<p>
Erf Function: Medium Values
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.65&#949; (Mean = 0.373&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 2.36&#949; (Mean = 0.539&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.76&#949; (Mean = 0.365&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> Max = 1.35&#949; (Mean = 0.307&#949;))<br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 1.35&#949; (Mean = 0.307&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.983&#949; (Mean = 0.213&#949;)</span><br> <br>
(<span class="emphasis"><em>GSL 1.16:</em></span> Max = 2.64&#949; (Mean = 0.662&#949;))<br>
(<span class="emphasis"><em>Cephes:</em></span> Max = 3.59&#949; (Mean = 0.779&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.76&#949; (Mean = 0.383&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 2.81&#949; (Mean = 0.739&#949;))
</p>
</td>
</tr>
<tr>
<td>
<p>
Erf Function: Large Values
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.14&#949; (Mean = 0.248&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 1.84&#949; (Mean = 0.331&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.57&#949; (Mean = 0.542&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> Max = 1.26&#949; (Mean = 0.441&#949;))<br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 1.26&#949; (Mean = 0.441&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.868&#949; (Mean = 0.147&#949;)</span><br> <br>
(<span class="emphasis"><em>GSL 1.16:</em></span> Max = 3.9&#949; (Mean = 0.472&#949;))<br>
(<span class="emphasis"><em>Cephes:</em></span> Max = 2.74&#949; (Mean = 0.413&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.57&#949; (Mean = 0.564&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 4.91&#949; (Mean = 1.54&#949;))
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><h5>
<a name="math_toolkit.sf_erf.error_function.h3"></a>
<span class="phrase"><a name="math_toolkit.sf_erf.error_function.testing"></a></span><a class="link" href="error_function.html#math_toolkit.sf_erf.error_function.testing">Testing</a>
</h5>
<p>
The tests for these functions come in two parts: basic sanity checks use
spot values calculated using <a href="http://functions.wolfram.com/webMathematica/FunctionEvaluation.jsp?name=Erf" target="_top">Mathworld's
online evaluator</a>, while accuracy checks use high-precision test values
calculated at 1000-bit precision with <a href="http://shoup.net/ntl/doc/RR.txt" target="_top">NTL::RR</a>
and this implementation. Note that the generic and type-specific versions
of these functions use differing implementations internally, so this gives
us reasonably independent test data. Using our test data to test other "known
good" implementations also provides an additional sanity check.
</p>
<h5>
<a name="math_toolkit.sf_erf.error_function.h4"></a>
<span class="phrase"><a name="math_toolkit.sf_erf.error_function.implementation"></a></span><a class="link" href="error_function.html#math_toolkit.sf_erf.error_function.implementation">Implementation</a>
</h5>
<p>
All versions of these functions first use the usual reflection formulas to
make their arguments positive:
</p>
<pre class="programlisting"><span class="identifier">erf</span><span class="special">(-</span><span class="identifier">z</span><span class="special">)</span> <span class="special">=</span> <span class="number">1</span> <span class="special">-</span> <span class="identifier">erf</span><span class="special">(</span><span class="identifier">z</span><span class="special">);</span>
<span class="identifier">erfc</span><span class="special">(-</span><span class="identifier">z</span><span class="special">)</span> <span class="special">=</span> <span class="number">2</span> <span class="special">-</span> <span class="identifier">erfc</span><span class="special">(</span><span class="identifier">z</span><span class="special">);</span> <span class="comment">// preferred when -z &lt; -0.5</span>
<span class="identifier">erfc</span><span class="special">(-</span><span class="identifier">z</span><span class="special">)</span> <span class="special">=</span> <span class="number">1</span> <span class="special">+</span> <span class="identifier">erf</span><span class="special">(</span><span class="identifier">z</span><span class="special">);</span> <span class="comment">// preferred when -0.5 &lt;= -z &lt; 0</span>
</pre>
<p>
The generic versions of these functions are implemented in terms of the incomplete
gamma function.
</p>
<p>
When the significand (mantissa) size is recognised (currently for 53, 64
and 113-bit reals, plus single-precision 24-bit handled via promotion to
double) then a series of rational approximations <a class="link" href="../sf_implementation.html#math_toolkit.sf_implementation.rational_approximations_used">devised
by JM</a> are used.
</p>
<p>
For <code class="computeroutput"><span class="identifier">z</span> <span class="special">&lt;=</span>
<span class="number">0.5</span></code> then a rational approximation to
erf is used, based on the observation that erf is an odd function and therefore
erf is calculated using:
</p>
<pre class="programlisting"><span class="identifier">erf</span><span class="special">(</span><span class="identifier">z</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">z</span> <span class="special">*</span> <span class="special">(</span><span class="identifier">C</span> <span class="special">+</span> <span class="identifier">R</span><span class="special">(</span><span class="identifier">z</span><span class="special">*</span><span class="identifier">z</span><span class="special">));</span>
</pre>
<p>
where the rational approximation R(z*z) is optimised for absolute error:
as long as its absolute error is small enough compared to the constant C,
then any round-off error incurred during the computation of R(z*z) will effectively
disappear from the result. As a result the error for erf and erfc in this
region is very low: the last bit is incorrect in only a very small number
of cases.
</p>
<p>
For <code class="computeroutput"><span class="identifier">z</span> <span class="special">&gt;</span>
<span class="number">0.5</span></code> we observe that over a small interval
[a, b) then:
</p>
<pre class="programlisting"><span class="identifier">erfc</span><span class="special">(</span><span class="identifier">z</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">exp</span><span class="special">(</span><span class="identifier">z</span><span class="special">*</span><span class="identifier">z</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">z</span> <span class="special">~</span> <span class="identifier">c</span>
</pre>
<p>
for some constant c.
</p>
<p>
Therefore for <code class="computeroutput"><span class="identifier">z</span> <span class="special">&gt;</span>
<span class="number">0.5</span></code> we calculate erfc using:
</p>
<pre class="programlisting"><span class="identifier">erfc</span><span class="special">(</span><span class="identifier">z</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">exp</span><span class="special">(-</span><span class="identifier">z</span><span class="special">*</span><span class="identifier">z</span><span class="special">)</span> <span class="special">*</span> <span class="special">(</span><span class="identifier">C</span> <span class="special">+</span> <span class="identifier">R</span><span class="special">(</span><span class="identifier">z</span> <span class="special">-</span> <span class="identifier">B</span><span class="special">))</span> <span class="special">/</span> <span class="identifier">z</span><span class="special">;</span>
</pre>
<p>
Again R(z - B) is optimised for absolute error, and the constant <code class="computeroutput"><span class="identifier">C</span></code> is the average of <code class="computeroutput"><span class="identifier">erfc</span><span class="special">(</span><span class="identifier">z</span><span class="special">)</span>
<span class="special">*</span> <span class="identifier">exp</span><span class="special">(</span><span class="identifier">z</span><span class="special">*</span><span class="identifier">z</span><span class="special">)</span> <span class="special">*</span>
<span class="identifier">z</span></code> taken at the endpoints of the
range. Once again, as long as the absolute error in R(z - B) is small compared
to <code class="computeroutput"><span class="identifier">c</span></code> then <code class="computeroutput"><span class="identifier">c</span>
<span class="special">+</span> <span class="identifier">R</span><span class="special">(</span><span class="identifier">z</span> <span class="special">-</span>
<span class="identifier">B</span><span class="special">)</span></code>
will be correctly rounded, and the error in the result will depend only on
the accuracy of the exp function. In practice, in all but a very small number
of cases, the error is confined to the last bit of the result. The constant
<code class="computeroutput"><span class="identifier">B</span></code> is chosen so that the left
hand end of the range of the rational approximation is 0.
</p>
<p>
For large <code class="computeroutput"><span class="identifier">z</span></code> over a range
[a, +&#8734;] the above approximation is modified to:
</p>
<pre class="programlisting"><span class="identifier">erfc</span><span class="special">(</span><span class="identifier">z</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">exp</span><span class="special">(-</span><span class="identifier">z</span><span class="special">*</span><span class="identifier">z</span><span class="special">)</span> <span class="special">*</span> <span class="special">(</span><span class="identifier">C</span> <span class="special">+</span> <span class="identifier">R</span><span class="special">(</span><span class="number">1</span> <span class="special">/</span> <span class="identifier">z</span><span class="special">))</span> <span class="special">/</span> <span class="identifier">z</span><span class="special">;</span>
</pre>
</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="../sf_erf.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_erf.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="error_inv.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
libs/math/doc/html/math_toolkit/sf_erf/error_inv.html
+351
View File
@@ -0,0 +1,351 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Error Function Inverses</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="../sf_erf.html" title="Error Functions">
<link rel="prev" href="error_function.html" title="Error Functions">
<link rel="next" href="../sf_poly.html" title="Polynomials">
</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="error_function.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_erf.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="../sf_poly.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.sf_erf.error_inv"></a><a class="link" href="error_inv.html" title="Error Function Inverses">Error Function Inverses</a>
</h3></div></div></div>
<h5>
<a name="math_toolkit.sf_erf.error_inv.h0"></a>
<span class="phrase"><a name="math_toolkit.sf_erf.error_inv.synopsis"></a></span><a class="link" href="error_inv.html#math_toolkit.sf_erf.error_inv.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">erf</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">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">erf_inv</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">p</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">erf_inv</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">p</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">erfc_inv</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">p</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">erfc_inv</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">p</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>
<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>: the return type is <code class="computeroutput"><span class="keyword">double</span></code> if T is an integer type, and T otherwise.
</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.sf_erf.error_inv.h1"></a>
<span class="phrase"><a name="math_toolkit.sf_erf.error_inv.description"></a></span><a class="link" href="error_inv.html#math_toolkit.sf_erf.error_inv.description">Description</a>
</h5>
<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">erf_inv</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">z</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">erf_inv</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">z</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 <a href="http://functions.wolfram.com/GammaBetaErf/InverseErf/" target="_top">inverse
error function</a> of z, that is a value x such that:
</p>
<pre class="programlisting"><span class="identifier">p</span> <span class="special">=</span> <span class="identifier">erf</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
<span class="inlinemediaobject"><img src="../../../graphs/erf_inv.svg" align="middle"></span>
</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">erfc_inv</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">z</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">erfc_inv</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">z</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 inverse of the complement of the error function of z, that is
a value x such that:
</p>
<pre class="programlisting"><span class="identifier">p</span> <span class="special">=</span> <span class="identifier">erfc</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
<span class="inlinemediaobject"><img src="../../../graphs/erfc_inv.svg" align="middle"></span>
</p>
<h5>
<a name="math_toolkit.sf_erf.error_inv.h2"></a>
<span class="phrase"><a name="math_toolkit.sf_erf.error_inv.accuracy"></a></span><a class="link" href="error_inv.html#math_toolkit.sf_erf.error_inv.accuracy">Accuracy</a>
</h5>
<p>
For types up to and including 80-bit long doubles the approximations used
are accurate to less than ~ 2 epsilon. For higher precision types these functions
have the same accuracy as the <a class="link" href="error_function.html" title="Error Functions">forward
error functions</a>.
</p>
<div class="table">
<a name="math_toolkit.sf_erf.error_inv.table_erf_inv"></a><p class="title"><b>Table&#160;6.30.&#160;Error rates for erf_inv</b></p>
<div class="table-contents"><table class="table" summary="Error rates for erf_inv">
<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>
Inverse Erf Function
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.09&#949; (Mean = 0.502&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.996&#949; (Mean = 0.389&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.996&#949; (Mean = 0.385&#949;)</span>
</p>
</td>
</tr></tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="math_toolkit.sf_erf.error_inv.table_erfc_inv"></a><p class="title"><b>Table&#160;6.31.&#160;Error rates for erfc_inv</b></p>
<div class="table-contents"><table class="table" summary="Error rates for erfc_inv">
<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>
Inverse Erfc Function
</p>
</td>
<td>
<p>
<span class="blue">Max = 1&#949; (Mean = 0.491&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.996&#949; (Mean = 0.397&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.996&#949; (Mean = 0.397&#949;)</span>
</p>
</td>
</tr>
<tr>
<td>
<p>
Inverse Erfc Function: extreme values
</p>
</td>
<td>
</td>
<td>
</td>
<td>
<p>
<span class="blue">Max = 1.62&#949; (Mean = 0.383&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.62&#949; (Mean = 0.385&#949;)</span>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><h5>
<a name="math_toolkit.sf_erf.error_inv.h3"></a>
<span class="phrase"><a name="math_toolkit.sf_erf.error_inv.testing"></a></span><a class="link" href="error_inv.html#math_toolkit.sf_erf.error_inv.testing">Testing</a>
</h5>
<p>
There are two sets of tests:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Basic sanity checks attempt to "round-trip" from <span class="emphasis"><em>x</em></span>
to <span class="emphasis"><em>p</em></span> and back again. These tests have quite generous
tolerances: in general both the error functions and their inverses change
so rapidly in some places that round tripping to more than a couple of
significant digits isn't possible. This is especially true when <span class="emphasis"><em>p</em></span>
is very near one: in this case there isn't enough "information content"
in the input to the inverse function to get back where you started.
</li>
<li class="listitem">
Accuracy checks using high-precision test values. These measure the accuracy
of the result, given <span class="emphasis"><em>exact</em></span> input values.
</li>
</ul></div>
<h5>
<a name="math_toolkit.sf_erf.error_inv.h4"></a>
<span class="phrase"><a name="math_toolkit.sf_erf.error_inv.implementation"></a></span><a class="link" href="error_inv.html#math_toolkit.sf_erf.error_inv.implementation">Implementation</a>
</h5>
<p>
These functions use a rational approximation <a class="link" href="../sf_implementation.html#math_toolkit.sf_implementation.rational_approximations_used">devised
by JM</a> to calculate an initial approximation to the result that is
accurate to ~10<sup>-19</sup>, then only if that has insufficient accuracy compared
to the epsilon for T, do we clean up the result using <a href="http://en.wikipedia.org/wiki/Simple_rational_approximation" target="_top">Halley
iteration</a>.
</p>
<p>
Constructing rational approximations to the erf/erfc functions is actually
surprisingly hard, especially at high precision. For this reason no attempt
has been made to achieve 10<sup>-34 </sup> accuracy suitable for use with 128-bit reals.
</p>
<p>
In the following discussion, <span class="emphasis"><em>p</em></span> is the value passed to
erf_inv, and <span class="emphasis"><em>q</em></span> is the value passed to erfc_inv, so that
<span class="emphasis"><em>p = 1 - q</em></span> and <span class="emphasis"><em>q = 1 - p</em></span> and in
both cases we want to solve for the same result <span class="emphasis"><em>x</em></span>.
</p>
<p>
For <span class="emphasis"><em>p &lt; 0.5</em></span> the inverse erf function is reasonably
smooth and the approximation:
</p>
<pre class="programlisting"><span class="identifier">x</span> <span class="special">=</span> <span class="identifier">p</span><span class="special">(</span><span class="identifier">p</span> <span class="special">+</span> <span class="number">10</span><span class="special">)(</span><span class="identifier">Y</span> <span class="special">+</span> <span class="identifier">R</span><span class="special">(</span><span class="identifier">p</span><span class="special">))</span>
</pre>
<p>
Gives a good result for a constant Y, and R(p) optimised for low absolute
error compared to |Y|.
</p>
<p>
For q &lt; 0.5 things get trickier, over the interval <span class="emphasis"><em>0.5 &gt;
q &gt; 0.25</em></span> the following approximation works well:
</p>
<pre class="programlisting"><span class="identifier">x</span> <span class="special">=</span> <span class="identifier">sqrt</span><span class="special">(-</span><span class="number">2l</span><span class="identifier">og</span><span class="special">(</span><span class="identifier">q</span><span class="special">))</span> <span class="special">/</span> <span class="special">(</span><span class="identifier">Y</span> <span class="special">+</span> <span class="identifier">R</span><span class="special">(</span><span class="identifier">q</span><span class="special">))</span>
</pre>
<p>
While for q &lt; 0.25, let
</p>
<pre class="programlisting"><span class="identifier">z</span> <span class="special">=</span> <span class="identifier">sqrt</span><span class="special">(-</span><span class="identifier">log</span><span class="special">(</span><span class="identifier">q</span><span class="special">))</span>
</pre>
<p>
Then the result is given by:
</p>
<pre class="programlisting"><span class="identifier">x</span> <span class="special">=</span> <span class="identifier">z</span><span class="special">(</span><span class="identifier">Y</span> <span class="special">+</span> <span class="identifier">R</span><span class="special">(</span><span class="identifier">z</span> <span class="special">-</span> <span class="identifier">B</span><span class="special">))</span>
</pre>
<p>
As before Y is a constant and the rational function R is optimised for low
absolute error compared to |Y|. B is also a constant: it is the smallest
value of <span class="emphasis"><em>z</em></span> for which each approximation is valid. There
are several approximations of this form each of which reaches a little further
into the tail of the erfc function (at <code class="computeroutput"><span class="keyword">long</span>
<span class="keyword">double</span></code> precision the extended exponent
range compared to <code class="computeroutput"><span class="keyword">double</span></code> means
that the tail goes on for a very long way indeed).
</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="error_function.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_erf.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="../sf_poly.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>