libstdc++
specfun.h
Go to the documentation of this file.
1 // Mathematical Special Functions for -*- C++ -*-
2 
3 // Copyright (C) 2006-2021 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file bits/specfun.h
26  * This is an internal header file, included by other library headers.
27  * Do not attempt to use it directly. @headername{cmath}
28  */
29 
30 #ifndef _GLIBCXX_BITS_SPECFUN_H
31 #define _GLIBCXX_BITS_SPECFUN_H 1
32 
33 #pragma GCC visibility push(default)
34 
35 #include <bits/c++config.h>
36 
37 #define __STDCPP_MATH_SPEC_FUNCS__ 201003L
38 
39 #define __cpp_lib_math_special_functions 201603L
40 
41 #if __cplusplus <= 201403L && __STDCPP_WANT_MATH_SPEC_FUNCS__ == 0
42 # error include <cmath> and define __STDCPP_WANT_MATH_SPEC_FUNCS__
43 #endif
44 
45 #include <bits/stl_algobase.h>
46 #include <limits>
47 #include <type_traits>
48 
49 #include <tr1/gamma.tcc>
50 #include <tr1/bessel_function.tcc>
51 #include <tr1/beta_function.tcc>
52 #include <tr1/ell_integral.tcc>
53 #include <tr1/exp_integral.tcc>
54 #include <tr1/hypergeometric.tcc>
55 #include <tr1/legendre_function.tcc>
56 #include <tr1/modified_bessel_func.tcc>
57 #include <tr1/poly_hermite.tcc>
58 #include <tr1/poly_laguerre.tcc>
59 #include <tr1/riemann_zeta.tcc>
60 
61 namespace std _GLIBCXX_VISIBILITY(default)
62 {
63 _GLIBCXX_BEGIN_NAMESPACE_VERSION
64 
65  /**
66  * @defgroup mathsf Mathematical Special Functions
67  * @ingroup numerics
68  *
69  * @section mathsf_desc Mathematical Special Functions
70  *
71  * A collection of advanced mathematical special functions,
72  * defined by ISO/IEC IS 29124 and then added to ISO C++ 2017.
73  *
74  *
75  * @subsection mathsf_intro Introduction and History
76  * The first significant library upgrade on the road to C++2011,
77  * <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1836.pdf">
78  * TR1</a>, included a set of 23 mathematical functions that significantly
79  * extended the standard transcendental functions inherited from C and declared
80  * in @<cmath@>.
81  *
82  * Although most components from TR1 were eventually adopted for C++11 these
83  * math functions were left behind out of concern for implementability.
84  * The math functions were published as a separate international standard
85  * <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2010/n3060.pdf">
86  * IS 29124 - Extensions to the C++ Library to Support Mathematical Special
87  * Functions</a>.
88  *
89  * For C++17 these functions were incorporated into the main standard.
90  *
91  * @subsection mathsf_contents Contents
92  * The following functions are implemented in namespace @c std:
93  * - @ref assoc_laguerre "assoc_laguerre - Associated Laguerre functions"
94  * - @ref assoc_legendre "assoc_legendre - Associated Legendre functions"
95  * - @ref beta "beta - Beta functions"
96  * - @ref comp_ellint_1 "comp_ellint_1 - Complete elliptic functions of the first kind"
97  * - @ref comp_ellint_2 "comp_ellint_2 - Complete elliptic functions of the second kind"
98  * - @ref comp_ellint_3 "comp_ellint_3 - Complete elliptic functions of the third kind"
99  * - @ref cyl_bessel_i "cyl_bessel_i - Regular modified cylindrical Bessel functions"
100  * - @ref cyl_bessel_j "cyl_bessel_j - Cylindrical Bessel functions of the first kind"
101  * - @ref cyl_bessel_k "cyl_bessel_k - Irregular modified cylindrical Bessel functions"
102  * - @ref cyl_neumann "cyl_neumann - Cylindrical Neumann functions or Cylindrical Bessel functions of the second kind"
103  * - @ref ellint_1 "ellint_1 - Incomplete elliptic functions of the first kind"
104  * - @ref ellint_2 "ellint_2 - Incomplete elliptic functions of the second kind"
105  * - @ref ellint_3 "ellint_3 - Incomplete elliptic functions of the third kind"
106  * - @ref expint "expint - The exponential integral"
107  * - @ref hermite "hermite - Hermite polynomials"
108  * - @ref laguerre "laguerre - Laguerre functions"
109  * - @ref legendre "legendre - Legendre polynomials"
110  * - @ref riemann_zeta "riemann_zeta - The Riemann zeta function"
111  * - @ref sph_bessel "sph_bessel - Spherical Bessel functions"
112  * - @ref sph_legendre "sph_legendre - Spherical Legendre functions"
113  * - @ref sph_neumann "sph_neumann - Spherical Neumann functions"
114  *
115  * The hypergeometric functions were stricken from the TR29124 and C++17
116  * versions of this math library because of implementation concerns.
117  * However, since they were in the TR1 version and since they are popular
118  * we kept them as an extension in namespace @c __gnu_cxx:
119  * - @ref __gnu_cxx::conf_hyperg "conf_hyperg - Confluent hypergeometric functions"
120  * - @ref __gnu_cxx::hyperg "hyperg - Hypergeometric functions"
121  *
122  * <!-- @subsection mathsf_general General Features -->
123  *
124  * @subsection mathsf_promotion Argument Promotion
125  * The arguments suppled to the non-suffixed functions will be promoted
126  * according to the following rules:
127  * 1. If any argument intended to be floating point is given an integral value
128  * That integral value is promoted to double.
129  * 2. All floating point arguments are promoted up to the largest floating
130  * point precision among them.
131  *
132  * @subsection mathsf_NaN NaN Arguments
133  * If any of the floating point arguments supplied to these functions is
134  * invalid or NaN (std::numeric_limits<Tp>::quiet_NaN),
135  * the value NaN is returned.
136  *
137  * @subsection mathsf_impl Implementation
138  *
139  * We strive to implement the underlying math with type generic algorithms
140  * to the greatest extent possible. In practice, the functions are thin
141  * wrappers that dispatch to function templates. Type dependence is
142  * controlled with std::numeric_limits and functions thereof.
143  *
144  * We don't promote @c float to @c double or @c double to <tt>long double</tt>
145  * reflexively. The goal is for @c float functions to operate more quickly,
146  * at the cost of @c float accuracy and possibly a smaller domain of validity.
147  * Similaryly, <tt>long double</tt> should give you more dynamic range
148  * and slightly more pecision than @c double on many systems.
149  *
150  * @subsection mathsf_testing Testing
151  *
152  * These functions have been tested against equivalent implementations
153  * from the <a href="http://www.gnu.org/software/gsl">
154  * Gnu Scientific Library, GSL</a> and
155  * <a href="http://www.boost.org/doc/libs/1_60_0/libs/math/doc/html/index.html">Boost</a>
156  * and the ratio
157  * @f[
158  * \frac{|f - f_{test}|}{|f_{test}|}
159  * @f]
160  * is generally found to be within 10<sup>-15</sup> for 64-bit double on
161  * linux-x86_64 systems over most of the ranges of validity.
162  *
163  * @todo Provide accuracy comparisons on a per-function basis for a small
164  * number of targets.
165  *
166  * @subsection mathsf_bibliography General Bibliography
167  *
168  * @see Abramowitz and Stegun: Handbook of Mathematical Functions,
169  * with Formulas, Graphs, and Mathematical Tables
170  * Edited by Milton Abramowitz and Irene A. Stegun,
171  * National Bureau of Standards Applied Mathematics Series - 55
172  * Issued June 1964, Tenth Printing, December 1972, with corrections
173  * Electronic versions of A&S abound including both pdf and navigable html.
174  * @see for example http://people.math.sfu.ca/~cbm/aands/
175  *
176  * @see The old A&S has been redone as the
177  * NIST Digital Library of Mathematical Functions: http://dlmf.nist.gov/
178  * This version is far more navigable and includes more recent work.
179  *
180  * @see An Atlas of Functions: with Equator, the Atlas Function Calculator
181  * 2nd Edition, by Oldham, Keith B., Myland, Jan, Spanier, Jerome
182  *
183  * @see Asymptotics and Special Functions by Frank W. J. Olver,
184  * Academic Press, 1974
185  *
186  * @see Numerical Recipes in C, The Art of Scientific Computing,
187  * by William H. Press, Second Ed., Saul A. Teukolsky,
188  * William T. Vetterling, and Brian P. Flannery,
189  * Cambridge University Press, 1992
190  *
191  * @see The Special Functions and Their Approximations: Volumes 1 and 2,
192  * by Yudell L. Luke, Academic Press, 1969
193  *
194  * @{
195  */
196 
197  // Associated Laguerre polynomials
198 
199  /**
200  * Return the associated Laguerre polynomial of order @c n,
201  * degree @c m: @f$ L_n^m(x) @f$ for @c float argument.
202  *
203  * @see assoc_laguerre for more details.
204  */
205  inline float
206  assoc_laguerref(unsigned int __n, unsigned int __m, float __x)
207  { return __detail::__assoc_laguerre<float>(__n, __m, __x); }
208 
209  /**
210  * Return the associated Laguerre polynomial of order @c n,
211  * degree @c m: @f$ L_n^m(x) @f$.
212  *
213  * @see assoc_laguerre for more details.
214  */
215  inline long double
216  assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x)
217  { return __detail::__assoc_laguerre<long double>(__n, __m, __x); }
218 
219  /**
220  * Return the associated Laguerre polynomial of nonnegative order @c n,
221  * nonnegative degree @c m and real argument @c x: @f$ L_n^m(x) @f$.
222  *
223  * The associated Laguerre function of real degree @f$ \alpha @f$,
224  * @f$ L_n^\alpha(x) @f$, is defined by
225  * @f[
226  * L_n^\alpha(x) = \frac{(\alpha + 1)_n}{n!}
227  * {}_1F_1(-n; \alpha + 1; x)
228  * @f]
229  * where @f$ (\alpha)_n @f$ is the Pochhammer symbol and
230  * @f$ {}_1F_1(a; c; x) @f$ is the confluent hypergeometric function.
231  *
232  * The associated Laguerre polynomial is defined for integral
233  * degree @f$ \alpha = m @f$ by:
234  * @f[
235  * L_n^m(x) = (-1)^m \frac{d^m}{dx^m} L_{n + m}(x)
236  * @f]
237  * where the Laguerre polynomial is defined by:
238  * @f[
239  * L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x})
240  * @f]
241  * and @f$ x >= 0 @f$.
242  * @see laguerre for details of the Laguerre function of degree @c n
243  *
244  * @tparam _Tp The floating-point type of the argument @c __x.
245  * @param __n The order of the Laguerre function, <tt>__n >= 0</tt>.
246  * @param __m The degree of the Laguerre function, <tt>__m >= 0</tt>.
247  * @param __x The argument of the Laguerre function, <tt>__x >= 0</tt>.
248  * @throw std::domain_error if <tt>__x < 0</tt>.
249  */
250  template<typename _Tp>
251  inline typename __gnu_cxx::__promote<_Tp>::__type
252  assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
253  {
254  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
255  return __detail::__assoc_laguerre<__type>(__n, __m, __x);
256  }
257 
258  // Associated Legendre functions
259 
260  /**
261  * Return the associated Legendre function of degree @c l and order @c m
262  * for @c float argument.
263  *
264  * @see assoc_legendre for more details.
265  */
266  inline float
267  assoc_legendref(unsigned int __l, unsigned int __m, float __x)
268  { return __detail::__assoc_legendre_p<float>(__l, __m, __x); }
269 
270  /**
271  * Return the associated Legendre function of degree @c l and order @c m.
272  *
273  * @see assoc_legendre for more details.
274  */
275  inline long double
276  assoc_legendrel(unsigned int __l, unsigned int __m, long double __x)
277  { return __detail::__assoc_legendre_p<long double>(__l, __m, __x); }
278 
279 
280  /**
281  * Return the associated Legendre function of degree @c l and order @c m.
282  *
283  * The associated Legendre function is derived from the Legendre function
284  * @f$ P_l(x) @f$ by the Rodrigues formula:
285  * @f[
286  * P_l^m(x) = (1 - x^2)^{m/2}\frac{d^m}{dx^m}P_l(x)
287  * @f]
288  * @see legendre for details of the Legendre function of degree @c l
289  *
290  * @tparam _Tp The floating-point type of the argument @c __x.
291  * @param __l The degree <tt>__l >= 0</tt>.
292  * @param __m The order <tt>__m <= l</tt>.
293  * @param __x The argument, <tt>abs(__x) <= 1</tt>.
294  * @throw std::domain_error if <tt>abs(__x) > 1</tt>.
295  */
296  template<typename _Tp>
297  inline typename __gnu_cxx::__promote<_Tp>::__type
298  assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
299  {
300  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
301  return __detail::__assoc_legendre_p<__type>(__l, __m, __x);
302  }
303 
304  // Beta functions
305 
306  /**
307  * Return the beta function, @f$ B(a,b) @f$, for @c float parameters @c a, @c b.
308  *
309  * @see beta for more details.
310  */
311  inline float
312  betaf(float __a, float __b)
313  { return __detail::__beta<float>(__a, __b); }
314 
315  /**
316  * Return the beta function, @f$B(a,b)@f$, for long double
317  * parameters @c a, @c b.
318  *
319  * @see beta for more details.
320  */
321  inline long double
322  betal(long double __a, long double __b)
323  { return __detail::__beta<long double>(__a, __b); }
324 
325  /**
326  * Return the beta function, @f$B(a,b)@f$, for real parameters @c a, @c b.
327  *
328  * The beta function is defined by
329  * @f[
330  * B(a,b) = \int_0^1 t^{a - 1} (1 - t)^{b - 1} dt
331  * = \frac{\Gamma(a)\Gamma(b)}{\Gamma(a+b)}
332  * @f]
333  * where @f$ a > 0 @f$ and @f$ b > 0 @f$
334  *
335  * @tparam _Tpa The floating-point type of the parameter @c __a.
336  * @tparam _Tpb The floating-point type of the parameter @c __b.
337  * @param __a The first argument of the beta function, <tt> __a > 0 </tt>.
338  * @param __b The second argument of the beta function, <tt> __b > 0 </tt>.
339  * @throw std::domain_error if <tt> __a < 0 </tt> or <tt> __b < 0 </tt>.
340  */
341  template<typename _Tpa, typename _Tpb>
342  inline typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type
343  beta(_Tpa __a, _Tpb __b)
344  {
345  typedef typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type __type;
346  return __detail::__beta<__type>(__a, __b);
347  }
348 
349  // Complete elliptic integrals of the first kind
350 
351  /**
352  * Return the complete elliptic integral of the first kind @f$ E(k) @f$
353  * for @c float modulus @c k.
354  *
355  * @see comp_ellint_1 for details.
356  */
357  inline float
358  comp_ellint_1f(float __k)
359  { return __detail::__comp_ellint_1<float>(__k); }
360 
361  /**
362  * Return the complete elliptic integral of the first kind @f$ E(k) @f$
363  * for long double modulus @c k.
364  *
365  * @see comp_ellint_1 for details.
366  */
367  inline long double
368  comp_ellint_1l(long double __k)
369  { return __detail::__comp_ellint_1<long double>(__k); }
370 
371  /**
372  * Return the complete elliptic integral of the first kind
373  * @f$ K(k) @f$ for real modulus @c k.
374  *
375  * The complete elliptic integral of the first kind is defined as
376  * @f[
377  * K(k) = F(k,\pi/2) = \int_0^{\pi/2}\frac{d\theta}
378  * {\sqrt{1 - k^2 sin^2\theta}}
379  * @f]
380  * where @f$ F(k,\phi) @f$ is the incomplete elliptic integral of the
381  * first kind and the modulus @f$ |k| <= 1 @f$.
382  * @see ellint_1 for details of the incomplete elliptic function
383  * of the first kind.
384  *
385  * @tparam _Tp The floating-point type of the modulus @c __k.
386  * @param __k The modulus, <tt> abs(__k) <= 1 </tt>
387  * @throw std::domain_error if <tt> abs(__k) > 1 </tt>.
388  */
389  template<typename _Tp>
390  inline typename __gnu_cxx::__promote<_Tp>::__type
391  comp_ellint_1(_Tp __k)
392  {
393  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
394  return __detail::__comp_ellint_1<__type>(__k);
395  }
396 
397  // Complete elliptic integrals of the second kind
398 
399  /**
400  * Return the complete elliptic integral of the second kind @f$ E(k) @f$
401  * for @c float modulus @c k.
402  *
403  * @see comp_ellint_2 for details.
404  */
405  inline float
406  comp_ellint_2f(float __k)
407  { return __detail::__comp_ellint_2<float>(__k); }
408 
409  /**
410  * Return the complete elliptic integral of the second kind @f$ E(k) @f$
411  * for long double modulus @c k.
412  *
413  * @see comp_ellint_2 for details.
414  */
415  inline long double
416  comp_ellint_2l(long double __k)
417  { return __detail::__comp_ellint_2<long double>(__k); }
418 
419  /**
420  * Return the complete elliptic integral of the second kind @f$ E(k) @f$
421  * for real modulus @c k.
422  *
423  * The complete elliptic integral of the second kind is defined as
424  * @f[
425  * E(k) = E(k,\pi/2) = \int_0^{\pi/2}\sqrt{1 - k^2 sin^2\theta}
426  * @f]
427  * where @f$ E(k,\phi) @f$ is the incomplete elliptic integral of the
428  * second kind and the modulus @f$ |k| <= 1 @f$.
429  * @see ellint_2 for details of the incomplete elliptic function
430  * of the second kind.
431  *
432  * @tparam _Tp The floating-point type of the modulus @c __k.
433  * @param __k The modulus, @c abs(__k) <= 1
434  * @throw std::domain_error if @c abs(__k) > 1.
435  */
436  template<typename _Tp>
437  inline typename __gnu_cxx::__promote<_Tp>::__type
438  comp_ellint_2(_Tp __k)
439  {
440  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
441  return __detail::__comp_ellint_2<__type>(__k);
442  }
443 
444  // Complete elliptic integrals of the third kind
445 
446  /**
447  * @brief Return the complete elliptic integral of the third kind
448  * @f$ \Pi(k,\nu) @f$ for @c float modulus @c k.
449  *
450  * @see comp_ellint_3 for details.
451  */
452  inline float
453  comp_ellint_3f(float __k, float __nu)
454  { return __detail::__comp_ellint_3<float>(__k, __nu); }
455 
456  /**
457  * @brief Return the complete elliptic integral of the third kind
458  * @f$ \Pi(k,\nu) @f$ for <tt>long double</tt> modulus @c k.
459  *
460  * @see comp_ellint_3 for details.
461  */
462  inline long double
463  comp_ellint_3l(long double __k, long double __nu)
464  { return __detail::__comp_ellint_3<long double>(__k, __nu); }
465 
466  /**
467  * Return the complete elliptic integral of the third kind
468  * @f$ \Pi(k,\nu) = \Pi(k,\nu,\pi/2) @f$ for real modulus @c k.
469  *
470  * The complete elliptic integral of the third kind is defined as
471  * @f[
472  * \Pi(k,\nu) = \Pi(k,\nu,\pi/2) = \int_0^{\pi/2}
473  * \frac{d\theta}
474  * {(1 - \nu \sin^2\theta)\sqrt{1 - k^2 \sin^2\theta}}
475  * @f]
476  * where @f$ \Pi(k,\nu,\phi) @f$ is the incomplete elliptic integral of the
477  * second kind and the modulus @f$ |k| <= 1 @f$.
478  * @see ellint_3 for details of the incomplete elliptic function
479  * of the third kind.
480  *
481  * @tparam _Tp The floating-point type of the modulus @c __k.
482  * @tparam _Tpn The floating-point type of the argument @c __nu.
483  * @param __k The modulus, @c abs(__k) <= 1
484  * @param __nu The argument
485  * @throw std::domain_error if @c abs(__k) > 1.
486  */
487  template<typename _Tp, typename _Tpn>
488  inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type
489  comp_ellint_3(_Tp __k, _Tpn __nu)
490  {
491  typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type;
492  return __detail::__comp_ellint_3<__type>(__k, __nu);
493  }
494 
495  // Regular modified cylindrical Bessel functions
496 
497  /**
498  * Return the regular modified Bessel function @f$ I_{\nu}(x) @f$
499  * for @c float order @f$ \nu @f$ and argument @f$ x >= 0 @f$.
500  *
501  * @see cyl_bessel_i for setails.
502  */
503  inline float
504  cyl_bessel_if(float __nu, float __x)
505  { return __detail::__cyl_bessel_i<float>(__nu, __x); }
506 
507  /**
508  * Return the regular modified Bessel function @f$ I_{\nu}(x) @f$
509  * for <tt>long double</tt> order @f$ \nu @f$ and argument @f$ x >= 0 @f$.
510  *
511  * @see cyl_bessel_i for setails.
512  */
513  inline long double
514  cyl_bessel_il(long double __nu, long double __x)
515  { return __detail::__cyl_bessel_i<long double>(__nu, __x); }
516 
517  /**
518  * Return the regular modified Bessel function @f$ I_{\nu}(x) @f$
519  * for real order @f$ \nu @f$ and argument @f$ x >= 0 @f$.
520  *
521  * The regular modified cylindrical Bessel function is:
522  * @f[
523  * I_{\nu}(x) = i^{-\nu}J_\nu(ix) = \sum_{k=0}^{\infty}
524  * \frac{(x/2)^{\nu + 2k}}{k!\Gamma(\nu+k+1)}
525  * @f]
526  *
527  * @tparam _Tpnu The floating-point type of the order @c __nu.
528  * @tparam _Tp The floating-point type of the argument @c __x.
529  * @param __nu The order
530  * @param __x The argument, <tt> __x >= 0 </tt>
531  * @throw std::domain_error if <tt> __x < 0 </tt>.
532  */
533  template<typename _Tpnu, typename _Tp>
534  inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
535  cyl_bessel_i(_Tpnu __nu, _Tp __x)
536  {
537  typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
538  return __detail::__cyl_bessel_i<__type>(__nu, __x);
539  }
540 
541  // Cylindrical Bessel functions (of the first kind)
542 
543  /**
544  * Return the Bessel function of the first kind @f$ J_{\nu}(x) @f$
545  * for @c float order @f$ \nu @f$ and argument @f$ x >= 0 @f$.
546  *
547  * @see cyl_bessel_j for setails.
548  */
549  inline float
550  cyl_bessel_jf(float __nu, float __x)
551  { return __detail::__cyl_bessel_j<float>(__nu, __x); }
552 
553  /**
554  * Return the Bessel function of the first kind @f$ J_{\nu}(x) @f$
555  * for <tt>long double</tt> order @f$ \nu @f$ and argument @f$ x >= 0 @f$.
556  *
557  * @see cyl_bessel_j for setails.
558  */
559  inline long double
560  cyl_bessel_jl(long double __nu, long double __x)
561  { return __detail::__cyl_bessel_j<long double>(__nu, __x); }
562 
563  /**
564  * Return the Bessel function @f$ J_{\nu}(x) @f$ of real order @f$ \nu @f$
565  * and argument @f$ x >= 0 @f$.
566  *
567  * The cylindrical Bessel function is:
568  * @f[
569  * J_{\nu}(x) = \sum_{k=0}^{\infty}
570  * \frac{(-1)^k (x/2)^{\nu + 2k}}{k!\Gamma(\nu+k+1)}
571  * @f]
572  *
573  * @tparam _Tpnu The floating-point type of the order @c __nu.
574  * @tparam _Tp The floating-point type of the argument @c __x.
575  * @param __nu The order
576  * @param __x The argument, <tt> __x >= 0 </tt>
577  * @throw std::domain_error if <tt> __x < 0 </tt>.
578  */
579  template<typename _Tpnu, typename _Tp>
580  inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
581  cyl_bessel_j(_Tpnu __nu, _Tp __x)
582  {
583  typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
584  return __detail::__cyl_bessel_j<__type>(__nu, __x);
585  }
586 
587  // Irregular modified cylindrical Bessel functions
588 
589  /**
590  * Return the irregular modified Bessel function @f$ K_{\nu}(x) @f$
591  * for @c float order @f$ \nu @f$ and argument @f$ x >= 0 @f$.
592  *
593  * @see cyl_bessel_k for setails.
594  */
595  inline float
596  cyl_bessel_kf(float __nu, float __x)
597  { return __detail::__cyl_bessel_k<float>(__nu, __x); }
598 
599  /**
600  * Return the irregular modified Bessel function @f$ K_{\nu}(x) @f$
601  * for <tt>long double</tt> order @f$ \nu @f$ and argument @f$ x >= 0 @f$.
602  *
603  * @see cyl_bessel_k for setails.
604  */
605  inline long double
606  cyl_bessel_kl(long double __nu, long double __x)
607  { return __detail::__cyl_bessel_k<long double>(__nu, __x); }
608 
609  /**
610  * Return the irregular modified Bessel function @f$ K_{\nu}(x) @f$
611  * of real order @f$ \nu @f$ and argument @f$ x @f$.
612  *
613  * The irregular modified Bessel function is defined by:
614  * @f[
615  * K_{\nu}(x) = \frac{\pi}{2}
616  * \frac{I_{-\nu}(x) - I_{\nu}(x)}{\sin \nu\pi}
617  * @f]
618  * where for integral @f$ \nu = n @f$ a limit is taken:
619  * @f$ lim_{\nu \to n} @f$.
620  * For negative argument we have simply:
621  * @f[
622  * K_{-\nu}(x) = K_{\nu}(x)
623  * @f]
624  *
625  * @tparam _Tpnu The floating-point type of the order @c __nu.
626  * @tparam _Tp The floating-point type of the argument @c __x.
627  * @param __nu The order
628  * @param __x The argument, <tt> __x >= 0 </tt>
629  * @throw std::domain_error if <tt> __x < 0 </tt>.
630  */
631  template<typename _Tpnu, typename _Tp>
632  inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
633  cyl_bessel_k(_Tpnu __nu, _Tp __x)
634  {
635  typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
636  return __detail::__cyl_bessel_k<__type>(__nu, __x);
637  }
638 
639  // Cylindrical Neumann functions
640 
641  /**
642  * Return the Neumann function @f$ N_{\nu}(x) @f$
643  * of @c float order @f$ \nu @f$ and argument @f$ x @f$.
644  *
645  * @see cyl_neumann for setails.
646  */
647  inline float
648  cyl_neumannf(float __nu, float __x)
649  { return __detail::__cyl_neumann_n<float>(__nu, __x); }
650 
651  /**
652  * Return the Neumann function @f$ N_{\nu}(x) @f$
653  * of <tt>long double</tt> order @f$ \nu @f$ and argument @f$ x @f$.
654  *
655  * @see cyl_neumann for setails.
656  */
657  inline long double
658  cyl_neumannl(long double __nu, long double __x)
659  { return __detail::__cyl_neumann_n<long double>(__nu, __x); }
660 
661  /**
662  * Return the Neumann function @f$ N_{\nu}(x) @f$
663  * of real order @f$ \nu @f$ and argument @f$ x >= 0 @f$.
664  *
665  * The Neumann function is defined by:
666  * @f[
667  * N_{\nu}(x) = \frac{J_{\nu}(x) \cos \nu\pi - J_{-\nu}(x)}
668  * {\sin \nu\pi}
669  * @f]
670  * where @f$ x >= 0 @f$ and for integral order @f$ \nu = n @f$
671  * a limit is taken: @f$ lim_{\nu \to n} @f$.
672  *
673  * @tparam _Tpnu The floating-point type of the order @c __nu.
674  * @tparam _Tp The floating-point type of the argument @c __x.
675  * @param __nu The order
676  * @param __x The argument, <tt> __x >= 0 </tt>
677  * @throw std::domain_error if <tt> __x < 0 </tt>.
678  */
679  template<typename _Tpnu, typename _Tp>
680  inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
681  cyl_neumann(_Tpnu __nu, _Tp __x)
682  {
683  typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
684  return __detail::__cyl_neumann_n<__type>(__nu, __x);
685  }
686 
687  // Incomplete elliptic integrals of the first kind
688 
689  /**
690  * Return the incomplete elliptic integral of the first kind @f$ E(k,\phi) @f$
691  * for @c float modulus @f$ k @f$ and angle @f$ \phi @f$.
692  *
693  * @see ellint_1 for details.
694  */
695  inline float
696  ellint_1f(float __k, float __phi)
697  { return __detail::__ellint_1<float>(__k, __phi); }
698 
699  /**
700  * Return the incomplete elliptic integral of the first kind @f$ E(k,\phi) @f$
701  * for <tt>long double</tt> modulus @f$ k @f$ and angle @f$ \phi @f$.
702  *
703  * @see ellint_1 for details.
704  */
705  inline long double
706  ellint_1l(long double __k, long double __phi)
707  { return __detail::__ellint_1<long double>(__k, __phi); }
708 
709  /**
710  * Return the incomplete elliptic integral of the first kind @f$ F(k,\phi) @f$
711  * for @c real modulus @f$ k @f$ and angle @f$ \phi @f$.
712  *
713  * The incomplete elliptic integral of the first kind is defined as
714  * @f[
715  * F(k,\phi) = \int_0^{\phi}\frac{d\theta}
716  * {\sqrt{1 - k^2 sin^2\theta}}
717  * @f]
718  * For @f$ \phi= \pi/2 @f$ this becomes the complete elliptic integral of
719  * the first kind, @f$ K(k) @f$. @see comp_ellint_1.
720  *
721  * @tparam _Tp The floating-point type of the modulus @c __k.
722  * @tparam _Tpp The floating-point type of the angle @c __phi.
723  * @param __k The modulus, <tt> abs(__k) <= 1 </tt>
724  * @param __phi The integral limit argument in radians
725  * @throw std::domain_error if <tt> abs(__k) > 1 </tt>.
726  */
727  template<typename _Tp, typename _Tpp>
728  inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
729  ellint_1(_Tp __k, _Tpp __phi)
730  {
731  typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
732  return __detail::__ellint_1<__type>(__k, __phi);
733  }
734 
735  // Incomplete elliptic integrals of the second kind
736 
737  /**
738  * @brief Return the incomplete elliptic integral of the second kind
739  * @f$ E(k,\phi) @f$ for @c float argument.
740  *
741  * @see ellint_2 for details.
742  */
743  inline float
744  ellint_2f(float __k, float __phi)
745  { return __detail::__ellint_2<float>(__k, __phi); }
746 
747  /**
748  * @brief Return the incomplete elliptic integral of the second kind
749  * @f$ E(k,\phi) @f$.
750  *
751  * @see ellint_2 for details.
752  */
753  inline long double
754  ellint_2l(long double __k, long double __phi)
755  { return __detail::__ellint_2<long double>(__k, __phi); }
756 
757  /**
758  * Return the incomplete elliptic integral of the second kind
759  * @f$ E(k,\phi) @f$.
760  *
761  * The incomplete elliptic integral of the second kind is defined as
762  * @f[
763  * E(k,\phi) = \int_0^{\phi} \sqrt{1 - k^2 sin^2\theta}
764  * @f]
765  * For @f$ \phi= \pi/2 @f$ this becomes the complete elliptic integral of
766  * the second kind, @f$ E(k) @f$. @see comp_ellint_2.
767  *
768  * @tparam _Tp The floating-point type of the modulus @c __k.
769  * @tparam _Tpp The floating-point type of the angle @c __phi.
770  * @param __k The modulus, <tt> abs(__k) <= 1 </tt>
771  * @param __phi The integral limit argument in radians
772  * @return The elliptic function of the second kind.
773  * @throw std::domain_error if <tt> abs(__k) > 1 </tt>.
774  */
775  template<typename _Tp, typename _Tpp>
776  inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
777  ellint_2(_Tp __k, _Tpp __phi)
778  {
779  typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
780  return __detail::__ellint_2<__type>(__k, __phi);
781  }
782 
783  // Incomplete elliptic integrals of the third kind
784 
785  /**
786  * @brief Return the incomplete elliptic integral of the third kind
787  * @f$ \Pi(k,\nu,\phi) @f$ for @c float argument.
788  *
789  * @see ellint_3 for details.
790  */
791  inline float
792  ellint_3f(float __k, float __nu, float __phi)
793  { return __detail::__ellint_3<float>(__k, __nu, __phi); }
794 
795  /**
796  * @brief Return the incomplete elliptic integral of the third kind
797  * @f$ \Pi(k,\nu,\phi) @f$.
798  *
799  * @see ellint_3 for details.
800  */
801  inline long double
802  ellint_3l(long double __k, long double __nu, long double __phi)
803  { return __detail::__ellint_3<long double>(__k, __nu, __phi); }
804 
805  /**
806  * @brief Return the incomplete elliptic integral of the third kind
807  * @f$ \Pi(k,\nu,\phi) @f$.
808  *
809  * The incomplete elliptic integral of the third kind is defined by:
810  * @f[
811  * \Pi(k,\nu,\phi) = \int_0^{\phi}
812  * \frac{d\theta}
813  * {(1 - \nu \sin^2\theta)
814  * \sqrt{1 - k^2 \sin^2\theta}}
815  * @f]
816  * For @f$ \phi= \pi/2 @f$ this becomes the complete elliptic integral of
817  * the third kind, @f$ \Pi(k,\nu) @f$. @see comp_ellint_3.
818  *
819  * @tparam _Tp The floating-point type of the modulus @c __k.
820  * @tparam _Tpn The floating-point type of the argument @c __nu.
821  * @tparam _Tpp The floating-point type of the angle @c __phi.
822  * @param __k The modulus, <tt> abs(__k) <= 1 </tt>
823  * @param __nu The second argument
824  * @param __phi The integral limit argument in radians
825  * @return The elliptic function of the third kind.
826  * @throw std::domain_error if <tt> abs(__k) > 1 </tt>.
827  */
828  template<typename _Tp, typename _Tpn, typename _Tpp>
829  inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type
830  ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
831  {
832  typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type;
833  return __detail::__ellint_3<__type>(__k, __nu, __phi);
834  }
835 
836  // Exponential integrals
837 
838  /**
839  * Return the exponential integral @f$ Ei(x) @f$ for @c float argument @c x.
840  *
841  * @see expint for details.
842  */
843  inline float
844  expintf(float __x)
845  { return __detail::__expint<float>(__x); }
846 
847  /**
848  * Return the exponential integral @f$ Ei(x) @f$
849  * for <tt>long double</tt> argument @c x.
850  *
851  * @see expint for details.
852  */
853  inline long double
854  expintl(long double __x)
855  { return __detail::__expint<long double>(__x); }
856 
857  /**
858  * Return the exponential integral @f$ Ei(x) @f$ for @c real argument @c x.
859  *
860  * The exponential integral is given by
861  * \f[
862  * Ei(x) = -\int_{-x}^\infty \frac{e^t}{t} dt
863  * \f]
864  *
865  * @tparam _Tp The floating-point type of the argument @c __x.
866  * @param __x The argument of the exponential integral function.
867  */
868  template<typename _Tp>
869  inline typename __gnu_cxx::__promote<_Tp>::__type
870  expint(_Tp __x)
871  {
872  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
873  return __detail::__expint<__type>(__x);
874  }
875 
876  // Hermite polynomials
877 
878  /**
879  * Return the Hermite polynomial @f$ H_n(x) @f$ of nonnegative order n
880  * and float argument @c x.
881  *
882  * @see hermite for details.
883  */
884  inline float
885  hermitef(unsigned int __n, float __x)
886  { return __detail::__poly_hermite<float>(__n, __x); }
887 
888  /**
889  * Return the Hermite polynomial @f$ H_n(x) @f$ of nonnegative order n
890  * and <tt>long double</tt> argument @c x.
891  *
892  * @see hermite for details.
893  */
894  inline long double
895  hermitel(unsigned int __n, long double __x)
896  { return __detail::__poly_hermite<long double>(__n, __x); }
897 
898  /**
899  * Return the Hermite polynomial @f$ H_n(x) @f$ of order n
900  * and @c real argument @c x.
901  *
902  * The Hermite polynomial is defined by:
903  * @f[
904  * H_n(x) = (-1)^n e^{x^2} \frac{d^n}{dx^n} e^{-x^2}
905  * @f]
906  *
907  * The Hermite polynomial obeys a reflection formula:
908  * @f[
909  * H_n(-x) = (-1)^n H_n(x)
910  * @f]
911  *
912  * @tparam _Tp The floating-point type of the argument @c __x.
913  * @param __n The order
914  * @param __x The argument
915  */
916  template<typename _Tp>
917  inline typename __gnu_cxx::__promote<_Tp>::__type
918  hermite(unsigned int __n, _Tp __x)
919  {
920  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
921  return __detail::__poly_hermite<__type>(__n, __x);
922  }
923 
924  // Laguerre polynomials
925 
926  /**
927  * Returns the Laguerre polynomial @f$ L_n(x) @f$ of nonnegative degree @c n
928  * and @c float argument @f$ x >= 0 @f$.
929  *
930  * @see laguerre for more details.
931  */
932  inline float
933  laguerref(unsigned int __n, float __x)
934  { return __detail::__laguerre<float>(__n, __x); }
935 
936  /**
937  * Returns the Laguerre polynomial @f$ L_n(x) @f$ of nonnegative degree @c n
938  * and <tt>long double</tt> argument @f$ x >= 0 @f$.
939  *
940  * @see laguerre for more details.
941  */
942  inline long double
943  laguerrel(unsigned int __n, long double __x)
944  { return __detail::__laguerre<long double>(__n, __x); }
945 
946  /**
947  * Returns the Laguerre polynomial @f$ L_n(x) @f$
948  * of nonnegative degree @c n and real argument @f$ x >= 0 @f$.
949  *
950  * The Laguerre polynomial is defined by:
951  * @f[
952  * L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x})
953  * @f]
954  *
955  * @tparam _Tp The floating-point type of the argument @c __x.
956  * @param __n The nonnegative order
957  * @param __x The argument <tt> __x >= 0 </tt>
958  * @throw std::domain_error if <tt> __x < 0 </tt>.
959  */
960  template<typename _Tp>
961  inline typename __gnu_cxx::__promote<_Tp>::__type
962  laguerre(unsigned int __n, _Tp __x)
963  {
964  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
965  return __detail::__laguerre<__type>(__n, __x);
966  }
967 
968  // Legendre polynomials
969 
970  /**
971  * Return the Legendre polynomial @f$ P_l(x) @f$ of nonnegative
972  * degree @f$ l @f$ and @c float argument @f$ |x| <= 0 @f$.
973  *
974  * @see legendre for more details.
975  */
976  inline float
977  legendref(unsigned int __l, float __x)
978  { return __detail::__poly_legendre_p<float>(__l, __x); }
979 
980  /**
981  * Return the Legendre polynomial @f$ P_l(x) @f$ of nonnegative
982  * degree @f$ l @f$ and <tt>long double</tt> argument @f$ |x| <= 0 @f$.
983  *
984  * @see legendre for more details.
985  */
986  inline long double
987  legendrel(unsigned int __l, long double __x)
988  { return __detail::__poly_legendre_p<long double>(__l, __x); }
989 
990  /**
991  * Return the Legendre polynomial @f$ P_l(x) @f$ of nonnegative
992  * degree @f$ l @f$ and real argument @f$ |x| <= 0 @f$.
993  *
994  * The Legendre function of order @f$ l @f$ and argument @f$ x @f$,
995  * @f$ P_l(x) @f$, is defined by:
996  * @f[
997  * P_l(x) = \frac{1}{2^l l!}\frac{d^l}{dx^l}(x^2 - 1)^{l}
998  * @f]
999  *
1000  * @tparam _Tp The floating-point type of the argument @c __x.
1001  * @param __l The degree @f$ l >= 0 @f$
1002  * @param __x The argument @c abs(__x) <= 1
1003  * @throw std::domain_error if @c abs(__x) > 1
1004  */
1005  template<typename _Tp>
1006  inline typename __gnu_cxx::__promote<_Tp>::__type
1007  legendre(unsigned int __l, _Tp __x)
1008  {
1009  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1010  return __detail::__poly_legendre_p<__type>(__l, __x);
1011  }
1012 
1013  // Riemann zeta functions
1014 
1015  /**
1016  * Return the Riemann zeta function @f$ \zeta(s) @f$
1017  * for @c float argument @f$ s @f$.
1018  *
1019  * @see riemann_zeta for more details.
1020  */
1021  inline float
1022  riemann_zetaf(float __s)
1023  { return __detail::__riemann_zeta<float>(__s); }
1024 
1025  /**
1026  * Return the Riemann zeta function @f$ \zeta(s) @f$
1027  * for <tt>long double</tt> argument @f$ s @f$.
1028  *
1029  * @see riemann_zeta for more details.
1030  */
1031  inline long double
1032  riemann_zetal(long double __s)
1033  { return __detail::__riemann_zeta<long double>(__s); }
1034 
1035  /**
1036  * Return the Riemann zeta function @f$ \zeta(s) @f$
1037  * for real argument @f$ s @f$.
1038  *
1039  * The Riemann zeta function is defined by:
1040  * @f[
1041  * \zeta(s) = \sum_{k=1}^{\infty} k^{-s} \hbox{ for } s > 1
1042  * @f]
1043  * and
1044  * @f[
1045  * \zeta(s) = \frac{1}{1-2^{1-s}}\sum_{k=1}^{\infty}(-1)^{k-1}k^{-s}
1046  * \hbox{ for } 0 <= s <= 1
1047  * @f]
1048  * For s < 1 use the reflection formula:
1049  * @f[
1050  * \zeta(s) = 2^s \pi^{s-1} \sin(\frac{\pi s}{2}) \Gamma(1-s) \zeta(1-s)
1051  * @f]
1052  *
1053  * @tparam _Tp The floating-point type of the argument @c __s.
1054  * @param __s The argument <tt> s != 1 </tt>
1055  */
1056  template<typename _Tp>
1057  inline typename __gnu_cxx::__promote<_Tp>::__type
1058  riemann_zeta(_Tp __s)
1059  {
1060  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1061  return __detail::__riemann_zeta<__type>(__s);
1062  }
1063 
1064  // Spherical Bessel functions
1065 
1066  /**
1067  * Return the spherical Bessel function @f$ j_n(x) @f$ of nonnegative order n
1068  * and @c float argument @f$ x >= 0 @f$.
1069  *
1070  * @see sph_bessel for more details.
1071  */
1072  inline float
1073  sph_besself(unsigned int __n, float __x)
1074  { return __detail::__sph_bessel<float>(__n, __x); }
1075 
1076  /**
1077  * Return the spherical Bessel function @f$ j_n(x) @f$ of nonnegative order n
1078  * and <tt>long double</tt> argument @f$ x >= 0 @f$.
1079  *
1080  * @see sph_bessel for more details.
1081  */
1082  inline long double
1083  sph_bessell(unsigned int __n, long double __x)
1084  { return __detail::__sph_bessel<long double>(__n, __x); }
1085 
1086  /**
1087  * Return the spherical Bessel function @f$ j_n(x) @f$ of nonnegative order n
1088  * and real argument @f$ x >= 0 @f$.
1089  *
1090  * The spherical Bessel function is defined by:
1091  * @f[
1092  * j_n(x) = \left(\frac{\pi}{2x} \right) ^{1/2} J_{n+1/2}(x)
1093  * @f]
1094  *
1095  * @tparam _Tp The floating-point type of the argument @c __x.
1096  * @param __n The integral order <tt> n >= 0 </tt>
1097  * @param __x The real argument <tt> x >= 0 </tt>
1098  * @throw std::domain_error if <tt> __x < 0 </tt>.
1099  */
1100  template<typename _Tp>
1101  inline typename __gnu_cxx::__promote<_Tp>::__type
1102  sph_bessel(unsigned int __n, _Tp __x)
1103  {
1104  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1105  return __detail::__sph_bessel<__type>(__n, __x);
1106  }
1107 
1108  // Spherical associated Legendre functions
1109 
1110  /**
1111  * Return the spherical Legendre function of nonnegative integral
1112  * degree @c l and order @c m and float angle @f$ \theta @f$ in radians.
1113  *
1114  * @see sph_legendre for details.
1115  */
1116  inline float
1117  sph_legendref(unsigned int __l, unsigned int __m, float __theta)
1118  { return __detail::__sph_legendre<float>(__l, __m, __theta); }
1119 
1120  /**
1121  * Return the spherical Legendre function of nonnegative integral
1122  * degree @c l and order @c m and <tt>long double</tt> angle @f$ \theta @f$
1123  * in radians.
1124  *
1125  * @see sph_legendre for details.
1126  */
1127  inline long double
1128  sph_legendrel(unsigned int __l, unsigned int __m, long double __theta)
1129  { return __detail::__sph_legendre<long double>(__l, __m, __theta); }
1130 
1131  /**
1132  * Return the spherical Legendre function of nonnegative integral
1133  * degree @c l and order @c m and real angle @f$ \theta @f$ in radians.
1134  *
1135  * The spherical Legendre function is defined by
1136  * @f[
1137  * Y_l^m(\theta,\phi) = (-1)^m[\frac{(2l+1)}{4\pi}
1138  * \frac{(l-m)!}{(l+m)!}]
1139  * P_l^m(\cos\theta) \exp^{im\phi}
1140  * @f]
1141  *
1142  * @tparam _Tp The floating-point type of the angle @c __theta.
1143  * @param __l The order <tt> __l >= 0 </tt>
1144  * @param __m The degree <tt> __m >= 0 </tt> and <tt> __m <= __l </tt>
1145  * @param __theta The radian polar angle argument
1146  */
1147  template<typename _Tp>
1148  inline typename __gnu_cxx::__promote<_Tp>::__type
1149  sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
1150  {
1151  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1152  return __detail::__sph_legendre<__type>(__l, __m, __theta);
1153  }
1154 
1155  // Spherical Neumann functions
1156 
1157  /**
1158  * Return the spherical Neumann function of integral order @f$ n >= 0 @f$
1159  * and @c float argument @f$ x >= 0 @f$.
1160  *
1161  * @see sph_neumann for details.
1162  */
1163  inline float
1164  sph_neumannf(unsigned int __n, float __x)
1165  { return __detail::__sph_neumann<float>(__n, __x); }
1166 
1167  /**
1168  * Return the spherical Neumann function of integral order @f$ n >= 0 @f$
1169  * and <tt>long double</tt> @f$ x >= 0 @f$.
1170  *
1171  * @see sph_neumann for details.
1172  */
1173  inline long double
1174  sph_neumannl(unsigned int __n, long double __x)
1175  { return __detail::__sph_neumann<long double>(__n, __x); }
1176 
1177  /**
1178  * Return the spherical Neumann function of integral order @f$ n >= 0 @f$
1179  * and real argument @f$ x >= 0 @f$.
1180  *
1181  * The spherical Neumann function is defined by
1182  * @f[
1183  * n_n(x) = \left(\frac{\pi}{2x} \right) ^{1/2} N_{n+1/2}(x)
1184  * @f]
1185  *
1186  * @tparam _Tp The floating-point type of the argument @c __x.
1187  * @param __n The integral order <tt> n >= 0 </tt>
1188  * @param __x The real argument <tt> __x >= 0 </tt>
1189  * @throw std::domain_error if <tt> __x < 0 </tt>.
1190  */
1191  template<typename _Tp>
1192  inline typename __gnu_cxx::__promote<_Tp>::__type
1193  sph_neumann(unsigned int __n, _Tp __x)
1194  {
1195  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1196  return __detail::__sph_neumann<__type>(__n, __x);
1197  }
1198 
1199  /// @} group mathsf
1200 
1201 _GLIBCXX_END_NAMESPACE_VERSION
1202 } // namespace std
1203 
1204 #ifndef __STRICT_ANSI__
1205 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
1206 {
1207 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1208 
1209  /** @addtogroup mathsf
1210  * @{
1211  */
1212 
1213  // Airy functions
1214 
1215  /**
1216  * Return the Airy function @f$ Ai(x) @f$ of @c float argument x.
1217  */
1218  inline float
1219  airy_aif(float __x)
1220  {
1221  float __Ai, __Bi, __Aip, __Bip;
1222  std::__detail::__airy<float>(__x, __Ai, __Bi, __Aip, __Bip);
1223  return __Ai;
1224  }
1225 
1226  /**
1227  * Return the Airy function @f$ Ai(x) @f$ of <tt>long double</tt> argument x.
1228  */
1229  inline long double
1230  airy_ail(long double __x)
1231  {
1232  long double __Ai, __Bi, __Aip, __Bip;
1233  std::__detail::__airy<long double>(__x, __Ai, __Bi, __Aip, __Bip);
1234  return __Ai;
1235  }
1236 
1237  /**
1238  * Return the Airy function @f$ Ai(x) @f$ of real argument x.
1239  */
1240  template<typename _Tp>
1241  inline typename __gnu_cxx::__promote<_Tp>::__type
1242  airy_ai(_Tp __x)
1243  {
1244  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1245  __type __Ai, __Bi, __Aip, __Bip;
1246  std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip);
1247  return __Ai;
1248  }
1249 
1250  /**
1251  * Return the Airy function @f$ Bi(x) @f$ of @c float argument x.
1252  */
1253  inline float
1254  airy_bif(float __x)
1255  {
1256  float __Ai, __Bi, __Aip, __Bip;
1257  std::__detail::__airy<float>(__x, __Ai, __Bi, __Aip, __Bip);
1258  return __Bi;
1259  }
1260 
1261  /**
1262  * Return the Airy function @f$ Bi(x) @f$ of <tt>long double</tt> argument x.
1263  */
1264  inline long double
1265  airy_bil(long double __x)
1266  {
1267  long double __Ai, __Bi, __Aip, __Bip;
1268  std::__detail::__airy<long double>(__x, __Ai, __Bi, __Aip, __Bip);
1269  return __Bi;
1270  }
1271 
1272  /**
1273  * Return the Airy function @f$ Bi(x) @f$ of real argument x.
1274  */
1275  template<typename _Tp>
1276  inline typename __gnu_cxx::__promote<_Tp>::__type
1277  airy_bi(_Tp __x)
1278  {
1279  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1280  __type __Ai, __Bi, __Aip, __Bip;
1281  std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip);
1282  return __Bi;
1283  }
1284 
1285  // Confluent hypergeometric functions
1286 
1287  /**
1288  * Return the confluent hypergeometric function @f$ {}_1F_1(a;c;x) @f$
1289  * of @c float numeratorial parameter @c a, denominatorial parameter @c c,
1290  * and argument @c x.
1291  *
1292  * @see conf_hyperg for details.
1293  */
1294  inline float
1295  conf_hypergf(float __a, float __c, float __x)
1296  { return std::__detail::__conf_hyperg<float>(__a, __c, __x); }
1297 
1298  /**
1299  * Return the confluent hypergeometric function @f$ {}_1F_1(a;c;x) @f$
1300  * of <tt>long double</tt> numeratorial parameter @c a,
1301  * denominatorial parameter @c c, and argument @c x.
1302  *
1303  * @see conf_hyperg for details.
1304  */
1305  inline long double
1306  conf_hypergl(long double __a, long double __c, long double __x)
1307  { return std::__detail::__conf_hyperg<long double>(__a, __c, __x); }
1308 
1309  /**
1310  * Return the confluent hypergeometric function @f$ {}_1F_1(a;c;x) @f$
1311  * of real numeratorial parameter @c a, denominatorial parameter @c c,
1312  * and argument @c x.
1313  *
1314  * The confluent hypergeometric function is defined by
1315  * @f[
1316  * {}_1F_1(a;c;x) = \sum_{n=0}^{\infty} \frac{(a)_n x^n}{(c)_n n!}
1317  * @f]
1318  * where the Pochhammer symbol is @f$ (x)_k = (x)(x+1)...(x+k-1) @f$,
1319  * @f$ (x)_0 = 1 @f$
1320  *
1321  * @param __a The numeratorial parameter
1322  * @param __c The denominatorial parameter
1323  * @param __x The argument
1324  */
1325  template<typename _Tpa, typename _Tpc, typename _Tp>
1326  inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type
1327  conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x)
1328  {
1329  typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type;
1330  return std::__detail::__conf_hyperg<__type>(__a, __c, __x);
1331  }
1332 
1333  // Hypergeometric functions
1334 
1335  /**
1336  * Return the hypergeometric function @f$ {}_2F_1(a,b;c;x) @f$
1337  * of @ float numeratorial parameters @c a and @c b,
1338  * denominatorial parameter @c c, and argument @c x.
1339  *
1340  * @see hyperg for details.
1341  */
1342  inline float
1343  hypergf(float __a, float __b, float __c, float __x)
1344  { return std::__detail::__hyperg<float>(__a, __b, __c, __x); }
1345 
1346  /**
1347  * Return the hypergeometric function @f$ {}_2F_1(a,b;c;x) @f$
1348  * of <tt>long double</tt> numeratorial parameters @c a and @c b,
1349  * denominatorial parameter @c c, and argument @c x.
1350  *
1351  * @see hyperg for details.
1352  */
1353  inline long double
1354  hypergl(long double __a, long double __b, long double __c, long double __x)
1355  { return std::__detail::__hyperg<long double>(__a, __b, __c, __x); }
1356 
1357  /**
1358  * Return the hypergeometric function @f$ {}_2F_1(a,b;c;x) @f$
1359  * of real numeratorial parameters @c a and @c b,
1360  * denominatorial parameter @c c, and argument @c x.
1361  *
1362  * The hypergeometric function is defined by
1363  * @f[
1364  * {}_2F_1(a;c;x) = \sum_{n=0}^{\infty} \frac{(a)_n (b)_n x^n}{(c)_n n!}
1365  * @f]
1366  * where the Pochhammer symbol is @f$ (x)_k = (x)(x+1)...(x+k-1) @f$,
1367  * @f$ (x)_0 = 1 @f$
1368  *
1369  * @param __a The first numeratorial parameter
1370  * @param __b The second numeratorial parameter
1371  * @param __c The denominatorial parameter
1372  * @param __x The argument
1373  */
1374  template<typename _Tpa, typename _Tpb, typename _Tpc, typename _Tp>
1375  inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type
1376  hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x)
1377  {
1378  typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>
1379  ::__type __type;
1380  return std::__detail::__hyperg<__type>(__a, __b, __c, __x);
1381  }
1382 
1383  /// @}
1384 _GLIBCXX_END_NAMESPACE_VERSION
1385 } // namespace __gnu_cxx
1386 #endif // __STRICT_ANSI__
1387 
1388 #pragma GCC visibility pop
1389 
1390 #endif // _GLIBCXX_BITS_SPECFUN_H
long double conf_hypergl(long double __a, long double __c, long double __x)
Definition: specfun.h:1306
long double sph_bessell(unsigned int __n, long double __x)
Definition: specfun.h:1083
float betaf(float __a, float __b)
Definition: specfun.h:312
long double expintl(long double __x)
Definition: specfun.h:854
float cyl_bessel_jf(float __nu, float __x)
Definition: specfun.h:550
float ellint_3f(float __k, float __nu, float __phi)
Return the incomplete elliptic integral of the third kind for float argument.
Definition: specfun.h:792
long double legendrel(unsigned int __l, long double __x)
Definition: specfun.h:987
__gnu_cxx::__promote_2< _Tpnu, _Tp >::__type cyl_bessel_i(_Tpnu __nu, _Tp __x)
Definition: specfun.h:535
long double comp_ellint_3l(long double __k, long double __nu)
Return the complete elliptic integral of the third kind for long double modulus k.
Definition: specfun.h:463
__gnu_cxx::__promote< _Tp >::__type sph_neumann(unsigned int __n, _Tp __x)
Definition: specfun.h:1193
long double riemann_zetal(long double __s)
Definition: specfun.h:1032
float cyl_bessel_kf(float __nu, float __x)
Definition: specfun.h:596
__gnu_cxx::__promote_3< _Tp, _Tpn, _Tpp >::__type ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
Return the incomplete elliptic integral of the third kind .
Definition: specfun.h:830
float comp_ellint_2f(float __k)
Definition: specfun.h:406
long double hermitel(unsigned int __n, long double __x)
Definition: specfun.h:895
__gnu_cxx::__promote< _Tp >::__type comp_ellint_2(_Tp __k)
Definition: specfun.h:438
float airy_bif(float __x)
Definition: specfun.h:1254
__gnu_cxx::__promote_3< _Tpa, _Tpc, _Tp >::__type conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x)
Definition: specfun.h:1327
long double sph_legendrel(unsigned int __l, unsigned int __m, long double __theta)
Definition: specfun.h:1128
float ellint_1f(float __k, float __phi)
Definition: specfun.h:696
__gnu_cxx::__promote< _Tp >::__type assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
Definition: specfun.h:298
__gnu_cxx::__promote< _Tp >::__type assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
Definition: specfun.h:252
float assoc_legendref(unsigned int __l, unsigned int __m, float __x)
Definition: specfun.h:267
long double sph_neumannl(unsigned int __n, long double __x)
Definition: specfun.h:1174
__gnu_cxx::__promote< _Tp >::__type airy_ai(_Tp __x)
Definition: specfun.h:1242
__gnu_cxx::__promote< _Tp >::__type sph_bessel(unsigned int __n, _Tp __x)
Definition: specfun.h:1102
long double comp_ellint_2l(long double __k)
Definition: specfun.h:416
__gnu_cxx::__promote_2< _Tpnu, _Tp >::__type cyl_bessel_j(_Tpnu __nu, _Tp __x)
Definition: specfun.h:581
float sph_besself(unsigned int __n, float __x)
Definition: specfun.h:1073
long double assoc_legendrel(unsigned int __l, unsigned int __m, long double __x)
Definition: specfun.h:276
__gnu_cxx::__promote< _Tp >::__type sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
Definition: specfun.h:1149
float expintf(float __x)
Definition: specfun.h:844
long double airy_bil(long double __x)
Definition: specfun.h:1265
float ellint_2f(float __k, float __phi)
Return the incomplete elliptic integral of the second kind for float argument.
Definition: specfun.h:744
__gnu_cxx::__promote_2< _Tpnu, _Tp >::__type cyl_neumann(_Tpnu __nu, _Tp __x)
Definition: specfun.h:681
long double ellint_2l(long double __k, long double __phi)
Return the incomplete elliptic integral of the second kind .
Definition: specfun.h:754
float cyl_neumannf(float __nu, float __x)
Definition: specfun.h:648
__gnu_cxx::__promote< _Tp >::__type riemann_zeta(_Tp __s)
Definition: specfun.h:1058
__gnu_cxx::__promote_2< _Tpa, _Tpb >::__type beta(_Tpa __a, _Tpb __b)
Definition: specfun.h:343
long double comp_ellint_1l(long double __k)
Definition: specfun.h:368
float comp_ellint_3f(float __k, float __nu)
Return the complete elliptic integral of the third kind for float modulus k.
Definition: specfun.h:453
__gnu_cxx::__promote_2< _Tpnu, _Tp >::__type cyl_bessel_k(_Tpnu __nu, _Tp __x)
Definition: specfun.h:633
float sph_neumannf(unsigned int __n, float __x)
Definition: specfun.h:1164
long double ellint_1l(long double __k, long double __phi)
Definition: specfun.h:706
float comp_ellint_1f(float __k)
Definition: specfun.h:358
long double airy_ail(long double __x)
Definition: specfun.h:1230
__gnu_cxx::__promote< _Tp >::__type expint(_Tp __x)
Definition: specfun.h:870
long double betal(long double __a, long double __b)
Definition: specfun.h:322
float hermitef(unsigned int __n, float __x)
Definition: specfun.h:885
__gnu_cxx::__promote< _Tp >::__type hermite(unsigned int __n, _Tp __x)
Definition: specfun.h:918
long double hypergl(long double __a, long double __b, long double __c, long double __x)
Definition: specfun.h:1354
long double ellint_3l(long double __k, long double __nu, long double __phi)
Return the incomplete elliptic integral of the third kind .
Definition: specfun.h:802
float sph_legendref(unsigned int __l, unsigned int __m, float __theta)
Definition: specfun.h:1117
float cyl_bessel_if(float __nu, float __x)
Definition: specfun.h:504
long double laguerrel(unsigned int __n, long double __x)
Definition: specfun.h:943
long double cyl_bessel_il(long double __nu, long double __x)
Definition: specfun.h:514
float conf_hypergf(float __a, float __c, float __x)
Definition: specfun.h:1295
long double cyl_bessel_kl(long double __nu, long double __x)
Definition: specfun.h:606
float hypergf(float __a, float __b, float __c, float __x)
Definition: specfun.h:1343
__gnu_cxx::__promote< _Tp >::__type comp_ellint_1(_Tp __k)
Definition: specfun.h:391
long double assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x)
Definition: specfun.h:216
__gnu_cxx::__promote< _Tp >::__type laguerre(unsigned int __n, _Tp __x)
Definition: specfun.h:962
__gnu_cxx::__promote< _Tp >::__type airy_bi(_Tp __x)
Definition: specfun.h:1277
__gnu_cxx::__promote_2< _Tp, _Tpp >::__type ellint_2(_Tp __k, _Tpp __phi)
Definition: specfun.h:777
__gnu_cxx::__promote_2< _Tp, _Tpn >::__type comp_ellint_3(_Tp __k, _Tpn __nu)
Definition: specfun.h:489
float laguerref(unsigned int __n, float __x)
Definition: specfun.h:933
long double cyl_bessel_jl(long double __nu, long double __x)
Definition: specfun.h:560
__gnu_cxx::__promote_2< _Tp, _Tpp >::__type ellint_1(_Tp __k, _Tpp __phi)
Definition: specfun.h:729
float legendref(unsigned int __l, float __x)
Definition: specfun.h:977
float airy_aif(float __x)
Definition: specfun.h:1219
__gnu_cxx::__promote_4< _Tpa, _Tpb, _Tpc, _Tp >::__type hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x)
Definition: specfun.h:1376
__gnu_cxx::__promote< _Tp >::__type legendre(unsigned int __l, _Tp __x)
Definition: specfun.h:1007
float assoc_laguerref(unsigned int __n, unsigned int __m, float __x)
Definition: specfun.h:206
long double cyl_neumannl(long double __nu, long double __x)
Definition: specfun.h:658
float riemann_zetaf(float __s)
Definition: specfun.h:1022
ISO C++ entities toplevel namespace is std.
GNU extensions for public use.