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