libs/math/doc/html/math_toolkit/bessel/bessel_root.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>Finding Zeros of Bessel Functions of the First and Second Kinds</title>
   5 <link rel="stylesheet" href="../../math.css" type="text/css">
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
   7 <link rel="home" href="../../index.html" title="Math Toolkit 2.11.0">
   8 <link rel="up" href="../bessel.html" title="Bessel Functions">
   9 <link rel="prev" href="bessel_first.html" title="Bessel Functions of the First and Second Kinds">
  10 <link rel="next" href="mbessel.html" title="Modified Bessel Functions of the First and Second Kinds">
  11 </head>
  12 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
  13 <table cellpadding="2" width="100%"><tr>
  14 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
  15 <td align="center"><a href="../../../../../../index.html">Home</a></td>
  16 <td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
  17 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
  18 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
  19 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
  20 </tr></table>
  21 <hr>
  22 <div class="spirit-nav">
  23 <a accesskey="p" href="bessel_first.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../bessel.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="mbessel.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
  24 </div>
  25 <div class="section">
  26 <div class="titlepage"><div><div><h3 class="title">
  27 <a name="math_toolkit.bessel.bessel_root"></a><a class="link" href="bessel_root.html" title="Finding Zeros of Bessel Functions of the First and Second Kinds">Finding Zeros of Bessel
  28       Functions of the First and Second Kinds</a>
  29 </h3></div></div></div>
  30 <h5>
  31 <a name="math_toolkit.bessel.bessel_root.h0"></a>
  32         <span class="phrase"><a name="math_toolkit.bessel.bessel_root.synopsis"></a></span><a class="link" href="bessel_root.html#math_toolkit.bessel.bessel_root.synopsis">Synopsis</a>
  33       </h5>
  34 <p>
  35         <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">math</span><span class="special">/</span><span class="identifier">special_functions</span><span class="special">/</span><span class="identifier">bessel</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
  36       </p>
  37 <p>
  38         Functions for obtaining both a single zero or root of the Bessel function,
  39         and placing multiple zeros into a container like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span></code>
  40         by providing an output iterator.
  41       </p>
  42 <p>
  43         The signature of the single value functions are:
  44       </p>
  45 <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>
  46 <span class="identifier">T</span> <span class="identifier">cyl_bessel_j_zero</span><span class="special">(</span>
  47          <span class="identifier">T</span> <span class="identifier">v</span><span class="special">,</span>            <span class="comment">// Floating-point value for Jv.</span>
  48          <span class="keyword">int</span> <span class="identifier">m</span><span class="special">);</span>         <span class="comment">// 1-based index of zero.</span>
  49
  50 <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>
  51 <span class="identifier">T</span> <span class="identifier">cyl_neumann_zero</span><span class="special">(</span>
  52          <span class="identifier">T</span> <span class="identifier">v</span><span class="special">,</span>            <span class="comment">// Floating-point value for Jv.</span>
  53          <span class="keyword">int</span> <span class="identifier">m</span><span class="special">);</span>         <span class="comment">// 1-based index of zero.</span>
  54 </pre>
  55 <p>
  56         and for multiple zeros:
  57       </p>
  58 <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> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
  59 <span class="identifier">OutputIterator</span> <span class="identifier">cyl_bessel_j_zero</span><span class="special">(</span>
  60                      <span class="identifier">T</span> <span class="identifier">v</span><span class="special">,</span>                       <span class="comment">// Floating-point value for Jv.</span>
  61                      <span class="keyword">int</span> <span class="identifier">start_index</span><span class="special">,</span>           <span class="comment">// 1-based index of first zero.</span>
  62                      <span class="keyword">unsigned</span> <span class="identifier">number_of_zeros</span><span class="special">,</span>  <span class="comment">// How many zeros to generate.</span>
  63                      <span class="identifier">OutputIterator</span> <span class="identifier">out_it</span><span class="special">);</span>    <span class="comment">// Destination for zeros.</span>
  64
  65 <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> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
  66 <span class="identifier">OutputIterator</span> <span class="identifier">cyl_neumann_zero</span><span class="special">(</span>
  67                      <span class="identifier">T</span> <span class="identifier">v</span><span class="special">,</span>                       <span class="comment">// Floating-point value for Jv.</span>
  68                      <span class="keyword">int</span> <span class="identifier">start_index</span><span class="special">,</span>           <span class="comment">// 1-based index of zero.</span>
  69                      <span class="keyword">unsigned</span> <span class="identifier">number_of_zeros</span><span class="special">,</span>  <span class="comment">// How many zeros to generate</span>
  70                      <span class="identifier">OutputIterator</span> <span class="identifier">out_it</span><span class="special">);</span>    <span class="comment">// Destination for zeros.</span>
  71 </pre>
  72 <p>
  73         There are also versions which allow control of the <a class="link" href="../../policy.html" title="Chapter&#160;20.&#160;Policies: Controlling Precision, Error Handling etc">Policies</a>
  74         for error handling and precision.
  75       </p>
  76 <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>
  77  <span class="identifier">T</span> <span class="identifier">cyl_bessel_j_zero</span><span class="special">(</span>
  78           <span class="identifier">T</span> <span class="identifier">v</span><span class="special">,</span>            <span class="comment">// Floating-point value for Jv.</span>
  79           <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span>          <span class="comment">// 1-based index of zero.</span>
  80           <span class="keyword">const</span> <span class="identifier">Policy</span><span class="special">&amp;);</span> <span class="comment">// Policy to use.</span>
  81
  82  <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>
  83  <span class="identifier">T</span> <span class="identifier">cyl_neumann_zero</span><span class="special">(</span>
  84           <span class="identifier">T</span> <span class="identifier">v</span><span class="special">,</span>            <span class="comment">// Floating-point value for Jv.</span>
  85           <span class="keyword">int</span> <span class="identifier">m</span><span class="special">,</span>          <span class="comment">// 1-based index of zero.</span>
  86           <span class="keyword">const</span> <span class="identifier">Policy</span><span class="special">&amp;);</span> <span class="comment">// Policy to use.</span>
  87
  88
  89 <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> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
  90 <span class="identifier">OutputIterator</span> <span class="identifier">cyl_bessel_j_zero</span><span class="special">(</span>
  91                      <span class="identifier">T</span> <span class="identifier">v</span><span class="special">,</span>                       <span class="comment">// Floating-point value for Jv.</span>
  92                      <span class="keyword">int</span> <span class="identifier">start_index</span><span class="special">,</span>           <span class="comment">// 1-based index of first zero.</span>
  93                      <span class="keyword">unsigned</span> <span class="identifier">number_of_zeros</span><span class="special">,</span>  <span class="comment">// How many zeros to generate.</span>
  94                      <span class="identifier">OutputIterator</span> <span class="identifier">out_it</span><span class="special">,</span>     <span class="comment">// Destination for zeros.</span>
  95                      <span class="keyword">const</span> <span class="identifier">Policy</span><span class="special">&amp;</span> <span class="identifier">pol</span><span class="special">);</span>        <span class="comment">// Policy to use.</span>
  96
  97 <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> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
  98 <span class="identifier">OutputIterator</span> <span class="identifier">cyl_neumann_zero</span><span class="special">(</span>
  99                      <span class="identifier">T</span> <span class="identifier">v</span><span class="special">,</span>                       <span class="comment">// Floating-point value for Jv.</span>
 100                      <span class="keyword">int</span> <span class="identifier">start_index</span><span class="special">,</span>           <span class="comment">// 1-based index of zero.</span>
 101                      <span class="keyword">unsigned</span> <span class="identifier">number_of_zeros</span><span class="special">,</span>  <span class="comment">// How many zeros to generate.</span>
 102                      <span class="identifier">OutputIterator</span> <span class="identifier">out_it</span><span class="special">,</span>     <span class="comment">// Destination for zeros.</span>
 103                      <span class="keyword">const</span> <span class="identifier">Policy</span><span class="special">&amp;</span> <span class="identifier">pol</span><span class="special">);</span>        <span class="comment">// Policy to use.</span>
 104 </pre>
 105 <h5>
 106 <a name="math_toolkit.bessel.bessel_root.h1"></a>
 107         <span class="phrase"><a name="math_toolkit.bessel.bessel_root.description"></a></span><a class="link" href="bessel_root.html#math_toolkit.bessel.bessel_root.description">Description</a>
 108       </h5>
 109 <p>
 110         Every real order &#957; cylindrical Bessel and Neumann functions have an infinite
 111         number of zeros on the positive real axis. The real zeros on the positive
 112         real axis can be found by solving for the roots of
 113       </p>
 114 <div class="blockquote"><blockquote class="blockquote"><p>
 115           <span class="emphasis"><em>J<sub>&#957;</sub>(j<sub>&#957;, m</sub>) = 0</em></span>
 116         </p></blockquote></div>
 117 <div class="blockquote"><blockquote class="blockquote"><p>
 118           <span class="emphasis"><em>Y<sub>&#957;</sub>(y<sub>&#957;, m</sub>) = 0</em></span>
 119         </p></blockquote></div>
 120 <p>
 121         Here, <span class="emphasis"><em>j<sub>&#957;, m</sub></em></span> represents the <span class="emphasis"><em>m<sup>th</sup></em></span> root
 122         of the cylindrical Bessel function of order <span class="emphasis"><em>&#957;</em></span>, and <span class="emphasis"><em>y<sub>&#957;,
 123         m</sub></em></span> represents the <span class="emphasis"><em>m<sup>th</sup></em></span> root of the cylindrical
 124         Neumann function of order <span class="emphasis"><em>&#957;</em></span>.
 125       </p>
 126 <p>
 127         The zeros or roots (values of <code class="computeroutput"><span class="identifier">x</span></code>
 128         where the function crosses the horizontal <code class="computeroutput"><span class="identifier">y</span>
 129         <span class="special">=</span> <span class="number">0</span></code>
 130         axis) of the Bessel and Neumann functions are computed by two functions,
 131         <code class="computeroutput"><span class="identifier">cyl_bessel_j_zero</span></code> and <code class="computeroutput"><span class="identifier">cyl_neumann_zero</span></code>.
 132       </p>
 133 <p>
 134         In each case the index or rank of the zero returned is 1-based, which is
 135         to say:
 136       </p>
 137 <div class="blockquote"><blockquote class="blockquote"><p>
 138           cyl_bessel_j_zero(v, 1);
 139         </p></blockquote></div>
 140 <p>
 141         returns the first zero of Bessel J.
 142       </p>
 143 <p>
 144         Passing an <code class="computeroutput"><span class="identifier">start_index</span> <span class="special">&lt;=</span>
 145         <span class="number">0</span></code> results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">domain_error</span></code>
 146         being raised.
 147       </p>
 148 <p>
 149         For certain parameters, however, the zero'th root is defined and it has a
 150         value of zero. For example, the zero'th root of <code class="computeroutput"><span class="identifier">J</span><span class="special">[</span><span class="identifier">sub</span> <span class="identifier">v</span><span class="special">](</span><span class="identifier">x</span><span class="special">)</span></code>
 151         is defined and it has a value of zero for all values of <code class="computeroutput"><span class="identifier">v</span>
 152         <span class="special">&gt;</span> <span class="number">0</span></code>
 153         and for negative integer values of <code class="computeroutput"><span class="identifier">v</span>
 154         <span class="special">=</span> <span class="special">-</span><span class="identifier">n</span></code>. Similar cases are described in the implementation
 155         details below.
 156       </p>
 157 <p>
 158         The order <code class="computeroutput"><span class="identifier">v</span></code> of <code class="computeroutput"><span class="identifier">J</span></code> can be positive, negative and zero for
 159         the <code class="computeroutput"><span class="identifier">cyl_bessel_j</span></code> and <code class="computeroutput"><span class="identifier">cyl_neumann</span></code> functions, but not infinite
 160         nor NaN.
 161       </p>
 162 <div class="blockquote"><blockquote class="blockquote"><p>
 163           <span class="inlinemediaobject"><img src="../../../graphs/bessel_j_zeros.svg" align="middle"></span>
 164
 165         </p></blockquote></div>
 166 <div class="blockquote"><blockquote class="blockquote"><p>
 167           <span class="inlinemediaobject"><img src="../../../graphs/neumann_y_zeros.svg" align="middle"></span>
 168
 169         </p></blockquote></div>
 170 <h5>
 171 <a name="math_toolkit.bessel.bessel_root.h2"></a>
 172         <span class="phrase"><a name="math_toolkit.bessel.bessel_root.examples_of_finding_bessel_and_n"></a></span><a class="link" href="bessel_root.html#math_toolkit.bessel.bessel_root.examples_of_finding_bessel_and_n">Examples
 173         of finding Bessel and Neumann zeros</a>
 174       </h5>
 175 <p>
 176         This example demonstrates calculating zeros of the Bessel and Neumann functions.
 177         It also shows how Boost.Math and Boost.Multiprecision can be combined to
 178         provide a many decimal digit precision. For 50 decimal digit precision we
 179         need to include
 180       </p>
 181 <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">multiprecision</span><span class="special">/</span><span class="identifier">cpp_dec_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 182 </pre>
 183 <p>
 184         and a <code class="computeroutput"><span class="keyword">typedef</span></code> for <code class="computeroutput"><span class="identifier">float_type</span></code> may be convenient (allowing
 185         a quick switch to re-compute at built-in <code class="computeroutput"><span class="keyword">double</span></code>
 186         or other precision)
 187       </p>
 188 <pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span> <span class="identifier">float_type</span><span class="special">;</span>
 189 </pre>
 190 <p>
 191         To use the functions for finding zeros of the functions we need
 192       </p>
 193 <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">bessel</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 194 </pre>
 195 <p>
 196         This file includes the forward declaration signatures for the zero-finding
 197         functions:
 198       </p>
 199 <pre class="programlisting"><span class="comment">//  #include &lt;boost/math/special_functions/math_fwd.hpp&gt;</span>
 200 </pre>
 201 <p>
 202         but more details are in the full documentation, for example at <a href="http://www.boost.org/doc/libs/1_53_0/libs/math/doc/sf_and_dist/html/math_toolkit/special/bessel/bessel_over.html" target="_top">Boost.Math
 203         Bessel functions</a>.
 204       </p>
 205 <p>
 206         This example shows obtaining both a single zero of the Bessel function, and
 207         then placing multiple zeros into a container like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span></code>
 208         by providing an iterator.
 209       </p>
 210 <div class="tip"><table border="0" summary="Tip">
 211 <tr>
 212 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../../doc/src/images/tip.png"></td>
 213 <th align="left">Tip</th>
 214 </tr>
 215 <tr><td align="left" valign="top"><p>
 216           It is always wise to place code using Boost.Math inside try'n'catch blocks;
 217           this will ensure that helpful error messages are shown when exceptional
 218           conditions arise.
 219         </p></td></tr>
 220 </table></div>
 221 <p>
 222         First, evaluate a single Bessel zero.
 223       </p>
 224 <p>
 225         The precision is controlled by the float-point type of template parameter
 226         <code class="computeroutput"><span class="identifier">T</span></code> of <code class="computeroutput"><span class="identifier">v</span></code>
 227         so this example has <code class="computeroutput"><span class="keyword">double</span></code> precision,
 228         at least 15 but up to 17 decimal digits (for the common 64-bit double).
 229       </p>
 230 <pre class="programlisting"><span class="comment">//    double root = boost::math::cyl_bessel_j_zero(0.0, 1);</span>
 231 <span class="comment">//    // Displaying with default precision of 6 decimal digits:</span>
 232 <span class="comment">//    std::cout &lt;&lt; "boost::math::cyl_bessel_j_zero(0.0, 1) " &lt;&lt; root &lt;&lt; std::endl; // 2.40483</span>
 233 <span class="comment">//    // And with all the guaranteed (15) digits:</span>
 234 <span class="comment">//    std::cout.precision(std::numeric_limits&lt;double&gt;::digits10);</span>
 235 <span class="comment">//    std::cout &lt;&lt; "boost::math::cyl_bessel_j_zero(0.0, 1) " &lt;&lt; root &lt;&lt; std::endl; // 2.40482555769577</span>
 236 </pre>
 237 <p>
 238         But note that because the parameter <code class="computeroutput"><span class="identifier">v</span></code>
 239         controls the precision of the result, <code class="computeroutput"><span class="identifier">v</span></code>
 240         <span class="bold"><strong>must be a floating-point type</strong></span>. So if you
 241         provide an integer type, say 0, rather than 0.0, then it will fail to compile
 242         thus:
 243       </p>
 244 <pre class="programlisting"><span class="identifier">root</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">cyl_bessel_j_zero</span><span class="special">(</span><span class="number">0</span><span class="special">,</span> <span class="number">1</span><span class="special">);</span>
 245 </pre>
 246 <p>
 247         with this error message
 248       </p>
 249 <pre class="programlisting"><span class="identifier">error</span> <span class="identifier">C2338</span><span class="special">:</span> <span class="identifier">Order</span> <span class="identifier">must</span> <span class="identifier">be</span> <span class="identifier">a</span> <span class="identifier">floating</span><span class="special">-</span><span class="identifier">point</span> <span class="identifier">type</span><span class="special">.</span>
 250 </pre>
 251 <p>
 252         Optionally, we can use a policy to ignore errors, C-style, returning some
 253         value, perhaps infinity or NaN, or the best that can be done. (See <a class="link" href="../pol_tutorial/user_def_err_pol.html" title="Calling User Defined Error Handlers">user error handling</a>).
 254       </p>
 255 <p>
 256         To create a (possibly unwise!) policy <code class="computeroutput"><span class="identifier">ignore_all_policy</span></code>
 257         that ignores all errors:
 258       </p>
 259 <pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">policies</span><span class="special">::</span><span class="identifier">policy</span><span class="special">&lt;</span>
 260   <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">policies</span><span class="special">::</span><span class="identifier">domain_error</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">policies</span><span class="special">::</span><span class="identifier">ignore_error</span><span class="special">&gt;,</span>
 261   <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">policies</span><span class="special">::</span><span class="identifier">overflow_error</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">policies</span><span class="special">::</span><span class="identifier">ignore_error</span><span class="special">&gt;,</span>
 262   <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">policies</span><span class="special">::</span><span class="identifier">underflow_error</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">policies</span><span class="special">::</span><span class="identifier">ignore_error</span><span class="special">&gt;,</span>
 263   <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">policies</span><span class="special">::</span><span class="identifier">denorm_error</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">policies</span><span class="special">::</span><span class="identifier">ignore_error</span><span class="special">&gt;,</span>
 264   <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">policies</span><span class="special">::</span><span class="identifier">pole_error</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">policies</span><span class="special">::</span><span class="identifier">ignore_error</span><span class="special">&gt;,</span>
 265   <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">policies</span><span class="special">::</span><span class="identifier">evaluation_error</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">policies</span><span class="special">::</span><span class="identifier">ignore_error</span><span class="special">&gt;</span>
 266             <span class="special">&gt;</span> <span class="identifier">ignore_all_policy</span><span class="special">;</span>
 267 </pre>
 268 <p>
 269         Examples of use of this <code class="computeroutput"><span class="identifier">ignore_all_policy</span></code>
 270         are
 271       </p>
 272 <pre class="programlisting"><span class="keyword">double</span> <span class="identifier">inf</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="keyword">double</span><span class="special">&gt;::</span><span class="identifier">infinity</span><span class="special">();</span>
 273 <span class="keyword">double</span> <span class="identifier">nan</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="keyword">double</span><span class="special">&gt;::</span><span class="identifier">quiet_NaN</span><span class="special">();</span>
 274
 275 <span class="keyword">double</span> <span class="identifier">dodgy_root</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">cyl_bessel_j_zero</span><span class="special">(-</span><span class="number">1.0</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">ignore_all_policy</span><span class="special">());</span>
 276 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"boost::math::cyl_bessel_j_zero(-1.0, 1) "</span> <span class="special">&lt;&lt;</span> <span class="identifier">dodgy_root</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 1.#QNAN</span>
 277 <span class="keyword">double</span> <span class="identifier">inf_root</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">cyl_bessel_j_zero</span><span class="special">(</span><span class="identifier">inf</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">ignore_all_policy</span><span class="special">());</span>
 278 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"boost::math::cyl_bessel_j_zero(inf, 1) "</span> <span class="special">&lt;&lt;</span> <span class="identifier">inf_root</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 1.#QNAN</span>
 279 <span class="keyword">double</span> <span class="identifier">nan_root</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">cyl_bessel_j_zero</span><span class="special">(</span><span class="identifier">nan</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">ignore_all_policy</span><span class="special">());</span>
 280 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"boost::math::cyl_bessel_j_zero(nan, 1) "</span> <span class="special">&lt;&lt;</span> <span class="identifier">nan_root</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// 1.#QNAN</span>
 281 </pre>
 282 <p>
 283         Another version of <code class="computeroutput"><span class="identifier">cyl_bessel_j_zero</span></code>
 284         allows calculation of multiple zeros with one call, placing the results in
 285         a container, often <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span></code>. For example, generate and display
 286         the first five <code class="computeroutput"><span class="keyword">double</span></code> roots
 287         of J<sub>v</sub> for integral order 2, as column <span class="emphasis"><em>J<sub>2</sub>(x)</em></span> in table
 288         1 of <a href="http://mathworld.wolfram.com/BesselFunctionZeros.html" target="_top">Wolfram
 289         Bessel Function Zeros</a>.
 290       </p>
 291 <pre class="programlisting"><span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">n_roots</span> <span class="special">=</span> <span class="number">5U</span><span class="special">;</span>
 292 <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">roots</span><span class="special">;</span>
 293 <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">cyl_bessel_j_zero</span><span class="special">(</span><span class="number">2.0</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">n_roots</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">back_inserter</span><span class="special">(</span><span class="identifier">roots</span><span class="special">));</span>
 294 <span class="identifier">std</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span><span class="identifier">roots</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span>
 295           <span class="identifier">roots</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span>
 296           <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">"\n"</span><span class="special">));</span>
 297 </pre>
 298 <p>
 299         Or we can use Boost.Multiprecision to generate 50 decimal digit roots of
 300         <span class="emphasis"><em>J<sub>v</sub></em></span> for non-integral order <code class="computeroutput"><span class="identifier">v</span><span class="special">=</span> <span class="number">71</span><span class="special">/</span><span class="number">19</span> <span class="special">==</span> <span class="number">3.736842</span></code>,
 301         expressed as an exact-integer fraction to generate the most accurate value
 302         possible for all floating-point types.
 303       </p>
 304 <p>
 305         We set the precision of the output stream, and show trailing zeros to display
 306         a fixed 50 decimal digits.
 307       </p>
 308 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">precision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float_type</span><span class="special">&gt;::</span><span class="identifier">digits10</span><span class="special">);</span> <span class="comment">// 50 decimal digits.</span>
 309 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">showpoint</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// Show trailing zeros.</span>
 310
 311 <span class="identifier">float_type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">float_type</span><span class="special">(</span><span class="number">71</span><span class="special">)</span> <span class="special">/</span> <span class="number">19</span><span class="special">;</span>
 312 <span class="identifier">float_type</span> <span class="identifier">r</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">cyl_bessel_j_zero</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="number">1</span><span class="special">);</span> <span class="comment">// 1st root.</span>
 313 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"x = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">x</span> <span class="special">&lt;&lt;</span> <span class="string">", r = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 314
 315 <span class="identifier">r</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">cyl_bessel_j_zero</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="number">20U</span><span class="special">);</span> <span class="comment">// 20th root.</span>
 316 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"x = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">x</span> <span class="special">&lt;&lt;</span> <span class="string">", r = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">r</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 317
 318 <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">float_type</span><span class="special">&gt;</span> <span class="identifier">zeros</span><span class="special">;</span>
 319 <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">cyl_bessel_j_zero</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">3</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">back_inserter</span><span class="special">(</span><span class="identifier">zeros</span><span class="special">));</span>
 320
 321 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cyl_bessel_j_zeros"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 322 <span class="comment">// Print the roots to the output stream.</span>
 323 <span class="identifier">std</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span><span class="identifier">zeros</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">zeros</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span>
 324           <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="identifier">float_type</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">"\n"</span><span class="special">));</span>
 325 </pre>
 326 <h6>
 327 <a name="math_toolkit.bessel.bessel_root.h3"></a>
 328         <span class="phrase"><a name="math_toolkit.bessel.bessel_root.using_output_iterator_to_sum_zer"></a></span><a class="link" href="bessel_root.html#math_toolkit.bessel.bessel_root.using_output_iterator_to_sum_zer">Using
 329         Output Iterator to sum zeros of Bessel Functions</a>
 330       </h6>
 331 <p>
 332         This example demonstrates summing zeros of the Bessel functions. To use the
 333         functions for finding zeros of the functions we need
 334       </p>
 335 <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">bessel</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 336 </pre>
 337 <p>
 338         We use the <code class="computeroutput"><span class="identifier">cyl_bessel_j_zero</span></code>
 339         output iterator parameter <code class="computeroutput"><span class="identifier">out_it</span></code>
 340         to create a sum of <span class="emphasis"><em>1/zeros<sup>2</sup></em></span> by defining a custom output
 341         iterator:
 342       </p>
 343 <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>
 344 <span class="keyword">struct</span> <span class="identifier">output_summation_iterator</span>
 345 <span class="special">{</span>
 346    <span class="identifier">output_summation_iterator</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">p</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">p_sum</span><span class="special">(</span><span class="identifier">p</span><span class="special">)</span>
 347    <span class="special">{}</span>
 348    <span class="identifier">output_summation_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">*()</span>
 349    <span class="special">{</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span>
 350     <span class="identifier">output_summation_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++()</span>
 351    <span class="special">{</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span>
 352    <span class="identifier">output_summation_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">)</span>
 353    <span class="special">{</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span>
 354    <span class="identifier">output_summation_iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">)</span>
 355    <span class="special">{</span>
 356      <span class="special">*</span><span class="identifier">p_sum</span> <span class="special">+=</span> <span class="number">1.</span><span class="special">/</span> <span class="special">(</span><span class="identifier">val</span> <span class="special">*</span> <span class="identifier">val</span><span class="special">);</span> <span class="comment">// Summing 1/zero^2.</span>
 357      <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
 358    <span class="special">}</span>
 359 <span class="keyword">private</span><span class="special">:</span>
 360    <span class="identifier">T</span><span class="special">*</span> <span class="identifier">p_sum</span><span class="special">;</span>
 361 <span class="special">};</span>
 362 </pre>
 363 <p>
 364         The sum is calculated for many values, converging on the analytical exact
 365         value of <code class="computeroutput"><span class="number">1</span><span class="special">/</span><span class="number">8</span></code>.
 366       </p>
 367 <pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">cyl_bessel_j_zero</span><span class="special">;</span>
 368 <span class="keyword">double</span> <span class="identifier">nu</span> <span class="special">=</span> <span class="number">1.</span><span class="special">;</span>
 369 <span class="keyword">double</span> <span class="identifier">sum</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
 370 <span class="identifier">output_summation_iterator</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="identifier">it</span><span class="special">(&amp;</span><span class="identifier">sum</span><span class="special">);</span>  <span class="comment">// sum of 1/zeros^2</span>
 371 <span class="identifier">cyl_bessel_j_zero</span><span class="special">(</span><span class="identifier">nu</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">10000</span><span class="special">,</span> <span class="identifier">it</span><span class="special">);</span>
 372
 373 <span class="keyword">double</span> <span class="identifier">s</span> <span class="special">=</span> <span class="number">1</span><span class="special">/(</span><span class="number">4</span> <span class="special">*</span> <span class="special">(</span><span class="identifier">nu</span> <span class="special">+</span> <span class="number">1</span><span class="special">));</span> <span class="comment">// 0.125 = 1/8 is exact analytical solution.</span>
 374 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="number">6</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">"nu = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">nu</span> <span class="special">&lt;&lt;</span> <span class="string">", sum = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">sum</span>
 375   <span class="special">&lt;&lt;</span> <span class="string">", exact = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">s</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 376 <span class="comment">// nu = 1.00000, sum = 0.124990, exact = 0.125000</span>
 377 </pre>
 378 <h6>
 379 <a name="math_toolkit.bessel.bessel_root.h4"></a>
 380         <span class="phrase"><a name="math_toolkit.bessel.bessel_root.calculating_zeros_of_the_neumann"></a></span><a class="link" href="bessel_root.html#math_toolkit.bessel.bessel_root.calculating_zeros_of_the_neumann">Calculating
 381         zeros of the Neumann function.</a>
 382       </h6>
 383 <p>
 384         This example also shows how Boost.Math and Boost.Multiprecision can be combined
 385         to provide a many decimal digit precision. For 50 decimal digit precision
 386         we need to include
 387       </p>
 388 <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">multiprecision</span><span class="special">/</span><span class="identifier">cpp_dec_float</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 389 </pre>
 390 <p>
 391         and a <code class="computeroutput"><span class="keyword">typedef</span></code> for <code class="computeroutput"><span class="identifier">float_type</span></code> may be convenient (allowing
 392         a quick switch to re-compute at built-in <code class="computeroutput"><span class="keyword">double</span></code>
 393         or other precision)
 394       </p>
 395 <pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">cpp_dec_float_50</span> <span class="identifier">float_type</span><span class="special">;</span>
 396 </pre>
 397 <p>
 398         To use the functions for finding zeros of the <code class="computeroutput"><span class="identifier">cyl_neumann</span></code>
 399         function we need:
 400       </p>
 401 <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">bessel</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 402 </pre>
 403 <p>
 404         The Neumann (Bessel Y) function zeros are evaluated very similarly:
 405       </p>
 406 <pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">cyl_neumann_zero</span><span class="special">;</span>
 407 <span class="keyword">double</span> <span class="identifier">zn</span> <span class="special">=</span> <span class="identifier">cyl_neumann_zero</span><span class="special">(</span><span class="number">2.</span><span class="special">,</span> <span class="number">1</span><span class="special">);</span>
 408 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cyl_neumann_zero(2., 1) = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">zn</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 409
 410 <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;</span> <span class="identifier">nzeros</span><span class="special">(</span><span class="number">3</span><span class="special">);</span> <span class="comment">// Space for 3 zeros.</span>
 411 <span class="identifier">cyl_neumann_zero</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;(</span><span class="number">2.F</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">nzeros</span><span class="special">.</span><span class="identifier">size</span><span class="special">(),</span> <span class="identifier">nzeros</span><span class="special">.</span><span class="identifier">begin</span><span class="special">());</span>
 412
 413 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cyl_neumann_zero&lt;float&gt;(2.F, 1, "</span><span class="special">;</span>
 414 <span class="comment">// Print the zeros to the output stream.</span>
 415 <span class="identifier">std</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span><span class="identifier">nzeros</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">nzeros</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span>
 416           <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">", "</span><span class="special">));</span>
 417
 418 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="string">"cyl_neumann_zero(static_cast&lt;float_type&gt;(220)/100, 1) = "</span>
 419   <span class="special">&lt;&lt;</span> <span class="identifier">cyl_neumann_zero</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">float_type</span><span class="special">&gt;(</span><span class="number">220</span><span class="special">)/</span><span class="number">100</span><span class="special">,</span> <span class="number">1</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 420 <span class="comment">// 3.6154383428745996706772556069431792744372398748422</span>
 421 </pre>
 422 <h6>
 423 <a name="math_toolkit.bessel.bessel_root.h5"></a>
 424         <span class="phrase"><a name="math_toolkit.bessel.bessel_root.error_messages_from_bad_input"></a></span><a class="link" href="bessel_root.html#math_toolkit.bessel.bessel_root.error_messages_from_bad_input">Error
 425         messages from 'bad' input</a>
 426       </h6>
 427 <p>
 428         Another example demonstrates calculating zeros of the Bessel functions showing
 429         the error messages from 'bad' input is handled by throwing exceptions.
 430       </p>
 431 <p>
 432         To use the functions for finding zeros of the functions we need:
 433       </p>
 434 <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">bessel</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 435 <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">airy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 436 </pre>
 437 <div class="tip"><table border="0" summary="Tip">
 438 <tr>
 439 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../../../doc/src/images/tip.png"></td>
 440 <th align="left">Tip</th>
 441 </tr>
 442 <tr><td align="left" valign="top"><p>
 443           It is always wise to place all code using Boost.Math inside try'n'catch
 444           blocks; this will ensure that helpful error messages can be shown when
 445           exceptional conditions arise.
 446         </p></td></tr>
 447 </table></div>
 448 <p>
 449         Examples below show messages from several 'bad' arguments that throw a <code class="computeroutput"><span class="identifier">domain_error</span></code> exception.
 450       </p>
 451 <pre class="programlisting"><span class="keyword">try</span>
 452 <span class="special">{</span> <span class="comment">// Try a zero order v.</span>
 453   <span class="keyword">float</span> <span class="identifier">dodgy_root</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">cyl_bessel_j_zero</span><span class="special">(</span><span class="number">0.F</span><span class="special">,</span> <span class="number">0</span><span class="special">);</span>
 454   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"boost::math::cyl_bessel_j_zero(0.F, 0) "</span> <span class="special">&lt;&lt;</span> <span class="identifier">dodgy_root</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 455   <span class="comment">// Thrown exception Error in function boost::math::cyl_bessel_j_zero&lt;double&gt;(double, int):</span>
 456   <span class="comment">// Requested the 0'th zero of J0, but the rank must be &gt; 0 !</span>
 457 <span class="special">}</span>
 458 <span class="keyword">catch</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">exception</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">)</span>
 459 <span class="special">{</span>
 460   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Thrown exception "</span> <span class="special">&lt;&lt;</span> <span class="identifier">ex</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 461 <span class="special">}</span>
 462 </pre>
 463 <div class="note"><table border="0" summary="Note">
 464 <tr>
 465 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
 466 <th align="left">Note</th>
 467 </tr>
 468 <tr><td align="left" valign="top"><p>
 469           The type shown in the error message is the type <span class="bold"><strong>after
 470           promotion</strong></span>, using <a class="link" href="../pol_ref/precision_pol.html" title="Precision Policies">precision
 471           policy</a> and <a class="link" href="../pol_ref/internal_promotion.html" title="Internal Floating-point Promotion Policies">internal
 472           promotion policy</a>, from <code class="computeroutput"><span class="keyword">float</span></code>
 473           to <code class="computeroutput"><span class="keyword">double</span></code> in this case.
 474         </p></td></tr>
 475 </table></div>
 476 <p>
 477         In this example the promotion goes:
 478       </p>
 479 <div class="orderedlist"><ol class="orderedlist" type="1">
 480 <li class="listitem">
 481             Arguments are <code class="computeroutput"><span class="keyword">float</span></code> and
 482             <code class="computeroutput"><span class="keyword">int</span></code>.
 483           </li>
 484 <li class="listitem">
 485             Treat <code class="computeroutput"><span class="keyword">int</span></code> "as if"
 486             it were a <code class="computeroutput"><span class="keyword">double</span></code>, so arguments
 487             are <code class="computeroutput"><span class="keyword">float</span></code> and <code class="computeroutput"><span class="keyword">double</span></code>.
 488           </li>
 489 <li class="listitem">
 490             Common type is <code class="computeroutput"><span class="keyword">double</span></code> -
 491             so that's the precision we want (and the type that will be returned).
 492           </li>
 493 <li class="listitem">
 494             Evaluate internally as <code class="computeroutput"><span class="keyword">double</span></code>
 495             for full <code class="computeroutput"><span class="keyword">float</span></code> precision.
 496           </li>
 497 </ol></div>
 498 <p>
 499         See full code for other examples that promote from <code class="computeroutput"><span class="keyword">double</span></code>
 500         to <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>.
 501       </p>
 502 <p>
 503         Other examples of 'bad' inputs like infinity and NaN are below. Some compiler
 504         warnings indicate that 'bad' values are detected at compile time.
 505       </p>
 506 <pre class="programlisting"><span class="keyword">try</span>
 507 <span class="special">{</span> <span class="comment">// order v = inf</span>
 508    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"boost::math::cyl_bessel_j_zero(inf, 1) "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 509    <span class="keyword">double</span> <span class="identifier">inf</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="keyword">double</span><span class="special">&gt;::</span><span class="identifier">infinity</span><span class="special">();</span>
 510    <span class="keyword">double</span> <span class="identifier">inf_root</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">cyl_bessel_j_zero</span><span class="special">(</span><span class="identifier">inf</span><span class="special">,</span> <span class="number">1</span><span class="special">);</span>
 511    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"boost::math::cyl_bessel_j_zero(inf, 1) "</span> <span class="special">&lt;&lt;</span> <span class="identifier">inf_root</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 512    <span class="comment">// Throw exception Error in function boost::math::cyl_bessel_j_zero&lt;long double&gt;(long double, unsigned):</span>
 513    <span class="comment">// Order argument is 1.#INF, but must be finite &gt;= 0 !</span>
 514 <span class="special">}</span>
 515 <span class="keyword">catch</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">exception</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">)</span>
 516 <span class="special">{</span>
 517   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Thrown exception "</span> <span class="special">&lt;&lt;</span> <span class="identifier">ex</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 518 <span class="special">}</span>
 519
 520 <span class="keyword">try</span>
 521 <span class="special">{</span> <span class="comment">// order v = NaN, rank m = 1</span>
 522    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"boost::math::cyl_bessel_j_zero(nan, 1) "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 523    <span class="keyword">double</span> <span class="identifier">nan</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="keyword">double</span><span class="special">&gt;::</span><span class="identifier">quiet_NaN</span><span class="special">();</span>
 524    <span class="keyword">double</span> <span class="identifier">nan_root</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">cyl_bessel_j_zero</span><span class="special">(</span><span class="identifier">nan</span><span class="special">,</span> <span class="number">1</span><span class="special">);</span>
 525    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"boost::math::cyl_bessel_j_zero(nan, 1) "</span> <span class="special">&lt;&lt;</span> <span class="identifier">nan_root</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 526    <span class="comment">// Throw exception Error in function boost::math::cyl_bessel_j_zero&lt;long double&gt;(long double, unsigned):</span>
 527    <span class="comment">// Order argument is 1.#QNAN, but must be finite &gt;= 0 !</span>
 528 <span class="special">}</span>
 529 <span class="keyword">catch</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">exception</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">)</span>
 530 <span class="special">{</span>
 531   <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Thrown exception "</span> <span class="special">&lt;&lt;</span> <span class="identifier">ex</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 532 <span class="special">}</span>
 533 </pre>
 534 <p>
 535         The output from other examples are shown appended to the full code listing.
 536       </p>
 537 <p>
 538         The full code (and output) for these examples is at <a href="../../../../example/bessel_zeros_example_1.cpp" target="_top">Bessel
 539         zeros</a>, <a href="../../../../example/bessel_zeros_interator_example.cpp" target="_top">Bessel
 540         zeros iterator</a>, <a href="../../../../example/neumann_zeros_example_1.cpp" target="_top">Neumann
 541         zeros</a>, <a href="../../../../example/bessel_errors_example.cpp" target="_top">Bessel
 542         error messages</a>.
 543       </p>
 544 <h4>
 545 <a name="math_toolkit.bessel.bessel_root.h6"></a>
 546         <span class="phrase"><a name="math_toolkit.bessel.bessel_root.implementation"></a></span><a class="link" href="bessel_root.html#math_toolkit.bessel.bessel_root.implementation">Implementation</a>
 547       </h4>
 548 <p>
 549         Various methods are used to compute initial estimates for <span class="emphasis"><em>j<sub>&#957;, m</sub></em></span>
 550         and <span class="emphasis"><em>y<sub>&#957;, m</sub></em></span> ; these are described in detail below.
 551       </p>
 552 <p>
 553         After finding the initial estimate of a given root, its precision is subsequently
 554         refined to the desired level using Newton-Raphson iteration from Boost.Math's
 555         <a class="link" href="../roots_deriv.html" title="Root Finding With Derivatives: Newton-Raphson, Halley &amp; Schr&#246;der">root-finding with derivatives</a>
 556         utilities combined with the functions <a class="link" href="bessel_first.html" title="Bessel Functions of the First and Second Kinds">cyl_bessel_j</a>
 557         and <a class="link" href="bessel_first.html" title="Bessel Functions of the First and Second Kinds">cyl_neumann</a>.
 558       </p>
 559 <p>
 560         Newton iteration requires both <span class="emphasis"><em>J<sub>&#957;</sub>(x)</em></span> or <span class="emphasis"><em>Y<sub>&#957;</sub>(x)</em></span>
 561         as well as its derivative. The derivatives of <span class="emphasis"><em>J<sub>&#957;</sub>(x)</em></span> and
 562         <span class="emphasis"><em>Y<sub>&#957;</sub>(x)</em></span> with respect to <span class="emphasis"><em>x</em></span> are given
 563         by M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions, NBS
 564         (1964). In particular,
 565       </p>
 566 <div class="blockquote"><blockquote class="blockquote"><p>
 567           <span class="serif_italic">d/<sub>dx</sub> <span class="emphasis"><em>J<sub>&#957;</sub>(x)</em></span> = <span class="emphasis"><em>J<sub>&#957;-1</sub>(x)</em></span>
 568           - &#957; J<sub>&#957;</sub>(x) / x</span>
 569         </p></blockquote></div>
 570 <div class="blockquote"><blockquote class="blockquote"><p>
 571           <span class="serif_italic">d/<sub>dx</sub> <span class="emphasis"><em>Y<sub>&#957;</sub>(x)</em></span> = <span class="emphasis"><em>Y<sub>&#957;-1</sub>(x)</em></span>
 572           - &#957; Y<sub>&#957;</sub>(x) / x</span>
 573         </p></blockquote></div>
 574 <p>
 575         Enumeration of the rank of a root (in other words the index of a root) begins
 576         with one and counts up, in other words <span class="emphasis"><em>m,=1,2,3,&#8230;</em></span> The
 577         value of the first root is always greater than zero.
 578       </p>
 579 <p>
 580         For certain special parameters, cylindrical Bessel functions and cylindrical
 581         Neumann functions have a root at the origin. For example, <span class="emphasis"><em>J<sub>&#957;</sub>(x)</em></span>
 582         has a root at the origin for every positive order <span class="emphasis"><em>&#957; &gt; 0</em></span>,
 583         and for every negative integer order <span class="emphasis"><em>&#957; = -n</em></span> with <span class="emphasis"><em>n
 584         &#8712; &#8469; <sup>+</sup></em></span> and <span class="emphasis"><em>n &#8800; 0</em></span>.
 585       </p>
 586 <p>
 587         In addition, <span class="emphasis"><em>Y<sub>&#957;</sub>(x)</em></span> has a root at the origin for every
 588         negative half-integer order <span class="emphasis"><em>&#957; = -n/2</em></span>, with <span class="emphasis"><em>n
 589         &#8712; &#8469; <sup>+</sup></em></span> and and <span class="emphasis"><em>n &#8800; 0</em></span>.
 590       </p>
 591 <p>
 592         For these special parameter values, the origin with a value of <span class="emphasis"><em>x
 593         = 0</em></span> is provided as the <span class="emphasis"><em>0<sup>th</sup></em></span> root generated
 594         by <code class="computeroutput"><span class="identifier">cyl_bessel_j_zero</span><span class="special">()</span></code>
 595         and <code class="computeroutput"><span class="identifier">cyl_neumann_zero</span><span class="special">()</span></code>.
 596       </p>
 597 <p>
 598         When calculating initial estimates for the roots of Bessel functions, a distinction
 599         is made between positive order and negative order, and different methods
 600         are used for these. In addition, different algorithms are used for the first
 601         root <span class="emphasis"><em>m = 1</em></span> and for subsequent roots with higher rank
 602         <span class="emphasis"><em>m &#8805; 2</em></span>. Furthermore, estimates of the roots for Bessel
 603         functions with order above and below a cutoff at <span class="emphasis"><em>&#957; = 2.2</em></span>
 604         are calculated with different methods.
 605       </p>
 606 <p>
 607         Calculations of the estimates of <span class="emphasis"><em>j<sub>&#957;,1</sub></em></span> and <span class="emphasis"><em>y<sub>&#957;,1</sub></em></span>
 608         with <span class="emphasis"><em>0 &#8804; &#957; &lt; 2.2</em></span> use empirically tabulated values. The
 609         coefficients for these have been generated by a computer algebra system.
 610       </p>
 611 <p>
 612         Calculations of the estimates of <span class="emphasis"><em>j<sub>&#957;,1</sub></em></span> and <span class="emphasis"><em>y<sub>&#957;,1</sub></em></span>
 613         with <span class="emphasis"><em>&#957;&#8805; 2.2</em></span> use Eqs.9.5.14 and 9.5.15 in M. Abramowitz
 614         and I. A. Stegun, Handbook of Mathematical Functions, NBS (1964).
 615       </p>
 616 <p>
 617         In particular,
 618       </p>
 619 <div class="blockquote"><blockquote class="blockquote"><p>
 620           <span class="serif_italic">j<sub>&#957;,1</sub> &#8773; &#957; + 1.85575 &#957;<sup>&#8531;</sup> + 1.033150 &#957;<sup>-&#8531;</sup> - 0.00397 &#957;<sup>-1</sup> - 0.0908
 621           &#957;<sup>-5/3</sup> + 0.043 &#957;<sup>-7/3</sup> + &#8230;</span>
 622         </p></blockquote></div>
 623 <p>
 624         and
 625       </p>
 626 <div class="blockquote"><blockquote class="blockquote"><p>
 627           <span class="serif_italic">y<sub>&#957;,1</sub> &#8773; &#957; + 0.93157 &#957;<sup>&#8531;</sup> + 0.26035 &#957;<sup>-&#8531;</sup> + 0.01198 &#957;<sup>-1</sup> - 0.0060
 628           &#957;<sup>-5/3</sup> - 0.001 &#957;<sup>-7/3</sup> + &#8230;</span>
 629         </p></blockquote></div>
 630 <p>
 631         Calculations of the estimates of <span class="emphasis"><em>j<sub>&#957;, m</sub></em></span> and <span class="emphasis"><em>y<sub>&#957;,
 632         m</sub></em></span> with rank <span class="emphasis"><em>m &gt; 2</em></span> and <span class="emphasis"><em>0 &#8804; &#957; &lt;
 633         2.2</em></span> use McMahon's approximation, as described in M. Abramowitz
 634         and I. A. Stegan, Section 9.5 and 9.5.12. In particular,
 635       </p>
 636 <div class="blockquote"><blockquote class="blockquote"><p>
 637           <span class="emphasis"><em>j<sub>&#957;,m</sub>, y<sub>&#957;,m</sub> &#8773;</em></span>
 638         </p></blockquote></div>
 639 <div class="blockquote"><blockquote class="blockquote"><div class="blockquote"><blockquote class="blockquote"><p>
 640             &#946; - (&#956;-1) / 8&#946;
 641           </p></blockquote></div></blockquote></div>
 642 <div class="blockquote"><blockquote class="blockquote"><div class="blockquote"><blockquote class="blockquote"><p>
 643             <span class="emphasis"><em>- 4(&#956;-1)(7&#956; - 31) / 3(8&#946;)<sup>3</sup></em></span>
 644           </p></blockquote></div></blockquote></div>
 645 <div class="blockquote"><blockquote class="blockquote"><div class="blockquote"><blockquote class="blockquote"><p>
 646             <span class="emphasis"><em>-32(&#956;-1)(83&#956;&#178; - 982&#956; + 3779) / 15(8&#946;)<sup>5</sup></em></span>
 647           </p></blockquote></div></blockquote></div>
 648 <div class="blockquote"><blockquote class="blockquote"><div class="blockquote"><blockquote class="blockquote"><p>
 649             <span class="emphasis"><em>-64(&#956;-1)(6949&#956;<sup>3</sup> - 153855&#956;&#178; + 1585743&#956;- 6277237) / 105(8a)<sup>7</sup></em></span>
 650           </p></blockquote></div></blockquote></div>
 651 <div class="blockquote"><blockquote class="blockquote"><div class="blockquote"><blockquote class="blockquote"><p>
 652             <span class="emphasis"><em>- &#8230;</em></span> &#8193; (5)
 653           </p></blockquote></div></blockquote></div>
 654 <p>
 655         where <span class="emphasis"><em>&#956; = 4&#957;<sup>2</sup></em></span> and <span class="emphasis"><em>&#946; = (m + &#189;&#957; - &#188;)&#960;</em></span> for
 656         <span class="emphasis"><em>j<sub>&#957;,m</sub></em></span> and <span class="emphasis"><em>&#946; = (m + &#189;&#957; -&#190;)&#960; for <span class="emphasis"><em>y<sub>&#957;,m</sub></em></span></em></span>.
 657       </p>
 658 <p>
 659         Calculations of the estimates of <span class="emphasis"><em>j<sub>&#957;, m</sub></em></span> and <span class="emphasis"><em>y<sub>&#957;,
 660         m</sub></em></span> with <span class="emphasis"><em>&#957; &#8805; 2.2</em></span> use one term in the asymptotic
 661         expansion given in Eq.9.5.22 and top line of Eq.9.5.26 combined with Eq.
 662         9.3.39, all in M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions,
 663         NBS (1964) explicit and easy-to-understand treatment for asymptotic expansion
 664         of zeros. The latter two equations are expressed for argument <span class="emphasis"><em>(x)</em></span>
 665         greater than one. (Olver also gives the series form of the equations in
 666         <a href="http://dlmf.nist.gov/10.21#vi" target="_top">&#167;10.21(vi) McMahon's Asymptotic
 667         Expansions for Large Zeros</a> - using slightly different variable names).
 668       </p>
 669 <p>
 670         In summary,
 671       </p>
 672 <div class="blockquote"><blockquote class="blockquote"><p>
 673           <span class="serif_italic">j<sub>&#957;, m</sub> &#8764; &#957;x(-&#950;) + f<sub>1</sub>(-&#950;/&#957;)</span>
 674         </p></blockquote></div>
 675 <p>
 676         where <span class="emphasis"><em>-&#950; = &#957;<sup>-2/3</sup>a<sub>m</sub></em></span> and <span class="emphasis"><em>a<sub>m</sub></em></span> is the absolute
 677         value of the <span class="emphasis"><em>m<sup>th</sup></em></span> root of <span class="emphasis"><em>Ai(x)</em></span>
 678         on the negative real axis.
 679       </p>
 680 <p>
 681         Here <span class="emphasis"><em>x = x(-&#950;)</em></span> is the inverse of the function
 682       </p>
 683 <div class="blockquote"><blockquote class="blockquote"><p>
 684           <span class="serif_italic">&#8532;(-&#950;)<sup>3/2</sup> = &#8730;(x&#178; - 1) - cos&#8315;&#185;(1/x)</span>
 685         </p></blockquote></div>
 686 <p>
 687         (7)
 688       </p>
 689 <p>
 690         Furthermore,
 691       </p>
 692 <div class="blockquote"><blockquote class="blockquote"><p>
 693           <span class="serif_italic">f<sub>1</sub>(-&#950;) = &#189;x(-&#950;) {h(-&#950;)}&#178; &#8901; b<sub>0</sub>(-&#950;)</span>
 694         </p></blockquote></div>
 695 <p>
 696         where
 697       </p>
 698 <div class="blockquote"><blockquote class="blockquote"><p>
 699           <span class="serif_italic">h(-&#950;) = {4(-&#950;) / (x&#178; - 1)}<sup>4</sup></span>
 700         </p></blockquote></div>
 701 <p>
 702         and
 703       </p>
 704 <div class="blockquote"><blockquote class="blockquote"><p>
 705           <span class="serif_italic">b<sub>0</sub>(-&#950;) = -5/(48&#950;&#178;) + 1/(-&#950;)<sup>&#189;</sup> &#8901; { 5/(24(x<sup>2</sup>-1)<sup>3/2</sup>) +
 706           1/(8(x<sup>2</sup>-1)<sup>&#189;)</sup>}</span>
 707         </p></blockquote></div>
 708 <p>
 709         When solving for <span class="emphasis"><em>x(-&#950;)</em></span> in Eq. 7 above, the right-hand-side
 710         is expanded to order 2 in a Taylor series for large <span class="emphasis"><em>x</em></span>.
 711         This results in
 712       </p>
 713 <div class="blockquote"><blockquote class="blockquote"><p>
 714           <span class="serif_italic">&#8532;(-&#950;)<sup>3/2</sup> &#8776; x + 1/2x - &#960;/2</span>
 715         </p></blockquote></div>
 716 <p>
 717         The positive root of the resulting quadratic equation is used to find an
 718         initial estimate <span class="emphasis"><em>x(-&#950;)</em></span>. This initial estimate is subsequently
 719         refined with several steps of Newton-Raphson iteration in Eq. 7.
 720       </p>
 721 <p>
 722         Estimates of the roots of cylindrical Bessel functions of negative order
 723         on the positive real axis are found using interlacing relations. For example,
 724         the <span class="emphasis"><em>m<sup>th</sup></em></span> root of the cylindrical Bessel function <span class="emphasis"><em>j<sub>-&#957;,m</sub></em></span>
 725         is bracketed by the <span class="emphasis"><em>m<sup>th</sup></em></span> root and the <span class="emphasis"><em>(m+1)<sup>th</sup></em></span>
 726         root of the Bessel function of corresponding positive integer order. In other
 727         words,
 728       </p>
 729 <div class="blockquote"><blockquote class="blockquote"><p>
 730           <span class="serif_italic">j<sub>n&#957;, m</sub> &lt; j<sub>-&#957;, m</sub> &lt; j<sub>n&#957;, m+1</sub></span>
 731         </p></blockquote></div>
 732 <p>
 733         where <span class="emphasis"><em>m &gt; 1</em></span> and <span class="emphasis"><em>n<sub>&#957;</sub></em></span> represents
 734         the integral floor of the absolute value of <span class="emphasis"><em>|-&#957;|</em></span>.
 735       </p>
 736 <p>
 737         Similar bracketing relations are used to find estimates of the roots of Neumann
 738         functions of negative order, whereby a discontinuity at every negative half-integer
 739         order needs to be handled.
 740       </p>
 741 <p>
 742         Bracketing relations do not hold for the first root of cylindrical Bessel
 743         functions and cylindrical Neumann functions with negative order. Therefore,
 744         iterative algorithms combined with root-finding via bisection are used to
 745         localize <span class="emphasis"><em>j<sub>-&#957;,1</sub></em></span> and <span class="emphasis"><em>y<sub>-&#957;,1</sub></em></span>.
 746       </p>
 747 <h4>
 748 <a name="math_toolkit.bessel.bessel_root.h7"></a>
 749         <span class="phrase"><a name="math_toolkit.bessel.bessel_root.testing"></a></span><a class="link" href="bessel_root.html#math_toolkit.bessel.bessel_root.testing">Testing</a>
 750       </h4>
 751 <p>
 752         The precision of evaluation of zeros was tested at 50 decimal digits using
 753         <code class="computeroutput"><span class="identifier">cpp_dec_float_50</span></code> and found
 754         identical with spot values computed by <a href="http://www.wolframalpha.com/" target="_top">Wolfram
 755         Alpha</a>.
 756       </p>
 757 </div>
 758 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 759 <td align="left"></td>
 760 <td align="right"><div class="copyright-footer">Copyright &#169; 2006-2019 Nikhar
 761       Agrawal, Anton Bikineev, Paul A. Bristow, Marco Guazzone, Christopher Kormanyos,
 762       Hubert Holin, Bruno Lalande, John Maddock, Jeremy Murphy, Matthew Pulver, Johan
 763       R&#229;de, Gautam Sewani, Benjamin Sobotta, Nicholas Thompson, Thijs van den Berg,
 764       Daryle Walker and Xiaogang Zhang<p>
 765         Distributed under the Boost Software License, Version 1.0. (See accompanying
 766         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>)
 767       </p>
 768 </div></td>
 769 </tr></table>
 770 <hr>
 771 <div class="spirit-nav">
 772 <a accesskey="p" href="bessel_first.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../bessel.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="mbessel.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 773 </div>
 774 </body>
 775 </html>