Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/c++/13/tr1/cmath
$ cat -n /usr/include/c++/13/tr1/cmath 1 // TR1 cmath -*- C++ -*- 2 3 // Copyright (C) 2006-2023 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 /** @file tr1/cmath 26 * This is a TR1 C++ Library header. 27 */ 28 29 #ifndef _GLIBCXX_TR1_CMATH 30 #define _GLIBCXX_TR1_CMATH 1 31 32 #pragma GCC system_header 33 34 #include <bits/requires_hosted.h> // TR1 35 36 #include <cmath> 37 38 #ifdef _GLIBCXX_USE_C99_MATH_TR1 39 40 #undef acosh 41 #undef acoshf 42 #undef acoshl 43 #undef asinh 44 #undef asinhf 45 #undef asinhl 46 #undef atanh 47 #undef atanhf 48 #undef atanhl 49 #undef cbrt 50 #undef cbrtf 51 #undef cbrtl 52 #undef copysign 53 #undef copysignf 54 #undef copysignl 55 #undef erf 56 #undef erff 57 #undef erfl 58 #undef erfc 59 #undef erfcf 60 #undef erfcl 61 #undef exp2 62 #undef exp2f 63 #undef exp2l 64 #undef expm1 65 #undef expm1f 66 #undef expm1l 67 #undef fdim 68 #undef fdimf 69 #undef fdiml 70 #undef fma 71 #undef fmaf 72 #undef fmal 73 #undef fmax 74 #undef fmaxf 75 #undef fmaxl 76 #undef fmin 77 #undef fminf 78 #undef fminl 79 #undef hypot 80 #undef hypotf 81 #undef hypotl 82 #undef ilogb 83 #undef ilogbf 84 #undef ilogbl 85 #undef lgamma 86 #undef lgammaf 87 #undef lgammal 88 #undef llrint 89 #undef llrintf 90 #undef llrintl 91 #undef llround 92 #undef llroundf 93 #undef llroundl 94 #undef log1p 95 #undef log1pf 96 #undef log1pl 97 #undef log2 98 #undef log2f 99 #undef log2l 100 #undef logb 101 #undef logbf 102 #undef logbl 103 #undef lrint 104 #undef lrintf 105 #undef lrintl 106 #undef lround 107 #undef lroundf 108 #undef lroundl 109 #undef nan 110 #undef nanf 111 #undef nanl 112 #undef nearbyint 113 #undef nearbyintf 114 #undef nearbyintl 115 #undef nextafter 116 #undef nextafterf 117 #undef nextafterl 118 #undef nexttoward 119 #undef nexttowardf 120 #undef nexttowardl 121 #undef remainder 122 #undef remainderf 123 #undef remainderl 124 #undef remquo 125 #undef remquof 126 #undef remquol 127 #undef rint 128 #undef rintf 129 #undef rintl 130 #undef round 131 #undef roundf 132 #undef roundl 133 #undef scalbln 134 #undef scalblnf 135 #undef scalblnl 136 #undef scalbn 137 #undef scalbnf 138 #undef scalbnl 139 #undef tgamma 140 #undef tgammaf 141 #undef tgammal 142 #undef trunc 143 #undef truncf 144 #undef truncl 145 146 #endif 147 148 namespace std _GLIBCXX_VISIBILITY(default) 149 { 150 _GLIBCXX_BEGIN_NAMESPACE_VERSION 151 152 namespace tr1 153 { 154 #if _GLIBCXX_USE_C99_MATH_TR1 155 156 // Using declarations to bring names from libc's <math.h> into std::tr1. 157 158 // types 159 using ::double_t; 160 using ::float_t; 161 162 // functions 163 using ::acosh; 164 using ::acoshf; 165 using ::acoshl; 166 167 using ::asinh; 168 using ::asinhf; 169 using ::asinhl; 170 171 using ::atanh; 172 using ::atanhf; 173 using ::atanhl; 174 175 using ::cbrt; 176 using ::cbrtf; 177 using ::cbrtl; 178 179 using ::copysign; 180 using ::copysignf; 181 using ::copysignl; 182 183 using ::erf; 184 using ::erff; 185 using ::erfl; 186 187 using ::erfc; 188 using ::erfcf; 189 using ::erfcl; 190 191 using ::exp2; 192 using ::exp2f; 193 using ::exp2l; 194 195 using ::expm1; 196 using ::expm1f; 197 using ::expm1l; 198 199 using ::fdim; 200 using ::fdimf; 201 using ::fdiml; 202 203 using ::fma; 204 using ::fmaf; 205 using ::fmal; 206 207 using ::fmax; 208 using ::fmaxf; 209 using ::fmaxl; 210 211 using ::fmin; 212 using ::fminf; 213 using ::fminl; 214 215 using ::hypot; 216 using ::hypotf; 217 using ::hypotl; 218 219 using ::ilogb; 220 using ::ilogbf; 221 using ::ilogbl; 222 223 using ::lgamma; 224 using ::lgammaf; 225 using ::lgammal; 226 227 using ::llrint; 228 using ::llrintf; 229 using ::llrintl; 230 231 using ::llround; 232 using ::llroundf; 233 using ::llroundl; 234 235 using ::log1p; 236 using ::log1pf; 237 using ::log1pl; 238 239 using ::log2; 240 using ::log2f; 241 using ::log2l; 242 243 using ::logb; 244 using ::logbf; 245 using ::logbl; 246 247 using ::lrint; 248 using ::lrintf; 249 using ::lrintl; 250 251 using ::lround; 252 using ::lroundf; 253 using ::lroundl; 254 255 using ::nan; 256 using ::nanf; 257 using ::nanl; 258 259 using ::nearbyint; 260 using ::nearbyintf; 261 using ::nearbyintl; 262 263 using ::nextafter; 264 using ::nextafterf; 265 using ::nextafterl; 266 267 using ::nexttoward; 268 using ::nexttowardf; 269 using ::nexttowardl; 270 271 using ::remainder; 272 using ::remainderf; 273 using ::remainderl; 274 275 using ::remquo; 276 using ::remquof; 277 using ::remquol; 278 279 using ::rint; 280 using ::rintf; 281 using ::rintl; 282 283 using ::round; 284 using ::roundf; 285 using ::roundl; 286 287 using ::scalbln; 288 using ::scalblnf; 289 using ::scalblnl; 290 291 using ::scalbn; 292 using ::scalbnf; 293 using ::scalbnl; 294 295 using ::tgamma; 296 using ::tgammaf; 297 using ::tgammal; 298 299 using ::trunc; 300 using ::truncf; 301 using ::truncl; 302 303 #endif 304 305 #if _GLIBCXX_USE_C99_MATH 306 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC 307 308 /// Function template definitions [8.16.3]. 309 template<typename _Tp> 310 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 311 int>::__type 312 fpclassify(_Tp __f) 313 { 314 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 315 return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 316 FP_SUBNORMAL, FP_ZERO, __type(__f)); 317 } 318 319 template<typename _Tp> 320 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 321 int>::__type 322 isfinite(_Tp __f) 323 { 324 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 325 return __builtin_isfinite(__type(__f)); 326 } 327 328 template<typename _Tp> 329 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 330 int>::__type 331 isinf(_Tp __f) 332 { 333 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 334 return __builtin_isinf(__type(__f)); 335 } 336 337 template<typename _Tp> 338 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 339 int>::__type 340 isnan(_Tp __f) 341 { 342 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 343 return __builtin_isnan(__type(__f)); 344 } 345 346 template<typename _Tp> 347 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 348 int>::__type 349 isnormal(_Tp __f) 350 { 351 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 352 return __builtin_isnormal(__type(__f)); 353 } 354 355 template<typename _Tp> 356 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 357 int>::__type 358 signbit(_Tp __f) 359 { 360 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 361 return __builtin_signbit(__type(__f)); 362 } 363 364 template<typename _Tp> 365 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 366 int>::__type 367 isgreater(_Tp __f1, _Tp __f2) 368 { 369 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 370 return __builtin_isgreater(__type(__f1), __type(__f2)); 371 } 372 373 template<typename _Tp> 374 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 375 int>::__type 376 isgreaterequal(_Tp __f1, _Tp __f2) 377 { 378 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 379 return __builtin_isgreaterequal(__type(__f1), __type(__f2)); 380 } 381 382 template<typename _Tp> 383 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 384 int>::__type 385 isless(_Tp __f1, _Tp __f2) 386 { 387 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 388 return __builtin_isless(__type(__f1), __type(__f2)); 389 } 390 391 template<typename _Tp> 392 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 393 int>::__type 394 islessequal(_Tp __f1, _Tp __f2) 395 { 396 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 397 return __builtin_islessequal(__type(__f1), __type(__f2)); 398 } 399 400 template<typename _Tp> 401 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 402 int>::__type 403 islessgreater(_Tp __f1, _Tp __f2) 404 { 405 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 406 return __builtin_islessgreater(__type(__f1), __type(__f2)); 407 } 408 409 template<typename _Tp> 410 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 411 int>::__type 412 isunordered(_Tp __f1, _Tp __f2) 413 { 414 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 415 return __builtin_isunordered(__type(__f1), __type(__f2)); 416 } 417 418 #endif 419 #endif 420 421 #if _GLIBCXX_USE_C99_MATH_TR1 422 423 /** Additional overloads [8.16.4]. 424 * @{ 425 */ 426 427 // For functions defined in C++03 the additional overloads are already 428 // declared in <cmath> so we can just re-declare them in std::tr1. 429 430 using std::acos; 431 using std::asin; 432 using std::atan; 433 using std::atan2; 434 using std::ceil; 435 using std::cos; 436 using std::cosh; 437 using std::exp; 438 using std::floor; 439 using std::fmod; 440 using std::frexp; 441 using std::ldexp; 442 using std::log; 443 using std::log10; 444 using std::sin; 445 using std::sinh; 446 using std::sqrt; 447 using std::tan; 448 using std::tanh; 449 450 #if __cplusplus >= 201103L 451 452 // Since C++11, <cmath> defines additional overloads for these functions 453 // in namespace std. 454 455 using std::acosh; 456 using std::asinh; 457 using std::atanh; 458 using std::cbrt; 459 using std::copysign; 460 using std::erf; 461 using std::erfc; 462 using std::exp2; 463 using std::expm1; 464 using std::fdim; 465 using std::fma; 466 using std::fmax; 467 using std::fmin; 468 using std::hypot; 469 using std::ilogb; 470 using std::lgamma; 471 using std::llrint; 472 using std::llround; 473 using std::log1p; 474 using std::log2; 475 using std::logb; 476 using std::lrint; 477 using std::lround; 478 using std::nan; 479 using std::nearbyint; 480 using std::nextafter; 481 using std::nexttoward; 482 using std::remainder; 483 using std::remquo; 484 using std::rint; 485 using std::round; 486 using std::scalbln; 487 using std::scalbn; 488 using std::tgamma; 489 using std::trunc; 490 491 #else // __cplusplus < 201103L 492 493 // In C++03 we need to provide the additional overloads. 494 495 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 496 inline float 497 acosh(float __x) 498 { return __builtin_acoshf(__x); } 499 500 inline long double 501 acosh(long double __x) 502 { return __builtin_acoshl(__x); } 503 #endif 504 505 template<typename _Tp> 506 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 507 double>::__type 508 acosh(_Tp __x) 509 { return __builtin_acosh(__x); } 510 511 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 512 inline float 513 asinh(float __x) 514 { return __builtin_asinhf(__x); } 515 516 inline long double 517 asinh(long double __x) 518 { return __builtin_asinhl(__x); } 519 #endif 520 521 template<typename _Tp> 522 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 523 double>::__type 524 asinh(_Tp __x) 525 { return __builtin_asinh(__x); } 526 527 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 528 inline float 529 atanh(float __x) 530 { return __builtin_atanhf(__x); } 531 532 inline long double 533 atanh(long double __x) 534 { return __builtin_atanhl(__x); } 535 #endif 536 537 template<typename _Tp> 538 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 539 double>::__type 540 atanh(_Tp __x) 541 { return __builtin_atanh(__x); } 542 543 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 544 inline float 545 cbrt(float __x) 546 { return __builtin_cbrtf(__x); } 547 548 inline long double 549 cbrt(long double __x) 550 { return __builtin_cbrtl(__x); } 551 #endif 552 553 template<typename _Tp> 554 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 555 double>::__type 556 cbrt(_Tp __x) 557 { return __builtin_cbrt(__x); } 558 559 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 560 inline float 561 copysign(float __x, float __y) 562 { return __builtin_copysignf(__x, __y); } 563 564 inline long double 565 copysign(long double __x, long double __y) 566 { return __builtin_copysignl(__x, __y); } 567 #endif 568 569 template<typename _Tp, typename _Up> 570 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 571 copysign(_Tp __x, _Up __y) 572 { 573 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 574 return copysign(__type(__x), __type(__y)); 575 } 576 577 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 578 inline float 579 erf(float __x) 580 { return __builtin_erff(__x); } 581 582 inline long double 583 erf(long double __x) 584 { return __builtin_erfl(__x); } 585 #endif 586 587 template<typename _Tp> 588 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 589 double>::__type 590 erf(_Tp __x) 591 { return __builtin_erf(__x); } 592 593 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 594 inline float 595 erfc(float __x) 596 { return __builtin_erfcf(__x); } 597 598 inline long double 599 erfc(long double __x) 600 { return __builtin_erfcl(__x); } 601 #endif 602 603 template<typename _Tp> 604 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 605 double>::__type 606 erfc(_Tp __x) 607 { return __builtin_erfc(__x); } 608 609 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 610 inline float 611 exp2(float __x) 612 { return __builtin_exp2f(__x); } 613 614 inline long double 615 exp2(long double __x) 616 { return __builtin_exp2l(__x); } 617 #endif 618 619 template<typename _Tp> 620 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 621 double>::__type 622 exp2(_Tp __x) 623 { return __builtin_exp2(__x); } 624 625 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 626 inline float 627 expm1(float __x) 628 { return __builtin_expm1f(__x); } 629 630 inline long double 631 expm1(long double __x) 632 { return __builtin_expm1l(__x); } 633 #endif 634 635 template<typename _Tp> 636 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 637 double>::__type 638 expm1(_Tp __x) 639 { return __builtin_expm1(__x); } 640 641 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 642 inline float 643 fdim(float __x, float __y) 644 { return __builtin_fdimf(__x, __y); } 645 646 inline long double 647 fdim(long double __x, long double __y) 648 { return __builtin_fdiml(__x, __y); } 649 #endif 650 651 template<typename _Tp, typename _Up> 652 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 653 fdim(_Tp __x, _Up __y) 654 { 655 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 656 return fdim(__type(__x), __type(__y)); 657 } 658 659 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 660 inline float 661 fma(float __x, float __y, float __z) 662 { return __builtin_fmaf(__x, __y, __z); } 663 664 inline long double 665 fma(long double __x, long double __y, long double __z) 666 { return __builtin_fmal(__x, __y, __z); } 667 #endif 668 669 template<typename _Tp, typename _Up, typename _Vp> 670 inline typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type 671 fma(_Tp __x, _Up __y, _Vp __z) 672 { 673 typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; 674 return fma(__type(__x), __type(__y), __type(__z)); 675 } 676 677 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 678 inline float 679 fmax(float __x, float __y) 680 { return __builtin_fmaxf(__x, __y); } 681 682 inline long double 683 fmax(long double __x, long double __y) 684 { return __builtin_fmaxl(__x, __y); } 685 #endif 686 687 template<typename _Tp, typename _Up> 688 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 689 fmax(_Tp __x, _Up __y) 690 { 691 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 692 return fmax(__type(__x), __type(__y)); 693 } 694 695 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 696 inline float 697 fmin(float __x, float __y) 698 { return __builtin_fminf(__x, __y); } 699 700 inline long double 701 fmin(long double __x, long double __y) 702 { return __builtin_fminl(__x, __y); } 703 #endif 704 705 template<typename _Tp, typename _Up> 706 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 707 fmin(_Tp __x, _Up __y) 708 { 709 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 710 return fmin(__type(__x), __type(__y)); 711 } 712 713 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 714 inline float 715 hypot(float __x, float __y) 716 { return __builtin_hypotf(__x, __y); } 717 718 inline long double 719 hypot(long double __x, long double __y) 720 { return __builtin_hypotl(__x, __y); } 721 #endif 722 723 template<typename _Tp, typename _Up> 724 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 725 hypot(_Tp __y, _Up __x) 726 { 727 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 728 return hypot(__type(__y), __type(__x)); 729 } 730 731 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 732 inline int 733 ilogb(float __x) 734 { return __builtin_ilogbf(__x); } 735 736 inline int 737 ilogb(long double __x) 738 { return __builtin_ilogbl(__x); } 739 #endif 740 741 template<typename _Tp> 742 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 743 int>::__type 744 ilogb(_Tp __x) 745 { return __builtin_ilogb(__x); } 746 747 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 748 inline float 749 lgamma(float __x) 750 { return __builtin_lgammaf(__x); } 751 752 inline long double 753 lgamma(long double __x) 754 { return __builtin_lgammal(__x); } 755 #endif 756 757 template<typename _Tp> 758 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 759 double>::__type 760 lgamma(_Tp __x) 761 { return __builtin_lgamma(__x); } 762 763 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 764 inline long long 765 llrint(float __x) 766 { return __builtin_llrintf(__x); } 767 768 inline long long 769 llrint(long double __x) 770 { return __builtin_llrintl(__x); } 771 #endif 772 773 template<typename _Tp> 774 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 775 long long>::__type 776 llrint(_Tp __x) 777 { return __builtin_llrint(__x); } 778 779 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 780 inline long long 781 llround(float __x) 782 { return __builtin_llroundf(__x); } 783 784 inline long long 785 llround(long double __x) 786 { return __builtin_llroundl(__x); } 787 #endif 788 789 template<typename _Tp> 790 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 791 long long>::__type 792 llround(_Tp __x) 793 { return __builtin_llround(__x); } 794 795 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 796 inline float 797 log1p(float __x) 798 { return __builtin_log1pf(__x); } 799 800 inline long double 801 log1p(long double __x) 802 { return __builtin_log1pl(__x); } 803 #endif 804 805 template<typename _Tp> 806 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 807 double>::__type 808 log1p(_Tp __x) 809 { return __builtin_log1p(__x); } 810 811 // DR 568. 812 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 813 inline float 814 log2(float __x) 815 { return __builtin_log2f(__x); } 816 817 inline long double 818 log2(long double __x) 819 { return __builtin_log2l(__x); } 820 #endif 821 822 template<typename _Tp> 823 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 824 double>::__type 825 log2(_Tp __x) 826 { return __builtin_log2(__x); } 827 828 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 829 inline float 830 logb(float __x) 831 { return __builtin_logbf(__x); } 832 833 inline long double 834 logb(long double __x) 835 { return __builtin_logbl(__x); } 836 #endif 837 838 template<typename _Tp> 839 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 840 double>::__type 841 logb(_Tp __x) 842 { 843 return __builtin_logb(__x); 844 } 845 846 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 847 inline long 848 lrint(float __x) 849 { return __builtin_lrintf(__x); } 850 851 inline long 852 lrint(long double __x) 853 { return __builtin_lrintl(__x); } 854 #endif 855 856 template<typename _Tp> 857 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 858 long>::__type 859 lrint(_Tp __x) 860 { return __builtin_lrint(__x); } 861 862 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 863 inline long 864 lround(float __x) 865 { return __builtin_lroundf(__x); } 866 867 inline long 868 lround(long double __x) 869 { return __builtin_lroundl(__x); } 870 #endif 871 872 template<typename _Tp> 873 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 874 long>::__type 875 lround(_Tp __x) 876 { return __builtin_lround(__x); } 877 878 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 879 inline float 880 nearbyint(float __x) 881 { return __builtin_nearbyintf(__x); } 882 883 inline long double 884 nearbyint(long double __x) 885 { return __builtin_nearbyintl(__x); } 886 #endif 887 888 template<typename _Tp> 889 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 890 double>::__type 891 nearbyint(_Tp __x) 892 { return __builtin_nearbyint(__x); } 893 894 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 895 inline float 896 nextafter(float __x, float __y) 897 { return __builtin_nextafterf(__x, __y); } 898 899 inline long double 900 nextafter(long double __x, long double __y) 901 { return __builtin_nextafterl(__x, __y); } 902 #endif 903 904 template<typename _Tp, typename _Up> 905 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 906 nextafter(_Tp __x, _Up __y) 907 { 908 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 909 return nextafter(__type(__x), __type(__y)); 910 } 911 912 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 913 inline float 914 nexttoward(float __x, long double __y) 915 { return __builtin_nexttowardf(__x, __y); } 916 917 inline long double 918 nexttoward(long double __x, long double __y) 919 { return __builtin_nexttowardl(__x, __y); } 920 #endif 921 922 template<typename _Tp> 923 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 924 double>::__type 925 nexttoward(_Tp __x, long double __y) 926 { return __builtin_nexttoward(__x, __y); } 927 928 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 929 inline float 930 remainder(float __x, float __y) 931 { return __builtin_remainderf(__x, __y); } 932 933 inline long double 934 remainder(long double __x, long double __y) 935 { return __builtin_remainderl(__x, __y); } 936 #endif 937 938 template<typename _Tp, typename _Up> 939 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 940 remainder(_Tp __x, _Up __y) 941 { 942 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 943 return remainder(__type(__x), __type(__y)); 944 } 945 946 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 947 inline float 948 remquo(float __x, float __y, int* __pquo) 949 { return __builtin_remquof(__x, __y, __pquo); } 950 951 inline long double 952 remquo(long double __x, long double __y, int* __pquo) 953 { return __builtin_remquol(__x, __y, __pquo); } 954 #endif 955 956 template<typename _Tp, typename _Up> 957 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 958 remquo(_Tp __x, _Up __y, int* __pquo) 959 { 960 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 961 return remquo(__type(__x), __type(__y), __pquo); 962 } 963 964 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 965 inline float 966 rint(float __x) 967 { return __builtin_rintf(__x); } 968 969 inline long double 970 rint(long double __x) 971 { return __builtin_rintl(__x); } 972 #endif 973 974 template<typename _Tp> 975 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 976 double>::__type 977 rint(_Tp __x) 978 { return __builtin_rint(__x); } 979 980 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 981 inline float 982 round(float __x) 983 { return __builtin_roundf(__x); } 984 985 inline long double 986 round(long double __x) 987 { return __builtin_roundl(__x); } 988 #endif 989 990 template<typename _Tp> 991 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 992 double>::__type 993 round(_Tp __x) 994 { return __builtin_round(__x); } 995 996 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 997 inline float 998 scalbln(float __x, long __ex) 999 { return __builtin_scalblnf(__x, __ex); } 1000 1001 inline long double 1002 scalbln(long double __x, long __ex) 1003 { return __builtin_scalblnl(__x, __ex); } 1004 #endif 1005 1006 template<typename _Tp> 1007 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1008 double>::__type 1009 scalbln(_Tp __x, long __ex) 1010 { return __builtin_scalbln(__x, __ex); } 1011 1012 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1013 inline float 1014 scalbn(float __x, int __ex) 1015 { return __builtin_scalbnf(__x, __ex); } 1016 1017 inline long double 1018 scalbn(long double __x, int __ex) 1019 { return __builtin_scalbnl(__x, __ex); } 1020 #endif 1021 1022 template<typename _Tp> 1023 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1024 double>::__type 1025 scalbn(_Tp __x, int __ex) 1026 { return __builtin_scalbn(__x, __ex); } 1027 1028 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1029 inline float 1030 tgamma(float __x) 1031 { return __builtin_tgammaf(__x); } 1032 1033 inline long double 1034 tgamma(long double __x) 1035 { return __builtin_tgammal(__x); } 1036 #endif 1037 1038 template<typename _Tp> 1039 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1040 double>::__type 1041 tgamma(_Tp __x) 1042 { return __builtin_tgamma(__x); } 1043 1044 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1045 inline float 1046 trunc(float __x) 1047 { return __builtin_truncf(__x); } 1048 1049 inline long double 1050 trunc(long double __x) 1051 { return __builtin_truncl(__x); } 1052 #endif 1053 1054 template<typename _Tp> 1055 inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1056 double>::__type 1057 trunc(_Tp __x) 1058 { return __builtin_trunc(__x); } 1059 1060 #endif // __cplusplus < 201103L 1061 1062 /// @} 1063 1064 #endif /* _GLIBCXX_USE_C99_MATH_TR1 */ 1065 1066 // DR 550. What should the return type of pow(float,int) be? 1067 // NB: C++11 and TR1 != C++03. 1068 1069 // We cannot do "using std::pow;" because that would bring in unwanted 1070 // pow(*, int) overloads in C++03, with the wrong return type. Instead we 1071 // define all the necessary overloads, but the std::tr1::pow(double, double) 1072 // overload cannot be provided here, because <tr1/math.h> would add it to 1073 // the global namespace where it would clash with ::pow(double,double) from 1074 // libc (revealed by the fix of PR c++/54537). 1075 // The solution is to forward std::tr1::pow(double,double) to 1076 // std::pow(double,double) via the function template below. See 1077 // the discussion about this issue here: 1078 // http://gcc.gnu.org/ml/gcc-patches/2012-09/msg01278.html 1079 1080 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1081 inline float 1082 pow(float __x, float __y) 1083 { return std::pow(__x, __y); } 1084 1085 inline long double 1086 pow(long double __x, long double __y) 1087 { return std::pow(__x, __y); } 1088 #endif 1089 1090 template<typename _Tp, typename _Up> 1091 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1092 pow(_Tp __x, _Up __y) 1093 { 1094 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1095 return std::pow(__type(__x), __type(__y)); 1096 } 1097 1098 #if __cplusplus >= 201103L 1099 // We also deal with fabs in a special way, because "using std::fabs;" 1100 // could bring in C++11's std::fabs<T>(const std::complex<T>&) with a 1101 // different return type from std::tr1::fabs<T>(const std::complex<T>&). 1102 // We define the necessary overloads, except std::tr1::fabs(double) which 1103 // could clash with ::fabs(double) from libc. 1104 // The function template handles double as well as integers, forwarding 1105 // to std::fabs. 1106 1107 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 1108 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1109 inline float 1110 fabs(float __x) 1111 { return __builtin_fabsf(__x); } 1112 1113 inline long double 1114 fabs(long double __x) 1115 { return __builtin_fabsl(__x); } 1116 #endif 1117 #endif 1118 1119 template<typename _Tp> 1120 inline typename __gnu_cxx::__promote<_Tp>::__type 1121 fabs(_Tp __x) 1122 { return std::fabs(__x); } 1123 1124 #else // ! C++11 1125 1126 // For C++03 just use std::fabs as there is no overload for std::complex<>. 1127 using std::fabs; 1128 1129 #endif // C++11 1130 1131 } // namespace tr1 1132 _GLIBCXX_END_NAMESPACE_VERSION 1133 } // namespace std 1134 1135 /** 1136 * @defgroup tr1_math_spec_func TR1 Mathematical Special Functions 1137 * @ingroup numerics 1138 * 1139 * A collection of advanced mathematical special functions. 1140 */ 1141 1142 #if _GLIBCXX_USE_STD_SPEC_FUNCS 1143 1144 namespace std _GLIBCXX_VISIBILITY(default) 1145 { 1146 _GLIBCXX_BEGIN_NAMESPACE_VERSION 1147 1148 namespace tr1 1149 { 1150 using std::assoc_laguerref; 1151 using std::assoc_laguerrel; 1152 using std::assoc_laguerre; 1153 1154 using std::assoc_legendref; 1155 using std::assoc_legendrel; 1156 using std::assoc_legendre; 1157 1158 using std::betaf; 1159 using std::betal; 1160 using std::beta; 1161 1162 using std::comp_ellint_1f; 1163 using std::comp_ellint_1l; 1164 using std::comp_ellint_1; 1165 1166 using std::comp_ellint_2f; 1167 using std::comp_ellint_2l; 1168 using std::comp_ellint_2; 1169 1170 using std::comp_ellint_3f; 1171 using std::comp_ellint_3l; 1172 using std::comp_ellint_3; 1173 1174 using std::cyl_bessel_if; 1175 using std::cyl_bessel_il; 1176 using std::cyl_bessel_i; 1177 1178 using std::cyl_bessel_jf; 1179 using std::cyl_bessel_jl; 1180 using std::cyl_bessel_j; 1181 1182 using std::cyl_bessel_kf; 1183 using std::cyl_bessel_kl; 1184 using std::cyl_bessel_k; 1185 1186 using std::cyl_neumannf; 1187 using std::cyl_neumannl; 1188 using std::cyl_neumann; 1189 1190 using std::ellint_1f; 1191 using std::ellint_1l; 1192 using std::ellint_1; 1193 1194 using std::ellint_2f; 1195 using std::ellint_2l; 1196 using std::ellint_2; 1197 1198 using std::ellint_3f; 1199 using std::ellint_3l; 1200 using std::ellint_3; 1201 1202 using std::expintf; 1203 using std::expintl; 1204 using std::expint; 1205 1206 using std::hermitef; 1207 using std::hermitel; 1208 using std::hermite; 1209 1210 using std::laguerref; 1211 using std::laguerrel; 1212 using std::laguerre; 1213 1214 using std::legendref; 1215 using std::legendrel; 1216 using std::legendre; 1217 1218 using std::riemann_zetaf; 1219 using std::riemann_zetal; 1220 using std::riemann_zeta; 1221 1222 using std::sph_besself; 1223 using std::sph_bessell; 1224 using std::sph_bessel; 1225 1226 using std::sph_legendref; 1227 using std::sph_legendrel; 1228 using std::sph_legendre; 1229 1230 using std::sph_neumannf; 1231 using std::sph_neumannl; 1232 using std::sph_neumann; 1233 1234 } // namespace tr1 1235 _GLIBCXX_END_NAMESPACE_VERSION 1236 } // namespace std 1237 1238 #else // ! _GLIBCXX_USE_STD_SPEC_FUNCS 1239 1240 #include <bits/stl_algobase.h> 1241 #include <limits> 1242 #include <tr1/type_traits> 1243 1244 #include <tr1/gamma.tcc> 1245 #include <tr1/bessel_function.tcc> 1246 #include <tr1/beta_function.tcc> 1247 #include <tr1/ell_integral.tcc> 1248 #include <tr1/exp_integral.tcc> 1249 #include <tr1/legendre_function.tcc> 1250 #include <tr1/modified_bessel_func.tcc> 1251 #include <tr1/poly_hermite.tcc> 1252 #include <tr1/poly_laguerre.tcc> 1253 #include <tr1/riemann_zeta.tcc> 1254 1255 namespace std _GLIBCXX_VISIBILITY(default) 1256 { 1257 _GLIBCXX_BEGIN_NAMESPACE_VERSION 1258 namespace tr1 1259 { 1260 /** @addtogroup tr1_math_spec_func 1261 * @{ 1262 */ 1263 1264 inline float 1265 assoc_laguerref(unsigned int __n, unsigned int __m, float __x) 1266 { return __detail::__assoc_laguerre<float>(__n, __m, __x); } 1267 1268 inline long double 1269 assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x) 1270 { 1271 return __detail::__assoc_laguerre<long double>(__n, __m, __x); 1272 } 1273 1274 /// 5.2.1.1 Associated Laguerre polynomials. 1275 template<typename _Tp> 1276 inline typename __gnu_cxx::__promote<_Tp>::__type 1277 assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) 1278 { 1279 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1280 return __detail::__assoc_laguerre<__type>(__n, __m, __x); 1281 } 1282 1283 inline float 1284 assoc_legendref(unsigned int __l, unsigned int __m, float __x) 1285 { return __detail::__assoc_legendre_p<float>(__l, __m, __x); } 1286 1287 inline long double 1288 assoc_legendrel(unsigned int __l, unsigned int __m, long double __x) 1289 { return __detail::__assoc_legendre_p<long double>(__l, __m, __x); } 1290 1291 /// 5.2.1.2 Associated Legendre functions. 1292 template<typename _Tp> 1293 inline typename __gnu_cxx::__promote<_Tp>::__type 1294 assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x) 1295 { 1296 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1297 return __detail::__assoc_legendre_p<__type>(__l, __m, __x); 1298 } 1299 1300 inline float 1301 betaf(float __x, float __y) 1302 { return __detail::__beta<float>(__x, __y); } 1303 1304 inline long double 1305 betal(long double __x, long double __y) 1306 { return __detail::__beta<long double>(__x, __y); } 1307 1308 /// 5.2.1.3 Beta functions. 1309 template<typename _Tpx, typename _Tpy> 1310 inline typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type 1311 beta(_Tpx __x, _Tpy __y) 1312 { 1313 typedef typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type __type; 1314 return __detail::__beta<__type>(__x, __y); 1315 } 1316 1317 inline float 1318 comp_ellint_1f(float __k) 1319 { return __detail::__comp_ellint_1<float>(__k); } 1320 1321 inline long double 1322 comp_ellint_1l(long double __k) 1323 { return __detail::__comp_ellint_1<long double>(__k); } 1324 1325 /// 5.2.1.4 Complete elliptic integrals of the first kind. 1326 template<typename _Tp> 1327 inline typename __gnu_cxx::__promote<_Tp>::__type 1328 comp_ellint_1(_Tp __k) 1329 { 1330 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1331 return __detail::__comp_ellint_1<__type>(__k); 1332 } 1333 1334 inline float 1335 comp_ellint_2f(float __k) 1336 { return __detail::__comp_ellint_2<float>(__k); } 1337 1338 inline long double 1339 comp_ellint_2l(long double __k) 1340 { return __detail::__comp_ellint_2<long double>(__k); } 1341 1342 /// 5.2.1.5 Complete elliptic integrals of the second kind. 1343 template<typename _Tp> 1344 inline typename __gnu_cxx::__promote<_Tp>::__type 1345 comp_ellint_2(_Tp __k) 1346 { 1347 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1348 return __detail::__comp_ellint_2<__type>(__k); 1349 } 1350 1351 inline float 1352 comp_ellint_3f(float __k, float __nu) 1353 { return __detail::__comp_ellint_3<float>(__k, __nu); } 1354 1355 inline long double 1356 comp_ellint_3l(long double __k, long double __nu) 1357 { return __detail::__comp_ellint_3<long double>(__k, __nu); } 1358 1359 /// 5.2.1.6 Complete elliptic integrals of the third kind. 1360 template<typename _Tp, typename _Tpn> 1361 inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type 1362 comp_ellint_3(_Tp __k, _Tpn __nu) 1363 { 1364 typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type; 1365 return __detail::__comp_ellint_3<__type>(__k, __nu); 1366 } 1367 1368 inline float 1369 cyl_bessel_if(float __nu, float __x) 1370 { return __detail::__cyl_bessel_i<float>(__nu, __x); } 1371 1372 inline long double 1373 cyl_bessel_il(long double __nu, long double __x) 1374 { return __detail::__cyl_bessel_i<long double>(__nu, __x); } 1375 1376 /// 5.2.1.8 Regular modified cylindrical Bessel functions. 1377 template<typename _Tpnu, typename _Tp> 1378 inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type 1379 cyl_bessel_i(_Tpnu __nu, _Tp __x) 1380 { 1381 typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; 1382 return __detail::__cyl_bessel_i<__type>(__nu, __x); 1383 } 1384 1385 inline float 1386 cyl_bessel_jf(float __nu, float __x) 1387 { return __detail::__cyl_bessel_j<float>(__nu, __x); } 1388 1389 inline long double 1390 cyl_bessel_jl(long double __nu, long double __x) 1391 { return __detail::__cyl_bessel_j<long double>(__nu, __x); } 1392 1393 /// 5.2.1.9 Cylindrical Bessel functions (of the first kind). 1394 template<typename _Tpnu, typename _Tp> 1395 inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type 1396 cyl_bessel_j(_Tpnu __nu, _Tp __x) 1397 { 1398 typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; 1399 return __detail::__cyl_bessel_j<__type>(__nu, __x); 1400 } 1401 1402 inline float 1403 cyl_bessel_kf(float __nu, float __x) 1404 { return __detail::__cyl_bessel_k<float>(__nu, __x); } 1405 1406 inline long double 1407 cyl_bessel_kl(long double __nu, long double __x) 1408 { return __detail::__cyl_bessel_k<long double>(__nu, __x); } 1409 1410 /// 5.2.1.10 Irregular modified cylindrical Bessel functions. 1411 template<typename _Tpnu, typename _Tp> 1412 inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type 1413 cyl_bessel_k(_Tpnu __nu, _Tp __x) 1414 { 1415 typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; 1416 return __detail::__cyl_bessel_k<__type>(__nu, __x); 1417 } 1418 1419 inline float 1420 cyl_neumannf(float __nu, float __x) 1421 { return __detail::__cyl_neumann_n<float>(__nu, __x); } 1422 1423 inline long double 1424 cyl_neumannl(long double __nu, long double __x) 1425 { return __detail::__cyl_neumann_n<long double>(__nu, __x); } 1426 1427 /// 5.2.1.11 Cylindrical Neumann functions. 1428 template<typename _Tpnu, typename _Tp> 1429 inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type 1430 cyl_neumann(_Tpnu __nu, _Tp __x) 1431 { 1432 typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; 1433 return __detail::__cyl_neumann_n<__type>(__nu, __x); 1434 } 1435 1436 inline float 1437 ellint_1f(float __k, float __phi) 1438 { return __detail::__ellint_1<float>(__k, __phi); } 1439 1440 inline long double 1441 ellint_1l(long double __k, long double __phi) 1442 { return __detail::__ellint_1<long double>(__k, __phi); } 1443 1444 /// 5.2.1.12 Incomplete elliptic integrals of the first kind. 1445 template<typename _Tp, typename _Tpp> 1446 inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type 1447 ellint_1(_Tp __k, _Tpp __phi) 1448 { 1449 typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; 1450 return __detail::__ellint_1<__type>(__k, __phi); 1451 } 1452 1453 inline float 1454 ellint_2f(float __k, float __phi) 1455 { return __detail::__ellint_2<float>(__k, __phi); } 1456 1457 inline long double 1458 ellint_2l(long double __k, long double __phi) 1459 { return __detail::__ellint_2<long double>(__k, __phi); } 1460 1461 /// 5.2.1.13 Incomplete elliptic integrals of the second kind. 1462 template<typename _Tp, typename _Tpp> 1463 inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type 1464 ellint_2(_Tp __k, _Tpp __phi) 1465 { 1466 typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; 1467 return __detail::__ellint_2<__type>(__k, __phi); 1468 } 1469 1470 inline float 1471 ellint_3f(float __k, float __nu, float __phi) 1472 { return __detail::__ellint_3<float>(__k, __nu, __phi); } 1473 1474 inline long double 1475 ellint_3l(long double __k, long double __nu, long double __phi) 1476 { return __detail::__ellint_3<long double>(__k, __nu, __phi); } 1477 1478 /// 5.2.1.14 Incomplete elliptic integrals of the third kind. 1479 template<typename _Tp, typename _Tpn, typename _Tpp> 1480 inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type 1481 ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi) 1482 { 1483 typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type; 1484 return __detail::__ellint_3<__type>(__k, __nu, __phi); 1485 } 1486 1487 inline float 1488 expintf(float __x) 1489 { return __detail::__expint<float>(__x); } 1490 1491 inline long double 1492 expintl(long double __x) 1493 { return __detail::__expint<long double>(__x); } 1494 1495 /// 5.2.1.15 Exponential integrals. 1496 template<typename _Tp> 1497 inline typename __gnu_cxx::__promote<_Tp>::__type 1498 expint(_Tp __x) 1499 { 1500 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1501 return __detail::__expint<__type>(__x); 1502 } 1503 1504 inline float 1505 hermitef(unsigned int __n, float __x) 1506 { return __detail::__poly_hermite<float>(__n, __x); } 1507 1508 inline long double 1509 hermitel(unsigned int __n, long double __x) 1510 { return __detail::__poly_hermite<long double>(__n, __x); } 1511 1512 /// 5.2.1.16 Hermite polynomials. 1513 template<typename _Tp> 1514 inline typename __gnu_cxx::__promote<_Tp>::__type 1515 hermite(unsigned int __n, _Tp __x) 1516 { 1517 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1518 return __detail::__poly_hermite<__type>(__n, __x); 1519 } 1520 1521 inline float 1522 laguerref(unsigned int __n, float __x) 1523 { return __detail::__laguerre<float>(__n, __x); } 1524 1525 inline long double 1526 laguerrel(unsigned int __n, long double __x) 1527 { return __detail::__laguerre<long double>(__n, __x); } 1528 1529 /// 5.2.1.18 Laguerre polynomials. 1530 template<typename _Tp> 1531 inline typename __gnu_cxx::__promote<_Tp>::__type 1532 laguerre(unsigned int __n, _Tp __x) 1533 { 1534 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1535 return __detail::__laguerre<__type>(__n, __x); 1536 } 1537 1538 inline float 1539 legendref(unsigned int __n, float __x) 1540 { return __detail::__poly_legendre_p<float>(__n, __x); } 1541 1542 inline long double 1543 legendrel(unsigned int __n, long double __x) 1544 { return __detail::__poly_legendre_p<long double>(__n, __x); } 1545 1546 /// 5.2.1.19 Legendre polynomials. 1547 template<typename _Tp> 1548 inline typename __gnu_cxx::__promote<_Tp>::__type 1549 legendre(unsigned int __n, _Tp __x) 1550 { 1551 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1552 return __detail::__poly_legendre_p<__type>(__n, __x); 1553 } 1554 1555 inline float 1556 riemann_zetaf(float __x) 1557 { return __detail::__riemann_zeta<float>(__x); } 1558 1559 inline long double 1560 riemann_zetal(long double __x) 1561 { return __detail::__riemann_zeta<long double>(__x); } 1562 1563 /// 5.2.1.20 Riemann zeta function. 1564 template<typename _Tp> 1565 inline typename __gnu_cxx::__promote<_Tp>::__type 1566 riemann_zeta(_Tp __x) 1567 { 1568 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1569 return __detail::__riemann_zeta<__type>(__x); 1570 } 1571 1572 inline float 1573 sph_besself(unsigned int __n, float __x) 1574 { return __detail::__sph_bessel<float>(__n, __x); } 1575 1576 inline long double 1577 sph_bessell(unsigned int __n, long double __x) 1578 { return __detail::__sph_bessel<long double>(__n, __x); } 1579 1580 /// 5.2.1.21 Spherical Bessel functions. 1581 template<typename _Tp> 1582 inline typename __gnu_cxx::__promote<_Tp>::__type 1583 sph_bessel(unsigned int __n, _Tp __x) 1584 { 1585 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1586 return __detail::__sph_bessel<__type>(__n, __x); 1587 } 1588 1589 inline float 1590 sph_legendref(unsigned int __l, unsigned int __m, float __theta) 1591 { return __detail::__sph_legendre<float>(__l, __m, __theta); } 1592 1593 inline long double 1594 sph_legendrel(unsigned int __l, unsigned int __m, long double __theta) 1595 { return __detail::__sph_legendre<long double>(__l, __m, __theta); } 1596 1597 /// 5.2.1.22 Spherical associated Legendre functions. 1598 template<typename _Tp> 1599 inline typename __gnu_cxx::__promote<_Tp>::__type 1600 sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) 1601 { 1602 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1603 return __detail::__sph_legendre<__type>(__l, __m, __theta); 1604 } 1605 1606 inline float 1607 sph_neumannf(unsigned int __n, float __x) 1608 { return __detail::__sph_neumann<float>(__n, __x); } 1609 1610 inline long double 1611 sph_neumannl(unsigned int __n, long double __x) 1612 { return __detail::__sph_neumann<long double>(__n, __x); } 1613 1614 /// 5.2.1.23 Spherical Neumann functions. 1615 template<typename _Tp> 1616 inline typename __gnu_cxx::__promote<_Tp>::__type 1617 sph_neumann(unsigned int __n, _Tp __x) 1618 { 1619 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1620 return __detail::__sph_neumann<__type>(__n, __x); 1621 } 1622 1623 /// @} tr1_math_spec_func 1624 1625 } // namespace tr1 1626 1627 _GLIBCXX_END_NAMESPACE_VERSION 1628 } // namespace std 1629 1630 #endif // _GLIBCXX_USE_STD_SPEC_FUNCS 1631 1632 #if _GLIBCXX_USE_STD_SPEC_FUNCS && !defined(__STRICT_ANSI__) 1633 namespace std _GLIBCXX_VISIBILITY(default) 1634 { 1635 _GLIBCXX_BEGIN_NAMESPACE_VERSION 1636 1637 namespace tr1 1638 { 1639 using __gnu_cxx::conf_hypergf; 1640 using __gnu_cxx::conf_hypergl; 1641 using __gnu_cxx::conf_hyperg; 1642 1643 using __gnu_cxx::hypergf; 1644 using __gnu_cxx::hypergl; 1645 using __gnu_cxx::hyperg; 1646 } // namespace tr1 1647 1648 _GLIBCXX_END_NAMESPACE_VERSION 1649 } // namespace std 1650 1651 #else // ! (_GLIBCXX_USE_STD_SPEC_FUNCS && !defined(__STRICT_ANSI__)) 1652 1653 #include <bits/stl_algobase.h> 1654 #include <limits> 1655 #include <tr1/type_traits> 1656 1657 #include <tr1/hypergeometric.tcc> 1658 1659 namespace std _GLIBCXX_VISIBILITY(default) 1660 { 1661 _GLIBCXX_BEGIN_NAMESPACE_VERSION 1662 1663 namespace tr1 1664 { 1665 /** @addtogroup tr1_math_spec_func 1666 * @{ 1667 */ 1668 1669 inline float 1670 conf_hypergf(float __a, float __c, float __x) 1671 { return __detail::__conf_hyperg<float>(__a, __c, __x); } 1672 1673 inline long double 1674 conf_hypergl(long double __a, long double __c, long double __x) 1675 { return __detail::__conf_hyperg<long double>(__a, __c, __x); } 1676 1677 /// 5.2.1.7 Confluent hypergeometric functions. 1678 template<typename _Tpa, typename _Tpc, typename _Tp> 1679 inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type 1680 conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x) 1681 { 1682 typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type; 1683 return __detail::__conf_hyperg<__type>(__a, __c, __x); 1684 } 1685 1686 inline float 1687 hypergf(float __a, float __b, float __c, float __x) 1688 { return __detail::__hyperg<float>(__a, __b, __c, __x); } 1689 1690 inline long double 1691 hypergl(long double __a, long double __b, long double __c, long double __x) 1692 { return __detail::__hyperg<long double>(__a, __b, __c, __x); } 1693 1694 /// 5.2.1.17 Hypergeometric functions. 1695 template<typename _Tpa, typename _Tpb, typename _Tpc, typename _Tp> 1696 inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type 1697 hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x) 1698 { 1699 typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type __type; 1700 return __detail::__hyperg<__type>(__a, __b, __c, __x); 1701 } 1702 1703 /// @} tr1_math_spec_func 1704 1705 } // namespace tr1 1706 1707 _GLIBCXX_END_NAMESPACE_VERSION 1708 } // namespace std 1709 #endif // _GLIBCXX_USE_STD_SPEC_FUNCS && !defined(__STRICT_ANSI__) 1710 1711 #endif // _GLIBCXX_TR1_CMATH
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™
