Gitiles
Code Review Sign In
gerrit.named-data.net / ndn-cxx / 1cf72e9bf879a166ecd338c157e4d37979db720c / . / ndnboost / math / special_functions / math_fwd.hpp
blob: aeb7b4c18a6611bf973b50a43dc5fb61ac9895c7 [file] [log] [blame]
Jeff Thompsonef2d5a42013-08-22 19:09:24 -0700[diff] [blame]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
26#include <ndnboost/math/special_functions/detail/round_fwd.hpp>
27#include <ndnboost/math/tools/promotion.hpp> // for argument promotion.
28#include <ndnboost/math/policies/policy.hpp>
29#include <ndnboost/mpl/comparison.hpp>
30#include <ndnboost/config/no_tr1/complex.hpp>
31
32#define BOOST_NO_MACRO_EXPAND /**/
33
34namespace ndnboost
35{
36 namespace math
37 { // Math functions (in roughly alphabetic order).
38
39 // Beta functions.
40 template <class RT1, class RT2>
41 typename tools::promote_args<RT1, RT2>::type
42 beta(RT1 a, RT2 b); // Beta function (2 arguments).
43
44 template <class RT1, class RT2, class A>
45 typename tools::promote_args<RT1, RT2, A>::type
46 beta(RT1 a, RT2 b, A x); // Beta function (3 arguments).
47
48 template <class RT1, class RT2, class RT3, class Policy>
49 typename tools::promote_args<RT1, RT2, RT3>::type
50 beta(RT1 a, RT2 b, RT3 x, const Policy& pol); // Beta function (3 arguments).
51
52 template <class RT1, class RT2, class RT3>
53 typename tools::promote_args<RT1, RT2, RT3>::type
54 betac(RT1 a, RT2 b, RT3 x);
55
56 template <class RT1, class RT2, class RT3, class Policy>
57 typename tools::promote_args<RT1, RT2, RT3>::type
58 betac(RT1 a, RT2 b, RT3 x, const Policy& pol);
59
60 template <class RT1, class RT2, class RT3>
61 typename tools::promote_args<RT1, RT2, RT3>::type
62 ibeta(RT1 a, RT2 b, RT3 x); // Incomplete beta function.
63
64 template <class RT1, class RT2, class RT3, class Policy>
65 typename tools::promote_args<RT1, RT2, RT3>::type
66 ibeta(RT1 a, RT2 b, RT3 x, const Policy& pol); // Incomplete beta function.
67
68 template <class RT1, class RT2, class RT3>
69 typename tools::promote_args<RT1, RT2, RT3>::type
70 ibetac(RT1 a, RT2 b, RT3 x); // Incomplete beta complement function.
71
72 template <class RT1, class RT2, class RT3, class Policy>
73 typename tools::promote_args<RT1, RT2, RT3>::type
74 ibetac(RT1 a, RT2 b, RT3 x, const Policy& pol); // Incomplete beta complement function.
75
76 template <class T1, class T2, class T3, class T4>
77 typename tools::promote_args<T1, T2, T3, T4>::type
78 ibeta_inv(T1 a, T2 b, T3 p, T4* py);
79
80 template <class T1, class T2, class T3, class T4, class Policy>
81 typename tools::promote_args<T1, T2, T3, T4>::type
82 ibeta_inv(T1 a, T2 b, T3 p, T4* py, const Policy& pol);
83
84 template <class RT1, class RT2, class RT3>
85 typename tools::promote_args<RT1, RT2, RT3>::type
86 ibeta_inv(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function.
87
88 template <class RT1, class RT2, class RT3, class Policy>
89 typename tools::promote_args<RT1, RT2, RT3>::type
90 ibeta_inv(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function.
91
92 template <class RT1, class RT2, class RT3>
93 typename tools::promote_args<RT1, RT2, RT3>::type
94 ibeta_inva(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function.
95
96 template <class RT1, class RT2, class RT3, class Policy>
97 typename tools::promote_args<RT1, RT2, RT3>::type
98 ibeta_inva(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function.
99
100 template <class RT1, class RT2, class RT3>
101 typename tools::promote_args<RT1, RT2, RT3>::type
102 ibeta_invb(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function.
103
104 template <class RT1, class RT2, class RT3, class Policy>
105 typename tools::promote_args<RT1, RT2, RT3>::type
106 ibeta_invb(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function.
107
108 template <class T1, class T2, class T3, class T4>
109 typename tools::promote_args<T1, T2, T3, T4>::type
110 ibetac_inv(T1 a, T2 b, T3 q, T4* py);
111
112 template <class T1, class T2, class T3, class T4, class Policy>
113 typename tools::promote_args<T1, T2, T3, T4>::type
114 ibetac_inv(T1 a, T2 b, T3 q, T4* py, const Policy& pol);
115
116 template <class RT1, class RT2, class RT3>
117 typename tools::promote_args<RT1, RT2, RT3>::type
118 ibetac_inv(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function.
119
120 template <class RT1, class RT2, class RT3, class Policy>
121 typename tools::promote_args<RT1, RT2, RT3>::type
122 ibetac_inv(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function.
123
124 template <class RT1, class RT2, class RT3>
125 typename tools::promote_args<RT1, RT2, RT3>::type
126 ibetac_inva(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function.
127
128 template <class RT1, class RT2, class RT3, class Policy>
129 typename tools::promote_args<RT1, RT2, RT3>::type
130 ibetac_inva(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function.
131
132 template <class RT1, class RT2, class RT3>
133 typename tools::promote_args<RT1, RT2, RT3>::type
134 ibetac_invb(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function.
135
136 template <class RT1, class RT2, class RT3, class Policy>
137 typename tools::promote_args<RT1, RT2, RT3>::type
138 ibetac_invb(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function.
139
140 template <class RT1, class RT2, class RT3>
141 typename tools::promote_args<RT1, RT2, RT3>::type
142 ibeta_derivative(RT1 a, RT2 b, RT3 x); // derivative of incomplete beta
143
144 template <class RT1, class RT2, class RT3, class Policy>
145 typename tools::promote_args<RT1, RT2, RT3>::type
146 ibeta_derivative(RT1 a, RT2 b, RT3 x, const Policy& pol); // derivative of incomplete beta
147
148 // erf & erfc error functions.
149 template <class RT> // Error function.
150 typename tools::promote_args<RT>::type erf(RT z);
151 template <class RT, class Policy> // Error function.
152 typename tools::promote_args<RT>::type erf(RT z, const Policy&);
153
154 template <class RT>// Error function complement.
155 typename tools::promote_args<RT>::type erfc(RT z);
156 template <class RT, class Policy>// Error function complement.
157 typename tools::promote_args<RT>::type erfc(RT z, const Policy&);
158
159 template <class RT>// Error function inverse.
160 typename tools::promote_args<RT>::type erf_inv(RT z);
161 template <class RT, class Policy>// Error function inverse.
162 typename tools::promote_args<RT>::type erf_inv(RT z, const Policy& pol);
163
164 template <class RT>// Error function complement inverse.
165 typename tools::promote_args<RT>::type erfc_inv(RT z);
166 template <class RT, class Policy>// Error function complement inverse.
167 typename tools::promote_args<RT>::type erfc_inv(RT z, const Policy& pol);
168
169 // Polynomials:
170 template <class T1, class T2, class T3>
171 typename tools::promote_args<T1, T2, T3>::type
172 legendre_next(unsigned l, T1 x, T2 Pl, T3 Plm1);
173
174 template <class T>
175 typename tools::promote_args<T>::type
176 legendre_p(int l, T x);
177
178 template <class T, class Policy>
179 typename tools::promote_args<T>::type
180 legendre_p(int l, T x, const Policy& pol);
181
182 template <class T>
183 typename tools::promote_args<T>::type
184 legendre_q(unsigned l, T x);
185
186 template <class T, class Policy>
187 typename tools::promote_args<T>::type
188 legendre_q(unsigned l, T x, const Policy& pol);
189
190 template <class T1, class T2, class T3>
191 typename tools::promote_args<T1, T2, T3>::type
192 legendre_next(unsigned l, unsigned m, T1 x, T2 Pl, T3 Plm1);
193
194 template <class T>
195 typename tools::promote_args<T>::type
196 legendre_p(int l, int m, T x);
197
198 template <class T, class Policy>
199 typename tools::promote_args<T>::type
200 legendre_p(int l, int m, T x, const Policy& pol);
201
202 template <class T1, class T2, class T3>
203 typename tools::promote_args<T1, T2, T3>::type
204 laguerre_next(unsigned n, T1 x, T2 Ln, T3 Lnm1);
205
206 template <class T1, class T2, class T3>
207 typename tools::promote_args<T1, T2, T3>::type
208 laguerre_next(unsigned n, unsigned l, T1 x, T2 Pl, T3 Plm1);
209
210 template <class T>
211 typename tools::promote_args<T>::type
212 laguerre(unsigned n, T x);
213
214 template <class T, class Policy>
215 typename tools::promote_args<T>::type
216 laguerre(unsigned n, unsigned m, T x, const Policy& pol);
217
218 template <class T1, class T2>
219 struct laguerre_result
220 {
221 typedef typename mpl::if_<
222 policies::is_policy<T2>,
223 typename tools::promote_args<T1>::type,
224 typename tools::promote_args<T2>::type
225 >::type type;
226 };
227
228 template <class T1, class T2>
229 typename laguerre_result<T1, T2>::type
230 laguerre(unsigned n, T1 m, T2 x);
231
232 template <class T>
233 typename tools::promote_args<T>::type
234 hermite(unsigned n, T x);
235
236 template <class T, class Policy>
237 typename tools::promote_args<T>::type
238 hermite(unsigned n, T x, const Policy& pol);
239
240 template <class T1, class T2, class T3>
241 typename tools::promote_args<T1, T2, T3>::type
242 hermite_next(unsigned n, T1 x, T2 Hn, T3 Hnm1);
243
244 template <class T1, class T2>
245 std::complex<typename tools::promote_args<T1, T2>::type>
246 spherical_harmonic(unsigned n, int m, T1 theta, T2 phi);
247
248 template <class T1, class T2, class Policy>
249 std::complex<typename tools::promote_args<T1, T2>::type>
250 spherical_harmonic(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
251
252 template <class T1, class T2>
253 typename tools::promote_args<T1, T2>::type
254 spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi);
255
256 template <class T1, class T2, class Policy>
257 typename tools::promote_args<T1, T2>::type
258 spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
259
260 template <class T1, class T2>
261 typename tools::promote_args<T1, T2>::type
262 spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi);
263
264 template <class T1, class T2, class Policy>
265 typename tools::promote_args<T1, T2>::type
266 spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
267
268 // Elliptic integrals:
269 template <class T1, class T2, class T3>
270 typename tools::promote_args<T1, T2, T3>::type
271 ellint_rf(T1 x, T2 y, T3 z);
272
273 template <class T1, class T2, class T3, class Policy>
274 typename tools::promote_args<T1, T2, T3>::type
275 ellint_rf(T1 x, T2 y, T3 z, const Policy& pol);
276
277 template <class T1, class T2, class T3>
278 typename tools::promote_args<T1, T2, T3>::type
279 ellint_rd(T1 x, T2 y, T3 z);
280
281 template <class T1, class T2, class T3, class Policy>
282 typename tools::promote_args<T1, T2, T3>::type
283 ellint_rd(T1 x, T2 y, T3 z, const Policy& pol);
284
285 template <class T1, class T2>
286 typename tools::promote_args<T1, T2>::type
287 ellint_rc(T1 x, T2 y);
288
289 template <class T1, class T2, class Policy>
290 typename tools::promote_args<T1, T2>::type
291 ellint_rc(T1 x, T2 y, const Policy& pol);
292
293 template <class T1, class T2, class T3, class T4>
294 typename tools::promote_args<T1, T2, T3, T4>::type
295 ellint_rj(T1 x, T2 y, T3 z, T4 p);
296
297 template <class T1, class T2, class T3, class T4, class Policy>
298 typename tools::promote_args<T1, T2, T3, T4>::type
299 ellint_rj(T1 x, T2 y, T3 z, T4 p, const Policy& pol);
300
301 template <typename T>
302 typename tools::promote_args<T>::type ellint_2(T k);
303
304 template <class T1, class T2>
305 typename tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi);
306
307 template <class T1, class T2, class Policy>
308 typename tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi, const Policy& pol);
309
310 template <typename T>
311 typename tools::promote_args<T>::type ellint_1(T k);
312
313 template <class T1, class T2>
314 typename tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi);
315
316 template <class T1, class T2, class Policy>
317 typename tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi, const Policy& pol);
318
319 namespace detail{
320
321 template <class T, class U, class V>
322 struct ellint_3_result
323 {
324 typedef typename mpl::if_<
325 policies::is_policy<V>,
326 typename tools::promote_args<T, U>::type,
327 typename tools::promote_args<T, U, V>::type
328 >::type type;
329 };
330
331 } // namespace detail
332
333
334 template <class T1, class T2, class T3>
335 typename detail::ellint_3_result<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi);
336
337 template <class T1, class T2, class T3, class Policy>
338 typename tools::promote_args<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi, const Policy& pol);
339
340 template <class T1, class T2>
341 typename tools::promote_args<T1, T2>::type ellint_3(T1 k, T2 v);
342
343 // Factorial functions.
344 // Note: not for integral types, at present.
345 template <class RT>
346 struct max_factorial;
347 template <class RT>
348 RT factorial(unsigned int);
349 template <class RT, class Policy>
350 RT factorial(unsigned int, const Policy& pol);
351 template <class RT>
352 RT unchecked_factorial(unsigned int BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(RT));
353 template <class RT>
354 RT double_factorial(unsigned i);
355 template <class RT, class Policy>
356 RT double_factorial(unsigned i, const Policy& pol);
357
358 template <class RT>
359 typename tools::promote_args<RT>::type falling_factorial(RT x, unsigned n);
360
361 template <class RT, class Policy>
362 typename tools::promote_args<RT>::type falling_factorial(RT x, unsigned n, const Policy& pol);
363
364 template <class RT>
365 typename tools::promote_args<RT>::type rising_factorial(RT x, int n);
366
367 template <class RT, class Policy>
368 typename tools::promote_args<RT>::type rising_factorial(RT x, int n, const Policy& pol);
369
370 // Gamma functions.
371 template <class RT>
372 typename tools::promote_args<RT>::type tgamma(RT z);
373
374 template <class RT>
375 typename tools::promote_args<RT>::type tgamma1pm1(RT z);
376
377 template <class RT, class Policy>
378 typename tools::promote_args<RT>::type tgamma1pm1(RT z, const Policy& pol);
379
380 template <class RT1, class RT2>
381 typename tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z);
382
383 template <class RT1, class RT2, class Policy>
384 typename tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z, const Policy& pol);
385
386 template <class RT>
387 typename tools::promote_args<RT>::type lgamma(RT z, int* sign);
388
389 template <class RT, class Policy>
390 typename tools::promote_args<RT>::type lgamma(RT z, int* sign, const Policy& pol);
391
392 template <class RT>
393 typename tools::promote_args<RT>::type lgamma(RT x);
394
395 template <class RT, class Policy>
396 typename tools::promote_args<RT>::type lgamma(RT x, const Policy& pol);
397
398 template <class RT1, class RT2>
399 typename tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z);
400
401 template <class RT1, class RT2, class Policy>
402 typename tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z, const Policy&);
403
404 template <class RT1, class RT2>
405 typename tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z);
406
407 template <class RT1, class RT2, class Policy>
408 typename tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z, const Policy&);
409
410 template <class RT1, class RT2>
411 typename tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z);
412
413 template <class RT1, class RT2, class Policy>
414 typename tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z, const Policy&);
415
416 template <class T1, class T2>
417 typename tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta);
418
419 template <class T1, class T2, class Policy>
420 typename tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta, const Policy&);
421
422 template <class T1, class T2>
423 typename tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b);
424
425 template <class T1, class T2, class Policy>
426 typename tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b, const Policy&);
427
428 template <class T1, class T2>
429 typename tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x);
430
431 template <class T1, class T2, class Policy>
432 typename tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x, const Policy&);
433
434 // gamma inverse.
435 template <class T1, class T2>
436 typename tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p);
437
438 template <class T1, class T2, class Policy>
439 typename tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p, const Policy&);
440
441 template <class T1, class T2>
442 typename tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p);
443
444 template <class T1, class T2, class Policy>
445 typename tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p, const Policy&);
446
447 template <class T1, class T2>
448 typename tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q);
449
450 template <class T1, class T2, class Policy>
451 typename tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q, const Policy&);
452
453 template <class T1, class T2>
454 typename tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q);
455
456 template <class T1, class T2, class Policy>
457 typename tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q, const Policy&);
458
459 // digamma:
460 template <class T>
461 typename tools::promote_args<T>::type digamma(T x);
462
463 template <class T, class Policy>
464 typename tools::promote_args<T>::type digamma(T x, const Policy&);
465
466 // Hypotenuse function sqrt(x ^ 2 + y ^ 2).
467 template <class T1, class T2>
468 typename tools::promote_args<T1, T2>::type
469 hypot(T1 x, T2 y);
470
471 template <class T1, class T2, class Policy>
472 typename tools::promote_args<T1, T2>::type
473 hypot(T1 x, T2 y, const Policy&);
474
475 // cbrt - cube root.
476 template <class RT>
477 typename tools::promote_args<RT>::type cbrt(RT z);
478
479 template <class RT, class Policy>
480 typename tools::promote_args<RT>::type cbrt(RT z, const Policy&);
481
482 // log1p is log(x + 1)
483 template <class T>
484 typename tools::promote_args<T>::type log1p(T);
485
486 template <class T, class Policy>
487 typename tools::promote_args<T>::type log1p(T, const Policy&);
488
489 // log1pmx is log(x + 1) - x
490 template <class T>
491 typename tools::promote_args<T>::type log1pmx(T);
492
493 template <class T, class Policy>
494 typename tools::promote_args<T>::type log1pmx(T, const Policy&);
495
496 // Exp (x) minus 1 functions.
497 template <class T>
498 typename tools::promote_args<T>::type expm1(T);
499
500 template <class T, class Policy>
501 typename tools::promote_args<T>::type expm1(T, const Policy&);
502
503 // Power - 1
504 template <class T1, class T2>
505 typename tools::promote_args<T1, T2>::type
506 powm1(const T1 a, const T2 z);
507
508 template <class T1, class T2, class Policy>
509 typename tools::promote_args<T1, T2>::type
510 powm1(const T1 a, const T2 z, const Policy&);
511
512 // sqrt(1+x) - 1
513 template <class T>
514 typename tools::promote_args<T>::type sqrt1pm1(const T& val);
515
516 template <class T, class Policy>
517 typename tools::promote_args<T>::type sqrt1pm1(const T& val, const Policy&);
518
519 // sinus cardinals:
520 template <class T>
521 typename tools::promote_args<T>::type sinc_pi(T x);
522
523 template <class T, class Policy>
524 typename tools::promote_args<T>::type sinc_pi(T x, const Policy&);
525
526 template <class T>
527 typename tools::promote_args<T>::type sinhc_pi(T x);
528
529 template <class T, class Policy>
530 typename tools::promote_args<T>::type sinhc_pi(T x, const Policy&);
531
532 // inverse hyperbolics:
533 template<typename T>
534 typename tools::promote_args<T>::type asinh(T x);
535
536 template<typename T, class Policy>
537 typename tools::promote_args<T>::type asinh(T x, const Policy&);
538
539 template<typename T>
540 typename tools::promote_args<T>::type acosh(T x);
541
542 template<typename T, class Policy>
543 typename tools::promote_args<T>::type acosh(T x, const Policy&);
544
545 template<typename T>
546 typename tools::promote_args<T>::type atanh(T x);
547
548 template<typename T, class Policy>
549 typename tools::promote_args<T>::type atanh(T x, const Policy&);
550
551 namespace detail{
552
553 typedef mpl::int_<0> bessel_no_int_tag; // No integer optimisation possible.
554 typedef mpl::int_<1> bessel_maybe_int_tag; // Maybe integer optimisation.
555 typedef mpl::int_<2> bessel_int_tag; // Definite integer optimistaion.
556
557 template <class T1, class T2, class Policy>
558 struct bessel_traits
559 {
560 typedef typename tools::promote_args<
561 T1, T2
562 >::type result_type;
563
564 typedef typename policies::precision<result_type, Policy>::type precision_type;
565
566 typedef typename mpl::if_<
567 mpl::or_<
568 mpl::less_equal<precision_type, mpl::int_<0> >,
569 mpl::greater<precision_type, mpl::int_<64> > >,
570 bessel_no_int_tag,
571 typename mpl::if_<
572 is_integral<T1>,
573 bessel_int_tag,
574 bessel_maybe_int_tag
575 >::type
576 >::type optimisation_tag;
577 };
578 } // detail
579
580 // Bessel functions:
581 template <class T1, class T2, class Policy>
582 typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_j(T1 v, T2 x, const Policy& pol);
583
584 template <class T1, class T2>
585 typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_j(T1 v, T2 x);
586
587 template <class T, class Policy>
588 typename detail::bessel_traits<T, T, Policy>::result_type sph_bessel(unsigned v, T x, const Policy& pol);
589
590 template <class T>
591 typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_bessel(unsigned v, T x);
592
593 template <class T1, class T2, class Policy>
594 typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_i(T1 v, T2 x, const Policy& pol);
595
596 template <class T1, class T2>
597 typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_i(T1 v, T2 x);
598
599 template <class T1, class T2, class Policy>
600 typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_k(T1 v, T2 x, const Policy& pol);
601
602 template <class T1, class T2>
603 typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_k(T1 v, T2 x);
604
605 template <class T1, class T2, class Policy>
606 typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_neumann(T1 v, T2 x, const Policy& pol);
607
608 template <class T1, class T2>
609 typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_neumann(T1 v, T2 x);
610
611 template <class T, class Policy>
612 typename detail::bessel_traits<T, T, Policy>::result_type sph_neumann(unsigned v, T x, const Policy& pol);
613
614 template <class T>
615 typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_neumann(unsigned v, T x);
616
617 template <class T, class Policy>
618 typename detail::bessel_traits<T, T, Policy>::result_type cyl_bessel_j_zero(T v, int m, const Policy& pol);
619
620 template <class T>
621 typename detail::bessel_traits<T, T, policies::policy<> >::result_type cyl_bessel_j_zero(T v, int m);
622
623 template <class T, class OutputIterator>
624 OutputIterator cyl_bessel_j_zero(T v,
625 int start_index,
626 unsigned number_of_zeros,
627 OutputIterator out_it);
628
629 template <class T, class OutputIterator, class Policy>
630 OutputIterator cyl_bessel_j_zero(T v,
631 int start_index,
632 unsigned number_of_zeros,
633 OutputIterator out_it,
634 const Policy&);
635
636 template <class T, class Policy>
637 typename detail::bessel_traits<T, T, Policy>::result_type cyl_neumann_zero(T v, int m, const Policy& pol);
638
639 template <class T>
640 typename detail::bessel_traits<T, T, policies::policy<> >::result_type cyl_neumann_zero(T v, int m);
641
642 template <class T, class OutputIterator>
643 OutputIterator cyl_neumann_zero(T v,
644 int start_index,
645 unsigned number_of_zeros,
646 OutputIterator out_it);
647
648 template <class T, class OutputIterator, class Policy>
649 OutputIterator cyl_neumann_zero(T v,
650 int start_index,
651 unsigned number_of_zeros,
652 OutputIterator out_it,
653 const Policy&);
654
655 template <class T1, class T2>
656 std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> cyl_hankel_1(T1 v, T2 x);
657
658 template <class T1, class T2, class Policy>
659 std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> cyl_hankel_1(T1 v, T2 x, const Policy& pol);
660
661 template <class T1, class T2, class Policy>
662 std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> cyl_hankel_2(T1 v, T2 x, const Policy& pol);
663
664 template <class T1, class T2>
665 std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> cyl_hankel_2(T1 v, T2 x);
666
667 template <class T1, class T2, class Policy>
668 std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> sph_hankel_1(T1 v, T2 x, const Policy& pol);
669
670 template <class T1, class T2>
671 std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> sph_hankel_1(T1 v, T2 x);
672
673 template <class T1, class T2, class Policy>
674 std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> sph_hankel_2(T1 v, T2 x, const Policy& pol);
675
676 template <class T1, class T2>
677 std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> sph_hankel_2(T1 v, T2 x);
678
679 template <class T, class Policy>
680 typename tools::promote_args<T>::type airy_ai(T x, const Policy&);
681
682 template <class T>
683 typename tools::promote_args<T>::type airy_ai(T x);
684
685 template <class T, class Policy>
686 typename tools::promote_args<T>::type airy_bi(T x, const Policy&);
687
688 template <class T>
689 typename tools::promote_args<T>::type airy_bi(T x);
690
691 template <class T, class Policy>
692 typename tools::promote_args<T>::type airy_ai_prime(T x, const Policy&);
693
694 template <class T>
695 typename tools::promote_args<T>::type airy_ai_prime(T x);
696
697 template <class T, class Policy>
698 typename tools::promote_args<T>::type airy_bi_prime(T x, const Policy&);
699
700 template <class T>
701 typename tools::promote_args<T>::type airy_bi_prime(T x);
702
703 template <class T>
704 T airy_ai_zero(unsigned m);
705 template <class T, class Policy>
706 T airy_ai_zero(unsigned m, const Policy&);
707
708 template <class OutputIterator>
709 OutputIterator airy_ai_zero(
710 unsigned start_index,
711 unsigned number_of_zeros,
712 OutputIterator out_it);
713 template <class OutputIterator, class Policy>
714 OutputIterator airy_ai_zero(
715 unsigned start_index,
716 unsigned number_of_zeros,
717 OutputIterator out_it,
718 const Policy&);
719
720 template <class T>
721 T airy_bi_zero(unsigned m);
722 template <class T, class Policy>
723 T airy_bi_zero(unsigned m, const Policy&);
724
725 template <class OutputIterator>
726 OutputIterator airy_bi_zero(
727 unsigned start_index,
728 unsigned number_of_zeros,
729 OutputIterator out_it);
730 template <class OutputIterator, class Policy>
731 OutputIterator airy_bi_zero(
732 unsigned start_index,
733 unsigned number_of_zeros,
734 OutputIterator out_it,
735 const Policy&);
736
737 template <class T, class Policy>
738 typename tools::promote_args<T>::type sin_pi(T x, const Policy&);
739
740 template <class T>
741 typename tools::promote_args<T>::type sin_pi(T x);
742
743 template <class T, class Policy>
744 typename tools::promote_args<T>::type cos_pi(T x, const Policy&);
745
746 template <class T>
747 typename tools::promote_args<T>::type cos_pi(T x);
748
749 template <class T>
750 int fpclassify BOOST_NO_MACRO_EXPAND(T t);
751
752 template <class T>
753 bool isfinite BOOST_NO_MACRO_EXPAND(T z);
754
755 template <class T>
756 bool isinf BOOST_NO_MACRO_EXPAND(T t);
757
758 template <class T>
759 bool isnan BOOST_NO_MACRO_EXPAND(T t);
760
761 template <class T>
762 bool isnormal BOOST_NO_MACRO_EXPAND(T t);
763
764 template<class T>
765 int signbit BOOST_NO_MACRO_EXPAND(T x);
766
767 template <class T>
768 int sign BOOST_NO_MACRO_EXPAND(const T& z);
769
770 template <class T, class U>
771 typename tools::promote_args<T, U>::type copysign BOOST_NO_MACRO_EXPAND(const T& x, const U& y);
772
773 template <class T>
774 typename tools::promote_args<T>::type changesign BOOST_NO_MACRO_EXPAND(const T& z);
775
776 // Exponential integrals:
777 namespace detail{
778
779 template <class T, class U>
780 struct expint_result
781 {
782 typedef typename mpl::if_<
783 policies::is_policy<U>,
784 typename tools::promote_args<T>::type,
785 typename tools::promote_args<U>::type
786 >::type type;
787 };
788
789 } // namespace detail
790
791 template <class T, class Policy>
792 typename tools::promote_args<T>::type expint(unsigned n, T z, const Policy&);
793
794 template <class T, class U>
795 typename detail::expint_result<T, U>::type expint(T const z, U const u);
796
797 template <class T>
798 typename tools::promote_args<T>::type expint(T z);
799
800 // Zeta:
801 template <class T, class Policy>
802 typename tools::promote_args<T>::type zeta(T s, const Policy&);
803
804 // Owen's T function:
805 template <class T1, class T2, class Policy>
806 typename tools::promote_args<T1, T2>::type owens_t(T1 h, T2 a, const Policy& pol);
807
808 template <class T1, class T2>
809 typename tools::promote_args<T1, T2>::type owens_t(T1 h, T2 a);
810
811 // Jacobi Functions:
812 template <class T, class U, class V, class Policy>
813 typename tools::promote_args<T, U, V>::type jacobi_elliptic(T k, U theta, V* pcn, V* pdn, const Policy&);
814
815 template <class T, class U, class V>
816 typename tools::promote_args<T, U, V>::type jacobi_elliptic(T k, U theta, V* pcn = 0, V* pdn = 0);
817
818 template <class U, class T, class Policy>
819 typename tools::promote_args<T, U>::type jacobi_sn(U k, T theta, const Policy& pol);
820
821 template <class U, class T>
822 typename tools::promote_args<T, U>::type jacobi_sn(U k, T theta);
823
824 template <class T, class U, class Policy>
825 typename tools::promote_args<T, U>::type jacobi_cn(T k, U theta, const Policy& pol);
826
827 template <class T, class U>
828 typename tools::promote_args<T, U>::type jacobi_cn(T k, U theta);
829
830 template <class T, class U, class Policy>
831 typename tools::promote_args<T, U>::type jacobi_dn(T k, U theta, const Policy& pol);
832
833 template <class T, class U>
834 typename tools::promote_args<T, U>::type jacobi_dn(T k, U theta);
835
836 template <class T, class U, class Policy>
837 typename tools::promote_args<T, U>::type jacobi_cd(T k, U theta, const Policy& pol);
838
839 template <class T, class U>
840 typename tools::promote_args<T, U>::type jacobi_cd(T k, U theta);
841
842 template <class T, class U, class Policy>
843 typename tools::promote_args<T, U>::type jacobi_dc(T k, U theta, const Policy& pol);
844
845 template <class T, class U>
846 typename tools::promote_args<T, U>::type jacobi_dc(T k, U theta);
847
848 template <class T, class U, class Policy>
849 typename tools::promote_args<T, U>::type jacobi_ns(T k, U theta, const Policy& pol);
850
851 template <class T, class U>
852 typename tools::promote_args<T, U>::type jacobi_ns(T k, U theta);
853
854 template <class T, class U, class Policy>
855 typename tools::promote_args<T, U>::type jacobi_sd(T k, U theta, const Policy& pol);
856
857 template <class T, class U>
858 typename tools::promote_args<T, U>::type jacobi_sd(T k, U theta);
859
860 template <class T, class U, class Policy>
861 typename tools::promote_args<T, U>::type jacobi_ds(T k, U theta, const Policy& pol);
862
863 template <class T, class U>
864 typename tools::promote_args<T, U>::type jacobi_ds(T k, U theta);
865
866 template <class T, class U, class Policy>
867 typename tools::promote_args<T, U>::type jacobi_nc(T k, U theta, const Policy& pol);
868
869 template <class T, class U>
870 typename tools::promote_args<T, U>::type jacobi_nc(T k, U theta);
871
872 template <class T, class U, class Policy>
873 typename tools::promote_args<T, U>::type jacobi_nd(T k, U theta, const Policy& pol);
874
875 template <class T, class U>
876 typename tools::promote_args<T, U>::type jacobi_nd(T k, U theta);
877
878 template <class T, class U, class Policy>
879 typename tools::promote_args<T, U>::type jacobi_sc(T k, U theta, const Policy& pol);
880
881 template <class T, class U>
882 typename tools::promote_args<T, U>::type jacobi_sc(T k, U theta);
883
884 template <class T, class U, class Policy>
885 typename tools::promote_args<T, U>::type jacobi_cs(T k, U theta, const Policy& pol);
886
887 template <class T, class U>
888 typename tools::promote_args<T, U>::type jacobi_cs(T k, U theta);
889
890
891 template <class T>
892 typename tools::promote_args<T>::type zeta(T s);
893
894 // pow:
895 template <int N, typename T, class Policy>
896 typename tools::promote_args<T>::type pow(T base, const Policy& policy);
897
898 template <int N, typename T>
899 typename tools::promote_args<T>::type pow(T base);
900
901 // next:
902 template <class T, class U, class Policy>
903 typename tools::promote_args<T, U>::type nextafter(const T&, const U&, const Policy&);
904 template <class T, class U>
905 typename tools::promote_args<T, U>::type nextafter(const T&, const U&);
906 template <class T, class Policy>
907 typename tools::promote_args<T>::type float_next(const T&, const Policy&);
908 template <class T>
909 typename tools::promote_args<T>::type float_next(const T&);
910 template <class T, class Policy>
911 typename tools::promote_args<T>::type float_prior(const T&, const Policy&);
912 template <class T>
913 typename tools::promote_args<T>::type float_prior(const T&);
914 template <class T, class U, class Policy>
915 typename tools::promote_args<T, U>::type float_distance(const T&, const U&, const Policy&);
916 template <class T, class U>
917 typename tools::promote_args<T, U>::type float_distance(const T&, const U&);
918 template <class T, class Policy>
919 typename tools::promote_args<T>::type float_advance(T val, int distance, const Policy& pol);
920 template <class T>
921 typename tools::promote_args<T>::type float_advance(const T& val, int distance);
922
923 } // namespace math
924} // namespace ndnboost
925
926#ifdef BOOST_HAS_LONG_LONG
927#define BOOST_MATH_DETAIL_LL_FUNC(Policy)\
928 \
929 template <class T>\
930 inline T modf(const T& v, ndnboost::long_long_type* ipart){ using ndnboost::math::modf; return modf(v, ipart, Policy()); }\
931 \
932 template <class T>\
933 inline ndnboost::long_long_type lltrunc(const T& v){ using ndnboost::math::lltrunc; return lltrunc(v, Policy()); }\
934 \
935 template <class T>\
936 inline ndnboost::long_long_type llround(const T& v){ using ndnboost::math::llround; return llround(v, Policy()); }\
937
938#else
939#define BOOST_MATH_DETAIL_LL_FUNC(Policy)
940#endif
941
942#define BOOST_MATH_DECLARE_SPECIAL_FUNCTIONS(Policy)\
943 \
944 BOOST_MATH_DETAIL_LL_FUNC(Policy)\
945 \
946 template <class RT1, class RT2>\
947 inline typename ndnboost::math::tools::promote_args<RT1, RT2>::type \
948 beta(RT1 a, RT2 b) { return ::ndnboost::math::beta(a, b, Policy()); }\
949\
950 template <class RT1, class RT2, class A>\
951 inline typename ndnboost::math::tools::promote_args<RT1, RT2, A>::type \
952 beta(RT1 a, RT2 b, A x){ return ::ndnboost::math::beta(a, b, x, Policy()); }\
953\
954 template <class RT1, class RT2, class RT3>\
955 inline typename ndnboost::math::tools::promote_args<RT1, RT2, RT3>::type \
956 betac(RT1 a, RT2 b, RT3 x) { return ::ndnboost::math::betac(a, b, x, Policy()); }\
957\
958 template <class RT1, class RT2, class RT3>\
959 inline typename ndnboost::math::tools::promote_args<RT1, RT2, RT3>::type \
960 ibeta(RT1 a, RT2 b, RT3 x){ return ::ndnboost::math::ibeta(a, b, x, Policy()); }\
961\
962 template <class RT1, class RT2, class RT3>\
963 inline typename ndnboost::math::tools::promote_args<RT1, RT2, RT3>::type \
964 ibetac(RT1 a, RT2 b, RT3 x){ return ::ndnboost::math::ibetac(a, b, x, Policy()); }\
965\
966 template <class T1, class T2, class T3, class T4>\
967 inline typename ndnboost::math::tools::promote_args<T1, T2, T3, T4>::type \
968 ibeta_inv(T1 a, T2 b, T3 p, T4* py){ return ::ndnboost::math::ibeta_inv(a, b, p, py, Policy()); }\
969\
970 template <class RT1, class RT2, class RT3>\
971 inline typename ndnboost::math::tools::promote_args<RT1, RT2, RT3>::type \
972 ibeta_inv(RT1 a, RT2 b, RT3 p){ return ::ndnboost::math::ibeta_inv(a, b, p, Policy()); }\
973\
974 template <class T1, class T2, class T3, class T4>\
975 inline typename ndnboost::math::tools::promote_args<T1, T2, T3, T4>::type \
976 ibetac_inv(T1 a, T2 b, T3 q, T4* py){ return ::ndnboost::math::ibetac_inv(a, b, q, py, Policy()); }\
977\
978 template <class RT1, class RT2, class RT3>\
979 inline typename ndnboost::math::tools::promote_args<RT1, RT2, RT3>::type \
980 ibeta_inva(RT1 a, RT2 b, RT3 p){ return ::ndnboost::math::ibeta_inva(a, b, p, Policy()); }\
981\
982 template <class T1, class T2, class T3>\
983 inline typename ndnboost::math::tools::promote_args<T1, T2, T3>::type \
984 ibetac_inva(T1 a, T2 b, T3 q){ return ::ndnboost::math::ibetac_inva(a, b, q, Policy()); }\
985\
986 template <class RT1, class RT2, class RT3>\
987 inline typename ndnboost::math::tools::promote_args<RT1, RT2, RT3>::type \
988 ibeta_invb(RT1 a, RT2 b, RT3 p){ return ::ndnboost::math::ibeta_invb(a, b, p, Policy()); }\
989\
990 template <class T1, class T2, class T3>\
991 inline typename ndnboost::math::tools::promote_args<T1, T2, T3>::type \
992 ibetac_invb(T1 a, T2 b, T3 q){ return ::ndnboost::math::ibetac_invb(a, b, q, Policy()); }\
993\
994 template <class RT1, class RT2, class RT3>\
995 inline typename ndnboost::math::tools::promote_args<RT1, RT2, RT3>::type \
996 ibetac_inv(RT1 a, RT2 b, RT3 q){ return ::ndnboost::math::ibetac_inv(a, b, q, Policy()); }\
997\
998 template <class RT1, class RT2, class RT3>\
999 inline typename ndnboost::math::tools::promote_args<RT1, RT2, RT3>::type \
1000 ibeta_derivative(RT1 a, RT2 b, RT3 x){ return ::ndnboost::math::ibeta_derivative(a, b, x, Policy()); }\
1001\
1002 template <class RT>\
1003 inline typename ndnboost::math::tools::promote_args<RT>::type erf(RT z) { return ::ndnboost::math::erf(z, Policy()); }\
1004\
1005 template <class RT>\
1006 inline typename ndnboost::math::tools::promote_args<RT>::type erfc(RT z){ return ::ndnboost::math::erfc(z, Policy()); }\
1007\
1008 template <class RT>\
1009 inline typename ndnboost::math::tools::promote_args<RT>::type erf_inv(RT z) { return ::ndnboost::math::erf_inv(z, Policy()); }\
1010\
1011 template <class RT>\
1012 inline typename ndnboost::math::tools::promote_args<RT>::type erfc_inv(RT z){ return ::ndnboost::math::erfc_inv(z, Policy()); }\
1013\
1014 using ndnboost::math::legendre_next;\
1015\
1016 template <class T>\
1017 inline typename ndnboost::math::tools::promote_args<T>::type \
1018 legendre_p(int l, T x){ return ::ndnboost::math::legendre_p(l, x, Policy()); }\
1019\
1020 template <class T>\
1021 inline typename ndnboost::math::tools::promote_args<T>::type \
1022 legendre_q(unsigned l, T x){ return ::ndnboost::math::legendre_q(l, x, Policy()); }\
1023\
1024 using ::ndnboost::math::legendre_next;\
1025\
1026 template <class T>\
1027 inline typename ndnboost::math::tools::promote_args<T>::type \
1028 legendre_p(int l, int m, T x){ return ::ndnboost::math::legendre_p(l, m, x, Policy()); }\
1029\
1030 using ::ndnboost::math::laguerre_next;\
1031\
1032 template <class T>\
1033 inline typename ndnboost::math::tools::promote_args<T>::type \
1034 laguerre(unsigned n, T x){ return ::ndnboost::math::laguerre(n, x, Policy()); }\
1035\
1036 template <class T1, class T2>\
1037 inline typename ndnboost::math::laguerre_result<T1, T2>::type \
1038 laguerre(unsigned n, T1 m, T2 x) { return ::ndnboost::math::laguerre(n, m, x, Policy()); }\
1039\
1040 template <class T>\
1041 inline typename ndnboost::math::tools::promote_args<T>::type \
1042 hermite(unsigned n, T x){ return ::ndnboost::math::hermite(n, x, Policy()); }\
1043\
1044 using ndnboost::math::hermite_next;\
1045\
1046 template <class T1, class T2>\
1047 inline std::complex<typename ndnboost::math::tools::promote_args<T1, T2>::type> \
1048 spherical_harmonic(unsigned n, int m, T1 theta, T2 phi){ return ndnboost::math::spherical_harmonic(n, m, theta, phi, Policy()); }\
1049\
1050 template <class T1, class T2>\
1051 inline typename ndnboost::math::tools::promote_args<T1, T2>::type \
1052 spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi){ return ::ndnboost::math::spherical_harmonic_r(n, m, theta, phi, Policy()); }\
1053\
1054 template <class T1, class T2>\
1055 inline typename ndnboost::math::tools::promote_args<T1, T2>::type \
1056 spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi){ return ndnboost::math::spherical_harmonic_i(n, m, theta, phi, Policy()); }\
1057\
1058 template <class T1, class T2, class Policy>\
1059 inline typename ndnboost::math::tools::promote_args<T1, T2>::type \
1060 spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);\
1061\
1062 template <class T1, class T2, class T3>\
1063 inline typename ndnboost::math::tools::promote_args<T1, T2, T3>::type \
1064 ellint_rf(T1 x, T2 y, T3 z){ return ::ndnboost::math::ellint_rf(x, y, z, Policy()); }\
1065\
1066 template <class T1, class T2, class T3>\
1067 inline typename ndnboost::math::tools::promote_args<T1, T2, T3>::type \
1068 ellint_rd(T1 x, T2 y, T3 z){ return ::ndnboost::math::ellint_rd(x, y, z, Policy()); }\
1069\
1070 template <class T1, class T2>\
1071 inline typename ndnboost::math::tools::promote_args<T1, T2>::type \
1072 ellint_rc(T1 x, T2 y){ return ::ndnboost::math::ellint_rc(x, y, Policy()); }\
1073\
1074 template <class T1, class T2, class T3, class T4>\
1075 inline typename ndnboost::math::tools::promote_args<T1, T2, T3, T4>::type \
1076 ellint_rj(T1 x, T2 y, T3 z, T4 p){ return ndnboost::math::ellint_rj(x, y, z, p, Policy()); }\
1077\
1078 template <typename T>\
1079 inline typename ndnboost::math::tools::promote_args<T>::type ellint_2(T k){ return ndnboost::math::ellint_2(k, Policy()); }\
1080\
1081 template <class T1, class T2>\
1082 inline typename ndnboost::math::tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi){ return ndnboost::math::ellint_2(k, phi, Policy()); }\
1083\
1084 template <typename T>\
1085 inline typename ndnboost::math::tools::promote_args<T>::type ellint_1(T k){ return ndnboost::math::ellint_1(k, Policy()); }\
1086\
1087 template <class T1, class T2>\
1088 inline typename ndnboost::math::tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi){ return ndnboost::math::ellint_1(k, phi, Policy()); }\
1089\
1090 template <class T1, class T2, class T3>\
1091 inline typename ndnboost::math::tools::promote_args<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi){ return ndnboost::math::ellint_3(k, v, phi, Policy()); }\
1092\
1093 template <class T1, class T2>\
1094 inline typename ndnboost::math::tools::promote_args<T1, T2>::type ellint_3(T1 k, T2 v){ return ndnboost::math::ellint_3(k, v, Policy()); }\
1095\
1096 using ndnboost::math::max_factorial;\
1097 template <class RT>\
1098 inline RT factorial(unsigned int i) { return ndnboost::math::factorial<RT>(i, Policy()); }\
1099 using ndnboost::math::unchecked_factorial;\
1100 template <class RT>\
1101 inline RT double_factorial(unsigned i){ return ndnboost::math::double_factorial<RT>(i, Policy()); }\
1102 template <class RT>\
1103 inline typename ndnboost::math::tools::promote_args<RT>::type falling_factorial(RT x, unsigned n){ return ndnboost::math::falling_factorial(x, n, Policy()); }\
1104 template <class RT>\
1105 inline typename ndnboost::math::tools::promote_args<RT>::type rising_factorial(RT x, unsigned n){ return ndnboost::math::rising_factorial(x, n, Policy()); }\
1106\
1107 template <class RT>\
1108 inline typename ndnboost::math::tools::promote_args<RT>::type tgamma(RT z){ return ndnboost::math::tgamma(z, Policy()); }\
1109\
1110 template <class RT>\
1111 inline typename ndnboost::math::tools::promote_args<RT>::type tgamma1pm1(RT z){ return ndnboost::math::tgamma1pm1(z, Policy()); }\
1112\
1113 template <class RT1, class RT2>\
1114 inline typename ndnboost::math::tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z){ return ndnboost::math::tgamma(a, z, Policy()); }\
1115\
1116 template <class RT>\
1117 inline typename ndnboost::math::tools::promote_args<RT>::type lgamma(RT z, int* sign){ return ndnboost::math::lgamma(z, sign, Policy()); }\
1118\
1119 template <class RT>\
1120 inline typename ndnboost::math::tools::promote_args<RT>::type lgamma(RT x){ return ndnboost::math::lgamma(x, Policy()); }\
1121\
1122 template <class RT1, class RT2>\
1123 inline typename ndnboost::math::tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z){ return ndnboost::math::tgamma_lower(a, z, Policy()); }\
1124\
1125 template <class RT1, class RT2>\
1126 inline typename ndnboost::math::tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z){ return ndnboost::math::gamma_q(a, z, Policy()); }\
1127\
1128 template <class RT1, class RT2>\
1129 inline typename ndnboost::math::tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z){ return ndnboost::math::gamma_p(a, z, Policy()); }\
1130\
1131 template <class T1, class T2>\
1132 inline typename ndnboost::math::tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta){ return ndnboost::math::tgamma_delta_ratio(z, delta, Policy()); }\
1133\
1134 template <class T1, class T2>\
1135 inline typename ndnboost::math::tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b) { return ndnboost::math::tgamma_ratio(a, b, Policy()); }\
1136\
1137 template <class T1, class T2>\
1138 inline typename ndnboost::math::tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x){ return ndnboost::math::gamma_p_derivative(a, x, Policy()); }\
1139\
1140 template <class T1, class T2>\
1141 inline typename ndnboost::math::tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p){ return ndnboost::math::gamma_p_inv(a, p, Policy()); }\
1142\
1143 template <class T1, class T2>\
1144 inline typename ndnboost::math::tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p){ return ndnboost::math::gamma_p_inva(a, p, Policy()); }\
1145\
1146 template <class T1, class T2>\
1147 inline typename ndnboost::math::tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q){ return ndnboost::math::gamma_q_inv(a, q, Policy()); }\
1148\
1149 template <class T1, class T2>\
1150 inline typename ndnboost::math::tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q){ return ndnboost::math::gamma_q_inva(a, q, Policy()); }\
1151\
1152 template <class T>\
1153 inline typename ndnboost::math::tools::promote_args<T>::type digamma(T x){ return ndnboost::math::digamma(x, Policy()); }\
1154\
1155 template <class T1, class T2>\
1156 inline typename ndnboost::math::tools::promote_args<T1, T2>::type \
1157 hypot(T1 x, T2 y){ return ndnboost::math::hypot(x, y, Policy()); }\
1158\
1159 template <class RT>\
1160 inline typename ndnboost::math::tools::promote_args<RT>::type cbrt(RT z){ return ndnboost::math::cbrt(z, Policy()); }\
1161\
1162 template <class T>\
1163 inline typename ndnboost::math::tools::promote_args<T>::type log1p(T x){ return ndnboost::math::log1p(x, Policy()); }\
1164\
1165 template <class T>\
1166 inline typename ndnboost::math::tools::promote_args<T>::type log1pmx(T x){ return ndnboost::math::log1pmx(x, Policy()); }\
1167\
1168 template <class T>\
1169 inline typename ndnboost::math::tools::promote_args<T>::type expm1(T x){ return ndnboost::math::expm1(x, Policy()); }\
1170\
1171 template <class T1, class T2>\
1172 inline typename ndnboost::math::tools::promote_args<T1, T2>::type \
1173 powm1(const T1 a, const T2 z){ return ndnboost::math::powm1(a, z, Policy()); }\
1174\
1175 template <class T>\
1176 inline typename ndnboost::math::tools::promote_args<T>::type sqrt1pm1(const T& val){ return ndnboost::math::sqrt1pm1(val, Policy()); }\
1177\
1178 template <class T>\
1179 inline typename ndnboost::math::tools::promote_args<T>::type sinc_pi(T x){ return ndnboost::math::sinc_pi(x, Policy()); }\
1180\
1181 template <class T>\
1182 inline typename ndnboost::math::tools::promote_args<T>::type sinhc_pi(T x){ return ndnboost::math::sinhc_pi(x, Policy()); }\
1183\
1184 template<typename T>\
1185 inline typename ndnboost::math::tools::promote_args<T>::type asinh(const T x){ return ndnboost::math::asinh(x, Policy()); }\
1186\
1187 template<typename T>\
1188 inline typename ndnboost::math::tools::promote_args<T>::type acosh(const T x){ return ndnboost::math::acosh(x, Policy()); }\
1189\
1190 template<typename T>\
1191 inline typename ndnboost::math::tools::promote_args<T>::type atanh(const T x){ return ndnboost::math::atanh(x, Policy()); }\
1192\
1193 template <class T1, class T2>\
1194 inline typename ndnboost::math::detail::bessel_traits<T1, T2, Policy >::result_type cyl_bessel_j(T1 v, T2 x)\
1195 { return ndnboost::math::cyl_bessel_j(v, x, Policy()); }\
1196\
1197 template <class T>\
1198 inline typename ndnboost::math::detail::bessel_traits<T, T, Policy >::result_type sph_bessel(unsigned v, T x)\
1199 { return ndnboost::math::sph_bessel(v, x, Policy()); }\
1200\
1201 template <class T1, class T2>\
1202 inline typename ndnboost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1203 cyl_bessel_i(T1 v, T2 x) { return ndnboost::math::cyl_bessel_i(v, x, Policy()); }\
1204\
1205 template <class T1, class T2>\
1206 inline typename ndnboost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1207 cyl_bessel_k(T1 v, T2 x) { return ndnboost::math::cyl_bessel_k(v, x, Policy()); }\
1208\
1209 template <class T1, class T2>\
1210 inline typename ndnboost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1211 cyl_neumann(T1 v, T2 x){ return ndnboost::math::cyl_neumann(v, x, Policy()); }\
1212\
1213 template <class T>\
1214 inline typename ndnboost::math::detail::bessel_traits<T, T, Policy >::result_type \
1215 sph_neumann(unsigned v, T x){ return ndnboost::math::sph_neumann(v, x, Policy()); }\
1216\
1217 template <class T>\
1218 inline typename ndnboost::math::detail::bessel_traits<T, T, Policy >::result_type cyl_bessel_j_zero(T v, int m)\
1219 { return ndnboost::math::cyl_bessel_j_zero(v, m, Policy()); }\
1220\
1221template <class OutputIterator, class T>\
1222 inline void cyl_bessel_j_zero(T v,\
1223 int start_index,\
1224 unsigned number_of_zeros,\
1225 OutputIterator out_it)\
1226 { ndnboost::math::cyl_bessel_j_zero(v, start_index, number_of_zeros, out_it, Policy()); }\
1227\
1228 template <class T>\
1229 inline typename ndnboost::math::detail::bessel_traits<T, T, Policy >::result_type cyl_neumann_zero(T v, int m)\
1230 { return ndnboost::math::cyl_neumann_zero(v, m, Policy()); }\
1231\
1232template <class OutputIterator, class T>\
1233 inline void cyl_neumann_zero(T v,\
1234 int start_index,\
1235 unsigned number_of_zeros,\
1236 OutputIterator out_it)\
1237 { ndnboost::math::cyl_neumann_zero(v, start_index, number_of_zeros, out_it, Policy()); }\
1238\
1239 template <class T>\
1240 inline typename ndnboost::math::tools::promote_args<T>::type sin_pi(T x){ return ndnboost::math::sin_pi(x); }\
1241\
1242 template <class T>\
1243 inline typename ndnboost::math::tools::promote_args<T>::type cos_pi(T x){ return ndnboost::math::cos_pi(x); }\
1244\
1245 using ndnboost::math::fpclassify;\
1246 using ndnboost::math::isfinite;\
1247 using ndnboost::math::isinf;\
1248 using ndnboost::math::isnan;\
1249 using ndnboost::math::isnormal;\
1250 using ndnboost::math::signbit;\
1251 using ndnboost::math::sign;\
1252 using ndnboost::math::copysign;\
1253 using ndnboost::math::changesign;\
1254 \
1255 template <class T, class U>\
1256 inline typename ndnboost::math::tools::promote_args<T,U>::type expint(T const& z, U const& u)\
1257 { return ndnboost::math::expint(z, u, Policy()); }\
1258 \
1259 template <class T>\
1260 inline typename ndnboost::math::tools::promote_args<T>::type expint(T z){ return ndnboost::math::expint(z, Policy()); }\
1261 \
1262 template <class T>\
1263 inline typename ndnboost::math::tools::promote_args<T>::type zeta(T s){ return ndnboost::math::zeta(s, Policy()); }\
1264 \
1265 template <class T>\
1266 inline T round(const T& v){ using ndnboost::math::round; return round(v, Policy()); }\
1267 \
1268 template <class T>\
1269 inline int iround(const T& v){ using ndnboost::math::iround; return iround(v, Policy()); }\
1270 \
1271 template <class T>\
1272 inline long lround(const T& v){ using ndnboost::math::lround; return lround(v, Policy()); }\
1273 \
1274 template <class T>\
1275 inline T trunc(const T& v){ using ndnboost::math::trunc; return trunc(v, Policy()); }\
1276 \
1277 template <class T>\
1278 inline int itrunc(const T& v){ using ndnboost::math::itrunc; return itrunc(v, Policy()); }\
1279 \
1280 template <class T>\
1281 inline long ltrunc(const T& v){ using ndnboost::math::ltrunc; return ltrunc(v, Policy()); }\
1282 \
1283 template <class T>\
1284 inline T modf(const T& v, T* ipart){ using ndnboost::math::modf; return modf(v, ipart, Policy()); }\
1285 \
1286 template <class T>\
1287 inline T modf(const T& v, int* ipart){ using ndnboost::math::modf; return modf(v, ipart, Policy()); }\
1288 \
1289 template <class T>\
1290 inline T modf(const T& v, long* ipart){ using ndnboost::math::modf; return modf(v, ipart, Policy()); }\
1291 \
1292 template <int N, class T>\
1293 inline typename ndnboost::math::tools::promote_args<T>::type pow(T v){ return ndnboost::math::pow<N>(v, Policy()); }\
1294 \
1295 template <class T> T nextafter(const T& a, const T& b){ return ndnboost::math::nextafter(a, b, Policy()); }\
1296 template <class T> T float_next(const T& a){ return ndnboost::math::float_next(a, Policy()); }\
1297 template <class T> T float_prior(const T& a){ return ndnboost::math::float_prior(a, Policy()); }\
1298 template <class T> T float_distance(const T& a, const T& b){ return ndnboost::math::float_distance(a, b, Policy()); }\
1299 \
1300 template <class RT1, class RT2>\
1301 inline typename ndnboost::math::tools::promote_args<RT1, RT2>::type owens_t(RT1 a, RT2 z){ return ndnboost::math::owens_t(a, z, Policy()); }\
1302 \
1303 template <class T1, class T2>\
1304 inline std::complex<typename ndnboost::math::detail::bessel_traits<T1, T2, Policy >::result_type> cyl_hankel_1(T1 v, T2 x)\
1305 { return ndnboost::math::cyl_hankel_1(v, x, Policy()); }\
1306 \
1307 template <class T1, class T2>\
1308 inline std::complex<typename ndnboost::math::detail::bessel_traits<T1, T2, Policy >::result_type> cyl_hankel_2(T1 v, T2 x)\
1309 { return ndnboost::math::cyl_hankel_2(v, x, Policy()); }\
1310 \
1311 template <class T1, class T2>\
1312 inline std::complex<typename ndnboost::math::detail::bessel_traits<T1, T2, Policy >::result_type> sph_hankel_1(T1 v, T2 x)\
1313 { return ndnboost::math::sph_hankel_1(v, x, Policy()); }\
1314 \
1315 template <class T1, class T2>\
1316 inline std::complex<typename ndnboost::math::detail::bessel_traits<T1, T2, Policy >::result_type> sph_hankel_2(T1 v, T2 x)\
1317 { return ndnboost::math::sph_hankel_2(v, x, Policy()); }\
1318 \
1319 template <class T>\
1320 inline typename ndnboost::math::tools::promote_args<T>::type jacobi_elliptic(T k, T theta, T* pcn, T* pdn)\
1321 { return ndnboost::math::jacobi_elliptic(k, theta, pcn, pdn, Policy()); }\
1322 \
1323 template <class U, class T>\
1324 inline typename ndnboost::math::tools::promote_args<T, U>::type jacobi_sn(U k, T theta)\
1325 { return ndnboost::math::jacobi_sn(k, theta, Policy()); }\
1326 \
1327 template <class T, class U>\
1328 inline typename ndnboost::math::tools::promote_args<T, U>::type jacobi_cn(T k, U theta)\
1329 { return ndnboost::math::jacobi_cn(k, theta, Policy()); }\
1330 \
1331 template <class T, class U>\
1332 inline typename ndnboost::math::tools::promote_args<T, U>::type jacobi_dn(T k, U theta)\
1333 { return ndnboost::math::jacobi_dn(k, theta, Policy()); }\
1334 \
1335 template <class T, class U>\
1336 inline typename ndnboost::math::tools::promote_args<T, U>::type jacobi_cd(T k, U theta)\
1337 { return ndnboost::math::jacobi_cd(k, theta, Policy()); }\
1338 \
1339 template <class T, class U>\
1340 inline typename ndnboost::math::tools::promote_args<T, U>::type jacobi_dc(T k, U theta)\
1341 { return ndnboost::math::jacobi_dc(k, theta, Policy()); }\
1342 \
1343 template <class T, class U>\
1344 inline typename ndnboost::math::tools::promote_args<T, U>::type jacobi_ns(T k, U theta)\
1345 { return ndnboost::math::jacobi_ns(k, theta, Policy()); }\
1346 \
1347 template <class T, class U>\
1348 inline typename ndnboost::math::tools::promote_args<T, U>::type jacobi_sd(T k, U theta)\
1349 { return ndnboost::math::jacobi_sd(k, theta, Policy()); }\
1350 \
1351 template <class T, class U>\
1352 inline typename ndnboost::math::tools::promote_args<T, U>::type jacobi_ds(T k, U theta)\
1353 { return ndnboost::math::jacobi_ds(k, theta, Policy()); }\
1354 \
1355 template <class T, class U>\
1356 inline typename ndnboost::math::tools::promote_args<T, U>::type jacobi_nc(T k, U theta)\
1357 { return ndnboost::math::jacobi_nc(k, theta, Policy()); }\
1358 \
1359 template <class T, class U>\
1360 inline typename ndnboost::math::tools::promote_args<T, U>::type jacobi_nd(T k, U theta)\
1361 { return ndnboost::math::jacobi_nd(k, theta, Policy()); }\
1362 \
1363 template <class T, class U>\
1364 inline typename ndnboost::math::tools::promote_args<T, U>::type jacobi_sc(T k, U theta)\
1365 { return ndnboost::math::jacobi_sc(k, theta, Policy()); }\
1366 \
1367 template <class T, class U>\
1368 inline typename ndnboost::math::tools::promote_args<T, U>::type jacobi_cs(T k, U theta)\
1369 { return ndnboost::math::jacobi_cs(k, theta, Policy()); }\
1370 \
1371 template <class T>\
1372 inline typename ndnboost::math::tools::promote_args<T>::type airy_ai(T x)\
1373 { return ndnboost::math::airy_ai(x, Policy()); }\
1374 \
1375 template <class T>\
1376 inline typename ndnboost::math::tools::promote_args<T>::type airy_bi(T x)\
1377 { return ndnboost::math::airy_bi(x, Policy()); }\
1378 \
1379 template <class T>\
1380 inline typename ndnboost::math::tools::promote_args<T>::type airy_ai_prime(T x)\
1381 { return ndnboost::math::airy_ai_prime(x, Policy()); }\
1382 \
1383 template <class T>\
1384 inline typename ndnboost::math::tools::promote_args<T>::type airy_bi_prime(T x)\
1385 { return ndnboost::math::airy_bi_prime(x, Policy()); }\
1386 \
1387 template <class T>\
1388 inline T airy_ai_zero(int m)\
1389 { return ndnboost::math::airy_ai_zero<T>(m, Policy()); }\
1390 template <class T, class OutputIterator>\
1391 OutputIterator airy_ai_zero(int start_index, unsigned number_of_zeros, OutputIterator out_it)\
1392 { return ndnboost::math::airy_ai_zero<T>(start_index, number_of_zeros, out_it, Policy()); }\
1393 \
1394 template <class T>\
1395 inline T airy_bi_zero(int m)\
1396 { return ndnboost::math::airy_bi_zero<T>(m, Policy()); }\
1397 template <class T, class OutputIterator>\
1398 OutputIterator airy_bi_zero(int start_index, unsigned number_of_zeros, OutputIterator out_it)\
1399 { return ndnboost::math::airy_bi_zero<T>(start_index, number_of_zeros, out_it, Policy()); }\
1400 \
1401
1402
1403
1404
1405
1406#endif // BOOST_MATH_SPECIAL_MATH_FWD_HPP
1407
1408