Debian Codegraph @

third-party/boost-math/include/boost/math/special_functions/math_fwd.hpp

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