math/special_functions/math_fwd.hpp

0001 // math_fwd.hpp
0002
0003 // TODO revise completely for new distribution classes.
0004
0005 // Copyright Paul A. Bristow 2006.
0006 // Copyright John Maddock 2006.
0007
0008 // Use, modification and distribution are subject to the
0009 // Boost Software License, Version 1.0.
0010 // (See accompanying file LICENSE_1_0.txt
0011 // or copy at http://www.boost.org/LICENSE_1_0.txt)
0012
0013 // Omnibus list of forward declarations of math special functions.
0014
0015 // IT = Integer type.
0016 // RT = Real type (built-in floating-point types, float, double, long double) & User Defined Types
0017 // AT = Integer or Real type
0018
0019 #ifndef BOOST_MATH_SPECIAL_MATH_FWD_HPP
0020 #define BOOST_MATH_SPECIAL_MATH_FWD_HPP
0021
0022 #ifdef _MSC_VER
0023 #pragma once
0024 #endif
0025
0026 #include <vector>
0027 #include <complex>
0028 #include <type_traits>
0029 #include <boost/math/special_functions/detail/round_fwd.hpp>
0030 #include <boost/math/tools/promotion.hpp> // for argument promotion.
0031 #include <boost/math/policies/policy.hpp>
0032
0033 #define BOOST_NO_MACRO_EXPAND /**/
0034
0035 namespace boost
0036 {
0037    namespace math
0038    { // Math functions (in roughly alphabetic order).
0039
0040    // Beta functions.
0041    template <class RT1, class RT2>
0042    tools::promote_args_t<RT1, RT2>
0043          beta(RT1 a, RT2 b); // Beta function (2 arguments).
0044
0045    template <class RT1, class RT2, class A>
0046    tools::promote_args_t<RT1, RT2, A>
0047          beta(RT1 a, RT2 b, A x); // Beta function (3 arguments).
0048
0049    template <class RT1, class RT2, class RT3, class Policy>
0050    tools::promote_args_t<RT1, RT2, RT3>
0051          beta(RT1 a, RT2 b, RT3 x, const Policy& pol); // Beta function (3 arguments).
0052
0053    template <class RT1, class RT2, class RT3>
0054    tools::promote_args_t<RT1, RT2, RT3>
0055          betac(RT1 a, RT2 b, RT3 x);
0056
0057    template <class RT1, class RT2, class RT3, class Policy>
0058    tools::promote_args_t<RT1, RT2, RT3>
0059          betac(RT1 a, RT2 b, RT3 x, const Policy& pol);
0060
0061    template <class RT1, class RT2, class RT3>
0062    tools::promote_args_t<RT1, RT2, RT3>
0063          ibeta(RT1 a, RT2 b, RT3 x); // Incomplete beta function.
0064
0065    template <class RT1, class RT2, class RT3, class Policy>
0066    tools::promote_args_t<RT1, RT2, RT3>
0067          ibeta(RT1 a, RT2 b, RT3 x, const Policy& pol); // Incomplete beta function.
0068
0069    template <class RT1, class RT2, class RT3>
0070    tools::promote_args_t<RT1, RT2, RT3>
0071          ibetac(RT1 a, RT2 b, RT3 x); // Incomplete beta complement function.
0072
0073    template <class RT1, class RT2, class RT3, class Policy>
0074    tools::promote_args_t<RT1, RT2, RT3>
0075          ibetac(RT1 a, RT2 b, RT3 x, const Policy& pol); // Incomplete beta complement function.
0076
0077    template <class T1, class T2, class T3, class T4>
0078    tools::promote_args_t<T1, T2, T3, T4>
0079          ibeta_inv(T1 a, T2 b, T3 p, T4* py);
0080
0081    template <class T1, class T2, class T3, class T4, class Policy>
0082    tools::promote_args_t<T1, T2, T3, T4>
0083          ibeta_inv(T1 a, T2 b, T3 p, T4* py, const Policy& pol);
0084
0085    template <class RT1, class RT2, class RT3>
0086    tools::promote_args_t<RT1, RT2, RT3>
0087          ibeta_inv(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function.
0088
0089    template <class RT1, class RT2, class RT3, class Policy>
0090    tools::promote_args_t<RT1, RT2, RT3>
0091          ibeta_inv(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function.
0092
0093    template <class RT1, class RT2, class RT3>
0094    tools::promote_args_t<RT1, RT2, RT3>
0095          ibeta_inva(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function.
0096
0097    template <class RT1, class RT2, class RT3, class Policy>
0098    tools::promote_args_t<RT1, RT2, RT3>
0099          ibeta_inva(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function.
0100
0101    template <class RT1, class RT2, class RT3>
0102    tools::promote_args_t<RT1, RT2, RT3>
0103          ibeta_invb(RT1 a, RT2 b, RT3 p); // Incomplete beta inverse function.
0104
0105    template <class RT1, class RT2, class RT3, class Policy>
0106    tools::promote_args_t<RT1, RT2, RT3>
0107          ibeta_invb(RT1 a, RT2 b, RT3 p, const Policy&); // Incomplete beta inverse function.
0108
0109    template <class T1, class T2, class T3, class T4>
0110    tools::promote_args_t<T1, T2, T3, T4>
0111          ibetac_inv(T1 a, T2 b, T3 q, T4* py);
0112
0113    template <class T1, class T2, class T3, class T4, class Policy>
0114    tools::promote_args_t<T1, T2, T3, T4>
0115          ibetac_inv(T1 a, T2 b, T3 q, T4* py, const Policy& pol);
0116
0117    template <class RT1, class RT2, class RT3>
0118    tools::promote_args_t<RT1, RT2, RT3>
0119          ibetac_inv(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function.
0120
0121    template <class RT1, class RT2, class RT3, class Policy>
0122    tools::promote_args_t<RT1, RT2, RT3>
0123          ibetac_inv(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function.
0124
0125    template <class RT1, class RT2, class RT3>
0126    tools::promote_args_t<RT1, RT2, RT3>
0127          ibetac_inva(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function.
0128
0129    template <class RT1, class RT2, class RT3, class Policy>
0130    tools::promote_args_t<RT1, RT2, RT3>
0131          ibetac_inva(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function.
0132
0133    template <class RT1, class RT2, class RT3>
0134    tools::promote_args_t<RT1, RT2, RT3>
0135          ibetac_invb(RT1 a, RT2 b, RT3 q); // Incomplete beta complement inverse function.
0136
0137    template <class RT1, class RT2, class RT3, class Policy>
0138    tools::promote_args_t<RT1, RT2, RT3>
0139          ibetac_invb(RT1 a, RT2 b, RT3 q, const Policy&); // Incomplete beta complement inverse function.
0140
0141    template <class RT1, class RT2, class RT3>
0142    tools::promote_args_t<RT1, RT2, RT3>
0143          ibeta_derivative(RT1 a, RT2 b, RT3 x);  // derivative of incomplete beta
0144
0145    template <class RT1, class RT2, class RT3, class Policy>
0146    tools::promote_args_t<RT1, RT2, RT3>
0147          ibeta_derivative(RT1 a, RT2 b, RT3 x, const Policy& pol);  // derivative of incomplete beta
0148
0149    // Binomial:
0150    template <class T, class Policy>
0151    T binomial_coefficient(unsigned n, unsigned k, const Policy& pol);
0152    template <class T>
0153    T binomial_coefficient(unsigned n, unsigned k);
0154
0155    // erf & erfc error functions.
0156    template <class RT> // Error function.
0157    tools::promote_args_t<RT> erf(RT z);
0158    template <class RT, class Policy> // Error function.
0159    tools::promote_args_t<RT> erf(RT z, const Policy&);
0160
0161    template <class RT>// Error function complement.
0162    tools::promote_args_t<RT> erfc(RT z);
0163    template <class RT, class Policy>// Error function complement.
0164    tools::promote_args_t<RT> erfc(RT z, const Policy&);
0165
0166    template <class RT>// Error function inverse.
0167    tools::promote_args_t<RT> erf_inv(RT z);
0168    template <class RT, class Policy>// Error function inverse.
0169    tools::promote_args_t<RT> erf_inv(RT z, const Policy& pol);
0170
0171    template <class RT>// Error function complement inverse.
0172    tools::promote_args_t<RT> erfc_inv(RT z);
0173    template <class RT, class Policy>// Error function complement inverse.
0174    tools::promote_args_t<RT> erfc_inv(RT z, const Policy& pol);
0175
0176    // Polynomials:
0177    template <class T1, class T2, class T3>
0178    tools::promote_args_t<T1, T2, T3>
0179          legendre_next(unsigned l, T1 x, T2 Pl, T3 Plm1);
0180
0181    template <class T>
0182    tools::promote_args_t<T>
0183          legendre_p(int l, T x);
0184    template <class T>
0185    tools::promote_args_t<T>
0186           legendre_p_prime(int l, T x);
0187
0188
0189    template <class T, class Policy>
0190    inline std::vector<T> legendre_p_zeros(int l, const Policy& pol);
0191
0192    template <class T>
0193    inline std::vector<T> legendre_p_zeros(int l);
0194
0195    template <class T, class Policy>
0196    typename std::enable_if<policies::is_policy<Policy>::value, tools::promote_args_t<T>>::type
0197          legendre_p(int l, T x, const Policy& pol);
0198    template <class T, class Policy>
0199    inline typename std::enable_if<policies::is_policy<Policy>::value, tools::promote_args_t<T>>::type
0200       legendre_p_prime(int l, T x, const Policy& pol);
0201
0202    template <class T>
0203    tools::promote_args_t<T>
0204          legendre_q(unsigned l, T x);
0205
0206    template <class T, class Policy>
0207    typename std::enable_if<policies::is_policy<Policy>::value, tools::promote_args_t<T>>::type
0208          legendre_q(unsigned l, T x, const Policy& pol);
0209
0210    template <class T1, class T2, class T3>
0211    tools::promote_args_t<T1, T2, T3>
0212          legendre_next(unsigned l, unsigned m, T1 x, T2 Pl, T3 Plm1);
0213
0214    template <class T>
0215    tools::promote_args_t<T>
0216          legendre_p(int l, int m, T x);
0217
0218    template <class T, class Policy>
0219    tools::promote_args_t<T>
0220          legendre_p(int l, int m, T x, const Policy& pol);
0221
0222    template <class T1, class T2, class T3>
0223    tools::promote_args_t<T1, T2, T3>
0224          laguerre_next(unsigned n, T1 x, T2 Ln, T3 Lnm1);
0225
0226    template <class T1, class T2, class T3>
0227    tools::promote_args_t<T1, T2, T3>
0228       laguerre_next(unsigned n, unsigned l, T1 x, T2 Pl, T3 Plm1);
0229
0230    template <class T>
0231    tools::promote_args_t<T>
0232       laguerre(unsigned n, T x);
0233
0234    template <class T, class Policy>
0235    tools::promote_args_t<T>
0236       laguerre(unsigned n, unsigned m, T x, const Policy& pol);
0237
0238    template <class T1, class T2>
0239    struct laguerre_result
0240    {
0241       using type = typename std::conditional<
0242          policies::is_policy<T2>::value,
0243          typename tools::promote_args<T1>::type,
0244          typename tools::promote_args<T2>::type
0245       >::type;
0246    };
0247
0248    template <class T1, class T2>
0249    typename laguerre_result<T1, T2>::type
0250       laguerre(unsigned n, T1 m, T2 x);
0251
0252    template <class T>
0253    tools::promote_args_t<T>
0254       hermite(unsigned n, T x);
0255
0256    template <class T, class Policy>
0257    tools::promote_args_t<T>
0258       hermite(unsigned n, T x, const Policy& pol);
0259
0260    template <class T1, class T2, class T3>
0261    tools::promote_args_t<T1, T2, T3>
0262       hermite_next(unsigned n, T1 x, T2 Hn, T3 Hnm1);
0263
0264    template<class T1, class T2, class T3>
0265    tools::promote_args_t<T1, T2, T3> chebyshev_next(T1 const & x, T2 const & Tn, T3 const & Tn_1);
0266
0267    template <class Real, class Policy>
0268    tools::promote_args_t<Real>
0269       chebyshev_t(unsigned n, Real const & x, const Policy&);
0270    template<class Real>
0271    tools::promote_args_t<Real> chebyshev_t(unsigned n, Real const & x);
0272
0273    template <class Real, class Policy>
0274    tools::promote_args_t<Real>
0275       chebyshev_u(unsigned n, Real const & x, const Policy&);
0276    template<class Real>
0277    tools::promote_args_t<Real> chebyshev_u(unsigned n, Real const & x);
0278
0279    template <class Real, class Policy>
0280    tools::promote_args_t<Real>
0281       chebyshev_t_prime(unsigned n, Real const & x, const Policy&);
0282    template<class Real>
0283    tools::promote_args_t<Real> chebyshev_t_prime(unsigned n, Real const & x);
0284
0285    template<class Real, class T2>
0286    Real chebyshev_clenshaw_recurrence(const Real* const c, size_t length, const T2& x);
0287
0288    template <class T1, class T2>
0289    std::complex<tools::promote_args_t<T1, T2>>
0290          spherical_harmonic(unsigned n, int m, T1 theta, T2 phi);
0291
0292    template <class T1, class T2, class Policy>
0293    std::complex<tools::promote_args_t<T1, T2>>
0294       spherical_harmonic(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
0295
0296    template <class T1, class T2>
0297    tools::promote_args_t<T1, T2>
0298          spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi);
0299
0300    template <class T1, class T2, class Policy>
0301    tools::promote_args_t<T1, T2>
0302       spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
0303
0304    template <class T1, class T2>
0305    tools::promote_args_t<T1, T2>
0306          spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi);
0307
0308    template <class T1, class T2, class Policy>
0309    tools::promote_args_t<T1, T2>
0310       spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
0311
0312    // Elliptic integrals:
0313    template <class T1, class T2, class T3>
0314    tools::promote_args_t<T1, T2, T3>
0315          ellint_rf(T1 x, T2 y, T3 z);
0316
0317    template <class T1, class T2, class T3, class Policy>
0318    tools::promote_args_t<T1, T2, T3>
0319          ellint_rf(T1 x, T2 y, T3 z, const Policy& pol);
0320
0321    template <class T1, class T2, class T3>
0322    tools::promote_args_t<T1, T2, T3>
0323          ellint_rd(T1 x, T2 y, T3 z);
0324
0325    template <class T1, class T2, class T3, class Policy>
0326    tools::promote_args_t<T1, T2, T3>
0327          ellint_rd(T1 x, T2 y, T3 z, const Policy& pol);
0328
0329    template <class T1, class T2>
0330    tools::promote_args_t<T1, T2>
0331          ellint_rc(T1 x, T2 y);
0332
0333    template <class T1, class T2, class Policy>
0334    tools::promote_args_t<T1, T2>
0335          ellint_rc(T1 x, T2 y, const Policy& pol);
0336
0337    template <class T1, class T2, class T3, class T4>
0338    tools::promote_args_t<T1, T2, T3, T4>
0339          ellint_rj(T1 x, T2 y, T3 z, T4 p);
0340
0341    template <class T1, class T2, class T3, class T4, class Policy>
0342    tools::promote_args_t<T1, T2, T3, T4>
0343          ellint_rj(T1 x, T2 y, T3 z, T4 p, const Policy& pol);
0344
0345    template <class T1, class T2, class T3>
0346    tools::promote_args_t<T1, T2, T3>
0347       ellint_rg(T1 x, T2 y, T3 z);
0348
0349    template <class T1, class T2, class T3, class Policy>
0350    tools::promote_args_t<T1, T2, T3>
0351       ellint_rg(T1 x, T2 y, T3 z, const Policy& pol);
0352
0353    template <typename T>
0354    tools::promote_args_t<T> ellint_2(T k);
0355
0356    template <class T1, class T2>
0357    tools::promote_args_t<T1, T2> ellint_2(T1 k, T2 phi);
0358
0359    template <class T1, class T2, class Policy>
0360    tools::promote_args_t<T1, T2> ellint_2(T1 k, T2 phi, const Policy& pol);
0361
0362    template <typename T>
0363    tools::promote_args_t<T> ellint_1(T k);
0364
0365    template <class T1, class T2>
0366    tools::promote_args_t<T1, T2> ellint_1(T1 k, T2 phi);
0367
0368    template <class T1, class T2, class Policy>
0369    tools::promote_args_t<T1, T2> ellint_1(T1 k, T2 phi, const Policy& pol);
0370
0371    template <typename T>
0372    tools::promote_args_t<T> ellint_d(T k);
0373
0374    template <class T1, class T2>
0375    tools::promote_args_t<T1, T2> ellint_d(T1 k, T2 phi);
0376
0377    template <class T1, class T2, class Policy>
0378    tools::promote_args_t<T1, T2> ellint_d(T1 k, T2 phi, const Policy& pol);
0379
0380    template <class T1, class T2>
0381    tools::promote_args_t<T1, T2> jacobi_zeta(T1 k, T2 phi);
0382
0383    template <class T1, class T2, class Policy>
0384    tools::promote_args_t<T1, T2> jacobi_zeta(T1 k, T2 phi, const Policy& pol);
0385
0386    template <class T1, class T2>
0387    tools::promote_args_t<T1, T2> heuman_lambda(T1 k, T2 phi);
0388
0389    template <class T1, class T2, class Policy>
0390    tools::promote_args_t<T1, T2> heuman_lambda(T1 k, T2 phi, const Policy& pol);
0391
0392    namespace detail{
0393
0394    template <class T, class U, class V>
0395    struct ellint_3_result
0396    {
0397       using type = typename std::conditional<
0398          policies::is_policy<V>::value,
0399          tools::promote_args_t<T, U>,
0400          tools::promote_args_t<T, U, V>
0401       >::type;
0402    };
0403
0404    } // namespace detail
0405
0406
0407    template <class T1, class T2, class T3>
0408    typename detail::ellint_3_result<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi);
0409
0410    template <class T1, class T2, class T3, class Policy>
0411    tools::promote_args_t<T1, T2, T3> ellint_3(T1 k, T2 v, T3 phi, const Policy& pol);
0412
0413    template <class T1, class T2>
0414    tools::promote_args_t<T1, T2> ellint_3(T1 k, T2 v);
0415
0416    // Factorial functions.
0417    // Note: not for integral types, at present.
0418    template <class RT>
0419    struct max_factorial;
0420    template <class RT>
0421    RT factorial(unsigned int);
0422    template <class RT, class Policy>
0423    RT factorial(unsigned int, const Policy& pol);
0424    template <class RT>
0425    RT unchecked_factorial(unsigned int BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_TYPE(RT));
0426    template <class RT>
0427    RT double_factorial(unsigned i);
0428    template <class RT, class Policy>
0429    RT double_factorial(unsigned i, const Policy& pol);
0430
0431    template <class RT>
0432    tools::promote_args_t<RT> falling_factorial(RT x, unsigned n);
0433
0434    template <class RT, class Policy>
0435    tools::promote_args_t<RT> falling_factorial(RT x, unsigned n, const Policy& pol);
0436
0437    template <class RT>
0438    tools::promote_args_t<RT> rising_factorial(RT x, int n);
0439
0440    template <class RT, class Policy>
0441    tools::promote_args_t<RT> rising_factorial(RT x, int n, const Policy& pol);
0442
0443    // Gamma functions.
0444    template <class RT>
0445    tools::promote_args_t<RT> tgamma(RT z);
0446
0447    template <class RT>
0448    tools::promote_args_t<RT> tgamma1pm1(RT z);
0449
0450    template <class RT, class Policy>
0451    tools::promote_args_t<RT> tgamma1pm1(RT z, const Policy& pol);
0452
0453    template <class RT1, class RT2>
0454    tools::promote_args_t<RT1, RT2> tgamma(RT1 a, RT2 z);
0455
0456    template <class RT1, class RT2, class Policy>
0457    tools::promote_args_t<RT1, RT2> tgamma(RT1 a, RT2 z, const Policy& pol);
0458
0459    template <class RT>
0460    tools::promote_args_t<RT> lgamma(RT z, int* sign);
0461
0462    template <class RT, class Policy>
0463    tools::promote_args_t<RT> lgamma(RT z, int* sign, const Policy& pol);
0464
0465    template <class RT>
0466    tools::promote_args_t<RT> lgamma(RT x);
0467
0468    template <class RT, class Policy>
0469    tools::promote_args_t<RT> lgamma(RT x, const Policy& pol);
0470
0471    template <class RT1, class RT2>
0472    tools::promote_args_t<RT1, RT2> tgamma_lower(RT1 a, RT2 z);
0473
0474    template <class RT1, class RT2, class Policy>
0475    tools::promote_args_t<RT1, RT2> tgamma_lower(RT1 a, RT2 z, const Policy&);
0476
0477    template <class RT1, class RT2>
0478    tools::promote_args_t<RT1, RT2> gamma_q(RT1 a, RT2 z);
0479
0480    template <class RT1, class RT2, class Policy>
0481    tools::promote_args_t<RT1, RT2> gamma_q(RT1 a, RT2 z, const Policy&);
0482
0483    template <class RT1, class RT2>
0484    tools::promote_args_t<RT1, RT2> gamma_p(RT1 a, RT2 z);
0485
0486    template <class RT1, class RT2, class Policy>
0487    tools::promote_args_t<RT1, RT2> gamma_p(RT1 a, RT2 z, const Policy&);
0488
0489    template <class T1, class T2>
0490    tools::promote_args_t<T1, T2> tgamma_delta_ratio(T1 z, T2 delta);
0491
0492    template <class T1, class T2, class Policy>
0493    tools::promote_args_t<T1, T2> tgamma_delta_ratio(T1 z, T2 delta, const Policy&);
0494
0495    template <class T1, class T2>
0496    tools::promote_args_t<T1, T2> tgamma_ratio(T1 a, T2 b);
0497
0498    template <class T1, class T2, class Policy>
0499    tools::promote_args_t<T1, T2> tgamma_ratio(T1 a, T2 b, const Policy&);
0500
0501    template <class T1, class T2>
0502    tools::promote_args_t<T1, T2> gamma_p_derivative(T1 a, T2 x);
0503
0504    template <class T1, class T2, class Policy>
0505    tools::promote_args_t<T1, T2> gamma_p_derivative(T1 a, T2 x, const Policy&);
0506
0507    // gamma inverse.
0508    template <class T1, class T2>
0509    tools::promote_args_t<T1, T2> gamma_p_inv(T1 a, T2 p);
0510
0511    template <class T1, class T2, class Policy>
0512    tools::promote_args_t<T1, T2> gamma_p_inva(T1 a, T2 p, const Policy&);
0513
0514    template <class T1, class T2>
0515    tools::promote_args_t<T1, T2> gamma_p_inva(T1 a, T2 p);
0516
0517    template <class T1, class T2, class Policy>
0518    tools::promote_args_t<T1, T2> gamma_p_inv(T1 a, T2 p, const Policy&);
0519
0520    template <class T1, class T2>
0521    tools::promote_args_t<T1, T2> gamma_q_inv(T1 a, T2 q);
0522
0523    template <class T1, class T2, class Policy>
0524    tools::promote_args_t<T1, T2> gamma_q_inv(T1 a, T2 q, const Policy&);
0525
0526    template <class T1, class T2>
0527    tools::promote_args_t<T1, T2> gamma_q_inva(T1 a, T2 q);
0528
0529    template <class T1, class T2, class Policy>
0530    tools::promote_args_t<T1, T2> gamma_q_inva(T1 a, T2 q, const Policy&);
0531
0532    // digamma:
0533    template <class T>
0534    tools::promote_args_t<T> digamma(T x);
0535
0536    template <class T, class Policy>
0537    tools::promote_args_t<T> digamma(T x, const Policy&);
0538
0539    // trigamma:
0540    template <class T>
0541    tools::promote_args_t<T> trigamma(T x);
0542
0543    template <class T, class Policy>
0544    tools::promote_args_t<T> trigamma(T x, const Policy&);
0545
0546    // polygamma:
0547    template <class T>
0548    tools::promote_args_t<T> polygamma(int n, T x);
0549
0550    template <class T, class Policy>
0551    tools::promote_args_t<T> polygamma(int n, T x, const Policy&);
0552
0553    // Hypotenuse function sqrt(x ^ 2 + y ^ 2).
0554    template <class T1, class T2>
0555    tools::promote_args_t<T1, T2>
0556          hypot(T1 x, T2 y);
0557
0558    template <class T1, class T2, class Policy>
0559    tools::promote_args_t<T1, T2>
0560          hypot(T1 x, T2 y, const Policy&);
0561
0562    // cbrt - cube root.
0563    template <class RT>
0564    tools::promote_args_t<RT> cbrt(RT z);
0565
0566    template <class RT, class Policy>
0567    tools::promote_args_t<RT> cbrt(RT z, const Policy&);
0568
0569    // log1p is log(x + 1)
0570    template <class T>
0571    tools::promote_args_t<T> log1p(T);
0572
0573    template <class T, class Policy>
0574    tools::promote_args_t<T> log1p(T, const Policy&);
0575
0576    // log1pmx is log(x + 1) - x
0577    template <class T>
0578    tools::promote_args_t<T> log1pmx(T);
0579
0580    template <class T, class Policy>
0581    tools::promote_args_t<T> log1pmx(T, const Policy&);
0582
0583    // Exp (x) minus 1 functions.
0584    template <class T>
0585    tools::promote_args_t<T> expm1(T);
0586
0587    template <class T, class Policy>
0588    tools::promote_args_t<T> expm1(T, const Policy&);
0589
0590    // Power - 1
0591    template <class T1, class T2>
0592    tools::promote_args_t<T1, T2>
0593          powm1(const T1 a, const T2 z);
0594
0595    template <class T1, class T2, class Policy>
0596    tools::promote_args_t<T1, T2>
0597          powm1(const T1 a, const T2 z, const Policy&);
0598
0599    // sqrt(1+x) - 1
0600    template <class T>
0601    tools::promote_args_t<T> sqrt1pm1(const T& val);
0602
0603    template <class T, class Policy>
0604    tools::promote_args_t<T> sqrt1pm1(const T& val, const Policy&);
0605
0606    // sinus cardinals:
0607    template <class T>
0608    tools::promote_args_t<T> sinc_pi(T x);
0609
0610    template <class T, class Policy>
0611    tools::promote_args_t<T> sinc_pi(T x, const Policy&);
0612
0613    template <class T>
0614    tools::promote_args_t<T> sinhc_pi(T x);
0615
0616    template <class T, class Policy>
0617    tools::promote_args_t<T> sinhc_pi(T x, const Policy&);
0618
0619    // inverse hyperbolics:
0620    template<typename T>
0621    tools::promote_args_t<T> asinh(T x);
0622
0623    template<typename T, class Policy>
0624    tools::promote_args_t<T> asinh(T x, const Policy&);
0625
0626    template<typename T>
0627    tools::promote_args_t<T> acosh(T x);
0628
0629    template<typename T, class Policy>
0630    tools::promote_args_t<T> acosh(T x, const Policy&);
0631
0632    template<typename T>
0633    tools::promote_args_t<T> atanh(T x);
0634
0635    template<typename T, class Policy>
0636    tools::promote_args_t<T> atanh(T x, const Policy&);
0637
0638    namespace detail{
0639
0640       typedef std::integral_constant<int, 0> bessel_no_int_tag;      // No integer optimisation possible.
0641       typedef std::integral_constant<int, 1> bessel_maybe_int_tag;   // Maybe integer optimisation.
0642       typedef std::integral_constant<int, 2> bessel_int_tag;         // Definite integer optimisation.
0643
0644       template <class T1, class T2, class Policy>
0645       struct bessel_traits
0646       {
0647          using result_type = typename std::conditional<
0648             std::is_integral<T1>::value,
0649             typename tools::promote_args<T2>::type,
0650             tools::promote_args_t<T1, T2>
0651          >::type;
0652
0653          typedef typename policies::precision<result_type, Policy>::type precision_type;
0654
0655          using optimisation_tag = typename std::conditional<
0656             (precision_type::value <= 0 || precision_type::value > 64),
0657             bessel_no_int_tag,
0658             typename std::conditional<
0659                std::is_integral<T1>::value,
0660                bessel_int_tag,
0661                bessel_maybe_int_tag
0662             >::type
0663          >::type;
0664
0665          using optimisation_tag128 = typename std::conditional<
0666             (precision_type::value <= 0 || precision_type::value > 113),
0667             bessel_no_int_tag,
0668             typename std::conditional<
0669                std::is_integral<T1>::value,
0670                bessel_int_tag,
0671                bessel_maybe_int_tag
0672             >::type
0673          >::type;
0674       };
0675    } // detail
0676
0677    // Bessel functions:
0678    template <class T1, class T2, class Policy>
0679    typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_j(T1 v, T2 x, const Policy& pol);
0680    template <class T1, class T2, class Policy>
0681    typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_j_prime(T1 v, T2 x, const Policy& pol);
0682
0683    template <class T1, class T2>
0684    typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_j(T1 v, T2 x);
0685    template <class T1, class T2>
0686    typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_j_prime(T1 v, T2 x);
0687
0688    template <class T, class Policy>
0689    typename detail::bessel_traits<T, T, Policy>::result_type sph_bessel(unsigned v, T x, const Policy& pol);
0690    template <class T, class Policy>
0691    typename detail::bessel_traits<T, T, Policy>::result_type sph_bessel_prime(unsigned v, T x, const Policy& pol);
0692
0693    template <class T>
0694    typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_bessel(unsigned v, T x);
0695    template <class T>
0696    typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_bessel_prime(unsigned v, T x);
0697
0698    template <class T1, class T2, class Policy>
0699    typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_i(T1 v, T2 x, const Policy& pol);
0700    template <class T1, class T2, class Policy>
0701    typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_i_prime(T1 v, T2 x, const Policy& pol);
0702
0703    template <class T1, class T2>
0704    typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_i(T1 v, T2 x);
0705    template <class T1, class T2>
0706    typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_i_prime(T1 v, T2 x);
0707
0708    template <class T1, class T2, class Policy>
0709    typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_k(T1 v, T2 x, const Policy& pol);
0710    template <class T1, class T2, class Policy>
0711    typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_k_prime(T1 v, T2 x, const Policy& pol);
0712
0713    template <class T1, class T2>
0714    typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_k(T1 v, T2 x);
0715    template <class T1, class T2>
0716    typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_k_prime(T1 v, T2 x);
0717
0718    template <class T1, class T2, class Policy>
0719    typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_neumann(T1 v, T2 x, const Policy& pol);
0720    template <class T1, class T2, class Policy>
0721    typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_neumann_prime(T1 v, T2 x, const Policy& pol);
0722
0723    template <class T1, class T2>
0724    typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_neumann(T1 v, T2 x);
0725    template <class T1, class T2>
0726    typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_neumann_prime(T1 v, T2 x);
0727
0728    template <class T, class Policy>
0729    typename detail::bessel_traits<T, T, Policy>::result_type sph_neumann(unsigned v, T x, const Policy& pol);
0730    template <class T, class Policy>
0731    typename detail::bessel_traits<T, T, Policy>::result_type sph_neumann_prime(unsigned v, T x, const Policy& pol);
0732
0733    template <class T>
0734    typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_neumann(unsigned v, T x);
0735    template <class T>
0736    typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_neumann_prime(unsigned v, T x);
0737
0738    template <class T, class Policy>
0739    typename detail::bessel_traits<T, T, Policy>::result_type cyl_bessel_j_zero(T v, int m, const Policy& pol);
0740
0741    template <class T>
0742    typename detail::bessel_traits<T, T, policies::policy<> >::result_type cyl_bessel_j_zero(T v, int m);
0743
0744    template <class T, class OutputIterator>
0745    OutputIterator cyl_bessel_j_zero(T v,
0746                           int start_index,
0747                           unsigned number_of_zeros,
0748                           OutputIterator out_it);
0749
0750    template <class T, class OutputIterator, class Policy>
0751    OutputIterator cyl_bessel_j_zero(T v,
0752                           int start_index,
0753                           unsigned number_of_zeros,
0754                           OutputIterator out_it,
0755                           const Policy&);
0756
0757    template <class T, class Policy>
0758    typename detail::bessel_traits<T, T, Policy>::result_type cyl_neumann_zero(T v, int m, const Policy& pol);
0759
0760    template <class T>
0761    typename detail::bessel_traits<T, T, policies::policy<> >::result_type cyl_neumann_zero(T v, int m);
0762
0763    template <class T, class OutputIterator>
0764    OutputIterator cyl_neumann_zero(T v,
0765                          int start_index,
0766                          unsigned number_of_zeros,
0767                          OutputIterator out_it);
0768
0769    template <class T, class OutputIterator, class Policy>
0770    OutputIterator cyl_neumann_zero(T v,
0771                          int start_index,
0772                          unsigned number_of_zeros,
0773                          OutputIterator out_it,
0774                          const Policy&);
0775
0776    template <class T1, class T2>
0777    std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> cyl_hankel_1(T1 v, T2 x);
0778
0779    template <class T1, class T2, class Policy>
0780    std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> cyl_hankel_1(T1 v, T2 x, const Policy& pol);
0781
0782    template <class T1, class T2, class Policy>
0783    std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> cyl_hankel_2(T1 v, T2 x, const Policy& pol);
0784
0785    template <class T1, class T2>
0786    std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> cyl_hankel_2(T1 v, T2 x);
0787
0788    template <class T1, class T2, class Policy>
0789    std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> sph_hankel_1(T1 v, T2 x, const Policy& pol);
0790
0791    template <class T1, class T2>
0792    std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> sph_hankel_1(T1 v, T2 x);
0793
0794    template <class T1, class T2, class Policy>
0795    std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> sph_hankel_2(T1 v, T2 x, const Policy& pol);
0796
0797    template <class T1, class T2>
0798    std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> sph_hankel_2(T1 v, T2 x);
0799
0800    template <class T, class Policy>
0801    tools::promote_args_t<T> airy_ai(T x, const Policy&);
0802
0803    template <class T>
0804    tools::promote_args_t<T> airy_ai(T x);
0805
0806    template <class T, class Policy>
0807    tools::promote_args_t<T> airy_bi(T x, const Policy&);
0808
0809    template <class T>
0810    tools::promote_args_t<T> airy_bi(T x);
0811
0812    template <class T, class Policy>
0813    tools::promote_args_t<T> airy_ai_prime(T x, const Policy&);
0814
0815    template <class T>
0816    tools::promote_args_t<T> airy_ai_prime(T x);
0817
0818    template <class T, class Policy>
0819    tools::promote_args_t<T> airy_bi_prime(T x, const Policy&);
0820
0821    template <class T>
0822    tools::promote_args_t<T> airy_bi_prime(T x);
0823
0824    template <class T>
0825    T airy_ai_zero(int m);
0826    template <class T, class Policy>
0827    T airy_ai_zero(int m, const Policy&);
0828
0829    template <class OutputIterator>
0830    OutputIterator airy_ai_zero(
0831                      int start_index,
0832                      unsigned number_of_zeros,
0833                      OutputIterator out_it);
0834    template <class OutputIterator, class Policy>
0835    OutputIterator airy_ai_zero(
0836                      int start_index,
0837                      unsigned number_of_zeros,
0838                      OutputIterator out_it,
0839                      const Policy&);
0840
0841    template <class T>
0842    T airy_bi_zero(int m);
0843    template <class T, class Policy>
0844    T airy_bi_zero(int m, const Policy&);
0845
0846    template <class OutputIterator>
0847    OutputIterator airy_bi_zero(
0848                      int start_index,
0849                      unsigned number_of_zeros,
0850                      OutputIterator out_it);
0851    template <class OutputIterator, class Policy>
0852    OutputIterator airy_bi_zero(
0853                      int start_index,
0854                      unsigned number_of_zeros,
0855                      OutputIterator out_it,
0856                      const Policy&);
0857
0858    template <class T, class Policy>
0859    tools::promote_args_t<T> sin_pi(T x, const Policy&);
0860
0861    template <class T>
0862    tools::promote_args_t<T> sin_pi(T x);
0863
0864    template <class T, class Policy>
0865    tools::promote_args_t<T> cos_pi(T x, const Policy&);
0866
0867    template <class T>
0868    tools::promote_args_t<T> cos_pi(T x);
0869
0870    template <class T>
0871    int fpclassify BOOST_NO_MACRO_EXPAND(T t);
0872
0873    template <class T>
0874    bool isfinite BOOST_NO_MACRO_EXPAND(T z);
0875
0876    template <class T>
0877    bool isinf BOOST_NO_MACRO_EXPAND(T t);
0878
0879    template <class T>
0880    bool isnan BOOST_NO_MACRO_EXPAND(T t);
0881
0882    template <class T>
0883    bool isnormal BOOST_NO_MACRO_EXPAND(T t);
0884
0885    template<class T>
0886    int signbit BOOST_NO_MACRO_EXPAND(T x);
0887
0888    template <class T>
0889    int sign BOOST_NO_MACRO_EXPAND(const T& z);
0890
0891    template <class T, class U>
0892    typename tools::promote_args_permissive<T, U>::type copysign BOOST_NO_MACRO_EXPAND(const T& x, const U& y);
0893
0894    template <class T>
0895    typename tools::promote_args_permissive<T>::type changesign BOOST_NO_MACRO_EXPAND(const T& z);
0896
0897    // Exponential integrals:
0898    namespace detail{
0899
0900    template <class T, class U>
0901    struct expint_result
0902    {
0903       typedef typename std::conditional<
0904          policies::is_policy<U>::value,
0905          tools::promote_args_t<T>,
0906          typename tools::promote_args<U>::type
0907       >::type type;
0908    };
0909
0910    } // namespace detail
0911
0912    template <class T, class Policy>
0913    tools::promote_args_t<T> expint(unsigned n, T z, const Policy&);
0914
0915    template <class T, class U>
0916    typename detail::expint_result<T, U>::type expint(T const z, U const u);
0917
0918    template <class T>
0919    tools::promote_args_t<T> expint(T z);
0920
0921    // Zeta:
0922    template <class T, class Policy>
0923    tools::promote_args_t<T> zeta(T s, const Policy&);
0924
0925    // Owen's T function:
0926    template <class T1, class T2, class Policy>
0927    tools::promote_args_t<T1, T2> owens_t(T1 h, T2 a, const Policy& pol);
0928
0929    template <class T1, class T2>
0930    tools::promote_args_t<T1, T2> owens_t(T1 h, T2 a);
0931
0932    // Jacobi Functions:
0933    template <class T, class U, class V, class Policy>
0934    tools::promote_args_t<T, U, V> jacobi_elliptic(T k, U theta, V* pcn, V* pdn, const Policy&);
0935
0936    template <class T, class U, class V>
0937    tools::promote_args_t<T, U, V> jacobi_elliptic(T k, U theta, V* pcn = 0, V* pdn = 0);
0938
0939    template <class U, class T, class Policy>
0940    tools::promote_args_t<T, U> jacobi_sn(U k, T theta, const Policy& pol);
0941
0942    template <class U, class T>
0943    tools::promote_args_t<T, U> jacobi_sn(U k, T theta);
0944
0945    template <class T, class U, class Policy>
0946    tools::promote_args_t<T, U> jacobi_cn(T k, U theta, const Policy& pol);
0947
0948    template <class T, class U>
0949    tools::promote_args_t<T, U> jacobi_cn(T k, U theta);
0950
0951    template <class T, class U, class Policy>
0952    tools::promote_args_t<T, U> jacobi_dn(T k, U theta, const Policy& pol);
0953
0954    template <class T, class U>
0955    tools::promote_args_t<T, U> jacobi_dn(T k, U theta);
0956
0957    template <class T, class U, class Policy>
0958    tools::promote_args_t<T, U> jacobi_cd(T k, U theta, const Policy& pol);
0959
0960    template <class T, class U>
0961    tools::promote_args_t<T, U> jacobi_cd(T k, U theta);
0962
0963    template <class T, class U, class Policy>
0964    tools::promote_args_t<T, U> jacobi_dc(T k, U theta, const Policy& pol);
0965
0966    template <class T, class U>
0967    tools::promote_args_t<T, U> jacobi_dc(T k, U theta);
0968
0969    template <class T, class U, class Policy>
0970    tools::promote_args_t<T, U> jacobi_ns(T k, U theta, const Policy& pol);
0971
0972    template <class T, class U>
0973    tools::promote_args_t<T, U> jacobi_ns(T k, U theta);
0974
0975    template <class T, class U, class Policy>
0976    tools::promote_args_t<T, U> jacobi_sd(T k, U theta, const Policy& pol);
0977
0978    template <class T, class U>
0979    tools::promote_args_t<T, U> jacobi_sd(T k, U theta);
0980
0981    template <class T, class U, class Policy>
0982    tools::promote_args_t<T, U> jacobi_ds(T k, U theta, const Policy& pol);
0983
0984    template <class T, class U>
0985    tools::promote_args_t<T, U> jacobi_ds(T k, U theta);
0986
0987    template <class T, class U, class Policy>
0988    tools::promote_args_t<T, U> jacobi_nc(T k, U theta, const Policy& pol);
0989
0990    template <class T, class U>
0991    tools::promote_args_t<T, U> jacobi_nc(T k, U theta);
0992
0993    template <class T, class U, class Policy>
0994    tools::promote_args_t<T, U> jacobi_nd(T k, U theta, const Policy& pol);
0995
0996    template <class T, class U>
0997    tools::promote_args_t<T, U> jacobi_nd(T k, U theta);
0998
0999    template <class T, class U, class Policy>
1000    tools::promote_args_t<T, U> jacobi_sc(T k, U theta, const Policy& pol);
1001
1002    template <class T, class U>
1003    tools::promote_args_t<T, U> jacobi_sc(T k, U theta);
1004
1005    template <class T, class U, class Policy>
1006    tools::promote_args_t<T, U> jacobi_cs(T k, U theta, const Policy& pol);
1007
1008    template <class T, class U>
1009    tools::promote_args_t<T, U> jacobi_cs(T k, U theta);
1010
1011    // Jacobi Theta Functions:
1012    template <class T, class U, class Policy>
1013    tools::promote_args_t<T, U> jacobi_theta1(T z, U q, const Policy& pol);
1014
1015    template <class T, class U>
1016    tools::promote_args_t<T, U> jacobi_theta1(T z, U q);
1017
1018    template <class T, class U, class Policy>
1019    tools::promote_args_t<T, U> jacobi_theta2(T z, U q, const Policy& pol);
1020
1021    template <class T, class U>
1022    tools::promote_args_t<T, U> jacobi_theta2(T z, U q);
1023
1024    template <class T, class U, class Policy>
1025    tools::promote_args_t<T, U> jacobi_theta3(T z, U q, const Policy& pol);
1026
1027    template <class T, class U>
1028    tools::promote_args_t<T, U> jacobi_theta3(T z, U q);
1029
1030    template <class T, class U, class Policy>
1031    tools::promote_args_t<T, U> jacobi_theta4(T z, U q, const Policy& pol);
1032
1033    template <class T, class U>
1034    tools::promote_args_t<T, U> jacobi_theta4(T z, U q);
1035
1036    template <class T, class U, class Policy>
1037    tools::promote_args_t<T, U> jacobi_theta1tau(T z, U tau, const Policy& pol);
1038
1039    template <class T, class U>
1040    tools::promote_args_t<T, U> jacobi_theta1tau(T z, U tau);
1041
1042    template <class T, class U, class Policy>
1043    tools::promote_args_t<T, U> jacobi_theta2tau(T z, U tau, const Policy& pol);
1044
1045    template <class T, class U>
1046    tools::promote_args_t<T, U> jacobi_theta2tau(T z, U tau);
1047
1048    template <class T, class U, class Policy>
1049    tools::promote_args_t<T, U> jacobi_theta3tau(T z, U tau, const Policy& pol);
1050
1051    template <class T, class U>
1052    tools::promote_args_t<T, U> jacobi_theta3tau(T z, U tau);
1053
1054    template <class T, class U, class Policy>
1055    tools::promote_args_t<T, U> jacobi_theta4tau(T z, U tau, const Policy& pol);
1056
1057    template <class T, class U>
1058    tools::promote_args_t<T, U> jacobi_theta4tau(T z, U tau);
1059
1060    template <class T, class U, class Policy>
1061    tools::promote_args_t<T, U> jacobi_theta3m1(T z, U q, const Policy& pol);
1062
1063    template <class T, class U>
1064    tools::promote_args_t<T, U> jacobi_theta3m1(T z, U q);
1065
1066    template <class T, class U, class Policy>
1067    tools::promote_args_t<T, U> jacobi_theta4m1(T z, U q, const Policy& pol);
1068
1069    template <class T, class U>
1070    tools::promote_args_t<T, U> jacobi_theta4m1(T z, U q);
1071
1072    template <class T, class U, class Policy>
1073    tools::promote_args_t<T, U> jacobi_theta3m1tau(T z, U tau, const Policy& pol);
1074
1075    template <class T, class U>
1076    tools::promote_args_t<T, U> jacobi_theta3m1tau(T z, U tau);
1077
1078    template <class T, class U, class Policy>
1079    tools::promote_args_t<T, U> jacobi_theta4m1tau(T z, U tau, const Policy& pol);
1080
1081    template <class T, class U>
1082    tools::promote_args_t<T, U> jacobi_theta4m1tau(T z, U tau);
1083
1084
1085    template <class T>
1086    tools::promote_args_t<T> zeta(T s);
1087
1088    // pow:
1089    template <int N, typename T, class Policy>
1090    BOOST_CXX14_CONSTEXPR tools::promote_args_t<T> pow(T base, const Policy& policy);
1091
1092    template <int N, typename T>
1093    BOOST_CXX14_CONSTEXPR tools::promote_args_t<T> pow(T base);
1094
1095    // next:
1096    template <class T, class U, class Policy>
1097    tools::promote_args_t<T, U> nextafter(const T&, const U&, const Policy&);
1098    template <class T, class U>
1099    tools::promote_args_t<T, U> nextafter(const T&, const U&);
1100    template <class T, class Policy>
1101    tools::promote_args_t<T> float_next(const T&, const Policy&);
1102    template <class T>
1103    tools::promote_args_t<T> float_next(const T&);
1104    template <class T, class Policy>
1105    tools::promote_args_t<T> float_prior(const T&, const Policy&);
1106    template <class T>
1107    tools::promote_args_t<T> float_prior(const T&);
1108    template <class T, class U, class Policy>
1109    tools::promote_args_t<T, U> float_distance(const T&, const U&, const Policy&);
1110    template <class T, class U>
1111    tools::promote_args_t<T, U> float_distance(const T&, const U&);
1112    template <class T, class Policy>
1113    tools::promote_args_t<T> float_advance(T val, int distance, const Policy& pol);
1114    template <class T>
1115    tools::promote_args_t<T> float_advance(const T& val, int distance);
1116
1117    template <class T, class Policy>
1118    tools::promote_args_t<T> ulp(const T& val, const Policy& pol);
1119    template <class T>
1120    tools::promote_args_t<T> ulp(const T& val);
1121
1122    template <class T, class U>
1123    tools::promote_args_t<T, U> relative_difference(const T&, const U&);
1124    template <class T, class U>
1125    tools::promote_args_t<T, U> epsilon_difference(const T&, const U&);
1126
1127    template<class T>
1128    BOOST_MATH_CONSTEXPR_TABLE_FUNCTION T unchecked_bernoulli_b2n(const std::size_t n);
1129    template <class T, class Policy>
1130    T bernoulli_b2n(const int i, const Policy &pol);
1131    template <class T>
1132    T bernoulli_b2n(const int i);
1133    template <class T, class OutputIterator, class Policy>
1134    OutputIterator bernoulli_b2n(const int start_index,
1135                                        const unsigned number_of_bernoullis_b2n,
1136                                        OutputIterator out_it,
1137                                        const Policy& pol);
1138    template <class T, class OutputIterator>
1139    OutputIterator bernoulli_b2n(const int start_index,
1140                                        const unsigned number_of_bernoullis_b2n,
1141                                        OutputIterator out_it);
1142    template <class T, class Policy>
1143    T tangent_t2n(const int i, const Policy &pol);
1144    template <class T>
1145    T tangent_t2n(const int i);
1146    template <class T, class OutputIterator, class Policy>
1147    OutputIterator tangent_t2n(const int start_index,
1148                                        const unsigned number_of_bernoullis_b2n,
1149                                        OutputIterator out_it,
1150                                        const Policy& pol);
1151    template <class T, class OutputIterator>
1152    OutputIterator tangent_t2n(const int start_index,
1153                                        const unsigned number_of_bernoullis_b2n,
1154                                        OutputIterator out_it);
1155
1156    // Lambert W:
1157    template <class T, class Policy>
1158    boost::math::tools::promote_args_t<T> lambert_w0(T z, const Policy& pol);
1159    template <class T>
1160    boost::math::tools::promote_args_t<T> lambert_w0(T z);
1161    template <class T, class Policy>
1162    boost::math::tools::promote_args_t<T> lambert_wm1(T z, const Policy& pol);
1163    template <class T>
1164    boost::math::tools::promote_args_t<T> lambert_wm1(T z);
1165    template <class T, class Policy>
1166    boost::math::tools::promote_args_t<T> lambert_w0_prime(T z, const Policy& pol);
1167    template <class T>
1168    boost::math::tools::promote_args_t<T> lambert_w0_prime(T z);
1169    template <class T, class Policy>
1170    boost::math::tools::promote_args_t<T> lambert_wm1_prime(T z, const Policy& pol);
1171    template <class T>
1172    boost::math::tools::promote_args_t<T> lambert_wm1_prime(T z);
1173
1174    // Hypergeometrics:
1175    template <class T1, class T2> tools::promote_args_t<T1, T2> hypergeometric_1F0(T1 a, T2 z);
1176    template <class T1, class T2, class Policy> tools::promote_args_t<T1, T2> hypergeometric_1F0(T1 a, T2 z, const Policy&);
1177
1178    template <class T1, class T2> tools::promote_args_t<T1, T2> hypergeometric_0F1(T1 b, T2 z);
1179    template <class T1, class T2, class Policy> tools::promote_args_t<T1, T2> hypergeometric_0F1(T1 b, T2 z, const Policy&);
1180
1181    template <class T1, class T2, class T3> tools::promote_args_t<T1, T2, T3> hypergeometric_2F0(T1 a1, T2 a2, T3 z);
1182    template <class T1, class T2, class T3, class Policy> tools::promote_args_t<T1, T2, T3> hypergeometric_2F0(T1 a1, T2 a2, T3 z, const Policy&);
1183
1184    template <class T1, class T2, class T3> tools::promote_args_t<T1, T2, T3> hypergeometric_1F1(T1 a, T2 b, T3 z);
1185    template <class T1, class T2, class T3, class Policy> tools::promote_args_t<T1, T2, T3> hypergeometric_1F1(T1 a, T2 b, T3 z, const Policy&);
1186
1187
1188     } // namespace math
1189 } // namespace boost
1190
1191 #define BOOST_MATH_DETAIL_LL_FUNC(Policy)\
1192    \
1193    template <class T>\
1194    inline T modf(const T& v, long long* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
1195    \
1196    template <class T>\
1197    inline long long lltrunc(const T& v){ using boost::math::lltrunc; return lltrunc(v, Policy()); }\
1198    \
1199    template <class T>\
1200    inline long long llround(const T& v){ using boost::math::llround; return llround(v, Policy()); }\
1201
1202 #  define BOOST_MATH_DETAIL_11_FUNC(Policy)\
1203    template <class T, class U, class V>\
1204    inline boost::math::tools::promote_args_t<T, U> hypergeometric_1F1(const T& a, const U& b, const V& z)\
1205    { return boost::math::hypergeometric_1F1(a, b, z, Policy()); }\
1206
1207 #define BOOST_MATH_DECLARE_SPECIAL_FUNCTIONS(Policy)\
1208    \
1209    BOOST_MATH_DETAIL_LL_FUNC(Policy)\
1210    BOOST_MATH_DETAIL_11_FUNC(Policy)\
1211    \
1212    template <class RT1, class RT2>\
1213    inline boost::math::tools::promote_args_t<RT1, RT2> \
1214    beta(RT1 a, RT2 b) { return ::boost::math::beta(a, b, Policy()); }\
1215 \
1216    template <class RT1, class RT2, class A>\
1217    inline boost::math::tools::promote_args_t<RT1, RT2, A> \
1218    beta(RT1 a, RT2 b, A x){ return ::boost::math::beta(a, b, x, Policy()); }\
1219 \
1220    template <class RT1, class RT2, class RT3>\
1221    inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
1222    betac(RT1 a, RT2 b, RT3 x) { return ::boost::math::betac(a, b, x, Policy()); }\
1223 \
1224    template <class RT1, class RT2, class RT3>\
1225    inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
1226    ibeta(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibeta(a, b, x, Policy()); }\
1227 \
1228    template <class RT1, class RT2, class RT3>\
1229    inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
1230    ibetac(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibetac(a, b, x, Policy()); }\
1231 \
1232    template <class T1, class T2, class T3, class T4>\
1233    inline boost::math::tools::promote_args_t<T1, T2, T3, T4>  \
1234    ibeta_inv(T1 a, T2 b, T3 p, T4* py){ return ::boost::math::ibeta_inv(a, b, p, py, Policy()); }\
1235 \
1236    template <class RT1, class RT2, class RT3>\
1237    inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
1238    ibeta_inv(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_inv(a, b, p, Policy()); }\
1239 \
1240    template <class T1, class T2, class T3, class T4>\
1241    inline boost::math::tools::promote_args_t<T1, T2, T3, T4> \
1242    ibetac_inv(T1 a, T2 b, T3 q, T4* py){ return ::boost::math::ibetac_inv(a, b, q, py, Policy()); }\
1243 \
1244    template <class RT1, class RT2, class RT3>\
1245    inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
1246    ibeta_inva(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_inva(a, b, p, Policy()); }\
1247 \
1248    template <class T1, class T2, class T3>\
1249    inline boost::math::tools::promote_args_t<T1, T2, T3> \
1250    ibetac_inva(T1 a, T2 b, T3 q){ return ::boost::math::ibetac_inva(a, b, q, Policy()); }\
1251 \
1252    template <class RT1, class RT2, class RT3>\
1253    inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
1254    ibeta_invb(RT1 a, RT2 b, RT3 p){ return ::boost::math::ibeta_invb(a, b, p, Policy()); }\
1255 \
1256    template <class T1, class T2, class T3>\
1257    inline boost::math::tools::promote_args_t<T1, T2, T3> \
1258    ibetac_invb(T1 a, T2 b, T3 q){ return ::boost::math::ibetac_invb(a, b, q, Policy()); }\
1259 \
1260    template <class RT1, class RT2, class RT3>\
1261    inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
1262    ibetac_inv(RT1 a, RT2 b, RT3 q){ return ::boost::math::ibetac_inv(a, b, q, Policy()); }\
1263 \
1264    template <class RT1, class RT2, class RT3>\
1265    inline boost::math::tools::promote_args_t<RT1, RT2, RT3> \
1266    ibeta_derivative(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibeta_derivative(a, b, x, Policy()); }\
1267 \
1268    template <class T> T binomial_coefficient(unsigned n, unsigned k){ return ::boost::math::binomial_coefficient<T, Policy>(n, k, Policy()); }\
1269 \
1270    template <class RT>\
1271    inline boost::math::tools::promote_args_t<RT> erf(RT z) { return ::boost::math::erf(z, Policy()); }\
1272 \
1273    template <class RT>\
1274    inline boost::math::tools::promote_args_t<RT> erfc(RT z){ return ::boost::math::erfc(z, Policy()); }\
1275 \
1276    template <class RT>\
1277    inline boost::math::tools::promote_args_t<RT> erf_inv(RT z) { return ::boost::math::erf_inv(z, Policy()); }\
1278 \
1279    template <class RT>\
1280    inline boost::math::tools::promote_args_t<RT> erfc_inv(RT z){ return ::boost::math::erfc_inv(z, Policy()); }\
1281 \
1282    using boost::math::legendre_next;\
1283 \
1284    template <class T>\
1285    inline boost::math::tools::promote_args_t<T> \
1286    legendre_p(int l, T x){ return ::boost::math::legendre_p(l, x, Policy()); }\
1287 \
1288    template <class T>\
1289    inline boost::math::tools::promote_args_t<T> \
1290    legendre_p_prime(int l, T x){ return ::boost::math::legendre_p(l, x, Policy()); }\
1291 \
1292    template <class T>\
1293    inline boost::math::tools::promote_args_t<T> \
1294    legendre_q(unsigned l, T x){ return ::boost::math::legendre_q(l, x, Policy()); }\
1295 \
1296    using ::boost::math::legendre_next;\
1297 \
1298    template <class T>\
1299    inline boost::math::tools::promote_args_t<T> \
1300    legendre_p(int l, int m, T x){ return ::boost::math::legendre_p(l, m, x, Policy()); }\
1301 \
1302    using ::boost::math::laguerre_next;\
1303 \
1304    template <class T>\
1305    inline boost::math::tools::promote_args_t<T> \
1306    laguerre(unsigned n, T x){ return ::boost::math::laguerre(n, x, Policy()); }\
1307 \
1308    template <class T1, class T2>\
1309    inline typename boost::math::laguerre_result<T1, T2>::type \
1310    laguerre(unsigned n, T1 m, T2 x) { return ::boost::math::laguerre(n, m, x, Policy()); }\
1311 \
1312    template <class T>\
1313    inline boost::math::tools::promote_args_t<T> \
1314    hermite(unsigned n, T x){ return ::boost::math::hermite(n, x, Policy()); }\
1315 \
1316    using boost::math::hermite_next;\
1317 \
1318    using boost::math::chebyshev_next;\
1319 \
1320   template<class Real>\
1321   Real chebyshev_t(unsigned n, Real const & x){ return ::boost::math::chebyshev_t(n, x, Policy()); }\
1322 \
1323   template<class Real>\
1324   Real chebyshev_u(unsigned n, Real const & x){ return ::boost::math::chebyshev_u(n, x, Policy()); }\
1325 \
1326   template<class Real>\
1327   Real chebyshev_t_prime(unsigned n, Real const & x){ return ::boost::math::chebyshev_t_prime(n, x, Policy()); }\
1328 \
1329   using ::boost::math::chebyshev_clenshaw_recurrence;\
1330 \
1331    template <class T1, class T2>\
1332    inline std::complex<boost::math::tools::promote_args_t<T1, T2>> \
1333    spherical_harmonic(unsigned n, int m, T1 theta, T2 phi){ return boost::math::spherical_harmonic(n, m, theta, phi, Policy()); }\
1334 \
1335    template <class T1, class T2>\
1336    inline boost::math::tools::promote_args_t<T1, T2> \
1337    spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi){ return ::boost::math::spherical_harmonic_r(n, m, theta, phi, Policy()); }\
1338 \
1339    template <class T1, class T2>\
1340    inline boost::math::tools::promote_args_t<T1, T2> \
1341    spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi){ return boost::math::spherical_harmonic_i(n, m, theta, phi, Policy()); }\
1342 \
1343    template <class T1, class T2, class Policy>\
1344    inline boost::math::tools::promote_args_t<T1, T2> \
1345       spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);\
1346 \
1347    template <class T1, class T2, class T3>\
1348    inline boost::math::tools::promote_args_t<T1, T2, T3> \
1349    ellint_rf(T1 x, T2 y, T3 z){ return ::boost::math::ellint_rf(x, y, z, Policy()); }\
1350 \
1351    template <class T1, class T2, class T3>\
1352    inline boost::math::tools::promote_args_t<T1, T2, T3> \
1353    ellint_rd(T1 x, T2 y, T3 z){ return ::boost::math::ellint_rd(x, y, z, Policy()); }\
1354 \
1355    template <class T1, class T2>\
1356    inline boost::math::tools::promote_args_t<T1, T2> \
1357    ellint_rc(T1 x, T2 y){ return ::boost::math::ellint_rc(x, y, Policy()); }\
1358 \
1359    template <class T1, class T2, class T3, class T4>\
1360    inline boost::math::tools::promote_args_t<T1, T2, T3, T4> \
1361    ellint_rj(T1 x, T2 y, T3 z, T4 p){ return boost::math::ellint_rj(x, y, z, p, Policy()); }\
1362 \
1363    template <class T1, class T2, class T3>\
1364    inline boost::math::tools::promote_args_t<T1, T2, T3> \
1365    ellint_rg(T1 x, T2 y, T3 z){ return ::boost::math::ellint_rg(x, y, z, Policy()); }\
1366    \
1367    template <typename T>\
1368    inline boost::math::tools::promote_args_t<T> ellint_2(T k){ return boost::math::ellint_2(k, Policy()); }\
1369 \
1370    template <class T1, class T2>\
1371    inline boost::math::tools::promote_args_t<T1, T2> ellint_2(T1 k, T2 phi){ return boost::math::ellint_2(k, phi, Policy()); }\
1372 \
1373    template <typename T>\
1374    inline boost::math::tools::promote_args_t<T> ellint_d(T k){ return boost::math::ellint_d(k, Policy()); }\
1375 \
1376    template <class T1, class T2>\
1377    inline boost::math::tools::promote_args_t<T1, T2> ellint_d(T1 k, T2 phi){ return boost::math::ellint_d(k, phi, Policy()); }\
1378 \
1379    template <class T1, class T2>\
1380    inline boost::math::tools::promote_args_t<T1, T2> jacobi_zeta(T1 k, T2 phi){ return boost::math::jacobi_zeta(k, phi, Policy()); }\
1381 \
1382    template <class T1, class T2>\
1383    inline boost::math::tools::promote_args_t<T1, T2> heuman_lambda(T1 k, T2 phi){ return boost::math::heuman_lambda(k, phi, Policy()); }\
1384 \
1385    template <typename T>\
1386    inline boost::math::tools::promote_args_t<T> ellint_1(T k){ return boost::math::ellint_1(k, Policy()); }\
1387 \
1388    template <class T1, class T2>\
1389    inline boost::math::tools::promote_args_t<T1, T2> ellint_1(T1 k, T2 phi){ return boost::math::ellint_1(k, phi, Policy()); }\
1390 \
1391    template <class T1, class T2, class T3>\
1392    inline boost::math::tools::promote_args_t<T1, T2, T3> ellint_3(T1 k, T2 v, T3 phi){ return boost::math::ellint_3(k, v, phi, Policy()); }\
1393 \
1394    template <class T1, class T2>\
1395    inline boost::math::tools::promote_args_t<T1, T2> ellint_3(T1 k, T2 v){ return boost::math::ellint_3(k, v, Policy()); }\
1396 \
1397    using boost::math::max_factorial;\
1398    template <class RT>\
1399    inline RT factorial(unsigned int i) { return boost::math::factorial<RT>(i, Policy()); }\
1400    using boost::math::unchecked_factorial;\
1401    template <class RT>\
1402    inline RT double_factorial(unsigned i){ return boost::math::double_factorial<RT>(i, Policy()); }\
1403    template <class RT>\
1404    inline boost::math::tools::promote_args_t<RT> falling_factorial(RT x, unsigned n){ return boost::math::falling_factorial(x, n, Policy()); }\
1405    template <class RT>\
1406    inline boost::math::tools::promote_args_t<RT> rising_factorial(RT x, unsigned n){ return boost::math::rising_factorial(x, n, Policy()); }\
1407 \
1408    template <class RT>\
1409    inline boost::math::tools::promote_args_t<RT> tgamma(RT z){ return boost::math::tgamma(z, Policy()); }\
1410 \
1411    template <class RT>\
1412    inline boost::math::tools::promote_args_t<RT> tgamma1pm1(RT z){ return boost::math::tgamma1pm1(z, Policy()); }\
1413 \
1414    template <class RT1, class RT2>\
1415    inline boost::math::tools::promote_args_t<RT1, RT2> tgamma(RT1 a, RT2 z){ return boost::math::tgamma(a, z, Policy()); }\
1416 \
1417    template <class RT>\
1418    inline boost::math::tools::promote_args_t<RT> lgamma(RT z, int* sign){ return boost::math::lgamma(z, sign, Policy()); }\
1419 \
1420    template <class RT>\
1421    inline boost::math::tools::promote_args_t<RT> lgamma(RT x){ return boost::math::lgamma(x, Policy()); }\
1422 \
1423    template <class RT1, class RT2>\
1424    inline boost::math::tools::promote_args_t<RT1, RT2> tgamma_lower(RT1 a, RT2 z){ return boost::math::tgamma_lower(a, z, Policy()); }\
1425 \
1426    template <class RT1, class RT2>\
1427    inline boost::math::tools::promote_args_t<RT1, RT2> gamma_q(RT1 a, RT2 z){ return boost::math::gamma_q(a, z, Policy()); }\
1428 \
1429    template <class RT1, class RT2>\
1430    inline boost::math::tools::promote_args_t<RT1, RT2> gamma_p(RT1 a, RT2 z){ return boost::math::gamma_p(a, z, Policy()); }\
1431 \
1432    template <class T1, class T2>\
1433    inline boost::math::tools::promote_args_t<T1, T2> tgamma_delta_ratio(T1 z, T2 delta){ return boost::math::tgamma_delta_ratio(z, delta, Policy()); }\
1434 \
1435    template <class T1, class T2>\
1436    inline boost::math::tools::promote_args_t<T1, T2> tgamma_ratio(T1 a, T2 b) { return boost::math::tgamma_ratio(a, b, Policy()); }\
1437 \
1438    template <class T1, class T2>\
1439    inline boost::math::tools::promote_args_t<T1, T2> gamma_p_derivative(T1 a, T2 x){ return boost::math::gamma_p_derivative(a, x, Policy()); }\
1440 \
1441    template <class T1, class T2>\
1442    inline boost::math::tools::promote_args_t<T1, T2> gamma_p_inv(T1 a, T2 p){ return boost::math::gamma_p_inv(a, p, Policy()); }\
1443 \
1444    template <class T1, class T2>\
1445    inline boost::math::tools::promote_args_t<T1, T2> gamma_p_inva(T1 a, T2 p){ return boost::math::gamma_p_inva(a, p, Policy()); }\
1446 \
1447    template <class T1, class T2>\
1448    inline boost::math::tools::promote_args_t<T1, T2> gamma_q_inv(T1 a, T2 q){ return boost::math::gamma_q_inv(a, q, Policy()); }\
1449 \
1450    template <class T1, class T2>\
1451    inline boost::math::tools::promote_args_t<T1, T2> gamma_q_inva(T1 a, T2 q){ return boost::math::gamma_q_inva(a, q, Policy()); }\
1452 \
1453    template <class T>\
1454    inline boost::math::tools::promote_args_t<T> digamma(T x){ return boost::math::digamma(x, Policy()); }\
1455 \
1456    template <class T>\
1457    inline boost::math::tools::promote_args_t<T> trigamma(T x){ return boost::math::trigamma(x, Policy()); }\
1458 \
1459    template <class T>\
1460    inline boost::math::tools::promote_args_t<T> polygamma(int n, T x){ return boost::math::polygamma(n, x, Policy()); }\
1461    \
1462    template <class T1, class T2>\
1463    inline boost::math::tools::promote_args_t<T1, T2> \
1464    hypot(T1 x, T2 y){ return boost::math::hypot(x, y, Policy()); }\
1465 \
1466    template <class RT>\
1467    inline boost::math::tools::promote_args_t<RT> cbrt(RT z){ return boost::math::cbrt(z, Policy()); }\
1468 \
1469    template <class T>\
1470    inline boost::math::tools::promote_args_t<T> log1p(T x){ return boost::math::log1p(x, Policy()); }\
1471 \
1472    template <class T>\
1473    inline boost::math::tools::promote_args_t<T> log1pmx(T x){ return boost::math::log1pmx(x, Policy()); }\
1474 \
1475    template <class T>\
1476    inline boost::math::tools::promote_args_t<T> expm1(T x){ return boost::math::expm1(x, Policy()); }\
1477 \
1478    template <class T1, class T2>\
1479    inline boost::math::tools::promote_args_t<T1, T2> \
1480    powm1(const T1 a, const T2 z){ return boost::math::powm1(a, z, Policy()); }\
1481 \
1482    template <class T>\
1483    inline boost::math::tools::promote_args_t<T> sqrt1pm1(const T& val){ return boost::math::sqrt1pm1(val, Policy()); }\
1484 \
1485    template <class T>\
1486    inline boost::math::tools::promote_args_t<T> sinc_pi(T x){ return boost::math::sinc_pi(x, Policy()); }\
1487 \
1488    template <class T>\
1489    inline boost::math::tools::promote_args_t<T> sinhc_pi(T x){ return boost::math::sinhc_pi(x, Policy()); }\
1490 \
1491    template<typename T>\
1492    inline boost::math::tools::promote_args_t<T> asinh(const T x){ return boost::math::asinh(x, Policy()); }\
1493 \
1494    template<typename T>\
1495    inline boost::math::tools::promote_args_t<T> acosh(const T x){ return boost::math::acosh(x, Policy()); }\
1496 \
1497    template<typename T>\
1498    inline boost::math::tools::promote_args_t<T> atanh(const T x){ return boost::math::atanh(x, Policy()); }\
1499 \
1500    template <class T1, class T2>\
1501    inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type cyl_bessel_j(T1 v, T2 x)\
1502    { return boost::math::cyl_bessel_j(v, x, Policy()); }\
1503 \
1504    template <class T1, class T2>\
1505    inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type cyl_bessel_j_prime(T1 v, T2 x)\
1506    { return boost::math::cyl_bessel_j_prime(v, x, Policy()); }\
1507 \
1508    template <class T>\
1509    inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type sph_bessel(unsigned v, T x)\
1510    { return boost::math::sph_bessel(v, x, Policy()); }\
1511 \
1512    template <class T>\
1513    inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type sph_bessel_prime(unsigned v, T x)\
1514    { return boost::math::sph_bessel_prime(v, x, Policy()); }\
1515 \
1516    template <class T1, class T2>\
1517    inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1518    cyl_bessel_i(T1 v, T2 x) { return boost::math::cyl_bessel_i(v, x, Policy()); }\
1519 \
1520    template <class T1, class T2>\
1521    inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1522    cyl_bessel_i_prime(T1 v, T2 x) { return boost::math::cyl_bessel_i_prime(v, x, Policy()); }\
1523 \
1524    template <class T1, class T2>\
1525    inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1526    cyl_bessel_k(T1 v, T2 x) { return boost::math::cyl_bessel_k(v, x, Policy()); }\
1527 \
1528    template <class T1, class T2>\
1529    inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1530    cyl_bessel_k_prime(T1 v, T2 x) { return boost::math::cyl_bessel_k_prime(v, x, Policy()); }\
1531 \
1532    template <class T1, class T2>\
1533    inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1534    cyl_neumann(T1 v, T2 x){ return boost::math::cyl_neumann(v, x, Policy()); }\
1535 \
1536    template <class T1, class T2>\
1537    inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
1538    cyl_neumann_prime(T1 v, T2 x){ return boost::math::cyl_neumann_prime(v, x, Policy()); }\
1539 \
1540    template <class T>\
1541    inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type \
1542    sph_neumann(unsigned v, T x){ return boost::math::sph_neumann(v, x, Policy()); }\
1543 \
1544    template <class T>\
1545    inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type \
1546    sph_neumann_prime(unsigned v, T x){ return boost::math::sph_neumann_prime(v, x, Policy()); }\
1547 \
1548    template <class T>\
1549    inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type cyl_bessel_j_zero(T v, int m)\
1550    { return boost::math::cyl_bessel_j_zero(v, m, Policy()); }\
1551 \
1552 template <class OutputIterator, class T>\
1553    inline void cyl_bessel_j_zero(T v,\
1554                                  int start_index,\
1555                                  unsigned number_of_zeros,\
1556                                  OutputIterator out_it)\
1557    { boost::math::cyl_bessel_j_zero(v, start_index, number_of_zeros, out_it, Policy()); }\
1558 \
1559    template <class T>\
1560    inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type cyl_neumann_zero(T v, int m)\
1561    { return boost::math::cyl_neumann_zero(v, m, Policy()); }\
1562 \
1563 template <class OutputIterator, class T>\
1564    inline void cyl_neumann_zero(T v,\
1565                                 int start_index,\
1566                                 unsigned number_of_zeros,\
1567                                 OutputIterator out_it)\
1568    { boost::math::cyl_neumann_zero(v, start_index, number_of_zeros, out_it, Policy()); }\
1569 \
1570    template <class T>\
1571    inline boost::math::tools::promote_args_t<T> sin_pi(T x){ return boost::math::sin_pi(x, Policy()); }\
1572 \
1573    template <class T>\
1574    inline boost::math::tools::promote_args_t<T> cos_pi(T x){ return boost::math::cos_pi(x, Policy()); }\
1575 \
1576    using boost::math::fpclassify;\
1577    using boost::math::isfinite;\
1578    using boost::math::isinf;\
1579    using boost::math::isnan;\
1580    using boost::math::isnormal;\
1581    using boost::math::signbit;\
1582    using boost::math::sign;\
1583    using boost::math::copysign;\
1584    using boost::math::changesign;\
1585    \
1586    template <class T, class U>\
1587    inline typename boost::math::tools::promote_args_t<T,U> expint(T const& z, U const& u)\
1588    { return boost::math::expint(z, u, Policy()); }\
1589    \
1590    template <class T>\
1591    inline boost::math::tools::promote_args_t<T> expint(T z){ return boost::math::expint(z, Policy()); }\
1592    \
1593    template <class T>\
1594    inline boost::math::tools::promote_args_t<T> zeta(T s){ return boost::math::zeta(s, Policy()); }\
1595    \
1596    template <class T>\
1597    inline T round(const T& v){ using boost::math::round; return round(v, Policy()); }\
1598    \
1599    template <class T>\
1600    inline int iround(const T& v){ using boost::math::iround; return iround(v, Policy()); }\
1601    \
1602    template <class T>\
1603    inline long lround(const T& v){ using boost::math::lround; return lround(v, Policy()); }\
1604    \
1605    template <class T>\
1606    inline T trunc(const T& v){ using boost::math::trunc; return trunc(v, Policy()); }\
1607    \
1608    template <class T>\
1609    inline int itrunc(const T& v){ using boost::math::itrunc; return itrunc(v, Policy()); }\
1610    \
1611    template <class T>\
1612    inline long ltrunc(const T& v){ using boost::math::ltrunc; return ltrunc(v, Policy()); }\
1613    \
1614    template <class T>\
1615    inline T modf(const T& v, T* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
1616    \
1617    template <class T>\
1618    inline T modf(const T& v, int* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
1619    \
1620    template <class T>\
1621    inline T modf(const T& v, long* ipart){ using boost::math::modf; return modf(v, ipart, Policy()); }\
1622    \
1623    template <int N, class T>\
1624    inline boost::math::tools::promote_args_t<T> pow(T v){ return boost::math::pow<N>(v, Policy()); }\
1625    \
1626    template <class T> T nextafter(const T& a, const T& b){ return static_cast<T>(boost::math::nextafter(a, b, Policy())); }\
1627    template <class T> T float_next(const T& a){ return static_cast<T>(boost::math::float_next(a, Policy())); }\
1628    template <class T> T float_prior(const T& a){ return static_cast<T>(boost::math::float_prior(a, Policy())); }\
1629    template <class T> T float_distance(const T& a, const T& b){ return static_cast<T>(boost::math::float_distance(a, b, Policy())); }\
1630    template <class T> T ulp(const T& a){ return static_cast<T>(boost::math::ulp(a, Policy())); }\
1631    \
1632    template <class RT1, class RT2>\
1633    inline boost::math::tools::promote_args_t<RT1, RT2> owens_t(RT1 a, RT2 z){ return boost::math::owens_t(a, z, Policy()); }\
1634    \
1635    template <class T1, class T2>\
1636    inline std::complex<typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type> cyl_hankel_1(T1 v, T2 x)\
1637    {  return boost::math::cyl_hankel_1(v, x, Policy()); }\
1638    \
1639    template <class T1, class T2>\
1640    inline std::complex<typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type> cyl_hankel_2(T1 v, T2 x)\
1641    { return boost::math::cyl_hankel_2(v, x, Policy()); }\
1642    \
1643    template <class T1, class T2>\
1644    inline std::complex<typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type> sph_hankel_1(T1 v, T2 x)\
1645    { return boost::math::sph_hankel_1(v, x, Policy()); }\
1646    \
1647    template <class T1, class T2>\
1648    inline std::complex<typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type> sph_hankel_2(T1 v, T2 x)\
1649    { return boost::math::sph_hankel_2(v, x, Policy()); }\
1650    \
1651    template <class T>\
1652    inline boost::math::tools::promote_args_t<T> jacobi_elliptic(T k, T theta, T* pcn, T* pdn)\
1653    { return static_cast<boost::math::tools::promote_args_t<T>>(boost::math::jacobi_elliptic(k, theta, pcn, pdn, Policy())); }\
1654    \
1655    template <class U, class T>\
1656    inline boost::math::tools::promote_args_t<T, U> jacobi_sn(U k, T theta)\
1657    { return boost::math::jacobi_sn(k, theta, Policy()); }\
1658    \
1659    template <class T, class U>\
1660    inline boost::math::tools::promote_args_t<T, U> jacobi_cn(T k, U theta)\
1661    { return boost::math::jacobi_cn(k, theta, Policy()); }\
1662    \
1663    template <class T, class U>\
1664    inline boost::math::tools::promote_args_t<T, U> jacobi_dn(T k, U theta)\
1665    { return boost::math::jacobi_dn(k, theta, Policy()); }\
1666    \
1667    template <class T, class U>\
1668    inline boost::math::tools::promote_args_t<T, U> jacobi_cd(T k, U theta)\
1669    { return boost::math::jacobi_cd(k, theta, Policy()); }\
1670    \
1671    template <class T, class U>\
1672    inline boost::math::tools::promote_args_t<T, U> jacobi_dc(T k, U theta)\
1673    { return boost::math::jacobi_dc(k, theta, Policy()); }\
1674    \
1675    template <class T, class U>\
1676    inline boost::math::tools::promote_args_t<T, U> jacobi_ns(T k, U theta)\
1677    { return boost::math::jacobi_ns(k, theta, Policy()); }\
1678    \
1679    template <class T, class U>\
1680    inline boost::math::tools::promote_args_t<T, U> jacobi_sd(T k, U theta)\
1681    { return boost::math::jacobi_sd(k, theta, Policy()); }\
1682    \
1683    template <class T, class U>\
1684    inline boost::math::tools::promote_args_t<T, U> jacobi_ds(T k, U theta)\
1685    { return boost::math::jacobi_ds(k, theta, Policy()); }\
1686    \
1687    template <class T, class U>\
1688    inline boost::math::tools::promote_args_t<T, U> jacobi_nc(T k, U theta)\
1689    { return boost::math::jacobi_nc(k, theta, Policy()); }\
1690    \
1691    template <class T, class U>\
1692    inline boost::math::tools::promote_args_t<T, U> jacobi_nd(T k, U theta)\
1693    { return boost::math::jacobi_nd(k, theta, Policy()); }\
1694    \
1695    template <class T, class U>\
1696    inline boost::math::tools::promote_args_t<T, U> jacobi_sc(T k, U theta)\
1697    { return boost::math::jacobi_sc(k, theta, Policy()); }\
1698    \
1699    template <class T, class U>\
1700    inline boost::math::tools::promote_args_t<T, U> jacobi_cs(T k, U theta)\
1701    { return boost::math::jacobi_cs(k, theta, Policy()); }\
1702    \
1703    template <class T, class U>\
1704    inline boost::math::tools::promote_args_t<T, U> jacobi_theta1(T z, U q)\
1705    { return boost::math::jacobi_theta1(z, q, Policy()); }\
1706    \
1707    template <class T, class U>\
1708    inline boost::math::tools::promote_args_t<T, U> jacobi_theta2(T z, U q)\
1709    { return boost::math::jacobi_theta2(z, q, Policy()); }\
1710    \
1711    template <class T, class U>\
1712    inline boost::math::tools::promote_args_t<T, U> jacobi_theta3(T z, U q)\
1713    { return boost::math::jacobi_theta3(z, q, Policy()); }\
1714    \
1715    template <class T, class U>\
1716    inline boost::math::tools::promote_args_t<T, U> jacobi_theta4(T z, U q)\
1717    { return boost::math::jacobi_theta4(z, q, Policy()); }\
1718    \
1719    template <class T, class U>\
1720    inline boost::math::tools::promote_args_t<T, U> jacobi_theta1tau(T z, U q)\
1721    { return boost::math::jacobi_theta1tau(z, q, Policy()); }\
1722    \
1723    template <class T, class U>\
1724    inline boost::math::tools::promote_args_t<T, U> jacobi_theta2tau(T z, U q)\
1725    { return boost::math::jacobi_theta2tau(z, q, Policy()); }\
1726    \
1727    template <class T, class U>\
1728    inline boost::math::tools::promote_args_t<T, U> jacobi_theta3tau(T z, U q)\
1729    { return boost::math::jacobi_theta3tau(z, q, Policy()); }\
1730    \
1731    template <class T, class U>\
1732    inline boost::math::tools::promote_args_t<T, U> jacobi_theta4tau(T z, U q)\
1733    { return boost::math::jacobi_theta4tau(z, q, Policy()); }\
1734    \
1735    template <class T, class U>\
1736    inline boost::math::tools::promote_args_t<T, U> jacobi_theta3m1(T z, U q)\
1737    { return boost::math::jacobi_theta3m1(z, q, Policy()); }\
1738    \
1739    template <class T, class U>\
1740    inline boost::math::tools::promote_args_t<T, U> jacobi_theta4m1(T z, U q)\
1741    { return boost::math::jacobi_theta4m1(z, q, Policy()); }\
1742    \
1743    template <class T, class U>\
1744    inline boost::math::tools::promote_args_t<T, U> jacobi_theta3m1tau(T z, U q)\
1745    { return boost::math::jacobi_theta3m1tau(z, q, Policy()); }\
1746    \
1747    template <class T, class U>\
1748    inline boost::math::tools::promote_args_t<T, U> jacobi_theta4m1tau(T z, U q)\
1749    { return boost::math::jacobi_theta4m1tau(z, q, Policy()); }\
1750    \
1751    template <class T>\
1752    inline boost::math::tools::promote_args_t<T> airy_ai(T x)\
1753    {  return boost::math::airy_ai(x, Policy());  }\
1754    \
1755    template <class T>\
1756    inline boost::math::tools::promote_args_t<T> airy_bi(T x)\
1757    {  return boost::math::airy_bi(x, Policy());  }\
1758    \
1759    template <class T>\
1760    inline boost::math::tools::promote_args_t<T> airy_ai_prime(T x)\
1761    {  return boost::math::airy_ai_prime(x, Policy());  }\
1762    \
1763    template <class T>\
1764    inline boost::math::tools::promote_args_t<T> airy_bi_prime(T x)\
1765    {  return boost::math::airy_bi_prime(x, Policy());  }\
1766    \
1767    template <class T>\
1768    inline T airy_ai_zero(int m)\
1769    { return boost::math::airy_ai_zero<T>(m, Policy()); }\
1770    template <class T, class OutputIterator>\
1771    OutputIterator airy_ai_zero(int start_index, unsigned number_of_zeros, OutputIterator out_it)\
1772    { return boost::math::airy_ai_zero<T>(start_index, number_of_zeros, out_it, Policy()); }\
1773    \
1774    template <class T>\
1775    inline T airy_bi_zero(int m)\
1776    { return boost::math::airy_bi_zero<T>(m, Policy()); }\
1777    template <class T, class OutputIterator>\
1778    OutputIterator airy_bi_zero(int start_index, unsigned number_of_zeros, OutputIterator out_it)\
1779    { return boost::math::airy_bi_zero<T>(start_index, number_of_zeros, out_it, Policy()); }\
1780    \
1781    template <class T>\
1782    T bernoulli_b2n(const int i)\
1783    { return boost::math::bernoulli_b2n<T>(i, Policy()); }\
1784    template <class T, class OutputIterator>\
1785    OutputIterator bernoulli_b2n(int start_index, unsigned number_of_bernoullis_b2n, OutputIterator out_it)\
1786    { return boost::math::bernoulli_b2n<T>(start_index, number_of_bernoullis_b2n, out_it, Policy()); }\
1787    \
1788    template <class T>\
1789    T tangent_t2n(const int i)\
1790    { return boost::math::tangent_t2n<T>(i, Policy()); }\
1791    template <class T, class OutputIterator>\
1792    OutputIterator tangent_t2n(int start_index, unsigned number_of_bernoullis_b2n, OutputIterator out_it)\
1793    { return boost::math::tangent_t2n<T>(start_index, number_of_bernoullis_b2n, out_it, Policy()); }\
1794    \
1795    template <class T> inline boost::math::tools::promote_args_t<T> lambert_w0(T z) { return boost::math::lambert_w0(z, Policy()); }\
1796    template <class T> inline boost::math::tools::promote_args_t<T> lambert_wm1(T z) { return boost::math::lambert_w0(z, Policy()); }\
1797    template <class T> inline boost::math::tools::promote_args_t<T> lambert_w0_prime(T z) { return boost::math::lambert_w0(z, Policy()); }\
1798    template <class T> inline boost::math::tools::promote_args_t<T> lambert_wm1_prime(T z) { return boost::math::lambert_w0(z, Policy()); }\
1799    \
1800    template <class T, class U>\
1801    inline boost::math::tools::promote_args_t<T, U> hypergeometric_1F0(const T& a, const U& z)\
1802    { return boost::math::hypergeometric_1F0(a, z, Policy()); }\
1803    \
1804    template <class T, class U>\
1805    inline boost::math::tools::promote_args_t<T, U> hypergeometric_0F1(const T& a, const U& z)\
1806    { return boost::math::hypergeometric_0F1(a, z, Policy()); }\
1807    \
1808    template <class T, class U, class V>\
1809    inline boost::math::tools::promote_args_t<T, U> hypergeometric_2F0(const T& a1, const U& a2, const V& z)\
1810    { return boost::math::hypergeometric_2F0(a1, a2, z, Policy()); }\
1811    \
1812
1813
1814
1815
1816
1817
1818 #endif // BOOST_MATH_SPECIAL_MATH_FWD_HPP