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