boost/math/special_functions/math_fwd.hpp

   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 <boost/math/special_functions/detail/round_fwd.hpp>
  27 #include <boost/math/tools/promotion.hpp> // for argument promotion.
  28 #include <boost/math/policies/policy.hpp>
  29 #include <boost/mpl/comparison.hpp>
  30 #include <boost/config/no_tr1/complex.hpp>
  31
  32 #define BOOST_NO_MACRO_EXPAND /**/
  33
  34 namespace boost
  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_permissive<T, U>::type copysign BOOST_NO_MACRO_EXPAND(const T& x, const U& y);
 772
 773    template <class T>
 774    typename tools::promote_args_permissive<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 boost
 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, boost::long_long_type* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
 931    \
 932    template <class T>\
 933    inline boost::long_long_type lltrunc(const T& v){ using boost::math::lltrunc; return lltrunc(v, Policy()); }\
 934    \
 935    template <class T>\
 936    inline boost::long_long_type llround(const T& v){ using boost::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 boost::math::tools::promote_args<RT1, RT2>::type \
 948    beta(RT1 a, RT2 b) { return ::boost::math::beta(a, b, Policy()); }\
 949 \
 950    template <class RT1, class RT2, class A>\
 951    inline typename boost::math::tools::promote_args<RT1, RT2, A>::type \
 952    beta(RT1 a, RT2 b, A x){ return ::boost::math::beta(a, b, x, Policy()); }\
 953 \
 954    template <class RT1, class RT2, class RT3>\
 955    inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
 956    betac(RT1 a, RT2 b, RT3 x) { return ::boost::math::betac(a, b, x, Policy()); }\
 957 \
 958    template <class RT1, class RT2, class RT3>\
 959    inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
 960    ibeta(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibeta(a, b, x, Policy()); }\
 961 \
 962    template <class RT1, class RT2, class RT3>\
 963    inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
 964    ibetac(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibetac(a, b, x, Policy()); }\
 965 \
 966    template <class T1, class T2, class T3, class T4>\
 967    inline typename boost::math::tools::promote_args<T1, T2, T3, T4>::type  \
 968    ibeta_inv(T1 a, T2 b, T3 p, T4* py){ return ::boost::math::ibeta_inv(a, b, p, py, Policy()); }\
 969 \
 970    template <class RT1, class RT2, class RT3>\
 971    inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
 972    ibeta_inv(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_inv(a, b, p, Policy()); }\
 973 \
 974    template <class T1, class T2, class T3, class T4>\
 975    inline typename boost::math::tools::promote_args<T1, T2, T3, T4>::type \
 976    ibetac_inv(T1 a, T2 b, T3 q, T4* py){ return ::boost::math::ibetac_inv(a, b, q, py, Policy()); }\
 977 \
 978    template <class RT1, class RT2, class RT3>\
 979    inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
 980    ibeta_inva(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_inva(a, b, p, Policy()); }\
 981 \
 982    template <class T1, class T2, class T3>\
 983    inline typename boost::math::tools::promote_args<T1, T2, T3>::type \
 984    ibetac_inva(T1 a, T2 b, T3 q){ return ::boost::math::ibetac_inva(a, b, q, Policy()); }\
 985 \
 986    template <class RT1, class RT2, class RT3>\
 987    inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
 988    ibeta_invb(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_invb(a, b, p, Policy()); }\
 989 \
 990    template <class T1, class T2, class T3>\
 991    inline typename boost::math::tools::promote_args<T1, T2, T3>::type \
 992    ibetac_invb(T1 a, T2 b, T3 q){ return ::boost::math::ibetac_invb(a, b, q, Policy()); }\
 993 \
 994    template <class RT1, class RT2, class RT3>\
 995    inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
 996    ibetac_inv(RT1 a, RT2 b, RT3 q){ return ::boost::math::ibetac_inv(a, b, q, Policy()); }\
 997 \
 998    template <class RT1, class RT2, class RT3>\
 999    inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
1000    ibeta_derivative(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibeta_derivative(a, b, x, Policy()); }\
1001 \
1002    template <class RT>\
1003    inline typename boost::math::tools::promote_args<RT>::type erf(RT z) { return ::boost::math::erf(z, Policy()); }\
1004 \
1005    template <class RT>\
1006    inline typename boost::math::tools::promote_args<RT>::type erfc(RT z){ return ::boost::math::erfc(z, Policy()); }\
1007 \
1008    template <class RT>\
1009    inline typename boost::math::tools::promote_args<RT>::type erf_inv(RT z) { return ::boost::math::erf_inv(z, Policy()); }\
1010 \
1011    template <class RT>\
1012    inline typename boost::math::tools::promote_args<RT>::type erfc_inv(RT z){ return ::boost::math::erfc_inv(z, Policy()); }\
1013 \
1014    using boost::math::legendre_next;\
1015 \
1016    template <class T>\
1017    inline typename boost::math::tools::promote_args<T>::type \
1018    legendre_p(int l, T x){ return ::boost::math::legendre_p(l, x, Policy()); }\
1019 \
1020    template <class T>\
1021    inline typename boost::math::tools::promote_args<T>::type \
1022    legendre_q(unsigned l, T x){ return ::boost::math::legendre_q(l, x, Policy()); }\
1023 \
1024    using ::boost::math::legendre_next;\
1025 \
1026    template <class T>\
1027    inline typename boost::math::tools::promote_args<T>::type \
1028    legendre_p(int l, int m, T x){ return ::boost::math::legendre_p(l, m, x, Policy()); }\
1029 \
1030    using ::boost::math::laguerre_next;\
1031 \
1032    template <class T>\
1033    inline typename boost::math::tools::promote_args<T>::type \
1034    laguerre(unsigned n, T x){ return ::boost::math::laguerre(n, x, Policy()); }\
1035 \
1036    template <class T1, class T2>\
1037    inline typename boost::math::laguerre_result<T1, T2>::type \
1038    laguerre(unsigned n, T1 m, T2 x) { return ::boost::math::laguerre(n, m, x, Policy()); }\
1039 \
1040    template <class T>\
1041    inline typename boost::math::tools::promote_args<T>::type \
1042    hermite(unsigned n, T x){ return ::boost::math::hermite(n, x, Policy()); }\
1043 \
1044    using boost::math::hermite_next;\
1045 \
1046    template <class T1, class T2>\
1047    inline std::complex<typename boost::math::tools::promote_args<T1, T2>::type> \
1048    spherical_harmonic(unsigned n, int m, T1 theta, T2 phi){ return boost::math::spherical_harmonic(n, m, theta, phi, Policy()); }\
1049 \
1050    template <class T1, class T2>\
1051    inline typename boost::math::tools::promote_args<T1, T2>::type \
1052    spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi){ return ::boost::math::spherical_harmonic_r(n, m, theta, phi, Policy()); }\
1053 \
1054    template <class T1, class T2>\
1055    inline typename boost::math::tools::promote_args<T1, T2>::type \
1056    spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi){ return boost::math::spherical_harmonic_i(n, m, theta, phi, Policy()); }\
1057 \
1058    template <class T1, class T2, class Policy>\
1059    inline typename boost::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 boost::math::tools::promote_args<T1, T2, T3>::type \
1064    ellint_rf(T1 x, T2 y, T3 z){ return ::boost::math::ellint_rf(x, y, z, Policy()); }\
1065 \
1066    template <class T1, class T2, class T3>\
1067    inline typename boost::math::tools::promote_args<T1, T2, T3>::type \
1068    ellint_rd(T1 x, T2 y, T3 z){ return ::boost::math::ellint_rd(x, y, z, Policy()); }\
1069 \
1070    template <class T1, class T2>\
1071    inline typename boost::math::tools::promote_args<T1, T2>::type \
1072    ellint_rc(T1 x, T2 y){ return ::boost::math::ellint_rc(x, y, Policy()); }\
1073 \
1074    template <class T1, class T2, class T3, class T4>\
1075    inline typename boost::math::tools::promote_args<T1, T2, T3, T4>::type \
1076    ellint_rj(T1 x, T2 y, T3 z, T4 p){ return boost::math::ellint_rj(x, y, z, p, Policy()); }\
1077 \
1078    template <typename T>\
1079    inline typename boost::math::tools::promote_args<T>::type ellint_2(T k){ return boost::math::ellint_2(k, Policy()); }\
1080 \
1081    template <class T1, class T2>\
1082    inline typename boost::math::tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi){ return boost::math::ellint_2(k, phi, Policy()); }\
1083 \
1084    template <typename T>\
1085    inline typename boost::math::tools::promote_args<T>::type ellint_1(T k){ return boost::math::ellint_1(k, Policy()); }\
1086 \
1087    template <class T1, class T2>\
1088    inline typename boost::math::tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi){ return boost::math::ellint_1(k, phi, Policy()); }\
1089 \
1090    template <class T1, class T2, class T3>\
1091    inline typename boost::math::tools::promote_args<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi){ return boost::math::ellint_3(k, v, phi, Policy()); }\
1092 \
1093    template <class T1, class T2>\
1094    inline typename boost::math::tools::promote_args<T1, T2>::type ellint_3(T1 k, T2 v){ return boost::math::ellint_3(k, v, Policy()); }\
1095 \
1096    using boost::math::max_factorial;\
1097    template <class RT>\
1098    inline RT factorial(unsigned int i) { return boost::math::factorial<RT>(i, Policy()); }\
1099    using boost::math::unchecked_factorial;\
1100    template <class RT>\
1101    inline RT double_factorial(unsigned i){ return boost::math::double_factorial<RT>(i, Policy()); }\
1102    template <class RT>\
1103    inline typename boost::math::tools::promote_args<RT>::type falling_factorial(RT x, unsigned n){ return boost::math::falling_factorial(x, n, Policy()); }\
1104    template <class RT>\
1105    inline typename boost::math::tools::promote_args<RT>::type rising_factorial(RT x, unsigned n){ return boost::math::rising_factorial(x, n, Policy()); }\
1106 \
1107    template <class RT>\
1108    inline typename boost::math::tools::promote_args<RT>::type tgamma(RT z){ return boost::math::tgamma(z, Policy()); }\
1109 \
1110    template <class RT>\
1111    inline typename boost::math::tools::promote_args<RT>::type tgamma1pm1(RT z){ return boost::math::tgamma1pm1(z, Policy()); }\
1112 \
1113    template <class RT1, class RT2>\
1114    inline typename boost::math::tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z){ return boost::math::tgamma(a, z, Policy()); }\
1115 \
1116    template <class RT>\
1117    inline typename boost::math::tools::promote_args<RT>::type lgamma(RT z, int* sign){ return boost::math::lgamma(z, sign, Policy()); }\
1118 \
1119    template <class RT>\
1120    inline typename boost::math::tools::promote_args<RT>::type lgamma(RT x){ return boost::math::lgamma(x, Policy()); }\
1121 \
1122    template <class RT1, class RT2>\
1123    inline typename boost::math::tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z){ return boost::math::tgamma_lower(a, z, Policy()); }\
1124 \
1125    template <class RT1, class RT2>\
1126    inline typename boost::math::tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z){ return boost::math::gamma_q(a, z, Policy()); }\
1127 \
1128    template <class RT1, class RT2>\
1129    inline typename boost::math::tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z){ return boost::math::gamma_p(a, z, Policy()); }\
1130 \
1131    template <class T1, class T2>\
1132    inline typename boost::math::tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta){ return boost::math::tgamma_delta_ratio(z, delta, Policy()); }\
1133 \
1134    template <class T1, class T2>\
1135    inline typename boost::math::tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b) { return boost::math::tgamma_ratio(a, b, Policy()); }\
1136 \
1137    template <class T1, class T2>\
1138    inline typename boost::math::tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x){ return boost::math::gamma_p_derivative(a, x, Policy()); }\
1139 \
1140    template <class T1, class T2>\
1141    inline typename boost::math::tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p){ return boost::math::gamma_p_inv(a, p, Policy()); }\
1142 \
1143    template <class T1, class T2>\
1144    inline typename boost::math::tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p){ return boost::math::gamma_p_inva(a, p, Policy()); }\
1145 \
1146    template <class T1, class T2>\
1147    inline typename boost::math::tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q){ return boost::math::gamma_q_inv(a, q, Policy()); }\
1148 \
1149    template <class T1, class T2>\
1150    inline typename boost::math::tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q){ return boost::math::gamma_q_inva(a, q, Policy()); }\
1151 \
1152    template <class T>\
1153    inline typename boost::math::tools::promote_args<T>::type digamma(T x){ return boost::math::digamma(x, Policy()); }\
1154 \
1155    template <class T1, class T2>\
1156    inline typename boost::math::tools::promote_args<T1, T2>::type \
1157    hypot(T1 x, T2 y){ return boost::math::hypot(x, y, Policy()); }\
1158 \
1159    template <class RT>\
1160    inline typename boost::math::tools::promote_args<RT>::type cbrt(RT z){ return boost::math::cbrt(z, Policy()); }\
1161 \
1162    template <class T>\
1163    inline typename boost::math::tools::promote_args<T>::type log1p(T x){ return boost::math::log1p(x, Policy()); }\
1164 \
1165    template <class T>\
1166    inline typename boost::math::tools::promote_args<T>::type log1pmx(T x){ return boost::math::log1pmx(x, Policy()); }\
1167 \
1168    template <class T>\
1169    inline typename boost::math::tools::promote_args<T>::type expm1(T x){ return boost::math::expm1(x, Policy()); }\
1170 \
1171    template <class T1, class T2>\
1172    inline typename boost::math::tools::promote_args<T1, T2>::type \
1173    powm1(const T1 a, const T2 z){ return boost::math::powm1(a, z, Policy()); }\
1174 \
1175    template <class T>\
1176    inline typename boost::math::tools::promote_args<T>::type sqrt1pm1(const T& val){ return boost::math::sqrt1pm1(val, Policy()); }\
1177 \
1178    template <class T>\
1179    inline typename boost::math::tools::promote_args<T>::type sinc_pi(T x){ return boost::math::sinc_pi(x, Policy()); }\
1180 \
1181    template <class T>\
1182    inline typename boost::math::tools::promote_args<T>::type sinhc_pi(T x){ return boost::math::sinhc_pi(x, Policy()); }\
1183 \
1184    template<typename T>\
1185    inline typename boost::math::tools::promote_args<T>::type asinh(const T x){ return boost::math::asinh(x, Policy()); }\
1186 \
1187    template<typename T>\
1188    inline typename boost::math::tools::promote_args<T>::type acosh(const T x){ return boost::math::acosh(x, Policy()); }\
1189 \
1190    template<typename T>\
1191    inline typename boost::math::tools::promote_args<T>::type atanh(const T x){ return boost::math::atanh(x, Policy()); }\
1192 \
1193    template <class T1, class T2>\
1194    inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type cyl_bessel_j(T1 v, T2 x)\
1195    { return boost::math::cyl_bessel_j(v, x, Policy()); }\
1196 \
1197    template <class T>\
1198    inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type sph_bessel(unsigned v, T x)\
1199    { return boost::math::sph_bessel(v, x, Policy()); }\
1200 \
1201    template <class T1, class T2>\
1202    inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1203    cyl_bessel_i(T1 v, T2 x) { return boost::math::cyl_bessel_i(v, x, Policy()); }\
1204 \
1205    template <class T1, class T2>\
1206    inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1207    cyl_bessel_k(T1 v, T2 x) { return boost::math::cyl_bessel_k(v, x, Policy()); }\
1208 \
1209    template <class T1, class T2>\
1210    inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1211    cyl_neumann(T1 v, T2 x){ return boost::math::cyl_neumann(v, x, Policy()); }\
1212 \
1213    template <class T>\
1214    inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type \
1215    sph_neumann(unsigned v, T x){ return boost::math::sph_neumann(v, x, Policy()); }\
1216 \
1217    template <class T>\
1218    inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type cyl_bessel_j_zero(T v, int m)\
1219    { return boost::math::cyl_bessel_j_zero(v, m, Policy()); }\
1220 \
1221 template <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    { boost::math::cyl_bessel_j_zero(v, start_index, number_of_zeros, out_it, Policy()); }\
1227 \
1228    template <class T>\
1229    inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type cyl_neumann_zero(T v, int m)\
1230    { return boost::math::cyl_neumann_zero(v, m, Policy()); }\
1231 \
1232 template <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    { boost::math::cyl_neumann_zero(v, start_index, number_of_zeros, out_it, Policy()); }\
1238 \
1239    template <class T>\
1240    inline typename boost::math::tools::promote_args<T>::type sin_pi(T x){ return boost::math::sin_pi(x); }\
1241 \
1242    template <class T>\
1243    inline typename boost::math::tools::promote_args<T>::type cos_pi(T x){ return boost::math::cos_pi(x); }\
1244 \
1245    using boost::math::fpclassify;\
1246    using boost::math::isfinite;\
1247    using boost::math::isinf;\
1248    using boost::math::isnan;\
1249    using boost::math::isnormal;\
1250    using boost::math::signbit;\
1251    using boost::math::sign;\
1252    using boost::math::copysign;\
1253    using boost::math::changesign;\
1254    \
1255    template <class T, class U>\
1256    inline typename boost::math::tools::promote_args<T,U>::type expint(T const& z, U const& u)\
1257    { return boost::math::expint(z, u, Policy()); }\
1258    \
1259    template <class T>\
1260    inline typename boost::math::tools::promote_args<T>::type expint(T z){ return boost::math::expint(z, Policy()); }\
1261    \
1262    template <class T>\
1263    inline typename boost::math::tools::promote_args<T>::type zeta(T s){ return boost::math::zeta(s, Policy()); }\
1264    \
1265    template <class T>\
1266    inline T round(const T& v){ using boost::math::round; return round(v, Policy()); }\
1267    \
1268    template <class T>\
1269    inline int iround(const T& v){ using boost::math::iround; return iround(v, Policy()); }\
1270    \
1271    template <class T>\
1272    inline long lround(const T& v){ using boost::math::lround; return lround(v, Policy()); }\
1273    \
1274    template <class T>\
1275    inline T trunc(const T& v){ using boost::math::trunc; return trunc(v, Policy()); }\
1276    \
1277    template <class T>\
1278    inline int itrunc(const T& v){ using boost::math::itrunc; return itrunc(v, Policy()); }\
1279    \
1280    template <class T>\
1281    inline long ltrunc(const T& v){ using boost::math::ltrunc; return ltrunc(v, Policy()); }\
1282    \
1283    template <class T>\
1284    inline T modf(const T& v, T* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
1285    \
1286    template <class T>\
1287    inline T modf(const T& v, int* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
1288    \
1289    template <class T>\
1290    inline T modf(const T& v, long* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
1291    \
1292    template <int N, class T>\
1293    inline typename boost::math::tools::promote_args<T>::type pow(T v){ return boost::math::pow<N>(v, Policy()); }\
1294    \
1295    template <class T> T nextafter(const T& a, const T& b){ return boost::math::nextafter(a, b, Policy()); }\
1296    template <class T> T float_next(const T& a){ return boost::math::float_next(a, Policy()); }\
1297    template <class T> T float_prior(const T& a){ return boost::math::float_prior(a, Policy()); }\
1298    template <class T> T float_distance(const T& a, const T& b){ return boost::math::float_distance(a, b, Policy()); }\
1299    \
1300    template <class RT1, class RT2>\
1301    inline typename boost::math::tools::promote_args<RT1, RT2>::type owens_t(RT1 a, RT2 z){ return boost::math::owens_t(a, z, Policy()); }\
1302    \
1303    template <class T1, class T2>\
1304    inline std::complex<typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type> cyl_hankel_1(T1 v, T2 x)\
1305    {  return boost::math::cyl_hankel_1(v, x, Policy()); }\
1306    \
1307    template <class T1, class T2>\
1308    inline std::complex<typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type> cyl_hankel_2(T1 v, T2 x)\
1309    { return boost::math::cyl_hankel_2(v, x, Policy()); }\
1310    \
1311    template <class T1, class T2>\
1312    inline std::complex<typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type> sph_hankel_1(T1 v, T2 x)\
1313    { return boost::math::sph_hankel_1(v, x, Policy()); }\
1314    \
1315    template <class T1, class T2>\
1316    inline std::complex<typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type> sph_hankel_2(T1 v, T2 x)\
1317    { return boost::math::sph_hankel_2(v, x, Policy()); }\
1318    \
1319    template <class T>\
1320    inline typename boost::math::tools::promote_args<T>::type jacobi_elliptic(T k, T theta, T* pcn, T* pdn)\
1321    { return boost::math::jacobi_elliptic(k, theta, pcn, pdn, Policy()); }\
1322    \
1323    template <class U, class T>\
1324    inline typename boost::math::tools::promote_args<T, U>::type jacobi_sn(U k, T theta)\
1325    { return boost::math::jacobi_sn(k, theta, Policy()); }\
1326    \
1327    template <class T, class U>\
1328    inline typename boost::math::tools::promote_args<T, U>::type jacobi_cn(T k, U theta)\
1329    { return boost::math::jacobi_cn(k, theta, Policy()); }\
1330    \
1331    template <class T, class U>\
1332    inline typename boost::math::tools::promote_args<T, U>::type jacobi_dn(T k, U theta)\
1333    { return boost::math::jacobi_dn(k, theta, Policy()); }\
1334    \
1335    template <class T, class U>\
1336    inline typename boost::math::tools::promote_args<T, U>::type jacobi_cd(T k, U theta)\
1337    { return boost::math::jacobi_cd(k, theta, Policy()); }\
1338    \
1339    template <class T, class U>\
1340    inline typename boost::math::tools::promote_args<T, U>::type jacobi_dc(T k, U theta)\
1341    { return boost::math::jacobi_dc(k, theta, Policy()); }\
1342    \
1343    template <class T, class U>\
1344    inline typename boost::math::tools::promote_args<T, U>::type jacobi_ns(T k, U theta)\
1345    { return boost::math::jacobi_ns(k, theta, Policy()); }\
1346    \
1347    template <class T, class U>\
1348    inline typename boost::math::tools::promote_args<T, U>::type jacobi_sd(T k, U theta)\
1349    { return boost::math::jacobi_sd(k, theta, Policy()); }\
1350    \
1351    template <class T, class U>\
1352    inline typename boost::math::tools::promote_args<T, U>::type jacobi_ds(T k, U theta)\
1353    { return boost::math::jacobi_ds(k, theta, Policy()); }\
1354    \
1355    template <class T, class U>\
1356    inline typename boost::math::tools::promote_args<T, U>::type jacobi_nc(T k, U theta)\
1357    { return boost::math::jacobi_nc(k, theta, Policy()); }\
1358    \
1359    template <class T, class U>\
1360    inline typename boost::math::tools::promote_args<T, U>::type jacobi_nd(T k, U theta)\
1361    { return boost::math::jacobi_nd(k, theta, Policy()); }\
1362    \
1363    template <class T, class U>\
1364    inline typename boost::math::tools::promote_args<T, U>::type jacobi_sc(T k, U theta)\
1365    { return boost::math::jacobi_sc(k, theta, Policy()); }\
1366    \
1367    template <class T, class U>\
1368    inline typename boost::math::tools::promote_args<T, U>::type jacobi_cs(T k, U theta)\
1369    { return boost::math::jacobi_cs(k, theta, Policy()); }\
1370    \
1371    template <class T>\
1372    inline typename boost::math::tools::promote_args<T>::type airy_ai(T x)\
1373    {  return boost::math::airy_ai(x, Policy());  }\
1374    \
1375    template <class T>\
1376    inline typename boost::math::tools::promote_args<T>::type airy_bi(T x)\
1377    {  return boost::math::airy_bi(x, Policy());  }\
1378    \
1379    template <class T>\
1380    inline typename boost::math::tools::promote_args<T>::type airy_ai_prime(T x)\
1381    {  return boost::math::airy_ai_prime(x, Policy());  }\
1382    \
1383    template <class T>\
1384    inline typename boost::math::tools::promote_args<T>::type airy_bi_prime(T x)\
1385    {  return boost::math::airy_bi_prime(x, Policy());  }\
1386    \
1387    template <class T>\
1388    inline T airy_ai_zero(int m)\
1389    { return boost::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 boost::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 boost::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 boost::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