libstdc++-v3/include/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