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.77.1">
7 <link rel=
"home" href=
"../../index.html" title=
"Math Toolkit 2.5.1">
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">
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>
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>
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>
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>
35 <code class=
"computeroutput"><span class=
"preprocessor">#include
</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">special_functions
</span><span class=
"special">/
</span><span class=
"identifier">bessel
</span><span class=
"special">.
</span><span class=
"identifier">hpp
</span><span class=
"special">></span></code>
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.
43 The signature of the single value functions are:
45 <pre class=
"programlisting"><span class=
"keyword">template
</span> <span class=
"special"><</span><span class=
"keyword">class
</span> <span class=
"identifier">T
</span><span class=
"special">></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>
50 <span class=
"keyword">template
</span> <span class=
"special"><</span><span class=
"keyword">class
</span> <span class=
"identifier">T
</span><span class=
"special">></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>
56 and for multiple zeros:
58 <pre class=
"programlisting"><span class=
"keyword">template
</span> <span class=
"special"><</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">></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>
65 <span class=
"keyword">template
</span> <span class=
"special"><</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">></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>
73 There are also versions which allow control of the
<a class=
"link" href=
"../../policy.html" title=
"Chapter 15. Policies: Controlling Precision, Error Handling etc">Policies
</a>
74 for error handling and precision.
76 <pre class=
"programlisting"> <span class=
"keyword">template
</span> <span class=
"special"><</span><span class=
"keyword">class
</span> <span class=
"identifier">T
</span><span class=
"special">></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">&);
</span> <span class=
"comment">// Policy to use.
</span>
82 <span class=
"keyword">template
</span> <span class=
"special"><</span><span class=
"keyword">class
</span> <span class=
"identifier">T
</span><span class=
"special">></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">&);
</span> <span class=
"comment">// Policy to use.
</span>
89 <span class=
"keyword">template
</span> <span class=
"special"><</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">></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">&</span> <span class=
"identifier">pol
</span><span class=
"special">);
</span> <span class=
"comment">// Policy to use.
</span>
97 <span class=
"keyword">template
</span> <span class=
"special"><</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">></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">&</span> <span class=
"identifier">pol
</span><span class=
"special">);
</span> <span class=
"comment">// Policy to use.
</span>
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>
110 Every real order
ν 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
115   <span class=
"emphasis"><em>J
<sub>ν</sub>(j
<sub>ν, m
</sub>) =
0</em></span>
118   <span class=
"emphasis"><em>Y
<sub>ν</sub>(y
<sub>ν, m
</sub>) =
0</em></span>
121 Here,
<span class=
"emphasis"><em>j
<sub>ν, 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>ν</em></span>, and
<span class=
"emphasis"><em>y
<sub>ν,
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>ν</em></span>.
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>.
134 In each case the index or rank of the zero returned is
1-based, which is
137 <pre class=
"programlisting"><span class=
"identifier">cyl_bessel_j_zero
</span><span class=
"special">(
</span><span class=
"identifier">v
</span><span class=
"special">,
</span> <span class=
"number">1</span><span class=
"special">);
</span>
140 returns the first zero of Bessel J.
143 Passing an
<code class=
"computeroutput"><span class=
"identifier">start_index
</span> <span class=
"special"><=
</span>
144 <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>
148 For certain parameters, however, the zero'th root is defined and it has a
149 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>
150 is defined and it has a value of zero for all values of
<code class=
"computeroutput"><span class=
"identifier">v
</span>
151 <span class=
"special">></span> <span class=
"number">0</span></code>
152 and for negative integer values of
<code class=
"computeroutput"><span class=
"identifier">v
</span>
153 <span class=
"special">=
</span> <span class=
"special">-
</span><span class=
"identifier">n
</span></code>. Similar cases are described in the implementation
157 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
158 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
162 <span class=
"inlinemediaobject"><img src=
"../../../graphs/bessel_j_zeros.svg" align=
"middle"></span>
165 <span class=
"inlinemediaobject"><img src=
"../../../graphs/neumann_y_zeros.svg" align=
"middle"></span>
168 <a name=
"math_toolkit.bessel.bessel_root.h2"></a>
169 <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
170 of finding Bessel and Neumann zeros
</a>
173 This example demonstrates calculating zeros of the Bessel and Neumann functions.
174 It also shows how Boost.Math and Boost.Multiprecision can be combined to
175 provide a many decimal digit precision. For
50 decimal digit precision we
178 <pre class=
"programlisting"><span class=
"preprocessor">#include
</span> <span class=
"special"><</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">></span>
181 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
182 a quick switch to re-compute at built-in
<code class=
"computeroutput"><span class=
"keyword">double
</span></code>
185 <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>
188 To use the functions for finding zeros of the functions we need
190 <pre class=
"programlisting"><span class=
"preprocessor">#include
</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">special_functions
</span><span class=
"special">/
</span><span class=
"identifier">bessel
</span><span class=
"special">.
</span><span class=
"identifier">hpp
</span><span class=
"special">></span>
193 This file includes the forward declaration signatures for the zero-finding
196 <pre class=
"programlisting"><span class=
"comment">// #include
<boost/math/special_functions/math_fwd.hpp
></span>
199 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
200 Bessel functions
</a>.
203 This example shows obtaining both a single zero of the Bessel function, and
204 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>
205 by providing an iterator.
207 <div class=
"tip"><table border=
"0" summary=
"Tip">
209 <td rowspan=
"2" align=
"center" valign=
"top" width=
"25"><img alt=
"[Tip]" src=
"../../../../../../doc/src/images/tip.png"></td>
210 <th align=
"left">Tip
</th>
212 <tr><td align=
"left" valign=
"top"><p>
213 It is always wise to place code using Boost.Math inside try'n'catch blocks;
214 this will ensure that helpful error messages are shown when exceptional
219 First, evaluate a single Bessel zero.
222 The precision is controlled by the float-point type of template parameter
223 <code class=
"computeroutput"><span class=
"identifier">T
</span></code> of
<code class=
"computeroutput"><span class=
"identifier">v
</span></code>
224 so this example has
<code class=
"computeroutput"><span class=
"keyword">double
</span></code> precision,
225 at least
15 but up to
17 decimal digits (for the common
64-bit double).
227 <pre class=
"programlisting"><span class=
"comment">// double root = boost::math::cyl_bessel_j_zero(
0.0,
1);
</span>
228 <span class=
"comment">// // Displaying with default precision of
6 decimal digits:
</span>
229 <span class=
"comment">// std::cout
<< "boost::math::cyl_bessel_j_zero(0.0, 1) " << root
<< std::endl; //
2.40483</span>
230 <span class=
"comment">// // And with all the guaranteed (
15) digits:
</span>
231 <span class=
"comment">// std::cout.precision(std::numeric_limits
<double
>::digits10);
</span>
232 <span class=
"comment">// std::cout
<< "boost::math::cyl_bessel_j_zero(0.0, 1) " << root
<< std::endl; //
2.40482555769577</span>
235 But note that because the parameter
<code class=
"computeroutput"><span class=
"identifier">v
</span></code>
236 controls the precision of the result,
<code class=
"computeroutput"><span class=
"identifier">v
</span></code>
237 <span class=
"bold"><strong>must be a floating-point type
</strong></span>. So if you
238 provide an integer type, say
0, rather than
0.0, then it will fail to compile
241 <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>
244 with this error message
246 <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>
249 Optionally, we can use a policy to ignore errors, C-style, returning some
250 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>).
253 To create a (possibly unwise!) policy
<code class=
"computeroutput"><span class=
"identifier">ignore_all_policy
</span></code>
254 that ignores all errors:
256 <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"><</span>
257 <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"><</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">>,
</span>
258 <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"><</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">>,
</span>
259 <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"><</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">>,
</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">denorm_error
</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">policies
</span><span class=
"special">::
</span><span class=
"identifier">ignore_error
</span><span class=
"special">>,
</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">pole_error
</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">policies
</span><span class=
"special">::
</span><span class=
"identifier">ignore_error
</span><span class=
"special">>,
</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">evaluation_error
</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">policies
</span><span class=
"special">::
</span><span class=
"identifier">ignore_error
</span><span class=
"special">></span>
263 <span class=
"special">></span> <span class=
"identifier">ignore_all_policy
</span><span class=
"special">;
</span>
266 Examples of use of this
<code class=
"computeroutput"><span class=
"identifier">ignore_all_policy
</span></code>
269 <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"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">infinity
</span><span class=
"special">();
</span>
270 <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"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">quiet_NaN
</span><span class=
"special">();
</span>
272 <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>
273 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"boost::math::cyl_bessel_j_zero(-1.0, 1) "</span> <span class=
"special"><<</span> <span class=
"identifier">dodgy_root
</span> <span class=
"special"><<</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>
274 <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>
275 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"boost::math::cyl_bessel_j_zero(inf, 1) "</span> <span class=
"special"><<</span> <span class=
"identifier">inf_root
</span> <span class=
"special"><<</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>
276 <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>
277 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"boost::math::cyl_bessel_j_zero(nan, 1) "</span> <span class=
"special"><<</span> <span class=
"identifier">nan_root
</span> <span class=
"special"><<</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>
280 Another version of
<code class=
"computeroutput"><span class=
"identifier">cyl_bessel_j_zero
</span></code>
281 allows calculation of multiple zeros with one call, placing the results in
282 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
283 the first five
<code class=
"computeroutput"><span class=
"keyword">double
</span></code> roots
284 of J
<sub>v
</sub> for integral order
2, as column
<span class=
"emphasis"><em>J
<sub>2</sub>(x)
</em></span> in table
285 1 of
<a href=
"http://mathworld.wolfram.com/BesselFunctionZeros.html" target=
"_top">Wolfram
286 Bessel Function Zeros
</a>.
288 <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>
289 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">vector
</span><span class=
"special"><</span><span class=
"keyword">double
</span><span class=
"special">></span> <span class=
"identifier">roots
</span><span class=
"special">;
</span>
290 <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>
291 <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>
292 <span class=
"identifier">roots
</span><span class=
"special">.
</span><span class=
"identifier">end
</span><span class=
"special">(),
</span>
293 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">ostream_iterator
</span><span class=
"special"><</span><span class=
"keyword">double
</span><span class=
"special">>(
</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>
296 Or we can use Boost.Multiprecision to generate
50 decimal digit roots of
297 <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>,
298 expressed as an exact-integer fraction to generate the most accurate value
299 possible for all floating-point types.
302 We set the precision of the output stream, and show trailing zeros to display
303 a fixed
50 decimal digits.
305 <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"><</span><span class=
"identifier">float_type
</span><span class=
"special">>::
</span><span class=
"identifier">digits10
</span><span class=
"special">);
</span> <span class=
"comment">//
50 decimal digits.
</span>
306 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">showpoint
</span> <span class=
"special"><<</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>
308 <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>
309 <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>
310 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"x = "</span> <span class=
"special"><<</span> <span class=
"identifier">x
</span> <span class=
"special"><<</span> <span class=
"string">", r = "</span> <span class=
"special"><<</span> <span class=
"identifier">r
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
312 <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>
313 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"x = "</span> <span class=
"special"><<</span> <span class=
"identifier">x
</span> <span class=
"special"><<</span> <span class=
"string">", r = "</span> <span class=
"special"><<</span> <span class=
"identifier">r
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
315 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">vector
</span><span class=
"special"><</span><span class=
"identifier">float_type
</span><span class=
"special">></span> <span class=
"identifier">zeros
</span><span class=
"special">;
</span>
316 <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>
318 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"cyl_bessel_j_zeros"</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
319 <span class=
"comment">// Print the roots to the output stream.
</span>
320 <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>
321 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">ostream_iterator
</span><span class=
"special"><</span><span class=
"identifier">float_type
</span><span class=
"special">>(
</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>
324 <a name=
"math_toolkit.bessel.bessel_root.h3"></a>
325 <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
326 Output Iterator to sum zeros of Bessel Functions
</a>
329 This example demonstrates summing zeros of the Bessel functions. To use the
330 functions for finding zeros of the functions we need
332 <pre class=
"programlisting"><span class=
"preprocessor">#include
</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">special_functions
</span><span class=
"special">/
</span><span class=
"identifier">bessel
</span><span class=
"special">.
</span><span class=
"identifier">hpp
</span><span class=
"special">></span>
335 We use the
<code class=
"computeroutput"><span class=
"identifier">cyl_bessel_j_zero
</span></code>
336 output iterator parameter
<code class=
"computeroutput"><span class=
"identifier">out_it
</span></code>
337 to create a sum of
<span class=
"emphasis"><em>1/zeros
<sup>2</sup></em></span> by defining a custom output
340 <pre class=
"programlisting"><span class=
"keyword">template
</span> <span class=
"special"><</span><span class=
"keyword">class
</span> <span class=
"identifier">T
</span><span class=
"special">></span>
341 <span class=
"keyword">struct
</span> <span class=
"identifier">output_summation_iterator
</span>
342 <span class=
"special">{
</span>
343 <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>
344 <span class=
"special">{}
</span>
345 <span class=
"identifier">output_summation_iterator
</span><span class=
"special">&</span> <span class=
"keyword">operator
</span><span class=
"special">*()
</span>
346 <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>
347 <span class=
"identifier">output_summation_iterator
</span><span class=
"special">&</span> <span class=
"keyword">operator
</span><span class=
"special">++()
</span>
348 <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>
349 <span class=
"identifier">output_summation_iterator
</span><span class=
"special">&</span> <span class=
"keyword">operator
</span><span class=
"special">++(
</span><span class=
"keyword">int
</span><span class=
"special">)
</span>
350 <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>
351 <span class=
"identifier">output_summation_iterator
</span><span class=
"special">&</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">&</span> <span class=
"identifier">val
</span><span class=
"special">)
</span>
352 <span class=
"special">{
</span>
353 <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>
354 <span class=
"keyword">return
</span> <span class=
"special">*
</span><span class=
"keyword">this
</span><span class=
"special">;
</span>
355 <span class=
"special">}
</span>
356 <span class=
"keyword">private
</span><span class=
"special">:
</span>
357 <span class=
"identifier">T
</span><span class=
"special">*
</span> <span class=
"identifier">p_sum
</span><span class=
"special">;
</span>
358 <span class=
"special">};
</span>
361 The sum is calculated for many values, converging on the analytical exact
362 value of
<code class=
"computeroutput"><span class=
"number">1</span><span class=
"special">/
</span><span class=
"number">8</span></code>.
364 <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>
365 <span class=
"keyword">double
</span> <span class=
"identifier">nu
</span> <span class=
"special">=
</span> <span class=
"number">1.
</span><span class=
"special">;
</span>
366 <span class=
"keyword">double
</span> <span class=
"identifier">sum
</span> <span class=
"special">=
</span> <span class=
"number">0</span><span class=
"special">;
</span>
367 <span class=
"identifier">output_summation_iterator
</span><span class=
"special"><</span><span class=
"keyword">double
</span><span class=
"special">></span> <span class=
"identifier">it
</span><span class=
"special">(
&</span><span class=
"identifier">sum
</span><span class=
"special">);
</span> <span class=
"comment">// sum of
1/zeros^
2</span>
368 <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>
370 <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>
371 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</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"><<</span> <span class=
"string">"nu = "</span> <span class=
"special"><<</span> <span class=
"identifier">nu
</span> <span class=
"special"><<</span> <span class=
"string">", sum = "</span> <span class=
"special"><<</span> <span class=
"identifier">sum
</span>
372 <span class=
"special"><<</span> <span class=
"string">", exact = "</span> <span class=
"special"><<</span> <span class=
"identifier">s
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
373 <span class=
"comment">// nu =
1.00000, sum =
0.124990, exact =
0.125000</span>
376 <a name=
"math_toolkit.bessel.bessel_root.h4"></a>
377 <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
378 zeros of the Neumann function.
</a>
381 This example also shows how Boost.Math and Boost.Multiprecision can be combined
382 to provide a many decimal digit precision. For
50 decimal digit precision
385 <pre class=
"programlisting"><span class=
"preprocessor">#include
</span> <span class=
"special"><</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">></span>
388 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
389 a quick switch to re-compute at built-in
<code class=
"computeroutput"><span class=
"keyword">double
</span></code>
392 <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>
395 To use the functions for finding zeros of the
<code class=
"computeroutput"><span class=
"identifier">cyl_neumann
</span></code>
398 <pre class=
"programlisting"><span class=
"preprocessor">#include
</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">special_functions
</span><span class=
"special">/
</span><span class=
"identifier">bessel
</span><span class=
"special">.
</span><span class=
"identifier">hpp
</span><span class=
"special">></span>
401 The Neumann (Bessel Y) function zeros are evaluated very similarly:
403 <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>
404 <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>
405 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"cyl_neumann_zero(2., 1) = "</span> <span class=
"special"><<</span> <span class=
"identifier">zn
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
407 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">vector
</span><span class=
"special"><</span><span class=
"keyword">float
</span><span class=
"special">></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>
408 <span class=
"identifier">cyl_neumann_zero
</span><span class=
"special"><</span><span class=
"keyword">float
</span><span class=
"special">>(
</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>
410 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"cyl_neumann_zero<float>(2.F, 1, "</span><span class=
"special">;
</span>
411 <span class=
"comment">// Print the zeros to the output stream.
</span>
412 <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>
413 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">ostream_iterator
</span><span class=
"special"><</span><span class=
"keyword">float
</span><span class=
"special">>(
</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>
415 <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=
"string">"cyl_neumann_zero(static_cast<float_type>(220)/100, 1) = "</span>
416 <span class=
"special"><<</span> <span class=
"identifier">cyl_neumann_zero
</span><span class=
"special">(
</span><span class=
"keyword">static_cast
</span><span class=
"special"><</span><span class=
"identifier">float_type
</span><span class=
"special">>(
</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"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
417 <span class=
"comment">//
3.6154383428745996706772556069431792744372398748422</span>
420 <a name=
"math_toolkit.bessel.bessel_root.h5"></a>
421 <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
422 messages from 'bad' input
</a>
425 Another example demonstrates calculating zeros of the Bessel functions showing
426 the error messages from 'bad' input is handled by throwing exceptions.
429 To use the functions for finding zeros of the functions we need:
431 <pre class=
"programlisting"><span class=
"preprocessor">#include
</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">special_functions
</span><span class=
"special">/
</span><span class=
"identifier">bessel
</span><span class=
"special">.
</span><span class=
"identifier">hpp
</span><span class=
"special">></span>
432 <span class=
"preprocessor">#include
</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">special_functions
</span><span class=
"special">/
</span><span class=
"identifier">airy
</span><span class=
"special">.
</span><span class=
"identifier">hpp
</span><span class=
"special">></span>
434 <div class=
"tip"><table border=
"0" summary=
"Tip">
436 <td rowspan=
"2" align=
"center" valign=
"top" width=
"25"><img alt=
"[Tip]" src=
"../../../../../../doc/src/images/tip.png"></td>
437 <th align=
"left">Tip
</th>
439 <tr><td align=
"left" valign=
"top"><p>
440 It is always wise to place all code using Boost.Math inside try'n'catch
441 blocks; this will ensure that helpful error messages can be shown when
442 exceptional conditions arise.
446 Examples below show messages from several 'bad' arguments that throw a
<code class=
"computeroutput"><span class=
"identifier">domain_error
</span></code> exception.
448 <pre class=
"programlisting"><span class=
"keyword">try
</span>
449 <span class=
"special">{
</span> <span class=
"comment">// Try a zero order v.
</span>
450 <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>
451 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"boost::math::cyl_bessel_j_zero(0.F, 0) "</span> <span class=
"special"><<</span> <span class=
"identifier">dodgy_root
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
452 <span class=
"comment">// Thrown exception Error in function boost::math::cyl_bessel_j_zero
<double
>(double, int):
</span>
453 <span class=
"comment">// Requested the
0'th zero of J0, but the rank must be
> 0 !
</span>
454 <span class=
"special">}
</span>
455 <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">&</span> <span class=
"identifier">ex
</span><span class=
"special">)
</span>
456 <span class=
"special">{
</span>
457 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"Thrown exception "</span> <span class=
"special"><<</span> <span class=
"identifier">ex
</span><span class=
"special">.
</span><span class=
"identifier">what
</span><span class=
"special">()
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
458 <span class=
"special">}
</span>
460 <div class=
"note"><table border=
"0" summary=
"Note">
462 <td rowspan=
"2" align=
"center" valign=
"top" width=
"25"><img alt=
"[Note]" src=
"../../../../../../doc/src/images/note.png"></td>
463 <th align=
"left">Note
</th>
465 <tr><td align=
"left" valign=
"top"><p>
466 The type shown in the error message is the type
<span class=
"bold"><strong>after
467 promotion
</strong></span>, using
<a class=
"link" href=
"../pol_ref/precision_pol.html" title=
"Precision Policies">precision
468 policy
</a> and
<a class=
"link" href=
"../pol_ref/internal_promotion.html" title=
"Internal Floating-point Promotion Policies">internal
469 promotion policy
</a>, from
<code class=
"computeroutput"><span class=
"keyword">float
</span></code>
470 to
<code class=
"computeroutput"><span class=
"keyword">double
</span></code> in this case.
474 In this example the promotion goes:
476 <div class=
"orderedlist"><ol class=
"orderedlist" type=
"1">
477 <li class=
"listitem">
478 Arguments are
<code class=
"computeroutput"><span class=
"keyword">float
</span></code> and
479 <code class=
"computeroutput"><span class=
"keyword">int
</span></code>.
481 <li class=
"listitem">
482 Treat
<code class=
"computeroutput"><span class=
"keyword">int
</span></code> "as if"
483 it were a
<code class=
"computeroutput"><span class=
"keyword">double
</span></code>, so arguments
484 are
<code class=
"computeroutput"><span class=
"keyword">float
</span></code> and
<code class=
"computeroutput"><span class=
"keyword">double
</span></code>.
486 <li class=
"listitem">
487 Common type is
<code class=
"computeroutput"><span class=
"keyword">double
</span></code> -
488 so that's the precision we want (and the type that will be returned).
490 <li class=
"listitem">
491 Evaluate internally as
<code class=
"computeroutput"><span class=
"keyword">double
</span></code>
492 for full
<code class=
"computeroutput"><span class=
"keyword">float
</span></code> precision.
496 See full code for other examples that promote from
<code class=
"computeroutput"><span class=
"keyword">double
</span></code>
497 to
<code class=
"computeroutput"><span class=
"keyword">long
</span> <span class=
"keyword">double
</span></code>.
500 Other examples of 'bad' inputs like infinity and NaN are below. Some compiler
501 warnings indicate that 'bad' values are detected at compile time.
503 <pre class=
"programlisting"><span class=
"keyword">try
</span>
504 <span class=
"special">{
</span> <span class=
"comment">// order v = inf
</span>
505 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"boost::math::cyl_bessel_j_zero(inf, 1) "</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
506 <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"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">infinity
</span><span class=
"special">();
</span>
507 <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>
508 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"boost::math::cyl_bessel_j_zero(inf, 1) "</span> <span class=
"special"><<</span> <span class=
"identifier">inf_root
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
509 <span class=
"comment">// Throw exception Error in function boost::math::cyl_bessel_j_zero
<long double
>(long double, unsigned):
</span>
510 <span class=
"comment">// Order argument is
1.#INF, but must be finite
>=
0 !
</span>
511 <span class=
"special">}
</span>
512 <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">&</span> <span class=
"identifier">ex
</span><span class=
"special">)
</span>
513 <span class=
"special">{
</span>
514 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"Thrown exception "</span> <span class=
"special"><<</span> <span class=
"identifier">ex
</span><span class=
"special">.
</span><span class=
"identifier">what
</span><span class=
"special">()
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
515 <span class=
"special">}
</span>
517 <span class=
"keyword">try
</span>
518 <span class=
"special">{
</span> <span class=
"comment">// order v = NaN, rank m =
1</span>
519 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"boost::math::cyl_bessel_j_zero(nan, 1) "</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
520 <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"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">quiet_NaN
</span><span class=
"special">();
</span>
521 <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>
522 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"boost::math::cyl_bessel_j_zero(nan, 1) "</span> <span class=
"special"><<</span> <span class=
"identifier">nan_root
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
523 <span class=
"comment">// Throw exception Error in function boost::math::cyl_bessel_j_zero
<long double
>(long double, unsigned):
</span>
524 <span class=
"comment">// Order argument is
1.#QNAN, but must be finite
>=
0 !
</span>
525 <span class=
"special">}
</span>
526 <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">&</span> <span class=
"identifier">ex
</span><span class=
"special">)
</span>
527 <span class=
"special">{
</span>
528 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"Thrown exception "</span> <span class=
"special"><<</span> <span class=
"identifier">ex
</span><span class=
"special">.
</span><span class=
"identifier">what
</span><span class=
"special">()
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
529 <span class=
"special">}
</span>
532 The output from other examples are shown appended to the full code listing.
535 The full code (and output) for these examples is at
<a href=
"../../../../example/bessel_zeros_example_1.cpp" target=
"_top">Bessel
536 zeros
</a>,
<a href=
"../../../../example/bessel_zeros_interator_example.cpp" target=
"_top">Bessel
537 zeros iterator
</a>,
<a href=
"../../../../example/neumann_zeros_example_1.cpp" target=
"_top">Neumann
538 zeros
</a>,
<a href=
"../../../../example/bessel_errors_example.cpp" target=
"_top">Bessel
542 <a name=
"math_toolkit.bessel.bessel_root.h6"></a>
543 <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>
546 Various methods are used to compute initial estimates for
<span class=
"emphasis"><em>j
<sub>ν, m
</sub></em></span>
547 and
<span class=
"emphasis"><em>y
<sub>ν, m
</sub></em></span> ; these are described in detail below.
550 After finding the initial estimate of a given root, its precision is subsequently
551 refined to the desired level using Newton-Raphson iteration from Boost.Math's
552 <a class=
"link" href=
"../roots/roots_deriv.html" title=
"Root Finding With Derivatives: Newton-Raphson, Halley & Schröder">root-finding with derivatives
</a>
553 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>
554 and
<a class=
"link" href=
"bessel_first.html" title=
"Bessel Functions of the First and Second Kinds">cyl_neumann
</a>.
557 Newton iteration requires both
<span class=
"emphasis"><em>J
<sub>ν</sub>(x)
</em></span> or
<span class=
"emphasis"><em>Y
<sub>ν</sub>(x)
</em></span>
558 as well as its derivative. The derivatives of
<span class=
"emphasis"><em>J
<sub>ν</sub>(x)
</em></span> and
559 <span class=
"emphasis"><em>Y
<sub>ν</sub>(x)
</em></span> with respect to
<span class=
"emphasis"><em>x
</em></span> are given
560 by M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions, NBS
561 (
1964). In particular,
564   <span class=
"emphasis"><em>d/
<sub>dx
</sub> <span class=
"emphasis"><em>J
<sub>ν</sub>(x)
</em></span> =
<span class=
"emphasis"><em>J
<sub>ν-
1</sub>(x)
</em></span> -
ν J
<sub>ν</sub>(x)
</em></span>
568   <span class=
"emphasis"><em>d/
<sub>dx
</sub> <span class=
"emphasis"><em>Y
<sub>ν</sub>(x)
</em></span> =
<span class=
"emphasis"><em>Y
<sub>ν-
1</sub>(x)
</em></span> -
ν Y
<sub>ν</sub>(x)
</em></span>
572 Enumeration of the rank of a root (in other words the index of a root) begins
573 with one and counts up, in other words
<span class=
"emphasis"><em>m,=
1,
2,
3,
…</em></span> The
574 value of the first root is always greater than zero.
577 For certain special parameters, cylindrical Bessel functions and cylindrical
578 Neumann functions have a root at the origin. For example,
<span class=
"emphasis"><em>J
<sub>ν</sub>(x)
</em></span>
579 has a root at the origin for every positive order
<span class=
"emphasis"><em>ν > 0</em></span>,
580 and for every negative integer order
<span class=
"emphasis"><em>ν = -n
</em></span> with
<span class=
"emphasis"><em>n
581 ∈ ℕ <sup>+
</sup></em></span> and
<span class=
"emphasis"><em>n
≠ 0</em></span>.
584 In addition,
<span class=
"emphasis"><em>Y
<sub>ν</sub>(x)
</em></span> has a root at the origin for every
585 negative half-integer order
<span class=
"emphasis"><em>ν = -n/
2</em></span>, with
<span class=
"emphasis"><em>n
586 ∈ ℕ <sup>+
</sup></em></span> and and
<span class=
"emphasis"><em>n
≠ 0</em></span>.
589 For these special parameter values, the origin with a value of
<span class=
"emphasis"><em>x
590 =
0</em></span> is provided as the
<span class=
"emphasis"><em>0<sup>th
</sup></em></span> root generated
591 by
<code class=
"computeroutput"><span class=
"identifier">cyl_bessel_j_zero
</span><span class=
"special">()
</span></code>
592 and
<code class=
"computeroutput"><span class=
"identifier">cyl_neumann_zero
</span><span class=
"special">()
</span></code>.
595 When calculating initial estimates for the roots of Bessel functions, a distinction
596 is made between positive order and negative order, and different methods
597 are used for these. In addition, different algorithms are used for the first
598 root
<span class=
"emphasis"><em>m =
1</em></span> and for subsequent roots with higher rank
599 <span class=
"emphasis"><em>m
≥ 2</em></span>. Furthermore, estimates of the roots for Bessel
600 functions with order above and below a cutoff at
<span class=
"emphasis"><em>ν =
2.2</em></span>
601 are calculated with different methods.
604 Calculations of the estimates of
<span class=
"emphasis"><em>j
<sub>ν,
1</sub></em></span> and
<span class=
"emphasis"><em>y
<sub>ν,
1</sub></em></span>
605 with
<span class=
"emphasis"><em>0 ≤ ν < 2.2</em></span> use empirically tabulated values. The
606 coefficients for these have been generated by a computer algebra system.
609 Calculations of the estimates of
<span class=
"emphasis"><em>j
<sub>ν,
1</sub></em></span> and
<span class=
"emphasis"><em>y
<sub>ν,
1</sub></em></span>
610 with
<span class=
"emphasis"><em>ν≥ 2.2</em></span> use Eqs
.9.5.14 and
9.5.15 in M. Abramowitz
611 and I. A. Stegun, Handbook of Mathematical Functions, NBS (
1964).
617   <span class=
"emphasis"><em>j
<sub>ν,
1</sub> ≅ ν +
1.85575 ν<sup>⅓</sup> +
1.033150 ν<sup>-
⅓</sup> -
0.00397 ν<sup>-
1</sup> -
0.0908 ν<sup>-
5/
3</sup> +
0.043 ν<sup>-
7/
3</sup> +
624   <span class=
"emphasis"><em>y
<sub>ν,
1</sub> ≅ ν +
0.93157 ν<sup>⅓</sup> +
0.26035 ν<sup>-
⅓</sup> +
0.01198 ν<sup>-
1</sup> -
0.0060 ν<sup>-
5/
3</sup> -
0.001 ν<sup>-
7/
3</sup> +
628 Calculations of the estimates of
<span class=
"emphasis"><em>j
<sub>ν, m
</sub></em></span> and
<span class=
"emphasis"><em>y
<sub>ν,
629 m
</sub></em></span> with rank
<span class=
"emphasis"><em>m
> 2</em></span> and
<span class=
"emphasis"><em>0 ≤ ν <
630 2.2</em></span> use McMahon's approximation, as described in M. Abramowitz
631 and I. A. Stegan, Section
9.5 and
9.5.12. In particular,
634   <span class=
"emphasis"><em>j
<sub>ν,m
</sub>, y
<sub>ν,m
</sub> ≅ β - (
μ-
1) /
8β</em></span>
637       <span class=
"emphasis"><em>-
4(
μ-
1)(
7μ -
31) /
3(
8β)
<sup>3</sup></em></span>
640       <span class=
"emphasis"><em>-
32(
μ-
1)(
83μ² -
982μ +
3779) /
15(
8β)
<sup>5</sup></em></span>
643       <span class=
"emphasis"><em>-
64(
μ-
1)(
6949μ<sup>3</sup> -
153855μ² +
1585743μ-
6277237) /
105(
8a)
<sup>7</sup></em></span>
646       <span class=
"emphasis"><em>-
…</em></span>     (
5)
649 where
<span class=
"emphasis"><em>μ =
4ν<sup>2</sup></em></span> and
<span class=
"emphasis"><em>β = (m +
½ν -
¼)
π</em></span> for
650 <span class=
"emphasis"><em>j
<sub>ν,m
</sub></em></span> and
<span class=
"emphasis"><em>β = (m +
½ν -
¾)
π for
<span class=
"emphasis"><em>y
<sub>ν,m
</sub></em></span></em></span>.
653 Calculations of the estimates of
<span class=
"emphasis"><em>j
<sub>ν, m
</sub></em></span> and
<span class=
"emphasis"><em>y
<sub>ν,
654 m
</sub></em></span> with
<span class=
"emphasis"><em>ν ≥ 2.2</em></span> use one term in the asymptotic
655 expansion given in Eq
.9.5.22 and top line of Eq
.9.5.26 combined with Eq.
656 9.3.39, all in M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions,
657 NBS (
1964) explicit and easy-to-understand treatment for asymptotic expansion
658 of zeros. The latter two equations are expressed for argument
<span class=
"emphasis"><em>(x)
</em></span>
659 greater than one. (Olver also gives the series form of the equations in
660 <a href=
"http://dlmf.nist.gov/10.21#vi" target=
"_top">§10.21(vi) McMahon's Asymptotic
661 Expansions for Large Zeros
</a> - using slightly different variable names).
667   <span class=
"emphasis"><em>j
<sub>ν, m
</sub> ∼ νx(-
ζ) + f
<sub>1</sub>(-
ζ/
ν)
</em></span>
670 where
<span class=
"emphasis"><em>-
ζ =
ν<sup>-
2/
3</sup>a
<sub>m
</sub></em></span> and
<span class=
"emphasis"><em>a
<sub>m
</sub></em></span> is the absolute
671 value of the
<span class=
"emphasis"><em>m
<sup>th
</sup></em></span> root of
<span class=
"emphasis"><em>Ai(x)
</em></span>
672 on the negative real axis.
675 Here
<span class=
"emphasis"><em>x = x(-
ζ)
</em></span> is the inverse of the function
678   <span class=
"emphasis"><em>⅔(-
ζ)
<sup>3/
2</sup> =
√(x
² -
1) - cos
⁻¹(
1/x)
</em></span>     (
7)
684   <span class=
"emphasis"><em>f
<sub>1</sub>(-
ζ) =
½x(-
ζ) {h(-
ζ)}
² ⋅ b
<sub>0</sub>(-
ζ)
</em></span>
690   <span class=
"emphasis"><em>h(-
ζ) = {
4(-
ζ) / (x
² -
1)}
<sup>4</sup></em></span>
696   <span class=
"emphasis"><em>b
<sub>0</sub>(-
ζ) = -
5/(
48ζ²) +
1/(-
ζ)
<sup>½</sup> ⋅ {
5/(
24(x
<sup>2</sup>-
1)
<sup>3/
2</sup>) +
1/(
8(x
<sup>2</sup>-
1)
<sup>½)
</sup>}
</em></span>
699 When solving for
<span class=
"emphasis"><em>x(-
ζ)
</em></span> in Eq.
7 above, the right-hand-side
700 is expanded to order
2 in a Taylor series for large
<span class=
"emphasis"><em>x
</em></span>.
704   <span class=
"emphasis"><em>⅔(-
ζ)
<sup>3/
2</sup> ≈ x +
1/
2x -
π/
2</em></span>
707 The positive root of the resulting quadratic equation is used to find an
708 initial estimate
<span class=
"emphasis"><em>x(-
ζ)
</em></span>. This initial estimate is subsequently
709 refined with several steps of Newton-Raphson iteration in Eq.
7.
712 Estimates of the roots of cylindrical Bessel functions of negative order
713 on the positive real axis are found using interlacing relations. For example,
714 the
<span class=
"emphasis"><em>m
<sup>th
</sup></em></span> root of the cylindrical Bessel function
<span class=
"emphasis"><em>j
<sub>-
ν,m
</sub></em></span>
715 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>
716 root of the Bessel function of corresponding positive integer order. In other
720   <span class=
"emphasis"><em>j
<sub>n
ν,m
</sub></em></span> < <span class=
"emphasis"><em>j
<sub>-
ν,m
</sub></em></span> < <span class=
"emphasis"><em>j
<sub>n
ν,m+
1</sub></em></span>
723 where
<span class=
"emphasis"><em>m
> 1</em></span> and
<span class=
"emphasis"><em>n
<sub>ν</sub></em></span> represents
724 the integral floor of the absolute value of
<span class=
"emphasis"><em>|-
ν|
</em></span>.
727 Similar bracketing relations are used to find estimates of the roots of Neumann
728 functions of negative order, whereby a discontinuity at every negative half-integer
729 order needs to be handled.
732 Bracketing relations do not hold for the first root of cylindrical Bessel
733 functions and cylindrical Neumann functions with negative order. Therefore,
734 iterative algorithms combined with root-finding via bisection are used to
735 localize
<span class=
"emphasis"><em>j
<sub>-
ν,
1</sub></em></span> and
<span class=
"emphasis"><em>y
<sub>-
ν,
1</sub></em></span>.
738 <a name=
"math_toolkit.bessel.bessel_root.h7"></a>
739 <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>
742 The precision of evaluation of zeros was tested at
50 decimal digits using
743 <code class=
"computeroutput"><span class=
"identifier">cpp_dec_float_50
</span></code> and found
744 identical with spot values computed by
<a href=
"http://www.wolframalpha.com/" target=
"_top">Wolfram
748 <table xmlns:
rev=
"http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width=
"100%"><tr>
749 <td align=
"left"></td>
750 <td align=
"right"><div class=
"copyright-footer">Copyright
© 2006-
2010,
2012-
2014 Nikhar Agrawal,
751 Anton Bikineev, Paul A. Bristow, Marco Guazzone, Christopher Kormanyos, Hubert
752 Holin, Bruno Lalande, John Maddock, Jeremy Murphy, Johan R
åde, Gautam Sewani,
753 Benjamin Sobotta, Thijs van den Berg, Daryle Walker and Xiaogang Zhang
<p>
754 Distributed under the Boost Software License, Version
1.0. (See accompanying
755 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>)
760 <div class=
"spirit-nav">
761 <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>
projects / ceph.git / blob