]> git.proxmox.com Git - ceph.git/blame - ceph/src/boost/boost/math/special_functions/math_fwd.hpp
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
import new upstream nautilus stable release 14.2.8
[ceph.git] / ceph / src / boost / boost / math / special_functions / math_fwd.hpp
CommitLineData
7c673cae
FG		 1// math_fwd.hpp
2
3// TODO revise completely for new distribution classes.
4
5// Copyright Paul A. Bristow 2006.
6// Copyright John Maddock 2006.
7
8// Use, modification and distribution are subject to the
9// Boost Software License, Version 1.0.
10// (See accompanying file LICENSE_1_0.txt
11// or copy at http://www.boost.org/LICENSE_1_0.txt)
12
13// Omnibus list of forward declarations of math special functions.
14
15// IT = Integer type.
16// RT = Real type (built-in floating-point types, float, double, long double) & User Defined Types
17// AT = Integer or Real type
18
19#ifndef BOOST_MATH_SPECIAL_MATH_FWD_HPP
20#define BOOST_MATH_SPECIAL_MATH_FWD_HPP
21
22#ifdef _MSC_VER
23#pragma once
24#endif
25
b32b8144 26#include <vector>
7c673cae
FG		 27#include <boost/math/special_functions/detail/round_fwd.hpp>
28#include <boost/math/tools/promotion.hpp> // for argument promotion.
29#include <boost/math/policies/policy.hpp>
30#include <boost/mpl/comparison.hpp>
31#include <boost/utility/enable_if.hpp>
32#include <boost/config/no_tr1/complex.hpp>
33
34#define BOOST_NO_MACRO_EXPAND /**/
35
36namespace boost
37{
38 namespace math
39 { // Math functions (in roughly alphabetic order).
40
41 // Beta functions.
42 template <class RT1, class RT2>
43 typename tools::promote_args<RT1, RT2>::type
44 beta(RT1 a, RT2 b); // Beta function (2 arguments).
45
46 template <class RT1, class RT2, class A>
47 typename tools::promote_args<RT1, RT2, A>::type
48 beta(RT1 a, RT2 b, A x); // Beta function (3 arguments).
49
50 template <class RT1, class RT2, class RT3, class Policy>
51 typename tools::promote_args<RT1, RT2, RT3>::type
52 beta(RT1 a, RT2 b, RT3 x, const Policy& pol); // Beta function (3 arguments).
53
54 template <class RT1, class RT2, class RT3>
55 typename tools::promote_args<RT1, RT2, RT3>::type
56 betac(RT1 a, RT2 b, RT3 x);
57
58 template <class RT1, class RT2, class RT3, class Policy>
59 typename tools::promote_args<RT1, RT2, RT3>::type
60 betac(RT1 a, RT2 b, RT3 x, const Policy& pol);
61
62 template <class RT1, class RT2, class RT3>
63 typename tools::promote_args<RT1, RT2, RT3>::type
64 ibeta(RT1 a, RT2 b, RT3 x); // Incomplete beta function.
65
66 template <class RT1, class RT2, class RT3, class Policy>
67 typename tools::promote_args<RT1, RT2, RT3>::type
68 ibeta(RT1 a, RT2 b, RT3 x, const Policy& pol); // Incomplete beta function.
69
70 template <class RT1, class RT2, class RT3>
71 typename tools::promote_args<RT1, RT2, RT3>::type
72 ibetac(RT1 a, RT2 b, RT3 x); // Incomplete beta complement function.
73
74 template <class RT1, class RT2, class RT3, class Policy>
75 typename tools::promote_args<RT1, RT2, RT3>::type
76 ibetac(RT1 a, RT2 b, RT3 x, const Policy& pol); // Incomplete beta complement function.
77
78 template <class T1, class T2, class T3, class T4>
79 typename tools::promote_args<T1, T2, T3, T4>::type
80 ibeta_inv(T1 a, T2 b, T3 p, T4* py);
81
82 template <class T1, class T2, class T3, class T4, class Policy>
83 typename tools::promote_args<T1, T2, T3, T4>::type
84 ibeta_inv(T1 a, T2 b, T3 p, T4* py, const Policy& pol);
85
86 template <class RT1, class RT2, class RT3>
87 typename tools::promote_args<RT1, RT2, RT3>::type
88 ibeta_inv(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function.
89
90 template <class RT1, class RT2, class RT3, class Policy>
91 typename tools::promote_args<RT1, RT2, RT3>::type
92 ibeta_inv(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function.
93
94 template <class RT1, class RT2, class RT3>
95 typename tools::promote_args<RT1, RT2, RT3>::type
96 ibeta_inva(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function.
97
98 template <class RT1, class RT2, class RT3, class Policy>
99 typename tools::promote_args<RT1, RT2, RT3>::type
100 ibeta_inva(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function.
101
102 template <class RT1, class RT2, class RT3>
103 typename tools::promote_args<RT1, RT2, RT3>::type
104 ibeta_invb(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function.
105
106 template <class RT1, class RT2, class RT3, class Policy>
107 typename tools::promote_args<RT1, RT2, RT3>::type
108 ibeta_invb(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function.
109
110 template <class T1, class T2, class T3, class T4>
111 typename tools::promote_args<T1, T2, T3, T4>::type
112 ibetac_inv(T1 a, T2 b, T3 q, T4* py);
113
114 template <class T1, class T2, class T3, class T4, class Policy>
115 typename tools::promote_args<T1, T2, T3, T4>::type
116 ibetac_inv(T1 a, T2 b, T3 q, T4* py, const Policy& pol);
117
118 template <class RT1, class RT2, class RT3>
119 typename tools::promote_args<RT1, RT2, RT3>::type
120 ibetac_inv(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function.
121
122 template <class RT1, class RT2, class RT3, class Policy>
123 typename tools::promote_args<RT1, RT2, RT3>::type
124 ibetac_inv(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function.
125
126 template <class RT1, class RT2, class RT3>
127 typename tools::promote_args<RT1, RT2, RT3>::type
128 ibetac_inva(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function.
129
130 template <class RT1, class RT2, class RT3, class Policy>
131 typename tools::promote_args<RT1, RT2, RT3>::type
132 ibetac_inva(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function.
133
134 template <class RT1, class RT2, class RT3>
135 typename tools::promote_args<RT1, RT2, RT3>::type
136 ibetac_invb(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function.
137
138 template <class RT1, class RT2, class RT3, class Policy>
139 typename tools::promote_args<RT1, RT2, RT3>::type
140 ibetac_invb(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function.
141
142 template <class RT1, class RT2, class RT3>
143 typename tools::promote_args<RT1, RT2, RT3>::type
144 ibeta_derivative(RT1 a, RT2 b, RT3 x); // derivative of incomplete beta
145
146 template <class RT1, class RT2, class RT3, class Policy>
147 typename tools::promote_args<RT1, RT2, RT3>::type
148 ibeta_derivative(RT1 a, RT2 b, RT3 x, const Policy& pol); // derivative of incomplete beta
149
150 // Binomial:
151 template <class T, class Policy>
152 T binomial_coefficient(unsigned n, unsigned k, const Policy& pol);
153 template <class T>
154 T binomial_coefficient(unsigned n, unsigned k);
155
156 // erf & erfc error functions.
157 template <class RT> // Error function.
158 typename tools::promote_args<RT>::type erf(RT z);
159 template <class RT, class Policy> // Error function.
160 typename tools::promote_args<RT>::type erf(RT z, const Policy&);
161
162 template <class RT>// Error function complement.
163 typename tools::promote_args<RT>::type erfc(RT z);
164 template <class RT, class Policy>// Error function complement.
165 typename tools::promote_args<RT>::type erfc(RT z, const Policy&);
166
167 template <class RT>// Error function inverse.
168 typename tools::promote_args<RT>::type erf_inv(RT z);
169 template <class RT, class Policy>// Error function inverse.
170 typename tools::promote_args<RT>::type erf_inv(RT z, const Policy& pol);
171
172 template <class RT>// Error function complement inverse.
173 typename tools::promote_args<RT>::type erfc_inv(RT z);
174 template <class RT, class Policy>// Error function complement inverse.
175 typename tools::promote_args<RT>::type erfc_inv(RT z, const Policy& pol);
176
177 // Polynomials:
178 template <class T1, class T2, class T3>
179 typename tools::promote_args<T1, T2, T3>::type
180 legendre_next(unsigned l, T1 x, T2 Pl, T3 Plm1);
181
182 template <class T>
183 typename tools::promote_args<T>::type
184 legendre_p(int l, T x);
b32b8144
FG		 185 template <class T>
186 typename tools::promote_args<T>::type
187 legendre_p_prime(int l, T x);
188
189
190 template <class T, class Policy>
191 inline std::vector<T> legendre_p_zeros(int l, const Policy& pol);
192
193 template <class T>
194 inline std::vector<T> legendre_p_zeros(int l);
195
7c673cae
FG		 196#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
197 template <class T, class Policy>
198 typename boost::enable_if_c<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
199 legendre_p(int l, T x, const Policy& pol);
b32b8144
FG		 200 template <class T, class Policy>
201 inline typename boost::enable_if_c<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
202 legendre_p_prime(int l, T x, const Policy& pol);
7c673cae
FG		 203#endif
204 template <class T>
205 typename tools::promote_args<T>::type
206 legendre_q(unsigned l, T x);
207#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
208 template <class T, class Policy>
209 typename boost::enable_if_c<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
210 legendre_q(unsigned l, T x, const Policy& pol);
211#endif
212 template <class T1, class T2, class T3>
213 typename tools::promote_args<T1, T2, T3>::type
214 legendre_next(unsigned l, unsigned m, T1 x, T2 Pl, T3 Plm1);
215
216 template <class T>
217 typename tools::promote_args<T>::type
218 legendre_p(int l, int m, T x);
219
220 template <class T, class Policy>
221 typename tools::promote_args<T>::type
222 legendre_p(int l, int m, T x, const Policy& pol);
223
224 template <class T1, class T2, class T3>
225 typename tools::promote_args<T1, T2, T3>::type
226 laguerre_next(unsigned n, T1 x, T2 Ln, T3 Lnm1);
227
228 template <class T1, class T2, class T3>
229 typename tools::promote_args<T1, T2, T3>::type
230 laguerre_next(unsigned n, unsigned l, T1 x, T2 Pl, T3 Plm1);
231
232 template <class T>
233 typename tools::promote_args<T>::type
234 laguerre(unsigned n, T x);
235
236 template <class T, class Policy>
237 typename tools::promote_args<T>::type
238 laguerre(unsigned n, unsigned m, T x, const Policy& pol);
239
240 template <class T1, class T2>
241 struct laguerre_result
242 {
243 typedef typename mpl::if_<
244 policies::is_policy<T2>,
245 typename tools::promote_args<T1>::type,
246 typename tools::promote_args<T2>::type
247 >::type type;
248 };
249
250 template <class T1, class T2>
251 typename laguerre_result<T1, T2>::type
252 laguerre(unsigned n, T1 m, T2 x);
253
254 template <class T>
255 typename tools::promote_args<T>::type
256 hermite(unsigned n, T x);
257
258 template <class T, class Policy>
259 typename tools::promote_args<T>::type
260 hermite(unsigned n, T x, const Policy& pol);
261
262 template <class T1, class T2, class T3>
263 typename tools::promote_args<T1, T2, T3>::type
264 hermite_next(unsigned n, T1 x, T2 Hn, T3 Hnm1);
265
b32b8144
FG		 266 template<class T1, class T2, class T3>
267 typename tools::promote_args<T1, T2, T3>::type chebyshev_next(T1 const & x, T2 const & Tn, T3 const & Tn_1);
268
269 template <class Real, class Policy>
270 typename tools::promote_args<Real>::type
271 chebyshev_t(unsigned n, Real const & x, const Policy&);
272 template<class Real>
273 typename tools::promote_args<Real>::type chebyshev_t(unsigned n, Real const & x);
274
275 template <class Real, class Policy>
276 typename tools::promote_args<Real>::type
277 chebyshev_u(unsigned n, Real const & x, const Policy&);
278 template<class Real>
279 typename tools::promote_args<Real>::type chebyshev_u(unsigned n, Real const & x);
280
281 template <class Real, class Policy>
282 typename tools::promote_args<Real>::type
283 chebyshev_t_prime(unsigned n, Real const & x, const Policy&);
284 template<class Real>
285 typename tools::promote_args<Real>::type chebyshev_t_prime(unsigned n, Real const & x);
286
287 template<class Real, class T2>
288 Real chebyshev_clenshaw_recurrence(const Real* const c, size_t length, const T2& x);
289
7c673cae
FG		 290 template <class T1, class T2>
291 std::complex<typename tools::promote_args<T1, T2>::type>
292 spherical_harmonic(unsigned n, int m, T1 theta, T2 phi);
293
294 template <class T1, class T2, class Policy>
295 std::complex<typename tools::promote_args<T1, T2>::type>
296 spherical_harmonic(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
297
298 template <class T1, class T2>
299 typename tools::promote_args<T1, T2>::type
300 spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi);
301
302 template <class T1, class T2, class Policy>
303 typename tools::promote_args<T1, T2>::type
304 spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
305
306 template <class T1, class T2>
307 typename tools::promote_args<T1, T2>::type
308 spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi);
309
310 template <class T1, class T2, class Policy>
311 typename tools::promote_args<T1, T2>::type
312 spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
313
314 // Elliptic integrals:
315 template <class T1, class T2, class T3>
316 typename tools::promote_args<T1, T2, T3>::type
317 ellint_rf(T1 x, T2 y, T3 z);
318
319 template <class T1, class T2, class T3, class Policy>
320 typename tools::promote_args<T1, T2, T3>::type
321 ellint_rf(T1 x, T2 y, T3 z, const Policy& pol);
322
323 template <class T1, class T2, class T3>
324 typename tools::promote_args<T1, T2, T3>::type
325 ellint_rd(T1 x, T2 y, T3 z);
326
327 template <class T1, class T2, class T3, class Policy>
328 typename tools::promote_args<T1, T2, T3>::type
329 ellint_rd(T1 x, T2 y, T3 z, const Policy& pol);
330
331 template <class T1, class T2>
332 typename tools::promote_args<T1, T2>::type
333 ellint_rc(T1 x, T2 y);
334
335 template <class T1, class T2, class Policy>
336 typename tools::promote_args<T1, T2>::type
337 ellint_rc(T1 x, T2 y, const Policy& pol);
338
339 template <class T1, class T2, class T3, class T4>
340 typename tools::promote_args<T1, T2, T3, T4>::type
341 ellint_rj(T1 x, T2 y, T3 z, T4 p);
342
343 template <class T1, class T2, class T3, class T4, class Policy>
344 typename tools::promote_args<T1, T2, T3, T4>::type
345 ellint_rj(T1 x, T2 y, T3 z, T4 p, const Policy& pol);
346
347 template <class T1, class T2, class T3>
348 typename tools::promote_args<T1, T2, T3>::type
349 ellint_rg(T1 x, T2 y, T3 z);
350
351 template <class T1, class T2, class T3, class Policy>
352 typename tools::promote_args<T1, T2, T3>::type
353 ellint_rg(T1 x, T2 y, T3 z, const Policy& pol);
354
355 template <typename T>
356 typename tools::promote_args<T>::type ellint_2(T k);
357
358 template <class T1, class T2>
359 typename tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi);
360
361 template <class T1, class T2, class Policy>
362 typename tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi, const Policy& pol);
363
364 template <typename T>
365 typename tools::promote_args<T>::type ellint_1(T k);
366
367 template <class T1, class T2>
368 typename tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi);
369
370 template <class T1, class T2, class Policy>
371 typename tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi, const Policy& pol);
372
373 template <typename T>
374 typename tools::promote_args<T>::type ellint_d(T k);
375
376 template <class T1, class T2>
377 typename tools::promote_args<T1, T2>::type ellint_d(T1 k, T2 phi);
378
379 template <class T1, class T2, class Policy>
380 typename tools::promote_args<T1, T2>::type ellint_d(T1 k, T2 phi, const Policy& pol);
381
382 template <class T1, class T2>
383 typename tools::promote_args<T1, T2>::type jacobi_zeta(T1 k, T2 phi);
384
385 template <class T1, class T2, class Policy>
386 typename tools::promote_args<T1, T2>::type jacobi_zeta(T1 k, T2 phi, const Policy& pol);
387
388 template <class T1, class T2>
389 typename tools::promote_args<T1, T2>::type heuman_lambda(T1 k, T2 phi);
390
391 template <class T1, class T2, class Policy>
392 typename tools::promote_args<T1, T2>::type heuman_lambda(T1 k, T2 phi, const Policy& pol);
393
394 namespace detail{
395
396 template <class T, class U, class V>
397 struct ellint_3_result
398 {
399 typedef typename mpl::if_<
400 policies::is_policy<V>,
401 typename tools::promote_args<T, U>::type,
402 typename tools::promote_args<T, U, V>::type
403 >::type type;
404 };
405
406 } // namespace detail
407
408
409 template <class T1, class T2, class T3>
410 typename detail::ellint_3_result<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi);
411
412 template <class T1, class T2, class T3, class Policy>
413 typename tools::promote_args<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi, const Policy& pol);
414
415 template <class T1, class T2>
416 typename tools::promote_args<T1, T2>::type ellint_3(T1 k, T2 v);
417
418 // Factorial functions.
419 // Note: not for integral types, at present.
420 template <class RT>
421 struct max_factorial;
422 template <class RT>
423 RT factorial(unsigned int);
424 template <class RT, class Policy>
425 RT factorial(unsigned int, const Policy& pol);
426 template <class RT>
427 RT unchecked_factorial(unsigned int BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(RT));
428 template <class RT>
429 RT double_factorial(unsigned i);
430 template <class RT, class Policy>
431 RT double_factorial(unsigned i, const Policy& pol);
432
433 template <class RT>
434 typename tools::promote_args<RT>::type falling_factorial(RT x, unsigned n);
435
436 template <class RT, class Policy>
437 typename tools::promote_args<RT>::type falling_factorial(RT x, unsigned n, const Policy& pol);
438
439 template <class RT>
440 typename tools::promote_args<RT>::type rising_factorial(RT x, int n);
441
442 template <class RT, class Policy>
443 typename tools::promote_args<RT>::type rising_factorial(RT x, int n, const Policy& pol);
444
445 // Gamma functions.
446 template <class RT>
447 typename tools::promote_args<RT>::type tgamma(RT z);
448
449 template <class RT>
450 typename tools::promote_args<RT>::type tgamma1pm1(RT z);
451
452 template <class RT, class Policy>
453 typename tools::promote_args<RT>::type tgamma1pm1(RT z, const Policy& pol);
454
455 template <class RT1, class RT2>
456 typename tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z);
457
458 template <class RT1, class RT2, class Policy>
459 typename tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z, const Policy& pol);
460
461 template <class RT>
462 typename tools::promote_args<RT>::type lgamma(RT z, int* sign);
463
464 template <class RT, class Policy>
465 typename tools::promote_args<RT>::type lgamma(RT z, int* sign, const Policy& pol);
466
467 template <class RT>
468 typename tools::promote_args<RT>::type lgamma(RT x);
469
470 template <class RT, class Policy>
471 typename tools::promote_args<RT>::type lgamma(RT x, const Policy& pol);
472
473 template <class RT1, class RT2>
474 typename tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z);
475
476 template <class RT1, class RT2, class Policy>
477 typename tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z, const Policy&);
478
479 template <class RT1, class RT2>
480 typename tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z);
481
482 template <class RT1, class RT2, class Policy>
483 typename tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z, const Policy&);
484
485 template <class RT1, class RT2>
486 typename tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z);
487
488 template <class RT1, class RT2, class Policy>
489 typename tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z, const Policy&);
490
491 template <class T1, class T2>
492 typename tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta);
493
494 template <class T1, class T2, class Policy>
495 typename tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta, const Policy&);
496
497 template <class T1, class T2>
498 typename tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b);
499
500 template <class T1, class T2, class Policy>
501 typename tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b, const Policy&);
502
503 template <class T1, class T2>
504 typename tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x);
505
506 template <class T1, class T2, class Policy>
507 typename tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x, const Policy&);
508
509 // gamma inverse.
510 template <class T1, class T2>
511 typename tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p);
512
513 template <class T1, class T2, class Policy>
514 typename tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p, const Policy&);
515
516 template <class T1, class T2>
517 typename tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p);
518
519 template <class T1, class T2, class Policy>
520 typename tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p, const Policy&);
521
522 template <class T1, class T2>
523 typename tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q);
524
525 template <class T1, class T2, class Policy>
526 typename tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q, const Policy&);
527
528 template <class T1, class T2>
529 typename tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q);
530
531 template <class T1, class T2, class Policy>
532 typename tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q, const Policy&);
533
534 // digamma:
535 template <class T>
536 typename tools::promote_args<T>::type digamma(T x);
537
538 template <class T, class Policy>
539 typename tools::promote_args<T>::type digamma(T x, const Policy&);
540
541 // trigamma:
542 template <class T>
543 typename tools::promote_args<T>::type trigamma(T x);
544
545 template <class T, class Policy>
546 typename tools::promote_args<T>::type trigamma(T x, const Policy&);
547
548 // polygamma:
549 template <class T>
550 typename tools::promote_args<T>::type polygamma(int n, T x);
551
552 template <class T, class Policy>
553 typename tools::promote_args<T>::type polygamma(int n, T x, const Policy&);
554
555 // Hypotenuse function sqrt(x ^ 2 + y ^ 2).
556 template <class T1, class T2>
557 typename tools::promote_args<T1, T2>::type
558 hypot(T1 x, T2 y);
559
560 template <class T1, class T2, class Policy>
561 typename tools::promote_args<T1, T2>::type
562 hypot(T1 x, T2 y, const Policy&);
563
564 // cbrt - cube root.
565 template <class RT>
566 typename tools::promote_args<RT>::type cbrt(RT z);
567
568 template <class RT, class Policy>
569 typename tools::promote_args<RT>::type cbrt(RT z, const Policy&);
570
571 // log1p is log(x + 1)
572 template <class T>
573 typename tools::promote_args<T>::type log1p(T);
574
575 template <class T, class Policy>
576 typename tools::promote_args<T>::type log1p(T, const Policy&);
577
578 // log1pmx is log(x + 1) - x
579 template <class T>
580 typename tools::promote_args<T>::type log1pmx(T);
581
582 template <class T, class Policy>
583 typename tools::promote_args<T>::type log1pmx(T, const Policy&);
584
585 // Exp (x) minus 1 functions.
586 template <class T>
587 typename tools::promote_args<T>::type expm1(T);
588
589 template <class T, class Policy>
590 typename tools::promote_args<T>::type expm1(T, const Policy&);
591
592 // Power - 1
593 template <class T1, class T2>
594 typename tools::promote_args<T1, T2>::type
595 powm1(const T1 a, const T2 z);
596
597 template <class T1, class T2, class Policy>
598 typename tools::promote_args<T1, T2>::type
599 powm1(const T1 a, const T2 z, const Policy&);
600
601 // sqrt(1+x) - 1
602 template <class T>
603 typename tools::promote_args<T>::type sqrt1pm1(const T& val);
604
605 template <class T, class Policy>
606 typename tools::promote_args<T>::type sqrt1pm1(const T& val, const Policy&);
607
608 // sinus cardinals:
609 template <class T>
610 typename tools::promote_args<T>::type sinc_pi(T x);
611
612 template <class T, class Policy>
613 typename tools::promote_args<T>::type sinc_pi(T x, const Policy&);
614
615 template <class T>
616 typename tools::promote_args<T>::type sinhc_pi(T x);
617
618 template <class T, class Policy>
619 typename tools::promote_args<T>::type sinhc_pi(T x, const Policy&);
620
621 // inverse hyperbolics:
622 template<typename T>
623 typename tools::promote_args<T>::type asinh(T x);
624
625 template<typename T, class Policy>
626 typename tools::promote_args<T>::type asinh(T x, const Policy&);
627
628 template<typename T>
629 typename tools::promote_args<T>::type acosh(T x);
630
631 template<typename T, class Policy>
632 typename tools::promote_args<T>::type acosh(T x, const Policy&);
633
634 template<typename T>
635 typename tools::promote_args<T>::type atanh(T x);
636
637 template<typename T, class Policy>
638 typename tools::promote_args<T>::type atanh(T x, const Policy&);
639
640 namespace detail{
641
642 typedef mpl::int_<0> bessel_no_int_tag; // No integer optimisation possible.
643 typedef mpl::int_<1> bessel_maybe_int_tag; // Maybe integer optimisation.
644 typedef mpl::int_<2> bessel_int_tag; // Definite integer optimistaion.
645
646 template <class T1, class T2, class Policy>
647 struct bessel_traits
648 {
649 typedef typename mpl::if_<
650 is_integral<T1>,
651 typename tools::promote_args<T2>::type,
652 typename tools::promote_args<T1, T2>::type
653 >::type result_type;
654
655 typedef typename policies::precision<result_type, Policy>::type precision_type;
656
657 typedef typename mpl::if_<
658 mpl::or_<
659 mpl::less_equal<precision_type, mpl::int_<0> >,
660 mpl::greater<precision_type, mpl::int_<64> > >,
661 bessel_no_int_tag,
662 typename mpl::if_<
663 is_integral<T1>,
664 bessel_int_tag,
665 bessel_maybe_int_tag
666 >::type
667 >::type optimisation_tag;
b32b8144
FG		 668 typedef typename mpl::if_<
669 mpl::or_<
670 mpl::less_equal<precision_type, mpl::int_<0> >,
671 mpl::greater<precision_type, mpl::int_<113> > >,
672 bessel_no_int_tag,
673 typename mpl::if_<
674 is_integral<T1>,
675 bessel_int_tag,
676 bessel_maybe_int_tag
677 >::type
678 >::type optimisation_tag128;
7c673cae
FG		 679 };
680 } // detail
681
682 // Bessel functions:
683 template <class T1, class T2, class Policy>
684 typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_j(T1 v, T2 x, const Policy& pol);
685 template <class T1, class T2, class Policy>
686 typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_j_prime(T1 v, T2 x, const Policy& pol);
687
688 template <class T1, class T2>
689 typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_j(T1 v, T2 x);
690 template <class T1, class T2>
691 typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_j_prime(T1 v, T2 x);
692
693 template <class T, class Policy>
694 typename detail::bessel_traits<T, T, Policy>::result_type sph_bessel(unsigned v, T x, const Policy& pol);
695 template <class T, class Policy>
696 typename detail::bessel_traits<T, T, Policy>::result_type sph_bessel_prime(unsigned v, T x, const Policy& pol);
697
698 template <class T>
699 typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_bessel(unsigned v, T x);
700 template <class T>
701 typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_bessel_prime(unsigned v, T x);
702
703 template <class T1, class T2, class Policy>
704 typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_i(T1 v, T2 x, const Policy& pol);
705 template <class T1, class T2, class Policy>
706 typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_i_prime(T1 v, T2 x, const Policy& pol);
707
708 template <class T1, class T2>
709 typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_i(T1 v, T2 x);
710 template <class T1, class T2>
711 typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_i_prime(T1 v, T2 x);
712
713 template <class T1, class T2, class Policy>
714 typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_k(T1 v, T2 x, const Policy& pol);
715 template <class T1, class T2, class Policy>
716 typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_k_prime(T1 v, T2 x, const Policy& pol);
717
718 template <class T1, class T2>
719 typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_k(T1 v, T2 x);
720 template <class T1, class T2>
721 typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_k_prime(T1 v, T2 x);
722
723 template <class T1, class T2, class Policy>
724 typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_neumann(T1 v, T2 x, const Policy& pol);
725 template <class T1, class T2, class Policy>
726 typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_neumann_prime(T1 v, T2 x, const Policy& pol);
727
728 template <class T1, class T2>
729 typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_neumann(T1 v, T2 x);
730 template <class T1, class T2>
731 typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_neumann_prime(T1 v, T2 x);
732
733 template <class T, class Policy>
734 typename detail::bessel_traits<T, T, Policy>::result_type sph_neumann(unsigned v, T x, const Policy& pol);
735 template <class T, class Policy>
736 typename detail::bessel_traits<T, T, Policy>::result_type sph_neumann_prime(unsigned v, T x, const Policy& pol);
737
738 template <class T>
739 typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_neumann(unsigned v, T x);
740 template <class T>
741 typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_neumann_prime(unsigned v, T x);
742
743 template <class T, class Policy>
744 typename detail::bessel_traits<T, T, Policy>::result_type cyl_bessel_j_zero(T v, int m, const Policy& pol);
745
746 template <class T>
747 typename detail::bessel_traits<T, T, policies::policy<> >::result_type cyl_bessel_j_zero(T v, int m);
748
749 template <class T, class OutputIterator>
750 OutputIterator cyl_bessel_j_zero(T v,
751 int start_index,
752 unsigned number_of_zeros,
753 OutputIterator out_it);
754
755 template <class T, class OutputIterator, class Policy>
756 OutputIterator cyl_bessel_j_zero(T v,
757 int start_index,
758 unsigned number_of_zeros,
759 OutputIterator out_it,
760 const Policy&);
761
762 template <class T, class Policy>
763 typename detail::bessel_traits<T, T, Policy>::result_type cyl_neumann_zero(T v, int m, const Policy& pol);
764
765 template <class T>
766 typename detail::bessel_traits<T, T, policies::policy<> >::result_type cyl_neumann_zero(T v, int m);
767
768 template <class T, class OutputIterator>
769 OutputIterator cyl_neumann_zero(T v,
770 int start_index,
771 unsigned number_of_zeros,
772 OutputIterator out_it);
773
774 template <class T, class OutputIterator, class Policy>
775 OutputIterator cyl_neumann_zero(T v,
776 int start_index,
777 unsigned number_of_zeros,
778 OutputIterator out_it,
779 const Policy&);
780
781 template <class T1, class T2>
782 std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> cyl_hankel_1(T1 v, T2 x);
783
784 template <class T1, class T2, class Policy>
785 std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> cyl_hankel_1(T1 v, T2 x, const Policy& pol);
786
787 template <class T1, class T2, class Policy>
788 std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> cyl_hankel_2(T1 v, T2 x, const Policy& pol);
789
790 template <class T1, class T2>
791 std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> cyl_hankel_2(T1 v, T2 x);
792
793 template <class T1, class T2, class Policy>
794 std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> sph_hankel_1(T1 v, T2 x, const Policy& pol);
795
796 template <class T1, class T2>
797 std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> sph_hankel_1(T1 v, T2 x);
798
799 template <class T1, class T2, class Policy>
800 std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> sph_hankel_2(T1 v, T2 x, const Policy& pol);
801
802 template <class T1, class T2>
803 std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> sph_hankel_2(T1 v, T2 x);
804
805 template <class T, class Policy>
806 typename tools::promote_args<T>::type airy_ai(T x, const Policy&);
807
808 template <class T>
809 typename tools::promote_args<T>::type airy_ai(T x);
810
811 template <class T, class Policy>
812 typename tools::promote_args<T>::type airy_bi(T x, const Policy&);
813
814 template <class T>
815 typename tools::promote_args<T>::type airy_bi(T x);
816
817 template <class T, class Policy>
818 typename tools::promote_args<T>::type airy_ai_prime(T x, const Policy&);
819
820 template <class T>
821 typename tools::promote_args<T>::type airy_ai_prime(T x);
822
823 template <class T, class Policy>
824 typename tools::promote_args<T>::type airy_bi_prime(T x, const Policy&);
825
826 template <class T>
827 typename tools::promote_args<T>::type airy_bi_prime(T x);
828
829 template <class T>
830 T airy_ai_zero(int m);
831 template <class T, class Policy>
832 T airy_ai_zero(int m, const Policy&);
833
834 template <class OutputIterator>
835 OutputIterator airy_ai_zero(
836 int start_index,
837 unsigned number_of_zeros,
838 OutputIterator out_it);
839 template <class OutputIterator, class Policy>
840 OutputIterator airy_ai_zero(
841 int start_index,
842 unsigned number_of_zeros,
843 OutputIterator out_it,
844 const Policy&);
845
846 template <class T>
847 T airy_bi_zero(int m);
848 template <class T, class Policy>
849 T airy_bi_zero(int m, const Policy&);
850
851 template <class OutputIterator>
852 OutputIterator airy_bi_zero(
853 int start_index,
854 unsigned number_of_zeros,
855 OutputIterator out_it);
856 template <class OutputIterator, class Policy>
857 OutputIterator airy_bi_zero(
858 int start_index,
859 unsigned number_of_zeros,
860 OutputIterator out_it,
861 const Policy&);
862
863 template <class T, class Policy>
864 typename tools::promote_args<T>::type sin_pi(T x, const Policy&);
865
866 template <class T>
867 typename tools::promote_args<T>::type sin_pi(T x);
868
869 template <class T, class Policy>
870 typename tools::promote_args<T>::type cos_pi(T x, const Policy&);
871
872 template <class T>
873 typename tools::promote_args<T>::type cos_pi(T x);
874
875 template <class T>
876 int fpclassify BOOST_NO_MACRO_EXPAND(T t);
877
878 template <class T>
879 bool isfinite BOOST_NO_MACRO_EXPAND(T z);
880
881 template <class T>
882 bool isinf BOOST_NO_MACRO_EXPAND(T t);
883
884 template <class T>
885 bool isnan BOOST_NO_MACRO_EXPAND(T t);
886
887 template <class T>
888 bool isnormal BOOST_NO_MACRO_EXPAND(T t);
889
890 template<class T>
891 int signbit BOOST_NO_MACRO_EXPAND(T x);
892
893 template <class T>
894 int sign BOOST_NO_MACRO_EXPAND(const T& z);
895
896 template <class T, class U>
897 typename tools::promote_args_permissive<T, U>::type copysign BOOST_NO_MACRO_EXPAND(const T& x, const U& y);
898
899 template <class T>
900 typename tools::promote_args_permissive<T>::type changesign BOOST_NO_MACRO_EXPAND(const T& z);
901
902 // Exponential integrals:
903 namespace detail{
904
905 template <class T, class U>
906 struct expint_result
907 {
908 typedef typename mpl::if_<
909 policies::is_policy<U>,
910 typename tools::promote_args<T>::type,
911 typename tools::promote_args<U>::type
912 >::type type;
913 };
914
915 } // namespace detail
916
917 template <class T, class Policy>
918 typename tools::promote_args<T>::type expint(unsigned n, T z, const Policy&);
919
920 template <class T, class U>
921 typename detail::expint_result<T, U>::type expint(T const z, U const u);
922
923 template <class T>
924 typename tools::promote_args<T>::type expint(T z);
925
926 // Zeta:
927 template <class T, class Policy>
928 typename tools::promote_args<T>::type zeta(T s, const Policy&);
929
930 // Owen's T function:
931 template <class T1, class T2, class Policy>
932 typename tools::promote_args<T1, T2>::type owens_t(T1 h, T2 a, const Policy& pol);
933
934 template <class T1, class T2>
935 typename tools::promote_args<T1, T2>::type owens_t(T1 h, T2 a);
936
937 // Jacobi Functions:
938 template <class T, class U, class V, class Policy>
939 typename tools::promote_args<T, U, V>::type jacobi_elliptic(T k, U theta, V* pcn, V* pdn, const Policy&);
940
941 template <class T, class U, class V>
942 typename tools::promote_args<T, U, V>::type jacobi_elliptic(T k, U theta, V* pcn = 0, V* pdn = 0);
943
944 template <class U, class T, class Policy>
945 typename tools::promote_args<T, U>::type jacobi_sn(U k, T theta, const Policy& pol);
946
947 template <class U, class T>
948 typename tools::promote_args<T, U>::type jacobi_sn(U k, T theta);
949
950 template <class T, class U, class Policy>
951 typename tools::promote_args<T, U>::type jacobi_cn(T k, U theta, const Policy& pol);
952
953 template <class T, class U>
954 typename tools::promote_args<T, U>::type jacobi_cn(T k, U theta);
955
956 template <class T, class U, class Policy>
957 typename tools::promote_args<T, U>::type jacobi_dn(T k, U theta, const Policy& pol);
958
959 template <class T, class U>
960 typename tools::promote_args<T, U>::type jacobi_dn(T k, U theta);
961
962 template <class T, class U, class Policy>
963 typename tools::promote_args<T, U>::type jacobi_cd(T k, U theta, const Policy& pol);
964
965 template <class T, class U>
966 typename tools::promote_args<T, U>::type jacobi_cd(T k, U theta);
967
968 template <class T, class U, class Policy>
969 typename tools::promote_args<T, U>::type jacobi_dc(T k, U theta, const Policy& pol);
970
971 template <class T, class U>
972 typename tools::promote_args<T, U>::type jacobi_dc(T k, U theta);
973
974 template <class T, class U, class Policy>
975 typename tools::promote_args<T, U>::type jacobi_ns(T k, U theta, const Policy& pol);
976
977 template <class T, class U>
978 typename tools::promote_args<T, U>::type jacobi_ns(T k, U theta);
979
980 template <class T, class U, class Policy>
981 typename tools::promote_args<T, U>::type jacobi_sd(T k, U theta, const Policy& pol);
982
983 template <class T, class U>
984 typename tools::promote_args<T, U>::type jacobi_sd(T k, U theta);
985
986 template <class T, class U, class Policy>
987 typename tools::promote_args<T, U>::type jacobi_ds(T k, U theta, const Policy& pol);
988
989 template <class T, class U>
990 typename tools::promote_args<T, U>::type jacobi_ds(T k, U theta);
991
992 template <class T, class U, class Policy>
993 typename tools::promote_args<T, U>::type jacobi_nc(T k, U theta, const Policy& pol);
994
995 template <class T, class U>
996 typename tools::promote_args<T, U>::type jacobi_nc(T k, U theta);
997
998 template <class T, class U, class Policy>
999 typename tools::promote_args<T, U>::type jacobi_nd(T k, U theta, const Policy& pol);
1000
1001 template <class T, class U>
1002 typename tools::promote_args<T, U>::type jacobi_nd(T k, U theta);
1003
1004 template <class T, class U, class Policy>
1005 typename tools::promote_args<T, U>::type jacobi_sc(T k, U theta, const Policy& pol);
1006
1007 template <class T, class U>
1008 typename tools::promote_args<T, U>::type jacobi_sc(T k, U theta);
1009
1010 template <class T, class U, class Policy>
1011 typename tools::promote_args<T, U>::type jacobi_cs(T k, U theta, const Policy& pol);
1012
1013 template <class T, class U>
1014 typename tools::promote_args<T, U>::type jacobi_cs(T k, U theta);
1015
1016
1017 template <class T>
1018 typename tools::promote_args<T>::type zeta(T s);
1019
1020 // pow:
1021 template <int N, typename T, class Policy>
1022 typename tools::promote_args<T>::type pow(T base, const Policy& policy);
1023
1024 template <int N, typename T>
1025 typename tools::promote_args<T>::type pow(T base);
1026
1027 // next:
1028 template <class T, class U, class Policy>
1029 typename tools::promote_args<T, U>::type nextafter(const T&, const U&, const Policy&);
1030 template <class T, class U>
1031 typename tools::promote_args<T, U>::type nextafter(const T&, const U&);
1032 template <class T, class Policy>
1033 typename tools::promote_args<T>::type float_next(const T&, const Policy&);
1034 template <class T>
1035 typename tools::promote_args<T>::type float_next(const T&);
1036 template <class T, class Policy>
1037 typename tools::promote_args<T>::type float_prior(const T&, const Policy&);
1038 template <class T>
1039 typename tools::promote_args<T>::type float_prior(const T&);
1040 template <class T, class U, class Policy>
1041 typename tools::promote_args<T, U>::type float_distance(const T&, const U&, const Policy&);
1042 template <class T, class U>
1043 typename tools::promote_args<T, U>::type float_distance(const T&, const U&);
1044 template <class T, class Policy>
1045 typename tools::promote_args<T>::type float_advance(T val, int distance, const Policy& pol);
1046 template <class T>
1047 typename tools::promote_args<T>::type float_advance(const T& val, int distance);
1048
1049 template <class T, class Policy>
1050 typename tools::promote_args<T>::type ulp(const T& val, const Policy& pol);
1051 template <class T>
1052 typename tools::promote_args<T>::type ulp(const T& val);
1053
1054 template <class T, class U>
1055 typename tools::promote_args<T, U>::type relative_difference(const T&, const U&);
1056 template <class T, class U>
1057 typename tools::promote_args<T, U>::type epsilon_difference(const T&, const U&);
1058
1059 template<class T>
11fdf7f2 1060 BOOST_MATH_CONSTEXPR_TABLE_FUNCTION T unchecked_bernoulli_b2n(const std::size_t n);
7c673cae
FG		 1061 template <class T, class Policy>
1062 T bernoulli_b2n(const int i, const Policy &pol);
1063 template <class T>
1064 T bernoulli_b2n(const int i);
1065 template <class T, class OutputIterator, class Policy>
1066 OutputIterator bernoulli_b2n(const int start_index,
1067 const unsigned number_of_bernoullis_b2n,
1068 OutputIterator out_it,
1069 const Policy& pol);
1070 template <class T, class OutputIterator>
1071 OutputIterator bernoulli_b2n(const int start_index,
1072 const unsigned number_of_bernoullis_b2n,
1073 OutputIterator out_it);
1074 template <class T, class Policy>
1075 T tangent_t2n(const int i, const Policy &pol);
1076 template <class T>
1077 T tangent_t2n(const int i);
1078 template <class T, class OutputIterator, class Policy>
1079 OutputIterator tangent_t2n(const int start_index,
1080 const unsigned number_of_bernoullis_b2n,
1081 OutputIterator out_it,
1082 const Policy& pol);
1083 template <class T, class OutputIterator>
1084 OutputIterator tangent_t2n(const int start_index,
1085 const unsigned number_of_bernoullis_b2n,
1086 OutputIterator out_it);
1087
92f5a8d4
TL		 1088 // Lambert W:
1089 template <class T, class Policy>
1090 typename boost::math::tools::promote_args<T>::type lambert_w0(T z, const Policy& pol);
1091 template <class T>
1092 typename boost::math::tools::promote_args<T>::type lambert_w0(T z);
1093 template <class T, class Policy>
1094 typename boost::math::tools::promote_args<T>::type lambert_wm1(T z, const Policy& pol);
1095 template <class T>
1096 typename boost::math::tools::promote_args<T>::type lambert_wm1(T z);
1097 template <class T, class Policy>
1098 typename boost::math::tools::promote_args<T>::type lambert_w0_prime(T z, const Policy& pol);
1099 template <class T>
1100 typename boost::math::tools::promote_args<T>::type lambert_w0_prime(T z);
1101 template <class T, class Policy>
1102 typename boost::math::tools::promote_args<T>::type lambert_wm1_prime(T z, const Policy& pol);
1103 template <class T>
1104 typename boost::math::tools::promote_args<T>::type lambert_wm1_prime(T z);
1105
1106 // Hypergeometrics:
1107 template <class T1, class T2> typename tools::promote_args<T1, T2>::type hypergeometric_1F0(T1 a, T2 z);
1108 template <class T1, class T2, class Policy> typename tools::promote_args<T1, T2>::type hypergeometric_1F0(T1 a, T2 z, const Policy&);
1109
1110 template <class T1, class T2> typename tools::promote_args<T1, T2>::type hypergeometric_0F1(T1 b, T2 z);
1111 template <class T1, class T2, class Policy> typename tools::promote_args<T1, T2>::type hypergeometric_0F1(T1 b, T2 z, const Policy&);
1112
1113 template <class T1, class T2, class T3> typename tools::promote_args<T1, T2, T3>::type hypergeometric_2F0(T1 a1, T2 a2, T3 z);
1114 template <class T1, class T2, class T3, class Policy> typename tools::promote_args<T1, T2, T3>::type hypergeometric_2F0(T1 a1, T2 a2, T3 z, const Policy&);
1115
1116 template <class T1, class T2, class T3> typename tools::promote_args<T1, T2, T3>::type hypergeometric_1F1(T1 a, T2 b, T3 z);
1117 template <class T1, class T2, class T3, class Policy> typename tools::promote_args<T1, T2, T3>::type hypergeometric_1F1(T1 a, T2 b, T3 z, const Policy&);
1118
1119
7c673cae
FG		 1120 } // namespace math
1121} // namespace boost
1122
1123#ifdef BOOST_HAS_LONG_LONG
1124#define BOOST_MATH_DETAIL_LL_FUNC(Policy)\
1125 \
1126 template <class T>\
1127 inline T modf(const T& v, boost::long_long_type* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
1128 \
1129 template <class T>\
1130 inline boost::long_long_type lltrunc(const T& v){ using boost::math::lltrunc; return lltrunc(v, Policy()); }\
1131 \
1132 template <class T>\
1133 inline boost::long_long_type llround(const T& v){ using boost::math::llround; return llround(v, Policy()); }\
1134
1135#else
1136#define BOOST_MATH_DETAIL_LL_FUNC(Policy)
1137#endif
1138
92f5a8d4
TL		 1139#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && !defined(BOOST_NO_CXX11_HDR_ARRAY)
1140# define BOOST_MATH_DETAIL_11_FUNC(Policy)\
1141 template <class T, class U, class V>\
1142 inline typename boost::math::tools::promote_args<T, U>::type hypergeometric_1F1(const T& a, const U& b, const V& z)\
1143 { return boost::math::hypergeometric_1F1(a, b, z, Policy()); }\
1144
1145#else
1146# define BOOST_MATH_DETAIL_11_FUNC(Policy)
1147#endif
1148
7c673cae
FG		 1149#define BOOST_MATH_DECLARE_SPECIAL_FUNCTIONS(Policy)\
1150 \
1151 BOOST_MATH_DETAIL_LL_FUNC(Policy)\
92f5a8d4 1152 BOOST_MATH_DETAIL_11_FUNC(Policy)\
7c673cae
FG		 1153 \
1154 template <class RT1, class RT2>\
1155 inline typename boost::math::tools::promote_args<RT1, RT2>::type \
1156 beta(RT1 a, RT2 b) { return ::boost::math::beta(a, b, Policy()); }\
1157\
1158 template <class RT1, class RT2, class A>\
1159 inline typename boost::math::tools::promote_args<RT1, RT2, A>::type \
1160 beta(RT1 a, RT2 b, A x){ return ::boost::math::beta(a, b, x, Policy()); }\
1161\
1162 template <class RT1, class RT2, class RT3>\
1163 inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
1164 betac(RT1 a, RT2 b, RT3 x) { return ::boost::math::betac(a, b, x, Policy()); }\
1165\
1166 template <class RT1, class RT2, class RT3>\
1167 inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
1168 ibeta(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibeta(a, b, x, Policy()); }\
1169\
1170 template <class RT1, class RT2, class RT3>\
1171 inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
1172 ibetac(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibetac(a, b, x, Policy()); }\
1173\
1174 template <class T1, class T2, class T3, class T4>\
1175 inline typename boost::math::tools::promote_args<T1, T2, T3, T4>::type \
1176 ibeta_inv(T1 a, T2 b, T3 p, T4* py){ return ::boost::math::ibeta_inv(a, b, p, py, Policy()); }\
1177\
1178 template <class RT1, class RT2, class RT3>\
1179 inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
1180 ibeta_inv(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_inv(a, b, p, Policy()); }\
1181\
1182 template <class T1, class T2, class T3, class T4>\
1183 inline typename boost::math::tools::promote_args<T1, T2, T3, T4>::type \
1184 ibetac_inv(T1 a, T2 b, T3 q, T4* py){ return ::boost::math::ibetac_inv(a, b, q, py, Policy()); }\
1185\
1186 template <class RT1, class RT2, class RT3>\
1187 inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
1188 ibeta_inva(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_inva(a, b, p, Policy()); }\
1189\
1190 template <class T1, class T2, class T3>\
1191 inline typename boost::math::tools::promote_args<T1, T2, T3>::type \
1192 ibetac_inva(T1 a, T2 b, T3 q){ return ::boost::math::ibetac_inva(a, b, q, Policy()); }\
1193\
1194 template <class RT1, class RT2, class RT3>\
1195 inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
1196 ibeta_invb(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_invb(a, b, p, Policy()); }\
1197\
1198 template <class T1, class T2, class T3>\
1199 inline typename boost::math::tools::promote_args<T1, T2, T3>::type \
1200 ibetac_invb(T1 a, T2 b, T3 q){ return ::boost::math::ibetac_invb(a, b, q, Policy()); }\
1201\
1202 template <class RT1, class RT2, class RT3>\
1203 inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
1204 ibetac_inv(RT1 a, RT2 b, RT3 q){ return ::boost::math::ibetac_inv(a, b, q, Policy()); }\
1205\
1206 template <class RT1, class RT2, class RT3>\
1207 inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
1208 ibeta_derivative(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibeta_derivative(a, b, x, Policy()); }\
1209\
1210 template <class T> T binomial_coefficient(unsigned n, unsigned k){ return ::boost::math::binomial_coefficient<T, Policy>(n, k, Policy()); }\
1211\
1212 template <class RT>\
1213 inline typename boost::math::tools::promote_args<RT>::type erf(RT z) { return ::boost::math::erf(z, Policy()); }\
1214\
1215 template <class RT>\
1216 inline typename boost::math::tools::promote_args<RT>::type erfc(RT z){ return ::boost::math::erfc(z, Policy()); }\
1217\
1218 template <class RT>\
1219 inline typename boost::math::tools::promote_args<RT>::type erf_inv(RT z) { return ::boost::math::erf_inv(z, Policy()); }\
1220\
1221 template <class RT>\
1222 inline typename boost::math::tools::promote_args<RT>::type erfc_inv(RT z){ return ::boost::math::erfc_inv(z, Policy()); }\
1223\
1224 using boost::math::legendre_next;\
1225\
1226 template <class T>\
1227 inline typename boost::math::tools::promote_args<T>::type \
1228 legendre_p(int l, T x){ return ::boost::math::legendre_p(l, x, Policy()); }\
b32b8144
FG		 1229\
1230 template <class T>\
1231 inline typename boost::math::tools::promote_args<T>::type \
1232 legendre_p_prime(int l, T x){ return ::boost::math::legendre_p(l, x, Policy()); }\
7c673cae
FG		 1233\
1234 template <class T>\
1235 inline typename boost::math::tools::promote_args<T>::type \
1236 legendre_q(unsigned l, T x){ return ::boost::math::legendre_q(l, x, Policy()); }\
1237\
1238 using ::boost::math::legendre_next;\
1239\
1240 template <class T>\
1241 inline typename boost::math::tools::promote_args<T>::type \
1242 legendre_p(int l, int m, T x){ return ::boost::math::legendre_p(l, m, x, Policy()); }\
1243\
1244 using ::boost::math::laguerre_next;\
1245\
1246 template <class T>\
1247 inline typename boost::math::tools::promote_args<T>::type \
1248 laguerre(unsigned n, T x){ return ::boost::math::laguerre(n, x, Policy()); }\
1249\
1250 template <class T1, class T2>\
1251 inline typename boost::math::laguerre_result<T1, T2>::type \
1252 laguerre(unsigned n, T1 m, T2 x) { return ::boost::math::laguerre(n, m, x, Policy()); }\
1253\
1254 template <class T>\
1255 inline typename boost::math::tools::promote_args<T>::type \
1256 hermite(unsigned n, T x){ return ::boost::math::hermite(n, x, Policy()); }\
1257\
1258 using boost::math::hermite_next;\
b32b8144
FG		 1259\
1260 using boost::math::chebyshev_next;\
1261\
1262 template<class Real>\
1263 Real chebyshev_t(unsigned n, Real const & x){ return ::boost::math::chebyshev_t(n, x, Policy()); }\
1264\
1265 template<class Real>\
1266 Real chebyshev_u(unsigned n, Real const & x){ return ::boost::math::chebyshev_u(n, x, Policy()); }\
1267\
1268 template<class Real>\
1269 Real chebyshev_t_prime(unsigned n, Real const & x){ return ::boost::math::chebyshev_t_prime(n, x, Policy()); }\
1270\
1271 using ::boost::math::chebyshev_clenshaw_recurrence;\
7c673cae
FG		 1272\
1273 template <class T1, class T2>\
1274 inline std::complex<typename boost::math::tools::promote_args<T1, T2>::type> \
1275 spherical_harmonic(unsigned n, int m, T1 theta, T2 phi){ return boost::math::spherical_harmonic(n, m, theta, phi, Policy()); }\
1276\
1277 template <class T1, class T2>\
1278 inline typename boost::math::tools::promote_args<T1, T2>::type \
1279 spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi){ return ::boost::math::spherical_harmonic_r(n, m, theta, phi, Policy()); }\
1280\
1281 template <class T1, class T2>\
1282 inline typename boost::math::tools::promote_args<T1, T2>::type \
1283 spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi){ return boost::math::spherical_harmonic_i(n, m, theta, phi, Policy()); }\
1284\
1285 template <class T1, class T2, class Policy>\
1286 inline typename boost::math::tools::promote_args<T1, T2>::type \
1287 spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);\
1288\
1289 template <class T1, class T2, class T3>\
1290 inline typename boost::math::tools::promote_args<T1, T2, T3>::type \
1291 ellint_rf(T1 x, T2 y, T3 z){ return ::boost::math::ellint_rf(x, y, z, Policy()); }\
1292\
1293 template <class T1, class T2, class T3>\
1294 inline typename boost::math::tools::promote_args<T1, T2, T3>::type \
1295 ellint_rd(T1 x, T2 y, T3 z){ return ::boost::math::ellint_rd(x, y, z, Policy()); }\
1296\
1297 template <class T1, class T2>\
1298 inline typename boost::math::tools::promote_args<T1, T2>::type \
1299 ellint_rc(T1 x, T2 y){ return ::boost::math::ellint_rc(x, y, Policy()); }\
1300\
1301 template <class T1, class T2, class T3, class T4>\
1302 inline typename boost::math::tools::promote_args<T1, T2, T3, T4>::type \
1303 ellint_rj(T1 x, T2 y, T3 z, T4 p){ return boost::math::ellint_rj(x, y, z, p, Policy()); }\
1304\
1305 template <class T1, class T2, class T3>\
1306 inline typename boost::math::tools::promote_args<T1, T2, T3>::type \
1307 ellint_rg(T1 x, T2 y, T3 z){ return ::boost::math::ellint_rg(x, y, z, Policy()); }\
1308 \
1309 template <typename T>\
1310 inline typename boost::math::tools::promote_args<T>::type ellint_2(T k){ return boost::math::ellint_2(k, Policy()); }\
1311\
1312 template <class T1, class T2>\
1313 inline typename boost::math::tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi){ return boost::math::ellint_2(k, phi, Policy()); }\
1314\
1315 template <typename T>\
1316 inline typename boost::math::tools::promote_args<T>::type ellint_d(T k){ return boost::math::ellint_d(k, Policy()); }\
1317\
1318 template <class T1, class T2>\
1319 inline typename boost::math::tools::promote_args<T1, T2>::type ellint_d(T1 k, T2 phi){ return boost::math::ellint_d(k, phi, Policy()); }\
1320\
1321 template <class T1, class T2>\
1322 inline typename boost::math::tools::promote_args<T1, T2>::type jacobi_zeta(T1 k, T2 phi){ return boost::math::jacobi_zeta(k, phi, Policy()); }\
1323\
1324 template <class T1, class T2>\
1325 inline typename boost::math::tools::promote_args<T1, T2>::type heuman_lambda(T1 k, T2 phi){ return boost::math::heuman_lambda(k, phi, Policy()); }\
1326\
1327 template <typename T>\
1328 inline typename boost::math::tools::promote_args<T>::type ellint_1(T k){ return boost::math::ellint_1(k, Policy()); }\
1329\
1330 template <class T1, class T2>\
1331 inline typename boost::math::tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi){ return boost::math::ellint_1(k, phi, Policy()); }\
1332\
1333 template <class T1, class T2, class T3>\
1334 inline typename boost::math::tools::promote_args<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi){ return boost::math::ellint_3(k, v, phi, Policy()); }\
1335\
1336 template <class T1, class T2>\
1337 inline typename boost::math::tools::promote_args<T1, T2>::type ellint_3(T1 k, T2 v){ return boost::math::ellint_3(k, v, Policy()); }\
1338\
1339 using boost::math::max_factorial;\
1340 template <class RT>\
1341 inline RT factorial(unsigned int i) { return boost::math::factorial<RT>(i, Policy()); }\
1342 using boost::math::unchecked_factorial;\
1343 template <class RT>\
1344 inline RT double_factorial(unsigned i){ return boost::math::double_factorial<RT>(i, Policy()); }\
1345 template <class RT>\
1346 inline typename boost::math::tools::promote_args<RT>::type falling_factorial(RT x, unsigned n){ return boost::math::falling_factorial(x, n, Policy()); }\
1347 template <class RT>\
1348 inline typename boost::math::tools::promote_args<RT>::type rising_factorial(RT x, unsigned n){ return boost::math::rising_factorial(x, n, Policy()); }\
1349\
1350 template <class RT>\
1351 inline typename boost::math::tools::promote_args<RT>::type tgamma(RT z){ return boost::math::tgamma(z, Policy()); }\
1352\
1353 template <class RT>\
1354 inline typename boost::math::tools::promote_args<RT>::type tgamma1pm1(RT z){ return boost::math::tgamma1pm1(z, Policy()); }\
1355\
1356 template <class RT1, class RT2>\
1357 inline typename boost::math::tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z){ return boost::math::tgamma(a, z, Policy()); }\
1358\
1359 template <class RT>\
1360 inline typename boost::math::tools::promote_args<RT>::type lgamma(RT z, int* sign){ return boost::math::lgamma(z, sign, Policy()); }\
1361\
1362 template <class RT>\
1363 inline typename boost::math::tools::promote_args<RT>::type lgamma(RT x){ return boost::math::lgamma(x, Policy()); }\
1364\
1365 template <class RT1, class RT2>\
1366 inline typename boost::math::tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z){ return boost::math::tgamma_lower(a, z, Policy()); }\
1367\
1368 template <class RT1, class RT2>\
1369 inline typename boost::math::tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z){ return boost::math::gamma_q(a, z, Policy()); }\
1370\
1371 template <class RT1, class RT2>\
1372 inline typename boost::math::tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z){ return boost::math::gamma_p(a, z, Policy()); }\
1373\
1374 template <class T1, class T2>\
1375 inline typename boost::math::tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta){ return boost::math::tgamma_delta_ratio(z, delta, Policy()); }\
1376\
1377 template <class T1, class T2>\
1378 inline typename boost::math::tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b) { return boost::math::tgamma_ratio(a, b, Policy()); }\
1379\
1380 template <class T1, class T2>\
1381 inline typename boost::math::tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x){ return boost::math::gamma_p_derivative(a, x, Policy()); }\
1382\
1383 template <class T1, class T2>\
1384 inline typename boost::math::tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p){ return boost::math::gamma_p_inv(a, p, Policy()); }\
1385\
1386 template <class T1, class T2>\
1387 inline typename boost::math::tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p){ return boost::math::gamma_p_inva(a, p, Policy()); }\
1388\
1389 template <class T1, class T2>\
1390 inline typename boost::math::tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q){ return boost::math::gamma_q_inv(a, q, Policy()); }\
1391\
1392 template <class T1, class T2>\
1393 inline typename boost::math::tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q){ return boost::math::gamma_q_inva(a, q, Policy()); }\
1394\
1395 template <class T>\
1396 inline typename boost::math::tools::promote_args<T>::type digamma(T x){ return boost::math::digamma(x, Policy()); }\
1397\
1398 template <class T>\
1399 inline typename boost::math::tools::promote_args<T>::type trigamma(T x){ return boost::math::trigamma(x, Policy()); }\
1400\
1401 template <class T>\
1402 inline typename boost::math::tools::promote_args<T>::type polygamma(int n, T x){ return boost::math::polygamma(n, x, Policy()); }\
1403 \
1404 template <class T1, class T2>\
1405 inline typename boost::math::tools::promote_args<T1, T2>::type \
1406 hypot(T1 x, T2 y){ return boost::math::hypot(x, y, Policy()); }\
1407\
1408 template <class RT>\
1409 inline typename boost::math::tools::promote_args<RT>::type cbrt(RT z){ return boost::math::cbrt(z, Policy()); }\
1410\
1411 template <class T>\
1412 inline typename boost::math::tools::promote_args<T>::type log1p(T x){ return boost::math::log1p(x, Policy()); }\
1413\
1414 template <class T>\
1415 inline typename boost::math::tools::promote_args<T>::type log1pmx(T x){ return boost::math::log1pmx(x, Policy()); }\
1416\
1417 template <class T>\
1418 inline typename boost::math::tools::promote_args<T>::type expm1(T x){ return boost::math::expm1(x, Policy()); }\
1419\
1420 template <class T1, class T2>\
1421 inline typename boost::math::tools::promote_args<T1, T2>::type \
1422 powm1(const T1 a, const T2 z){ return boost::math::powm1(a, z, Policy()); }\
1423\
1424 template <class T>\
1425 inline typename boost::math::tools::promote_args<T>::type sqrt1pm1(const T& val){ return boost::math::sqrt1pm1(val, Policy()); }\
1426\
1427 template <class T>\
1428 inline typename boost::math::tools::promote_args<T>::type sinc_pi(T x){ return boost::math::sinc_pi(x, Policy()); }\
1429\
1430 template <class T>\
1431 inline typename boost::math::tools::promote_args<T>::type sinhc_pi(T x){ return boost::math::sinhc_pi(x, Policy()); }\
1432\
1433 template<typename T>\
1434 inline typename boost::math::tools::promote_args<T>::type asinh(const T x){ return boost::math::asinh(x, Policy()); }\
1435\
1436 template<typename T>\
1437 inline typename boost::math::tools::promote_args<T>::type acosh(const T x){ return boost::math::acosh(x, Policy()); }\
1438\
1439 template<typename T>\
1440 inline typename boost::math::tools::promote_args<T>::type atanh(const T x){ return boost::math::atanh(x, Policy()); }\
1441\
1442 template <class T1, class T2>\
1443 inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type cyl_bessel_j(T1 v, T2 x)\
1444 { return boost::math::cyl_bessel_j(v, x, Policy()); }\
1445\
1446 template <class T1, class T2>\
1447 inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type cyl_bessel_j_prime(T1 v, T2 x)\
1448 { return boost::math::cyl_bessel_j_prime(v, x, Policy()); }\
1449\
1450 template <class T>\
1451 inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type sph_bessel(unsigned v, T x)\
1452 { return boost::math::sph_bessel(v, x, Policy()); }\
1453\
1454 template <class T>\
1455 inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type sph_bessel_prime(unsigned v, T x)\
1456 { return boost::math::sph_bessel_prime(v, x, Policy()); }\
1457\
1458 template <class T1, class T2>\
1459 inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1460 cyl_bessel_i(T1 v, T2 x) { return boost::math::cyl_bessel_i(v, x, Policy()); }\
1461\
1462 template <class T1, class T2>\
1463 inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1464 cyl_bessel_i_prime(T1 v, T2 x) { return boost::math::cyl_bessel_i_prime(v, x, Policy()); }\
1465\
1466 template <class T1, class T2>\
1467 inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1468 cyl_bessel_k(T1 v, T2 x) { return boost::math::cyl_bessel_k(v, x, Policy()); }\
1469\
1470 template <class T1, class T2>\
1471 inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1472 cyl_bessel_k_prime(T1 v, T2 x) { return boost::math::cyl_bessel_k_prime(v, x, Policy()); }\
1473\
1474 template <class T1, class T2>\
1475 inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1476 cyl_neumann(T1 v, T2 x){ return boost::math::cyl_neumann(v, x, Policy()); }\
1477\
1478 template <class T1, class T2>\
1479 inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1480 cyl_neumann_prime(T1 v, T2 x){ return boost::math::cyl_neumann_prime(v, x, Policy()); }\
1481\
1482 template <class T>\
1483 inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type \
1484 sph_neumann(unsigned v, T x){ return boost::math::sph_neumann(v, x, Policy()); }\
1485\
1486 template <class T>\
1487 inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type \
1488 sph_neumann_prime(unsigned v, T x){ return boost::math::sph_neumann_prime(v, x, Policy()); }\
1489\
1490 template <class T>\
1491 inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type cyl_bessel_j_zero(T v, int m)\
1492 { return boost::math::cyl_bessel_j_zero(v, m, Policy()); }\
1493\
1494template <class OutputIterator, class T>\
1495 inline void cyl_bessel_j_zero(T v,\
1496 int start_index,\
1497 unsigned number_of_zeros,\
1498 OutputIterator out_it)\
1499 { boost::math::cyl_bessel_j_zero(v, start_index, number_of_zeros, out_it, Policy()); }\
1500\
1501 template <class T>\
1502 inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type cyl_neumann_zero(T v, int m)\
1503 { return boost::math::cyl_neumann_zero(v, m, Policy()); }\
1504\
1505template <class OutputIterator, class T>\
1506 inline void cyl_neumann_zero(T v,\
1507 int start_index,\
1508 unsigned number_of_zeros,\
1509 OutputIterator out_it)\
1510 { boost::math::cyl_neumann_zero(v, start_index, number_of_zeros, out_it, Policy()); }\
1511\
1512 template <class T>\
1513 inline typename boost::math::tools::promote_args<T>::type sin_pi(T x){ return boost::math::sin_pi(x); }\
1514\
1515 template <class T>\
1516 inline typename boost::math::tools::promote_args<T>::type cos_pi(T x){ return boost::math::cos_pi(x); }\
1517\
1518 using boost::math::fpclassify;\
1519 using boost::math::isfinite;\
1520 using boost::math::isinf;\
1521 using boost::math::isnan;\
1522 using boost::math::isnormal;\
1523 using boost::math::signbit;\
1524 using boost::math::sign;\
1525 using boost::math::copysign;\
1526 using boost::math::changesign;\
1527 \
1528 template <class T, class U>\
1529 inline typename boost::math::tools::promote_args<T,U>::type expint(T const& z, U const& u)\
1530 { return boost::math::expint(z, u, Policy()); }\
1531 \
1532 template <class T>\
1533 inline typename boost::math::tools::promote_args<T>::type expint(T z){ return boost::math::expint(z, Policy()); }\
1534 \
1535 template <class T>\
1536 inline typename boost::math::tools::promote_args<T>::type zeta(T s){ return boost::math::zeta(s, Policy()); }\
1537 \
1538 template <class T>\
1539 inline T round(const T& v){ using boost::math::round; return round(v, Policy()); }\
1540 \
1541 template <class T>\
1542 inline int iround(const T& v){ using boost::math::iround; return iround(v, Policy()); }\
1543 \
1544 template <class T>\
1545 inline long lround(const T& v){ using boost::math::lround; return lround(v, Policy()); }\
1546 \
1547 template <class T>\
1548 inline T trunc(const T& v){ using boost::math::trunc; return trunc(v, Policy()); }\
1549 \
1550 template <class T>\
1551 inline int itrunc(const T& v){ using boost::math::itrunc; return itrunc(v, Policy()); }\
1552 \
1553 template <class T>\
1554 inline long ltrunc(const T& v){ using boost::math::ltrunc; return ltrunc(v, Policy()); }\
1555 \
1556 template <class T>\
1557 inline T modf(const T& v, T* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
1558 \
1559 template <class T>\
1560 inline T modf(const T& v, int* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
1561 \
1562 template <class T>\
1563 inline T modf(const T& v, long* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
1564 \
1565 template <int N, class T>\
1566 inline typename boost::math::tools::promote_args<T>::type pow(T v){ return boost::math::pow<N>(v, Policy()); }\
1567 \
1568 template <class T> T nextafter(const T& a, const T& b){ return boost::math::nextafter(a, b, Policy()); }\
1569 template <class T> T float_next(const T& a){ return boost::math::float_next(a, Policy()); }\
1570 template <class T> T float_prior(const T& a){ return boost::math::float_prior(a, Policy()); }\
1571 template <class T> T float_distance(const T& a, const T& b){ return boost::math::float_distance(a, b, Policy()); }\
1572 template <class T> T ulp(const T& a){ return boost::math::ulp(a, Policy()); }\
1573 \
1574 template <class RT1, class RT2>\
1575 inline typename boost::math::tools::promote_args<RT1, RT2>::type owens_t(RT1 a, RT2 z){ return boost::math::owens_t(a, z, Policy()); }\
1576 \
1577 template <class T1, class T2>\
1578 inline std::complex<typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type> cyl_hankel_1(T1 v, T2 x)\
1579 { return boost::math::cyl_hankel_1(v, x, Policy()); }\
1580 \
1581 template <class T1, class T2>\
1582 inline std::complex<typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type> cyl_hankel_2(T1 v, T2 x)\
1583 { return boost::math::cyl_hankel_2(v, x, Policy()); }\
1584 \
1585 template <class T1, class T2>\
1586 inline std::complex<typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type> sph_hankel_1(T1 v, T2 x)\
1587 { return boost::math::sph_hankel_1(v, x, Policy()); }\
1588 \
1589 template <class T1, class T2>\
1590 inline std::complex<typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type> sph_hankel_2(T1 v, T2 x)\
1591 { return boost::math::sph_hankel_2(v, x, Policy()); }\
1592 \
1593 template <class T>\
1594 inline typename boost::math::tools::promote_args<T>::type jacobi_elliptic(T k, T theta, T* pcn, T* pdn)\
1595 { return boost::math::jacobi_elliptic(k, theta, pcn, pdn, Policy()); }\
1596 \
1597 template <class U, class T>\
1598 inline typename boost::math::tools::promote_args<T, U>::type jacobi_sn(U k, T theta)\
1599 { return boost::math::jacobi_sn(k, theta, Policy()); }\
1600 \
1601 template <class T, class U>\
1602 inline typename boost::math::tools::promote_args<T, U>::type jacobi_cn(T k, U theta)\
1603 { return boost::math::jacobi_cn(k, theta, Policy()); }\
1604 \
1605 template <class T, class U>\
1606 inline typename boost::math::tools::promote_args<T, U>::type jacobi_dn(T k, U theta)\
1607 { return boost::math::jacobi_dn(k, theta, Policy()); }\
1608 \
1609 template <class T, class U>\
1610 inline typename boost::math::tools::promote_args<T, U>::type jacobi_cd(T k, U theta)\
1611 { return boost::math::jacobi_cd(k, theta, Policy()); }\
1612 \
1613 template <class T, class U>\
1614 inline typename boost::math::tools::promote_args<T, U>::type jacobi_dc(T k, U theta)\
1615 { return boost::math::jacobi_dc(k, theta, Policy()); }\
1616 \
1617 template <class T, class U>\
1618 inline typename boost::math::tools::promote_args<T, U>::type jacobi_ns(T k, U theta)\
1619 { return boost::math::jacobi_ns(k, theta, Policy()); }\
1620 \
1621 template <class T, class U>\
1622 inline typename boost::math::tools::promote_args<T, U>::type jacobi_sd(T k, U theta)\
1623 { return boost::math::jacobi_sd(k, theta, Policy()); }\
1624 \
1625 template <class T, class U>\
1626 inline typename boost::math::tools::promote_args<T, U>::type jacobi_ds(T k, U theta)\
1627 { return boost::math::jacobi_ds(k, theta, Policy()); }\
1628 \
1629 template <class T, class U>\
1630 inline typename boost::math::tools::promote_args<T, U>::type jacobi_nc(T k, U theta)\
1631 { return boost::math::jacobi_nc(k, theta, Policy()); }\
1632 \
1633 template <class T, class U>\
1634 inline typename boost::math::tools::promote_args<T, U>::type jacobi_nd(T k, U theta)\
1635 { return boost::math::jacobi_nd(k, theta, Policy()); }\
1636 \
1637 template <class T, class U>\
1638 inline typename boost::math::tools::promote_args<T, U>::type jacobi_sc(T k, U theta)\
1639 { return boost::math::jacobi_sc(k, theta, Policy()); }\
1640 \
1641 template <class T, class U>\
1642 inline typename boost::math::tools::promote_args<T, U>::type jacobi_cs(T k, U theta)\
1643 { return boost::math::jacobi_cs(k, theta, Policy()); }\
1644 \
1645 template <class T>\
1646 inline typename boost::math::tools::promote_args<T>::type airy_ai(T x)\
1647 { return boost::math::airy_ai(x, Policy()); }\
1648 \
1649 template <class T>\
1650 inline typename boost::math::tools::promote_args<T>::type airy_bi(T x)\
1651 { return boost::math::airy_bi(x, Policy()); }\
1652 \
1653 template <class T>\
1654 inline typename boost::math::tools::promote_args<T>::type airy_ai_prime(T x)\
1655 { return boost::math::airy_ai_prime(x, Policy()); }\
1656 \
1657 template <class T>\
1658 inline typename boost::math::tools::promote_args<T>::type airy_bi_prime(T x)\
1659 { return boost::math::airy_bi_prime(x, Policy()); }\
1660 \
1661 template <class T>\
1662 inline T airy_ai_zero(int m)\
1663 { return boost::math::airy_ai_zero<T>(m, Policy()); }\
1664 template <class T, class OutputIterator>\
1665 OutputIterator airy_ai_zero(int start_index, unsigned number_of_zeros, OutputIterator out_it)\
1666 { return boost::math::airy_ai_zero<T>(start_index, number_of_zeros, out_it, Policy()); }\
1667 \
1668 template <class T>\
1669 inline T airy_bi_zero(int m)\
1670 { return boost::math::airy_bi_zero<T>(m, Policy()); }\
1671 template <class T, class OutputIterator>\
1672 OutputIterator airy_bi_zero(int start_index, unsigned number_of_zeros, OutputIterator out_it)\
1673 { return boost::math::airy_bi_zero<T>(start_index, number_of_zeros, out_it, Policy()); }\
1674 \
1675 template <class T>\
1676 T bernoulli_b2n(const int i)\
1677 { return boost::math::bernoulli_b2n<T>(i, Policy()); }\
1678 template <class T, class OutputIterator>\
1679 OutputIterator bernoulli_b2n(int start_index, unsigned number_of_bernoullis_b2n, OutputIterator out_it)\
1680 { return boost::math::bernoulli_b2n<T>(start_index, number_of_bernoullis_b2n, out_it, Policy()); }\
1681 \
1682 template <class T>\
1683 T tangent_t2n(const int i)\
1684 { return boost::math::tangent_t2n<T>(i, Policy()); }\
1685 template <class T, class OutputIterator>\
1686 OutputIterator tangent_t2n(int start_index, unsigned number_of_bernoullis_b2n, OutputIterator out_it)\
1687 { return boost::math::tangent_t2n<T>(start_index, number_of_bernoullis_b2n, out_it, Policy()); }\
1688 \
92f5a8d4
TL		 1689 template <class T> inline typename boost::math::tools::promote_args<T>::type lambert_w0(T z) { return boost::math::lambert_w0(z, Policy()); }\
1690 template <class T> inline typename boost::math::tools::promote_args<T>::type lambert_wm1(T z) { return boost::math::lambert_w0(z, Policy()); }\
1691 template <class T> inline typename boost::math::tools::promote_args<T>::type lambert_w0_prime(T z) { return boost::math::lambert_w0(z, Policy()); }\
1692 template <class T> inline typename boost::math::tools::promote_args<T>::type lambert_wm1_prime(T z) { return boost::math::lambert_w0(z, Policy()); }\
1693 \
1694 template <class T, class U>\
1695 inline typename boost::math::tools::promote_args<T, U>::type hypergeometric_1F0(const T& a, const U& z)\
1696 { return boost::math::hypergeometric_1F0(a, z, Policy()); }\
1697 \
1698 template <class T, class U>\
1699 inline typename boost::math::tools::promote_args<T, U>::type hypergeometric_0F1(const T& a, const U& z)\
1700 { return boost::math::hypergeometric_0F1(a, z, Policy()); }\
1701 \
1702 template <class T, class U, class V>\
1703 inline typename boost::math::tools::promote_args<T, U>::type hypergeometric_2F0(const T& a1, const U& a2, const V& z)\
1704 { return boost::math::hypergeometric_2F0(a1, a2, z, Policy()); }\
1705 \
1706
7c673cae
FG		 1707
1708
1709
1710
1711
1712#endif // BOOST_MATH_SPECIAL_MATH_FWD_HPP
Ceph