libstdc++-v3/include/tr1/cmath

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