[DEV] add v1.66.0

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

View File

@@ -0,0 +1,245 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Chebyshev Polynomials</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.6.0">
<link rel="up" href="../sf_poly.html" title="Polynomials">
<link rel="prev" href="hermite.html" title="Hermite Polynomials">
<link rel="next" href="sph_harm.html" title="Spherical Harmonics">
</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="hermite.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_poly.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="sph_harm.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_poly.chebyshev"></a><a class="link" href="chebyshev.html" title="Chebyshev Polynomials">Chebyshev Polynomials</a>
</h3></div></div></div>
<h5>
<a name="math_toolkit.sf_poly.chebyshev.h0"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.chebyshev.synopsis"></a></span><a class="link" href="chebyshev.html#math_toolkit.sf_poly.chebyshev.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">chebyshev</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">Real1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Real2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Real3</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">chebyshev_next</span><span class="special">(</span><span class="identifier">Real1</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">Real2</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="identifier">Tn</span><span class="special">,</span> <span class="identifier">Real3</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="identifier">Tn_1</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Real</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">chebyshev_t</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">Real</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Real</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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">chebyshev_t</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">Real</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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">Real</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">chebyshev_u</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">Real</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Real</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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">chebyshev_u</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">Real</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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">Real</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">chebyshev_t_prime</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">Real</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Real1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Real2</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">chebyshev_clenshaw_recurrence</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Real</span><span class="special">*</span> <span class="keyword">const</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">length</span><span class="special">,</span> <span class="identifier">Real2</span> <span class="identifier">x</span><span class="special">);</span>
<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
<span class="quote">&#8220;<span class="quote">Real analysts cannot do without Fourier, complex analysts cannot do
without Laurent, and numerical analysts cannot do without Chebyshev</span>&#8221;</span>--Lloyd
N. Trefethen
</p>
<p>
The Chebyshev polynomials of the first kind are defined by the recurrence
<span class="emphasis"><em>T</em></span><sub>n+1</sub>(<span class="emphasis"><em>x</em></span>) := <span class="emphasis"><em>2xT</em></span><sub>n</sub>(<span class="emphasis"><em>x</em></span>)
- <span class="emphasis"><em>T</em></span><sub>n-1</sub>(<span class="emphasis"><em>x</em></span>), <span class="emphasis"><em>n &gt; 0</em></span>,
where <span class="emphasis"><em>T</em></span><sub>0</sub>(<span class="emphasis"><em>x</em></span>) := 1 and <span class="emphasis"><em>T</em></span><sub>1</sub>(<span class="emphasis"><em>x</em></span>)
:= <span class="emphasis"><em>x</em></span>. These can be calculated in Boost using the following
simple code
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">0.5</span><span class="special">;</span>
<span class="keyword">double</span> <span class="identifier">T12</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">chebyshev_t</span><span class="special">(</span><span class="number">12</span><span class="special">,</span> <span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
Calculation of derivatives is also straightforward:
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">T12_prime</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">chebyshev_t_prime</span><span class="special">(</span><span class="number">12</span><span class="special">,</span> <span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
The complexity of evaluation of the <span class="emphasis"><em>n</em></span>-th Chebyshev polynomial
by these functions is linear. So they are unsuitable for use in calculation
of (say) a Chebyshev series, as a sum of linear scaling functions scales
quadratically. Though there are very sophisticated algorithms for the evaluation
of Chebyshev series, a linear time algorithm is presented below:
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">0.5</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">c</span><span class="special">{</span><span class="number">14.2</span><span class="special">,</span> <span class="special">-</span><span class="number">13.7</span><span class="special">,</span> <span class="number">82.3</span><span class="special">,</span> <span class="number">96</span><span class="special">};</span>
<span class="keyword">double</span> <span class="identifier">T0</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
<span class="keyword">double</span> <span class="identifier">T1</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">;</span>
<span class="keyword">double</span> <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">c</span><span class="special">[</span><span class="number">0</span><span class="special">]*</span><span class="identifier">T0</span><span class="special">/</span><span class="number">2</span><span class="special">;</span>
<span class="keyword">unsigned</span> <span class="identifier">l</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
<span class="keyword">while</span><span class="special">(</span><span class="identifier">l</span> <span class="special">&lt;</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">size</span><span class="special">())</span>
<span class="special">{</span>
<span class="identifier">f</span> <span class="special">+=</span> <span class="identifier">c</span><span class="special">[</span><span class="identifier">l</span><span class="special">]*</span><span class="identifier">T1</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">T0</span><span class="special">,</span> <span class="identifier">T1</span><span class="special">);</span>
<span class="identifier">T1</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">chebyshev_next</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">T0</span><span class="special">,</span> <span class="identifier">T1</span><span class="special">);</span>
<span class="special">++</span><span class="identifier">l</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
This uses the <code class="computeroutput"><span class="identifier">chebyshev_next</span></code>
function to evaluate each term of the Chebyshev series in constant time.
However, this naive algorithm has a catastrophic loss of precision as <span class="emphasis"><em>x</em></span>
approaches 1. A method to mitigate this way given by <a href="http://www.ams.org/journals/mcom/1955-09-051/S0025-5718-1955-0071856-0/S0025-5718-1955-0071856-0.pdf" target="_top">Clenshaw</a>,
and is implemented in boost as
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">0.5</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">c</span><span class="special">{</span><span class="number">14.2</span><span class="special">,</span> <span class="special">-</span><span class="number">13.7</span><span class="special">,</span> <span class="number">82.3</span><span class="special">,</span> <span class="number">96</span><span class="special">};</span>
<span class="keyword">double</span> <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">chebyshev_clenshaw_recurrence</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">data</span><span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">size</span><span class="special">(),</span> <span class="identifier">Real</span> <span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
N.B.: There is factor of <span class="emphasis"><em>2</em></span> difference in our definition
of the first coefficient in the Chebyshev series from Clenshaw's original
work. This is because two traditions exist in notation for the Chebyshev
series expansion,
</p>
<p>
<span class="emphasis"><em>f</em></span>(<span class="emphasis"><em>x</em></span>) &#8776; &#8721;<sub>n=0</sub><sup>N-1</sup> <span class="emphasis"><em>a</em></span><sub>n</sub><span class="emphasis"><em>T</em></span><sub>n</sub>(<span class="emphasis"><em>x</em></span>)
</p>
<p>
and
</p>
<p>
<span class="emphasis"><em>f</em></span>(<span class="emphasis"><em>x</em></span>) &#8776; <span class="emphasis"><em>c</em></span><sub>0</sub>/2
+ &#8721;<sub>n=1</sub><sup>N-1</sup> <span class="emphasis"><em>c</em></span><sub>n</sub><span class="emphasis"><em>T</em></span><sub>n</sub>(<span class="emphasis"><em>x</em></span>)
</p>
<p>
<span class="emphasis"><em><span class="bold"><strong>boost math always uses the second convention,
with the factor of 1/2 on the first coefficient.</strong></span></em></span>
</p>
<p>
Chebyshev polynomials of the second kind can be evaluated via <code class="computeroutput"><span class="identifier">chebyshev_u</span></code>:
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="special">-</span><span class="number">0.23</span><span class="special">;</span>
<span class="keyword">double</span> <span class="identifier">U1</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">chebyshev_u</span><span class="special">(</span><span class="number">1</span><span class="special">,</span> <span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
The evaluation of Chebyshev polynomials by a three-term recurrence is known
to be <a href="https://link.springer.com/article/10.1007/s11075-014-9925-x" target="_top">mixed
forward-backward stable</a> for <span class="emphasis"><em>x</em></span> &#8714; [-1,
1]. However, the author does not know of a similar result for <span class="emphasis"><em>x</em></span>
outside [-1, 1]. For this reason, evaluation of Chebyshev polynomials outside
of [-1, 1] is strongly discouraged. That said, small rounding errors in the
course of a computation will often lead to this situation, and termination
of the computation due to these small problems is very discouraging. For
this reason, <code class="computeroutput"><span class="identifier">chebyshev_t</span></code>
and <code class="computeroutput"><span class="identifier">chebyshev_u</span></code> have code
paths for <span class="emphasis"><em>x &gt; 1</em></span> and <span class="emphasis"><em>x &lt; -1</em></span>
which do not use three-term recurrences. These code paths are <span class="emphasis"><em>much
slower</em></span>, and should be avoided if at all possible.
</p>
<p>
Evaluation of a Chebyshev series is relatively simple. The real challenge
is <span class="emphasis"><em>generation</em></span> of the Chebyshev series. For this purpose,
boost provides a <span class="emphasis"><em>Chebyshev transform</em></span>, a projection operator
which projects a function onto a finite-dimensional span of Chebyshev polynomials.
But before we discuss the API, let's analyze why we might want to project
a function onto a span of Chebyshev polynomials.
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
We want a numerically stable way to evaluate the function's derivative
</li>
<li class="listitem">
Our function is expensive to evaluate, and we wish to find a less expensive
way to estimate its value. An example are the standard library transcendental
functions: These functions are guaranteed to evaluate to within 1 ulp
of the exact value, but often this accuracy is not needed. A projection
onto the Chebyshev polynomials with a low accuracy requirement can vastly
accelerate the computation of these functions.
</li>
<li class="listitem">
We wish to numerically integrate the function
</li>
</ul></div>
<p>
The API is given below.
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">chebyshev_transform</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">Real</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">chebyshev_transform</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">&gt;</span>
<span class="identifier">chebyshev_transform</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">F</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">Real</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">Real</span> <span class="identifier">b</span><span class="special">,</span> <span class="identifier">Real</span> <span class="identifier">tol</span><span class="special">=</span><span class="number">500</span><span class="special">*</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">Real</span><span class="special">&gt;::</span><span class="identifier">epsilon</span><span class="special">());</span>
<span class="identifier">Real</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">Real</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">Real</span> <span class="identifier">integrate</span><span class="special">()</span> <span class="keyword">const</span>
<span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">Real</span><span class="special">&gt;&amp;</span> <span class="identifier">coefficients</span><span class="special">()</span> <span class="keyword">const</span>
<span class="identifier">Real</span> <span class="identifier">prime</span><span class="special">(</span><span class="identifier">Real</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span>
<span class="special">};</span>
<span class="special">}}//</span> <span class="identifier">end</span> <span class="identifier">namespaces</span>
</pre>
<p>
The Chebyshev transform takes a function <span class="emphasis"><em>f</em></span> and returns
a <span class="emphasis"><em>near-minimax</em></span> approximation to <span class="emphasis"><em>f</em></span>
in terms of Chebyshev polynomials. By <span class="emphasis"><em>near-minimax</em></span>,
we mean that the resulting Chebyshev polynomial is "very close"
the polynomial <span class="emphasis"><em>p</em></span><sub>n</sub> which minimizes the uniform norm of
<span class="emphasis"><em>f</em></span> - <span class="emphasis"><em>p</em></span><sub>n</sub>. The notion of "very
close" can be made rigorous; see Trefethen's "Approximation Theory
and Approximation Practice" for details.
</p>
<p>
The Chebyshev transform works by creating a vector of values by evaluating
the input function at the Chebyshev points, and then performing a discrete
cosine transform on the resulting vector. In order to do this efficiently,
we have used FFTW3. So to compile, you must have <code class="computeroutput"><span class="identifier">FFTW3</span></code>
installed, and link with <code class="computeroutput"><span class="special">-</span><span class="identifier">lfftw3</span></code>
for double precision, <code class="computeroutput"><span class="special">-</span><span class="identifier">lfftw3f</span></code>
for float precision, <code class="computeroutput"><span class="special">-</span><span class="identifier">lfftw3l</span></code>
for long double precision, and -lfftwq for quad (<code class="computeroutput"><span class="identifier">__float128</span></code>)
precision. After the coefficients of the Chebyshev series are known, the
routine goes back through them and filters out all the coefficients whose
absolute ratio to the largest coefficient are less than the tolerance requested
in the constructor.
</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, 2017 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, Nicholas Thompson, 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="hermite.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_poly.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="sph_harm.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,244 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Hermite Polynomials</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.6.0">
<link rel="up" href="../sf_poly.html" title="Polynomials">
<link rel="prev" href="laguerre.html" title="Laguerre (and Associated) Polynomials">
<link rel="next" href="chebyshev.html" title="Chebyshev 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="laguerre.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_poly.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="chebyshev.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_poly.hermite"></a><a class="link" href="hermite.html" title="Hermite Polynomials">Hermite Polynomials</a>
</h3></div></div></div>
<h5>
<a name="math_toolkit.sf_poly.hermite.h0"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.hermite.synopsis"></a></span><a class="link" href="hermite.html#math_toolkit.sf_poly.hermite.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">hermite</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">hermite</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</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;18.&#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">hermite</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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">,</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">hermite_next</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">Hn</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">Hnm1</span><span class="special">);</span>
<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<h5>
<a name="math_toolkit.sf_poly.hermite.h1"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.hermite.description"></a></span><a class="link" href="hermite.html#math_toolkit.sf_poly.hermite.description">Description</a>
</h5>
<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>: note than when there is a single
template argument the result is the same type as that argument or <code class="computeroutput"><span class="keyword">double</span></code> if the template argument is an integer
type.
</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">hermite</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</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;18.&#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">hermite</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the value of the Hermite Polynomial of order <span class="emphasis"><em>n</em></span>
at point <span class="emphasis"><em>x</em></span>:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/hermite_0.svg"></span>
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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;18.&#160;Policies: Controlling Precision, Error Handling etc">policy
documentation for more details</a>.
</p>
<p>
The following graph illustrates the behaviour of the first few Hermite Polynomials:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../graphs/hermite.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">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">hermite_next</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">Hn</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">Hnm1</span><span class="special">);</span>
</pre>
<p>
Implements the three term recurrence relation for the Hermite polynomials,
this function can be used to create a sequence of values evaluated at the
same <span class="emphasis"><em>x</em></span>, and for rising <span class="emphasis"><em>n</em></span>.
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/hermite_1.svg"></span>
</p>
<p>
For example we could produce a vector of the first 10 polynomial values using:
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">0.5</span><span class="special">;</span> <span class="comment">// Abscissa value</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">hermite</span><span class="special">(</span><span class="number">0</span><span class="special">,</span> <span class="identifier">x</span><span class="special">)).</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">hermite</span><span class="special">(</span><span class="number">1</span><span class="special">,</span> <span class="identifier">x</span><span class="special">));</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">l</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">l</span><span class="special">)</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">hermite_next</span><span class="special">(</span><span class="identifier">l</span><span class="special">,</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">v</span><span class="special">[</span><span class="identifier">l</span><span class="special">],</span> <span class="identifier">v</span><span class="special">[</span><span class="identifier">l</span><span class="special">-</span><span class="number">1</span><span class="special">]));</span>
</pre>
<p>
Formally the arguments are:
</p>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">n</span></dt>
<dd><p>
The degree <span class="emphasis"><em>n</em></span> of the last polynomial calculated.
</p></dd>
<dt><span class="term">x</span></dt>
<dd><p>
The abscissa value
</p></dd>
<dt><span class="term">Hn</span></dt>
<dd><p>
The value of the polynomial evaluated at degree <span class="emphasis"><em>n</em></span>.
</p></dd>
<dt><span class="term">Hnm1</span></dt>
<dd><p>
The value of the polynomial evaluated at degree <span class="emphasis"><em>n-1</em></span>.
</p></dd>
</dl>
</div>
<h5>
<a name="math_toolkit.sf_poly.hermite.h2"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.hermite.accuracy"></a></span><a class="link" href="hermite.html#math_toolkit.sf_poly.hermite.accuracy">Accuracy</a>
</h5>
<p>
The following table shows peak errors (in units of epsilon) for various domains
of input arguments. 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>.
</p>
<div class="table">
<a name="math_toolkit.sf_poly.hermite.table_hermite"></a><p class="title"><b>Table&#160;6.37.&#160;Error rates for hermite</b></p>
<div class="table-contents"><table class="table" summary="Error rates for hermite">
<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>
Hermite Polynomials
</p>
</td>
<td>
<p>
<span class="blue">Max = 4.46&#949; (Mean = 1.41&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0&#949; (Mean = 0&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 6.24&#949; (Mean = 2.07&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 6.24&#949; (Mean = 2.07&#949;)</span>
</p>
</td>
</tr></tbody>
</table></div>
</div>
<br class="table-break"><p>
Note that the worst errors occur when the degree increases, values greater
than ~120 are very unlikely to produce sensible results, especially in the
associated polynomial case when the order is also large. Further the relative
errors are likely to grow arbitrarily large when the function is very close
to a root.
</p>
<h5>
<a name="math_toolkit.sf_poly.hermite.h3"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.hermite.testing"></a></span><a class="link" href="hermite.html#math_toolkit.sf_poly.hermite.testing">Testing</a>
</h5>
<p>
A mixture of spot tests of values calculated using functions.wolfram.com,
and randomly generated test data are used: the test data was computed using
<a href="http://shoup.net/ntl/doc/RR.txt" target="_top">NTL::RR</a> at 1000-bit
precision.
</p>
<h5>
<a name="math_toolkit.sf_poly.hermite.h4"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.hermite.implementation"></a></span><a class="link" href="hermite.html#math_toolkit.sf_poly.hermite.implementation">Implementation</a>
</h5>
<p>
These functions are implemented using the stable three term recurrence relations.
These relations guarantee low absolute error but cannot guarantee low relative
error near one of the roots of the polynomials.
</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, 2017 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, Nicholas Thompson, 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="laguerre.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_poly.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="chebyshev.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,385 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Laguerre (and Associated) Polynomials</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.6.0">
<link rel="up" href="../sf_poly.html" title="Polynomials">
<link rel="prev" href="legendre_stieltjes.html" title="Legendre-Stieltjes Polynomials">
<link rel="next" href="hermite.html" title="Hermite 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="legendre_stieltjes.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_poly.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="hermite.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_poly.laguerre"></a><a class="link" href="laguerre.html" title="Laguerre (and Associated) Polynomials">Laguerre (and Associated)
Polynomials</a>
</h3></div></div></div>
<h5>
<a name="math_toolkit.sf_poly.laguerre.h0"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.laguerre.synopsis"></a></span><a class="link" href="laguerre.html#math_toolkit.sf_poly.laguerre.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">laguerre</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">laguerre</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</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;18.&#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">laguerre</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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">laguerre</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</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;18.&#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">laguerre</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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">,</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">laguerre_next</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">Ln</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">Lnm1</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">laguerre_next</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">Ln</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">Lnm1</span><span class="special">);</span>
<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<h5>
<a name="math_toolkit.sf_poly.laguerre.h1"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.laguerre.description"></a></span><a class="link" href="laguerre.html#math_toolkit.sf_poly.laguerre.description">Description</a>
</h5>
<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>: note than when there is a single
template argument the result is the same type as that argument or <code class="computeroutput"><span class="keyword">double</span></code> if the template argument is an integer
type.
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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;18.&#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">laguerre</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</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;18.&#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">laguerre</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the value of the Laguerre Polynomial of order <span class="emphasis"><em>n</em></span>
at point <span class="emphasis"><em>x</em></span>:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/laguerre_0.svg"></span>
</p>
<p>
The following graph illustrates the behaviour of the first few Laguerre Polynomials:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../graphs/laguerre.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">laguerre</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</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;18.&#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">laguerre</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the Associated Laguerre polynomial of degree <span class="emphasis"><em>n</em></span>
and order <span class="emphasis"><em>m</em></span> at point <span class="emphasis"><em>x</em></span>:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/laguerre_1.svg"></span>
</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">laguerre_next</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">Ln</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">Lnm1</span><span class="special">);</span>
</pre>
<p>
Implements the three term recurrence relation for the Laguerre polynomials,
this function can be used to create a sequence of values evaluated at the
same <span class="emphasis"><em>x</em></span>, and for rising <span class="emphasis"><em>n</em></span>.
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/laguerre_2.svg"></span>
</p>
<p>
For example we could produce a vector of the first 10 polynomial values using:
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">0.5</span><span class="special">;</span> <span class="comment">// Abscissa value</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">laguerre</span><span class="special">(</span><span class="number">0</span><span class="special">,</span> <span class="identifier">x</span><span class="special">)).</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">laguerre</span><span class="special">(</span><span class="number">1</span><span class="special">,</span> <span class="identifier">x</span><span class="special">));</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">l</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">l</span><span class="special">)</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">laguerre_next</span><span class="special">(</span><span class="identifier">l</span><span class="special">,</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">v</span><span class="special">[</span><span class="identifier">l</span><span class="special">],</span> <span class="identifier">v</span><span class="special">[</span><span class="identifier">l</span><span class="special">-</span><span class="number">1</span><span class="special">]));</span>
</pre>
<p>
Formally the arguments are:
</p>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">n</span></dt>
<dd><p>
The degree <span class="emphasis"><em>n</em></span> of the last polynomial calculated.
</p></dd>
<dt><span class="term">x</span></dt>
<dd><p>
The abscissa value
</p></dd>
<dt><span class="term">Ln</span></dt>
<dd><p>
The value of the polynomial evaluated at degree <span class="emphasis"><em>n</em></span>.
</p></dd>
<dt><span class="term">Lnm1</span></dt>
<dd><p>
The value of the polynomial evaluated at degree <span class="emphasis"><em>n-1</em></span>.
</p></dd>
</dl>
</div>
<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">laguerre_next</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">Ln</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">Lnm1</span><span class="special">);</span>
</pre>
<p>
Implements the three term recurrence relation for the Associated Laguerre
polynomials, this function can be used to create a sequence of values evaluated
at the same <span class="emphasis"><em>x</em></span>, and for rising degree <span class="emphasis"><em>n</em></span>.
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/laguerre_3.svg"></span>
</p>
<p>
For example we could produce a vector of the first 10 polynomial values using:
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">0.5</span><span class="special">;</span> <span class="comment">// Abscissa value</span>
<span class="keyword">int</span> <span class="identifier">m</span> <span class="special">=</span> <span class="number">10</span><span class="special">;</span> <span class="comment">// order</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">laguerre</span><span class="special">(</span><span class="number">0</span><span class="special">,</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">x</span><span class="special">)).</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">laguerre</span><span class="special">(</span><span class="number">1</span><span class="special">,</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">x</span><span class="special">));</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">l</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">l</span><span class="special">)</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">laguerre_next</span><span class="special">(</span><span class="identifier">l</span><span class="special">,</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">v</span><span class="special">[</span><span class="identifier">l</span><span class="special">],</span> <span class="identifier">v</span><span class="special">[</span><span class="identifier">l</span><span class="special">-</span><span class="number">1</span><span class="special">]));</span>
</pre>
<p>
Formally the arguments are:
</p>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">n</span></dt>
<dd><p>
The degree of the last polynomial calculated.
</p></dd>
<dt><span class="term">m</span></dt>
<dd><p>
The order of the Associated Polynomial.
</p></dd>
<dt><span class="term">x</span></dt>
<dd><p>
The abscissa value.
</p></dd>
<dt><span class="term">Ln</span></dt>
<dd><p>
The value of the polynomial evaluated at degree <span class="emphasis"><em>n</em></span>.
</p></dd>
<dt><span class="term">Lnm1</span></dt>
<dd><p>
The value of the polynomial evaluated at degree <span class="emphasis"><em>n-1</em></span>.
</p></dd>
</dl>
</div>
<h5>
<a name="math_toolkit.sf_poly.laguerre.h2"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.laguerre.accuracy"></a></span><a class="link" href="laguerre.html#math_toolkit.sf_poly.laguerre.accuracy">Accuracy</a>
</h5>
<p>
The following table shows peak errors (in units of epsilon) for various domains
of input arguments. 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>.
</p>
<div class="table">
<a name="math_toolkit.sf_poly.laguerre.table_laguerre_n_x_"></a><p class="title"><b>Table&#160;6.35.&#160;Error rates for laguerre(n, x)</b></p>
<div class="table-contents"><table class="table" summary="Error rates for laguerre(n, x)">
<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>
Laguerre Polynomials
</p>
</td>
<td>
<p>
<span class="blue">Max = 3.1e+003&#949; (Mean = 185&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 6.82&#949; (Mean = 0.408&#949;)</span><br> <br>
(<span class="emphasis"><em>GSL 1.16:</em></span> Max = 3.1e+03&#949; (Mean = 185&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.39e+04&#949; (Mean = 828&#949;)</span><br>
<br> (<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> Max = 4.2e+03&#949; (Mean
= 251&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.39e+04&#949; (Mean = 828&#949;)</span>
</p>
</td>
</tr></tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="math_toolkit.sf_poly.laguerre.table_laguerre_n_m_x_"></a><p class="title"><b>Table&#160;6.36.&#160;Error rates for laguerre(n, m, x)</b></p>
<div class="table-contents"><table class="table" summary="Error rates for laguerre(n, m, x)">
<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>
Associated Laguerre Polynomials
</p>
</td>
<td>
<p>
<span class="blue">Max = 434&#949; (Mean = 11.1&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.84&#949; (Mean = 0.0358&#949;)</span><br> <br>
(<span class="emphasis"><em>GSL 1.16:</em></span> Max = 434&#949; (Mean = 10.7&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 167&#949; (Mean = 6.38&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> Max = 206&#949; (Mean = 6.86&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 167&#949; (Mean = 6.38&#949;)</span>
</p>
</td>
</tr></tbody>
</table></div>
</div>
<br class="table-break"><p>
Note that the worst errors occur when the degree increases, values greater
than ~120 are very unlikely to produce sensible results, especially in the
associated polynomial case when the order is also large. Further the relative
errors are likely to grow arbitrarily large when the function is very close
to a root.
</p>
<h5>
<a name="math_toolkit.sf_poly.laguerre.h3"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.laguerre.testing"></a></span><a class="link" href="laguerre.html#math_toolkit.sf_poly.laguerre.testing">Testing</a>
</h5>
<p>
A mixture of spot tests of values calculated using functions.wolfram.com,
and randomly generated test data are used: the test data was computed using
<a href="http://shoup.net/ntl/doc/RR.txt" target="_top">NTL::RR</a> at 1000-bit
precision.
</p>
<h5>
<a name="math_toolkit.sf_poly.laguerre.h4"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.laguerre.implementation"></a></span><a class="link" href="laguerre.html#math_toolkit.sf_poly.laguerre.implementation">Implementation</a>
</h5>
<p>
These functions are implemented using the stable three term recurrence relations.
These relations guarantee low absolute error but cannot guarantee low relative
error near one of the roots of the polynomials.
</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, 2017 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, Nicholas Thompson, 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="legendre_stieltjes.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_poly.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="hermite.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,650 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Legendre (and Associated) Polynomials</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.6.0">
<link rel="up" href="../sf_poly.html" title="Polynomials">
<link rel="prev" href="../sf_poly.html" title="Polynomials">
<link rel="next" href="legendre_stieltjes.html" title="Legendre-Stieltjes 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="../sf_poly.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_poly.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="legendre_stieltjes.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_poly.legendre"></a><a class="link" href="legendre.html" title="Legendre (and Associated) Polynomials">Legendre (and Associated)
Polynomials</a>
</h3></div></div></div>
<h5>
<a name="math_toolkit.sf_poly.legendre.h0"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.legendre.synopsis"></a></span><a class="link" href="legendre.html#math_toolkit.sf_poly.legendre.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">legendre</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">legendre_p</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</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;18.&#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">legendre_p</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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">legendre_p_prime</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</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;18.&#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">legendre_p_prime</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">legendre_p_zeros</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">legendre_p_zeros</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">l</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">legendre_p</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</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;18.&#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">legendre_p</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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">legendre_q</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</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;18.&#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">legendre_q</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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">,</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">legendre_next</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">Pl</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">Plm1</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">legendre_next</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">Pl</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">Plm1</span><span class="special">);</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>: note than when there is a single
template argument the result is the same type as that argument or <code class="computeroutput"><span class="keyword">double</span></code> if the template argument is an integer
type.
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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;18.&#160;Policies: Controlling Precision, Error Handling etc">policy
documentation for more details</a>.
</p>
<h5>
<a name="math_toolkit.sf_poly.legendre.h1"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.legendre.description"></a></span><a class="link" href="legendre.html#math_toolkit.sf_poly.legendre.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">legendre_p</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">l</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</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;18.&#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">legendre_p</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">l</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the Legendre Polynomial of the first kind:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/legendre_0.svg"></span>
</p>
<p>
Requires -1 &lt;= x &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>
Negative orders are handled via the reflection formula:
</p>
<p>
P<sub>-l-1</sub>(x) = P<sub>l</sub>(x)
</p>
<p>
The following graph illustrates the behaviour of the first few Legendre Polynomials:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../graphs/legendre_p.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">legendre_p_prime</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</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;18.&#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">legendre_p_prime</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the derivatives of the Legendre polynomials.
</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">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">legendre_p_zeros</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">legendre_p_zeros</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">l</span><span class="special">);</span>
</pre>
<p>
The zeros of the Legendre polynomials are calculated by Newton's method using
an initial guess given by Tricomi with root bracketing provided by Szego.
</p>
<p>
Since the Legendre polynomials are alternatively even and odd, only the non-negative
zeros are returned. For the odd Legendre polynomials, the first zero is always
zero. The rest of the zeros are returned in increasing order.
</p>
<p>
Note that the argument to the routine is an integer, and the output is a
floating-point type. Hence the template argument is mandatory. The time to
extract a single root is linear in <code class="computeroutput"><span class="identifier">l</span></code>
(this is scaling to evaluate the Legendre polynomials), so recovering all
roots is &#119926;(<code class="computeroutput"><span class="identifier">l</span></code><sup>2</sup>). Algorithms
with linear scaling <a href="http://dx.doi.org/10.1137/06067016X" target="_top">exist</a>
for recovering all roots, but requires tooling not currently built into boost.math.
This implementation proceeds under the assumption that calculating zeros
of these functions will not be a bottleneck for any workflow.
</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">legendre_p</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</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;18.&#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">legendre_p</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the associated Legendre polynomial of the first kind:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/legendre_1.svg"></span>
</p>
<p>
Requires -1 &lt;= x &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>
Negative values of <span class="emphasis"><em>l</em></span> and <span class="emphasis"><em>m</em></span> are
handled via the identity relations:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/legendre_3.svg"></span>
</p>
<div class="caution"><table border="0" summary="Caution">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="../../../../../../doc/src/images/caution.png"></td>
<th align="left">Caution</th>
</tr>
<tr><td align="left" valign="top">
<p>
The definition of the associated Legendre polynomial used here includes
a leading Condon-Shortley phase term of (-1)<sup>m</sup>. This matches the definition
given by Abramowitz and Stegun (8.6.6) and that used by <a href="http://mathworld.wolfram.com/LegendrePolynomial.html" target="_top">Mathworld</a>
and <a href="http://documents.wolfram.com/mathematica/functions/LegendreP" target="_top">Mathematica's
LegendreP function</a>. However, uses in the literature do not always
include this phase term, and strangely the specification for the associated
Legendre function in the C++ TR1 (assoc_legendre) also omits it, in spite
of stating that it uses Abramowitz and Stegun as the final arbiter on these
matters.
</p>
<p>
See:
</p>
<p>
<a href="http://mathworld.wolfram.com/LegendrePolynomial.html" target="_top">Weisstein,
Eric W. "Legendre Polynomial." From MathWorld--A Wolfram Web
Resource</a>.
</p>
<p>
Abramowitz, M. and Stegun, I. A. (Eds.). "Legendre Functions"
and "Orthogonal Polynomials." Ch. 22 in Chs. 8 and 22 in Handbook
of Mathematical Functions with Formulas, Graphs, and Mathematical Tables,
9th printing. New York: Dover, pp. 331-339 and 771-802, 1972.
</p>
</td></tr>
</table></div>
<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">legendre_q</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</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;18.&#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">legendre_q</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the value of the Legendre polynomial that is the second solution
to the Legendre differential equation, for example:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/legendre_2.svg"></span>
</p>
<p>
Requires -1 &lt;= x &lt;= 1, otherwise <a class="link" href="../error_handling.html#math_toolkit.error_handling.domain_error">domain_error</a>
is called.
</p>
<p>
The following graph illustrates the first few Legendre functions of the second
kind:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../graphs/legendre_q.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">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">legendre_next</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">Pl</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">Plm1</span><span class="special">);</span>
</pre>
<p>
Implements the three term recurrence relation for the Legendre polynomials,
this function can be used to create a sequence of values evaluated at the
same <span class="emphasis"><em>x</em></span>, and for rising <span class="emphasis"><em>l</em></span>. This
recurrence relation holds for Legendre Polynomials of both the first and
second kinds.
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/legendre_4.svg"></span>
</p>
<p>
For example we could produce a vector of the first 10 polynomial values using:
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">0.5</span><span class="special">;</span> <span class="comment">// Abscissa value</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">legendre_p</span><span class="special">(</span><span class="number">0</span><span class="special">,</span> <span class="identifier">x</span><span class="special">));</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">legendre_p</span><span class="special">(</span><span class="number">1</span><span class="special">,</span> <span class="identifier">x</span><span class="special">));</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">l</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">l</span><span class="special">)</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">legendre_next</span><span class="special">(</span><span class="identifier">l</span><span class="special">,</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">v</span><span class="special">[</span><span class="identifier">l</span><span class="special">],</span> <span class="identifier">v</span><span class="special">[</span><span class="identifier">l</span><span class="special">-</span><span class="number">1</span><span class="special">]));</span>
<span class="comment">// Double check values:</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">l</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">l</span><span class="special">)</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">v</span><span class="special">[</span><span class="identifier">l</span><span class="special">]</span> <span class="special">==</span> <span class="identifier">legendre_p</span><span class="special">(</span><span class="identifier">l</span><span class="special">,</span> <span class="identifier">x</span><span class="special">));</span>
</pre>
<p>
Formally the arguments are:
</p>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">l</span></dt>
<dd><p>
The degree of the last polynomial calculated.
</p></dd>
<dt><span class="term">x</span></dt>
<dd><p>
The abscissa value
</p></dd>
<dt><span class="term">Pl</span></dt>
<dd><p>
The value of the polynomial evaluated at degree <span class="emphasis"><em>l</em></span>.
</p></dd>
<dt><span class="term">Plm1</span></dt>
<dd><p>
The value of the polynomial evaluated at degree <span class="emphasis"><em>l-1</em></span>.
</p></dd>
</dl>
</div>
<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">legendre_next</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T2</span> <span class="identifier">Pl</span><span class="special">,</span> <span class="identifier">T3</span> <span class="identifier">Plm1</span><span class="special">);</span>
</pre>
<p>
Implements the three term recurrence relation for the Associated Legendre
polynomials, this function can be used to create a sequence of values evaluated
at the same <span class="emphasis"><em>x</em></span>, and for rising <span class="emphasis"><em>l</em></span>.
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/legendre_5.svg"></span>
</p>
<p>
For example we could produce a vector of the first m+10 polynomial values
using:
</p>
<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">0.5</span><span class="special">;</span> <span class="comment">// Abscissa value</span>
<span class="keyword">int</span> <span class="identifier">m</span> <span class="special">=</span> <span class="number">10</span><span class="special">;</span> <span class="comment">// order</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">legendre_p</span><span class="special">(</span><span class="identifier">m</span><span class="special">,</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">x</span><span class="special">));</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">legendre_p</span><span class="special">(</span><span class="number">1</span> <span class="special">+</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">x</span><span class="special">));</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">l</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">l</span><span class="special">)</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">legendre_next</span><span class="special">(</span><span class="identifier">l</span> <span class="special">+</span> <span class="number">10</span><span class="special">,</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">v</span><span class="special">[</span><span class="identifier">l</span><span class="special">],</span> <span class="identifier">v</span><span class="special">[</span><span class="identifier">l</span><span class="special">-</span><span class="number">1</span><span class="special">]));</span>
<span class="comment">// Double check values:</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">l</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">l</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">l</span><span class="special">)</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">v</span><span class="special">[</span><span class="identifier">l</span><span class="special">]</span> <span class="special">==</span> <span class="identifier">legendre_p</span><span class="special">(</span><span class="number">10</span> <span class="special">+</span> <span class="identifier">l</span><span class="special">,</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">x</span><span class="special">));</span>
</pre>
<p>
Formally the arguments are:
</p>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">l</span></dt>
<dd><p>
The degree of the last polynomial calculated.
</p></dd>
<dt><span class="term">m</span></dt>
<dd><p>
The order of the Associated Polynomial.
</p></dd>
<dt><span class="term">x</span></dt>
<dd><p>
The abscissa value
</p></dd>
<dt><span class="term">Pl</span></dt>
<dd><p>
The value of the polynomial evaluated at degree <span class="emphasis"><em>l</em></span>.
</p></dd>
<dt><span class="term">Plm1</span></dt>
<dd><p>
The value of the polynomial evaluated at degree <span class="emphasis"><em>l-1</em></span>.
</p></dd>
</dl>
</div>
<h5>
<a name="math_toolkit.sf_poly.legendre.h2"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.legendre.accuracy"></a></span><a class="link" href="legendre.html#math_toolkit.sf_poly.legendre.accuracy">Accuracy</a>
</h5>
<p>
The following table shows peak errors (in units of epsilon) for various domains
of input arguments. 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>.
</p>
<div class="table">
<a name="math_toolkit.sf_poly.legendre.table_legendre_p"></a><p class="title"><b>Table&#160;6.32.&#160;Error rates for legendre_p</b></p>
<div class="table-contents"><table class="table" summary="Error rates for legendre_p">
<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>
Legendre Polynomials: Small Values
</p>
</td>
<td>
<p>
<span class="blue">Max = 211&#949; (Mean = 20.4&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.732&#949; (Mean = 0.0619&#949;)</span><br>
<br> (<span class="emphasis"><em>GSL 1.16:</em></span> Max = 211&#949; (Mean = 20.4&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 69.2&#949; (Mean = 9.58&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> Max = 124&#949; (Mean = 13.2&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 69.2&#949; (Mean = 9.58&#949;)</span>
</p>
</td>
</tr>
<tr>
<td>
<p>
Legendre Polynomials: Large Values
</p>
</td>
<td>
<p>
<span class="blue">Max = 300&#949; (Mean = 33.2&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.632&#949; (Mean = 0.0693&#949;)</span><br>
<br> (<span class="emphasis"><em>GSL 1.16:</em></span> Max = 300&#949; (Mean = 33.2&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 699&#949; (Mean = 59.6&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> Max = 343&#949; (Mean = 32.1&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 699&#949; (Mean = 59.6&#949;)</span>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="math_toolkit.sf_poly.legendre.table_legendre_q"></a><p class="title"><b>Table&#160;6.33.&#160;Error rates for legendre_q</b></p>
<div class="table-contents"><table class="table" summary="Error rates for legendre_q">
<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>
Legendre Polynomials: Small Values
</p>
</td>
<td>
<p>
<span class="blue">Max = 46.4&#949; (Mean = 7.32&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.612&#949; (Mean = 0.0517&#949;)</span><br>
<br> (<span class="emphasis"><em>GSL 1.16:</em></span> Max = 46.4&#949; (Mean = 7.46&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 50.9&#949; (Mean = 9&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 50.9&#949; (Mean = 8.98&#949;)</span>
</p>
</td>
</tr>
<tr>
<td>
<p>
Legendre Polynomials: Large Values
</p>
</td>
<td>
<p>
<span class="blue">Max = 4.6e+003&#949; (Mean = 366&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.49&#949; (Mean = 0.202&#949;)</span><br> <br>
(<span class="emphasis"><em>GSL 1.16:</em></span> Max = 4.6e+03&#949; (Mean = 366&#949;))
</p>
</td>
<td>
<p>
<span class="blue">Max = 5.98e+03&#949; (Mean = 478&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 5.98e+03&#949; (Mean = 478&#949;)</span>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="math_toolkit.sf_poly.legendre.table_legendre_p_associated_"></a><p class="title"><b>Table&#160;6.34.&#160;Error rates for legendre_p (associated)</b></p>
<div class="table-contents"><table class="table" summary="Error rates for legendre_p (associated)">
<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>
Associated Legendre Polynomials: Small Values
</p>
</td>
<td>
<p>
<span class="blue">Max = 121&#949; (Mean = 7.14&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.999&#949; (Mean = 0.05&#949;)</span><br> <br>
(<span class="emphasis"><em>GSL 1.16:</em></span> Max = 121&#949; (Mean = 6.75&#949;) <a class="link" href="../logs_and_tables/logs.html#errors_GNU_C_version_5_1_0_linux_double_legendre_p_associated__GSL_1_16_Associated_Legendre_Polynomials_Small_Values">And
other failures.</a>)
</p>
</td>
<td>
<p>
<span class="blue">Max = 175&#949; (Mean = 9.88&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> Max = 175&#949; (Mean = 9.36&#949;)
<a class="link" href="../logs_and_tables/logs.html#errors_GNU_C_version_5_1_0_linux_long_double_legendre_p_associated___tr1_cmath__Associated_Legendre_Polynomials_Small_Values">And
other failures.</a>)
</p>
</td>
<td>
<p>
<span class="blue">Max = 77.7&#949; (Mean = 5.59&#949;)</span>
</p>
</td>
</tr></tbody>
</table></div>
</div>
<br class="table-break"><p>
Note that the worst errors occur when the order increases, values greater
than ~120 are very unlikely to produce sensible results, especially in the
associated polynomial case when the degree is also large. Further the relative
errors are likely to grow arbitrarily large when the function is very close
to a root.
</p>
<h5>
<a name="math_toolkit.sf_poly.legendre.h3"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.legendre.testing"></a></span><a class="link" href="legendre.html#math_toolkit.sf_poly.legendre.testing">Testing</a>
</h5>
<p>
A mixture of spot tests of values calculated using functions.wolfram.com,
and randomly generated test data are used: the test data was computed using
<a href="http://shoup.net/ntl/doc/RR.txt" target="_top">NTL::RR</a> at 1000-bit
precision.
</p>
<h5>
<a name="math_toolkit.sf_poly.legendre.h4"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.legendre.implementation"></a></span><a class="link" href="legendre.html#math_toolkit.sf_poly.legendre.implementation">Implementation</a>
</h5>
<p>
These functions are implemented using the stable three term recurrence relations.
These relations guarantee low absolute error but cannot guarantee low relative
error near one of the roots of the polynomials.
</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, 2017 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, Nicholas Thompson, 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_poly.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_poly.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="legendre_stieltjes.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,137 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Legendre-Stieltjes Polynomials</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.6.0">
<link rel="up" href="../sf_poly.html" title="Polynomials">
<link rel="prev" href="legendre.html" title="Legendre (and Associated) Polynomials">
<link rel="next" href="laguerre.html" title="Laguerre (and Associated) 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="legendre.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_poly.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="laguerre.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_poly.legendre_stieltjes"></a><a class="link" href="legendre_stieltjes.html" title="Legendre-Stieltjes Polynomials">Legendre-Stieltjes
Polynomials</a>
</h3></div></div></div>
<h5>
<a name="math_toolkit.sf_poly.legendre_stieltjes.h0"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.legendre_stieltjes.synopsis"></a></span><a class="link" href="legendre_stieltjes.html#math_toolkit.sf_poly.legendre_stieltjes.synopsis">Synopsis</a>
</h5>
<pre class="programlisting">
#include &lt;boost/math/special_functions/legendre_stieltjes.hpp&gt;
<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>
<span class="keyword">class</span> <span class="identifier">legendre_stieltjes</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">legendre_stieltjes</span><span class="special">(</span><span class="identifier">size_t</span> <span class="identifier">m</span><span class="special">);</span>
<span class="identifier">Real</span> <span class="identifier">norm_sq</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="identifier">Real</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">Real</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
<span class="identifier">Real</span> <span class="identifier">prime</span><span class="special">(</span><span class="identifier">Real</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">Real</span><span class="special">&gt;</span> <span class="identifier">zeros</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}}</span>
</pre>
<h5>
<a name="math_toolkit.sf_poly.legendre_stieltjes.h1"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.legendre_stieltjes.description"></a></span><a class="link" href="legendre_stieltjes.html#math_toolkit.sf_poly.legendre_stieltjes.description">Description</a>
</h5>
<p>
The Legendre-Stieltjes polynomials are a family of polynomials used to generate
Gauss-Konrod quadrature formulas. Gauss-Konrod quadratures are algorithms
which extend a Gaussian quadrature in such a way that all abscissas are reused
when computed a higher-order estimate of the integral, allowing efficient
calculation of an error estimate. The Legendre-Stieltjes polynomials assist
with this task because their zeros <span class="emphasis"><em>interlace</em></span> the zeros
of the Legendre polynomials, meaning that between any two zeros of a Legendre
polynomial of degree n, there exists a zero of the Legendre-Stieltjes polynomial
of degree n+1.
</p>
<p>
The Legendre-Stieltjes polynomials <span class="emphasis"><em>E</em></span><sub>n+1</sub> are defined by
the property that they have <span class="emphasis"><em>n</em></span> vanishing moments against
the oscillatory measure P<sub>n</sub>, i.e., &#8747;<sub>-1</sub><sup>1</sup> E<sub>n+1</sub>(x)P<sub>n</sub>(x) x<sup>k</sup> dx = 0 for <span class="emphasis"><em>k
= 0, 1, ..., n</em></span>. The first few are
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
E<sub>1</sub>(x) = P<sub>1</sub>(x)
</li>
<li class="listitem">
E<sub>2</sub>(x) = P<sub>2</sub>(x) - 2P<sub>0</sub>(x)/5
</li>
<li class="listitem">
E<sub>3</sub>(x) = P<sub>3</sub>(x) - 9P<sub>1</sub>(x)/14
</li>
<li class="listitem">
E<sub>4</sub>(x) = P<sub>4</sub>(x) - 20P<sub>2</sub>(x)/27 + 14P<sub>0</sub>(x)/891
</li>
<li class="listitem">
E<sub>5</sub>(x) = P<sub>5</sub>(x) - 35P<sub>3</sub>(x)/44 + 135P<sub>1</sub>(x)/12584
</li>
</ul></div>
<p>
where P<sub>i</sub> are the Legendre polynomials. The scaling follows <a href="http://www.ams.org/journals/mcom/1968-22-104/S0025-5718-68-99866-9/S0025-5718-68-99866-9.pdf" target="_top">Patterson</a>,
who expanded the Legendre-Stieltjes polynomials in a Legendre series and
took the coefficient of the highest-order Legendre polynomial in the series
to be unity.
</p>
<p>
The Legendre-Stieltjes polynomials do not satisfy three-term recurrence relations
or have a particulary simple representation. Hence the constructor call determines
what, in fact, the polynomial is. Once the constructor comes back, the polynomial
can be evaluated via the Legendre series.
</p>
<p>
Example usage:
</p>
<pre class="programlisting"><span class="comment">// Call to the constructor determines the coefficients in the Legendre expansion</span>
<span class="identifier">legendre_stieltjes</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">E</span><span class="special">(</span><span class="number">12</span><span class="special">);</span>
<span class="comment">// Evaluate the polynomial at a point:</span>
<span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">E</span><span class="special">(</span><span class="number">0.3</span><span class="special">);</span>
<span class="comment">// Evaluate the derivative at a point:</span>
<span class="keyword">double</span> <span class="identifier">x_p</span> <span class="special">=</span> <span class="identifier">E</span><span class="special">.</span><span class="identifier">prime</span><span class="special">(</span><span class="number">0.3</span><span class="special">);</span>
<span class="comment">// Use the norm_sq to change between scalings, if desired:</span>
<span class="keyword">double</span> <span class="identifier">norm</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">E</span><span class="special">.</span><span class="identifier">norm_sq</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, 2017 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, Nicholas Thompson, 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="legendre.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_poly.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="laguerre.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@@ -0,0 +1,335 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Spherical Harmonics</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.6.0">
<link rel="up" href="../sf_poly.html" title="Polynomials">
<link rel="prev" href="chebyshev.html" title="Chebyshev Polynomials">
<link rel="next" href="../bessel.html" title="Bessel 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="chebyshev.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_poly.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="../bessel.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_poly.sph_harm"></a><a class="link" href="sph_harm.html" title="Spherical Harmonics">Spherical Harmonics</a>
</h3></div></div></div>
<h5>
<a name="math_toolkit.sf_poly.sph_harm.h0"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.sph_harm.synopsis"></a></span><a class="link" href="sph_harm.html#math_toolkit.sf_poly.sph_harm.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">spherical_harmonic</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>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</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="special">&gt;</span> <span class="identifier">spherical_harmonic</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">theta</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;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</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="special">&gt;</span> <span class="identifier">spherical_harmonic</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">theta</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;18.&#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">spherical_harmonic_r</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">theta</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;18.&#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">spherical_harmonic_r</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">theta</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;18.&#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">spherical_harmonic_i</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">theta</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;18.&#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">spherical_harmonic_i</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">theta</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;18.&#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.sf_poly.sph_harm.h1"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.sph_harm.description"></a></span><a class="link" href="sph_harm.html#math_toolkit.sf_poly.sph_harm.description">Description</a>
</h5>
<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.
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;18.&#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;18.&#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>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</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="special">&gt;</span> <span class="identifier">spherical_harmonic</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">theta</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;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">complex</span><span class="special">&lt;</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="special">&gt;</span> <span class="identifier">spherical_harmonic</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">theta</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;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the value of the Spherical Harmonic Y<sub>n</sub><sup>m</sup>(theta, phi):
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/spherical_0.svg"></span>
</p>
<p>
The spherical harmonics Y<sub>n</sub><sup>m</sup>(theta, phi) are the angular portion of the solution
to Laplace's equation in spherical coordinates where azimuthal symmetry is
not present.
</p>
<div class="caution"><table border="0" summary="Caution">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="../../../../../../doc/src/images/caution.png"></td>
<th align="left">Caution</th>
</tr>
<tr><td align="left" valign="top">
<p>
Care must be taken in correctly identifying the arguments to this function:
&#952; &#160; is taken as the polar (colatitudinal) coordinate with &#952; &#160; in [0, &#960;], and &#966; &#160; as
the azimuthal (longitudinal) coordinate with &#966; &#160; in [0,2&#960;). This is the convention
used in Physics, and matches the definition used by <a href="http://documents.wolfram.com/mathematica/functions/SphericalHarmonicY" target="_top">Mathematica
in the function SpericalHarmonicY</a>, but is opposite to the usual
mathematical conventions.
</p>
<p>
Some other sources include an additional Condon-Shortley phase term of
(-1)<sup>m</sup> in the definition of this function: note however that our definition
of the associated Legendre polynomial already includes this term.
</p>
<p>
This implementation returns zero for m &gt; n
</p>
<p>
For &#952; &#160; outside [0, &#960;] and &#966; &#160; outside [0, 2&#960;] this implementation follows the convention
used by Mathematica: the function is periodic with period &#960; &#160; in &#952; &#160; and 2&#960; &#160; in &#966;.
Please note that this is not the behaviour one would get from a casual
application of the function's definition. Cautious users should keep &#952; &#160; and
&#966; &#160; to the range [0, &#960;] and [0, 2&#960;] respectively.
</p>
<p>
See: <a href="http://mathworld.wolfram.com/SphericalHarmonic.html" target="_top">Weisstein,
Eric W. "Spherical Harmonic." From MathWorld--A Wolfram Web Resource</a>.
</p>
</td></tr>
</table></div>
<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">spherical_harmonic_r</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">theta</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;18.&#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">spherical_harmonic_r</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">theta</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;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the real part of Y<sub>n</sub><sup>m</sup>(theta, phi):
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/spherical_1.svg"></span>
</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">spherical_harmonic_i</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">theta</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;18.&#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">spherical_harmonic_i</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span> <span class="identifier">T1</span> <span class="identifier">theta</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;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
</pre>
<p>
Returns the imaginary part of Y<sub>n</sub><sup>m</sup>(theta, phi):
</p>
<p>
<span class="inlinemediaobject"><img src="../../../equations/spherical_2.svg"></span>
</p>
<h5>
<a name="math_toolkit.sf_poly.sph_harm.h2"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.sph_harm.accuracy"></a></span><a class="link" href="sph_harm.html#math_toolkit.sf_poly.sph_harm.accuracy">Accuracy</a>
</h5>
<p>
The following table shows peak errors for various domains of input arguments.
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>. Peak errors are the same for both the real and imaginary
parts, as the error is dominated by calculation of the associated Legendre
polynomials: especially near the roots of the associated Legendre function.
</p>
<p>
All values are in units of epsilon.
</p>
<div class="table">
<a name="math_toolkit.sf_poly.sph_harm.table_spherical_harmonic_r"></a><p class="title"><b>Table&#160;6.38.&#160;Error rates for spherical_harmonic_r</b></p>
<div class="table-contents"><table class="table" summary="Error rates for spherical_harmonic_r">
<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>
Spherical Harmonics
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.27e+004&#949; (Mean = 725&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.58&#949; (Mean = 0.0707&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.89e+03&#949; (Mean = 108&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.03e+04&#949; (Mean = 327&#949;)</span>
</p>
</td>
</tr></tbody>
</table></div>
</div>
<br class="table-break"><div class="table">
<a name="math_toolkit.sf_poly.sph_harm.table_spherical_harmonic_i"></a><p class="title"><b>Table&#160;6.39.&#160;Error rates for spherical_harmonic_i</b></p>
<div class="table-contents"><table class="table" summary="Error rates for spherical_harmonic_i">
<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>
Spherical Harmonics
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.27e+004&#949; (Mean = 725&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.36&#949; (Mean = 0.0765&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 2.89e+03&#949; (Mean = 108&#949;)</span>
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.03e+04&#949; (Mean = 327&#949;)</span>
</p>
</td>
</tr></tbody>
</table></div>
</div>
<br class="table-break"><p>
Note that the worst errors occur when the degree increases, values greater
than ~120 are very unlikely to produce sensible results, especially when
the order is also large. Further the relative errors are likely to grow arbitrarily
large when the function is very close to a root.
</p>
<h5>
<a name="math_toolkit.sf_poly.sph_harm.h3"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.sph_harm.testing"></a></span><a class="link" href="sph_harm.html#math_toolkit.sf_poly.sph_harm.testing">Testing</a>
</h5>
<p>
A mixture of spot tests of values calculated using functions.wolfram.com,
and randomly generated test data are used: the test data was computed using
<a href="http://shoup.net/ntl/doc/RR.txt" target="_top">NTL::RR</a> at 1000-bit
precision.
</p>
<h5>
<a name="math_toolkit.sf_poly.sph_harm.h4"></a>
<span class="phrase"><a name="math_toolkit.sf_poly.sph_harm.implementation"></a></span><a class="link" href="sph_harm.html#math_toolkit.sf_poly.sph_harm.implementation">Implementation</a>
</h5>
<p>
These functions are implemented fairly naively using the formulae given above.
Some extra care is taken to prevent roundoff error when converting from polar
coordinates (so for example the <span class="emphasis"><em>1-x<sup>2</sup></em></span> term used by the
associated Legendre functions is calculated without roundoff error using
<span class="emphasis"><em>x = cos(theta)</em></span>, and <span class="emphasis"><em>1-x<sup>2</sup> = sin<sup>2</sup>(theta)</em></span>).
The limiting factor in the error rates for these functions is the need to
calculate values near the roots of the associated Legendre functions.
</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, 2017 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, Nicholas Thompson, 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="chebyshev.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../sf_poly.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="../bessel.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>