l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.8/include/tr1/cmath

   1 // TR1 cmath -*- C++ -*-
   2
   3 // Copyright (C) 2006-2013 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 namespace tr1
 149 {
 150 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 151
 152 #if _GLIBCXX_USE_C99_MATH_TR1
 153
 154   // types
 155   using ::double_t;
 156   using ::float_t;
 157
 158   // functions
 159   using ::acosh;
 160   using ::acoshf;
 161   using ::acoshl;
 162
 163   using ::asinh;
 164   using ::asinhf;
 165   using ::asinhl;
 166
 167   using ::atanh;
 168   using ::atanhf;
 169   using ::atanhl;
 170
 171   using ::cbrt;
 172   using ::cbrtf;
 173   using ::cbrtl;
 174
 175   using ::copysign;
 176   using ::copysignf;
 177   using ::copysignl;
 178
 179   using ::erf;
 180   using ::erff;
 181   using ::erfl;
 182
 183   using ::erfc;
 184   using ::erfcf;
 185   using ::erfcl;
 186
 187   using ::exp2;
 188   using ::exp2f;
 189   using ::exp2l;
 190
 191   using ::expm1;
 192   using ::expm1f;
 193   using ::expm1l;
 194
 195   using ::fdim;
 196   using ::fdimf;
 197   using ::fdiml;
 198
 199   using ::fma;
 200   using ::fmaf;
 201   using ::fmal;
 202
 203   using ::fmax;
 204   using ::fmaxf;
 205   using ::fmaxl;
 206
 207   using ::fmin;
 208   using ::fminf;
 209   using ::fminl;
 210
 211   using ::hypot;
 212   using ::hypotf;
 213   using ::hypotl;
 214
 215   using ::ilogb;
 216   using ::ilogbf;
 217   using ::ilogbl;
 218
 219   using ::lgamma;
 220   using ::lgammaf;
 221   using ::lgammal;
 222
 223   using ::llrint;
 224   using ::llrintf;
 225   using ::llrintl;
 226
 227   using ::llround;
 228   using ::llroundf;
 229   using ::llroundl;
 230
 231   using ::log1p;
 232   using ::log1pf;
 233   using ::log1pl;
 234
 235   using ::log2;
 236   using ::log2f;
 237   using ::log2l;
 238
 239   using ::logb;
 240   using ::logbf;
 241   using ::logbl;
 242
 243   using ::lrint;
 244   using ::lrintf;
 245   using ::lrintl;
 246
 247   using ::lround;
 248   using ::lroundf;
 249   using ::lroundl;
 250
 251   using ::nan;
 252   using ::nanf;
 253   using ::nanl;
 254
 255   using ::nearbyint;
 256   using ::nearbyintf;
 257   using ::nearbyintl;
 258
 259   using ::nextafter;
 260   using ::nextafterf;
 261   using ::nextafterl;
 262
 263   using ::nexttoward;
 264   using ::nexttowardf;
 265   using ::nexttowardl;
 266
 267   using ::remainder;
 268   using ::remainderf;
 269   using ::remainderl;
 270
 271   using ::remquo;
 272   using ::remquof;
 273   using ::remquol;
 274
 275   using ::rint;
 276   using ::rintf;
 277   using ::rintl;
 278
 279   using ::round;
 280   using ::roundf;
 281   using ::roundl;
 282
 283   using ::scalbln;
 284   using ::scalblnf;
 285   using ::scalblnl;
 286
 287   using ::scalbn;
 288   using ::scalbnf;
 289   using ::scalbnl;
 290
 291   using ::tgamma;
 292   using ::tgammaf;
 293   using ::tgammal;
 294
 295   using ::trunc;
 296   using ::truncf;
 297   using ::truncl;
 298
 299 #endif
 300
 301 #if _GLIBCXX_USE_C99_MATH
 302 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
 303
 304   /// Function template definitions [8.16.3].
 305   template<typename _Tp>
 306     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 307                                            int>::__type
 308     fpclassify(_Tp __f)
 309     {
 310       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 311       return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
 312                                   FP_SUBNORMAL, FP_ZERO, __type(__f));
 313     }
 314
 315   template<typename _Tp>
 316     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 317                                            int>::__type
 318     isfinite(_Tp __f)
 319     {
 320       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 321       return __builtin_isfinite(__type(__f));
 322     }
 323
 324   template<typename _Tp>
 325     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 326                                            int>::__type
 327     isinf(_Tp __f)
 328     {
 329       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 330       return __builtin_isinf(__type(__f));
 331     }
 332
 333   template<typename _Tp>
 334     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 335                                            int>::__type
 336     isnan(_Tp __f)
 337     {
 338       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 339       return __builtin_isnan(__type(__f));
 340     }
 341
 342   template<typename _Tp>
 343     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 344                                            int>::__type
 345     isnormal(_Tp __f)
 346     {
 347       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 348       return __builtin_isnormal(__type(__f));
 349     }
 350
 351   template<typename _Tp>
 352     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 353                                            int>::__type
 354     signbit(_Tp __f)
 355     {
 356       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 357       return __builtin_signbit(__type(__f));
 358     }
 359
 360   template<typename _Tp>
 361     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 362                                            int>::__type
 363     isgreater(_Tp __f1, _Tp __f2)
 364     {
 365       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 366       return __builtin_isgreater(__type(__f1), __type(__f2));
 367     }
 368
 369   template<typename _Tp>
 370     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 371                                            int>::__type
 372     isgreaterequal(_Tp __f1, _Tp __f2)
 373     {
 374       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 375       return __builtin_isgreaterequal(__type(__f1), __type(__f2));
 376     }
 377
 378   template<typename _Tp>
 379     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 380                                            int>::__type
 381     isless(_Tp __f1, _Tp __f2)
 382     {
 383       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 384       return __builtin_isless(__type(__f1), __type(__f2));
 385     }
 386
 387   template<typename _Tp>
 388     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 389                                            int>::__type
 390     islessequal(_Tp __f1, _Tp __f2)
 391     {
 392       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 393       return __builtin_islessequal(__type(__f1), __type(__f2));
 394     }
 395
 396   template<typename _Tp>
 397     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 398                                            int>::__type
 399     islessgreater(_Tp __f1, _Tp __f2)
 400     {
 401       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 402       return __builtin_islessgreater(__type(__f1), __type(__f2));
 403     }
 404
 405   template<typename _Tp>
 406     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 407                                            int>::__type
 408     isunordered(_Tp __f1, _Tp __f2)
 409     {
 410       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 411       return __builtin_isunordered(__type(__f1), __type(__f2));
 412     }
 413
 414 #endif
 415 #endif
 416
 417 #if _GLIBCXX_USE_C99_MATH_TR1
 418
 419   /// Additional overloads [8.16.4].
 420   using std::acos;
 421
 422   inline float
 423   acosh(float __x)
 424   { return __builtin_acoshf(__x); }
 425
 426   inline long double
 427   acosh(long double __x)
 428   { return __builtin_acoshl(__x); }
 429
 430   template<typename _Tp>
 431     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 432                                            double>::__type
 433     acosh(_Tp __x)
 434     { return __builtin_acosh(__x); }
 435
 436   using std::asin;
 437
 438   inline float
 439   asinh(float __x)
 440   { return __builtin_asinhf(__x); }
 441
 442   inline long double
 443   asinh(long double __x)
 444   { return __builtin_asinhl(__x); }
 445
 446   template<typename _Tp>
 447     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 448                                            double>::__type
 449     asinh(_Tp __x)
 450     { return __builtin_asinh(__x); }
 451
 452   using std::atan;
 453   using std::atan2;
 454
 455   inline float
 456   atanh(float __x)
 457   { return __builtin_atanhf(__x); }
 458
 459   inline long double
 460   atanh(long double __x)
 461   { return __builtin_atanhl(__x); }
 462
 463   template<typename _Tp>
 464     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 465                                            double>::__type
 466     atanh(_Tp __x)
 467     { return __builtin_atanh(__x); }
 468
 469   inline float
 470   cbrt(float __x)
 471   { return __builtin_cbrtf(__x); }
 472
 473   inline long double
 474   cbrt(long double __x)
 475   { return __builtin_cbrtl(__x); }
 476
 477   template<typename _Tp>
 478     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 479                                            double>::__type
 480     cbrt(_Tp __x)
 481     { return __builtin_cbrt(__x); }
 482
 483   using std::ceil;
 484
 485   inline float
 486   copysign(float __x, float __y)
 487   { return __builtin_copysignf(__x, __y); }
 488
 489   inline long double
 490   copysign(long double __x, long double __y)
 491   { return __builtin_copysignl(__x, __y); }
 492
 493   template<typename _Tp, typename _Up>
 494     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 495     copysign(_Tp __x, _Up __y)
 496     {
 497       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 498       return copysign(__type(__x), __type(__y));
 499     }
 500
 501   using std::cos;
 502   using std::cosh;
 503
 504   inline float
 505   erf(float __x)
 506   { return __builtin_erff(__x); }
 507
 508   inline long double
 509   erf(long double __x)
 510   { return __builtin_erfl(__x); }
 511
 512   template<typename _Tp>
 513     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 514                                            double>::__type
 515     erf(_Tp __x)
 516     { return __builtin_erf(__x); }
 517
 518   inline float
 519   erfc(float __x)
 520   { return __builtin_erfcf(__x); }
 521
 522   inline long double
 523   erfc(long double __x)
 524   { return __builtin_erfcl(__x); }
 525
 526   template<typename _Tp>
 527     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 528                                            double>::__type
 529     erfc(_Tp __x)
 530     { return __builtin_erfc(__x); }
 531
 532   using std::exp;
 533
 534   inline float
 535   exp2(float __x)
 536   { return __builtin_exp2f(__x); }
 537
 538   inline long double
 539   exp2(long double __x)
 540   { return __builtin_exp2l(__x); }
 541
 542   template<typename _Tp>
 543     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 544                                            double>::__type
 545     exp2(_Tp __x)
 546     { return __builtin_exp2(__x); }
 547
 548   inline float
 549   expm1(float __x)
 550   { return __builtin_expm1f(__x); }
 551
 552   inline long double
 553   expm1(long double __x)
 554   { return __builtin_expm1l(__x); }
 555
 556   template<typename _Tp>
 557     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 558                                            double>::__type
 559     expm1(_Tp __x)
 560     { return __builtin_expm1(__x); }
 561
 562   // Note: we deal with fabs in a special way, because an using std::fabs
 563   // would bring in also the overloads for complex types, which in C++0x
 564   // mode have a different return type.
 565   // With __CORRECT_ISO_CPP_MATH_H_PROTO, math.h imports std::fabs in the
 566   // global namespace after the declarations of the float / double / long
 567   // double overloads but before the std::complex overloads.
 568   using ::fabs;
 569
 570 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 571   inline float
 572   fabs(float __x)
 573   { return __builtin_fabsf(__x); }
 574
 575   inline long double
 576   fabs(long double __x)
 577   { return __builtin_fabsl(__x); }
 578
 579   template<typename _Tp>
 580     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 581                                            double>::__type
 582     fabs(_Tp __x)
 583     { return __builtin_fabs(__x); }
 584 #endif
 585
 586   inline float
 587   fdim(float __x, float __y)
 588   { return __builtin_fdimf(__x, __y); }
 589
 590   inline long double
 591   fdim(long double __x, long double __y)
 592   { return __builtin_fdiml(__x, __y); }
 593
 594   template<typename _Tp, typename _Up>
 595     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 596     fdim(_Tp __x, _Up __y)
 597     {
 598       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 599       return fdim(__type(__x), __type(__y));
 600     }
 601
 602   using std::floor;
 603
 604   inline float
 605   fma(float __x, float __y, float __z)
 606   { return __builtin_fmaf(__x, __y, __z); }
 607
 608   inline long double
 609   fma(long double __x, long double __y, long double __z)
 610   { return __builtin_fmal(__x, __y, __z); }
 611
 612   template<typename _Tp, typename _Up, typename _Vp>
 613     inline typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
 614     fma(_Tp __x, _Up __y, _Vp __z)
 615     {
 616       typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
 617       return fma(__type(__x), __type(__y), __type(__z));
 618     }
 619
 620   inline float
 621   fmax(float __x, float __y)
 622   { return __builtin_fmaxf(__x, __y); }
 623
 624   inline long double
 625   fmax(long double __x, long double __y)
 626   { return __builtin_fmaxl(__x, __y); }
 627
 628   template<typename _Tp, typename _Up>
 629     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 630     fmax(_Tp __x, _Up __y)
 631     {
 632       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 633       return fmax(__type(__x), __type(__y));
 634     }
 635
 636   inline float
 637   fmin(float __x, float __y)
 638   { return __builtin_fminf(__x, __y); }
 639
 640   inline long double
 641   fmin(long double __x, long double __y)
 642   { return __builtin_fminl(__x, __y); }
 643
 644   template<typename _Tp, typename _Up>
 645     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 646     fmin(_Tp __x, _Up __y)
 647     {
 648       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 649       return fmin(__type(__x), __type(__y));
 650     }
 651
 652   using std::fmod;
 653   using std::frexp;
 654
 655   inline float
 656   hypot(float __x, float __y)
 657   { return __builtin_hypotf(__x, __y); }
 658
 659   inline long double
 660   hypot(long double __x, long double __y)
 661   { return __builtin_hypotl(__x, __y); }
 662
 663   template<typename _Tp, typename _Up>
 664     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 665     hypot(_Tp __y, _Up __x)
 666     {
 667       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 668       return hypot(__type(__y), __type(__x));
 669     }
 670
 671   inline int
 672   ilogb(float __x)
 673   { return __builtin_ilogbf(__x); }
 674
 675   inline int
 676   ilogb(long double __x)
 677   { return __builtin_ilogbl(__x); }
 678
 679   template<typename _Tp>
 680     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 681                                            int>::__type
 682     ilogb(_Tp __x)
 683     { return __builtin_ilogb(__x); }
 684
 685   using std::ldexp;
 686
 687   inline float
 688   lgamma(float __x)
 689   { return __builtin_lgammaf(__x); }
 690
 691   inline long double
 692   lgamma(long double __x)
 693   { return __builtin_lgammal(__x); }
 694
 695   template<typename _Tp>
 696     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 697                                            double>::__type
 698     lgamma(_Tp __x)
 699     { return __builtin_lgamma(__x); }
 700
 701   inline long long
 702   llrint(float __x)
 703   { return __builtin_llrintf(__x); }
 704
 705   inline long long
 706   llrint(long double __x)
 707   { return __builtin_llrintl(__x); }
 708
 709   template<typename _Tp>
 710     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 711                                            long long>::__type
 712     llrint(_Tp __x)
 713     { return __builtin_llrint(__x); }
 714
 715   inline long long
 716   llround(float __x)
 717   { return __builtin_llroundf(__x); }
 718
 719   inline long long
 720   llround(long double __x)
 721   { return __builtin_llroundl(__x); }
 722
 723   template<typename _Tp>
 724     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 725                                            long long>::__type
 726     llround(_Tp __x)
 727     { return __builtin_llround(__x); }
 728
 729   using std::log;
 730   using std::log10;
 731
 732   inline float
 733   log1p(float __x)
 734   { return __builtin_log1pf(__x); }
 735
 736   inline long double
 737   log1p(long double __x)
 738   { return __builtin_log1pl(__x); }
 739
 740   template<typename _Tp>
 741     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 742                                            double>::__type
 743     log1p(_Tp __x)
 744     { return __builtin_log1p(__x); }
 745
 746   // DR 568.
 747   inline float
 748   log2(float __x)
 749   { return __builtin_log2f(__x); }
 750
 751   inline long double
 752   log2(long double __x)
 753   { return __builtin_log2l(__x); }
 754
 755   template<typename _Tp>
 756     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 757                                            double>::__type
 758     log2(_Tp __x)
 759     { return __builtin_log2(__x); }
 760
 761   inline float
 762   logb(float __x)
 763   { return __builtin_logbf(__x); }
 764
 765   inline long double
 766   logb(long double __x)
 767   { return __builtin_logbl(__x); }
 768
 769   template<typename _Tp>
 770     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 771                                            double>::__type
 772     logb(_Tp __x)
 773     {
 774       return __builtin_logb(__x);
 775     }
 776
 777   inline long
 778   lrint(float __x)
 779   { return __builtin_lrintf(__x); }
 780
 781   inline long
 782   lrint(long double __x)
 783   { return __builtin_lrintl(__x); }
 784
 785   template<typename _Tp>
 786     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 787                                            long>::__type
 788     lrint(_Tp __x)
 789     { return __builtin_lrint(__x); }
 790
 791   inline long
 792   lround(float __x)
 793   { return __builtin_lroundf(__x); }
 794
 795   inline long
 796   lround(long double __x)
 797   { return __builtin_lroundl(__x); }
 798
 799   template<typename _Tp>
 800     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 801                                            long>::__type
 802     lround(_Tp __x)
 803     { return __builtin_lround(__x); }
 804
 805   inline float
 806   nearbyint(float __x)
 807   { return __builtin_nearbyintf(__x); }
 808
 809   inline long double
 810   nearbyint(long double __x)
 811   { return __builtin_nearbyintl(__x); }
 812
 813   template<typename _Tp>
 814     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 815                                            double>::__type
 816     nearbyint(_Tp __x)
 817     { return __builtin_nearbyint(__x); }
 818
 819   inline float
 820   nextafter(float __x, float __y)
 821   { return __builtin_nextafterf(__x, __y); }
 822
 823   inline long double
 824   nextafter(long double __x, long double __y)
 825   { return __builtin_nextafterl(__x, __y); }
 826
 827   template<typename _Tp, typename _Up>
 828     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 829     nextafter(_Tp __x, _Up __y)
 830     {
 831       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 832       return nextafter(__type(__x), __type(__y));
 833     }
 834
 835   inline float
 836   nexttoward(float __x, long double __y)
 837   { return __builtin_nexttowardf(__x, __y); }
 838
 839   inline long double
 840   nexttoward(long double __x, long double __y)
 841   { return __builtin_nexttowardl(__x, __y); }
 842
 843   template<typename _Tp>
 844     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 845                                            double>::__type
 846     nexttoward(_Tp __x, long double __y)
 847     { return __builtin_nexttoward(__x, __y); }
 848
 849   // DR 550. What should the return type of pow(float,int) be?
 850   // NB: C++0x and TR1 != C++03.
 851   //   using std::pow;
 852
 853   inline float
 854   remainder(float __x, float __y)
 855   { return __builtin_remainderf(__x, __y); }
 856
 857   inline long double
 858   remainder(long double __x, long double __y)
 859   { return __builtin_remainderl(__x, __y); }
 860
 861   template<typename _Tp, typename _Up>
 862     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 863     remainder(_Tp __x, _Up __y)
 864     {
 865       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 866       return remainder(__type(__x), __type(__y));
 867     }
 868
 869   inline float
 870   remquo(float __x, float __y, int* __pquo)
 871   { return __builtin_remquof(__x, __y, __pquo); }
 872
 873   inline long double
 874   remquo(long double __x, long double __y, int* __pquo)
 875   { return __builtin_remquol(__x, __y, __pquo); }
 876
 877   template<typename _Tp, typename _Up>
 878     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
 879     remquo(_Tp __x, _Up __y, int* __pquo)
 880     {
 881       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 882       return remquo(__type(__x), __type(__y), __pquo);
 883     }
 884
 885   inline float
 886   rint(float __x)
 887   { return __builtin_rintf(__x); }
 888
 889   inline long double
 890   rint(long double __x)
 891   { return __builtin_rintl(__x); }
 892
 893   template<typename _Tp>
 894     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 895                                            double>::__type
 896     rint(_Tp __x)
 897     { return __builtin_rint(__x); }
 898
 899   inline float
 900   round(float __x)
 901   { return __builtin_roundf(__x); }
 902
 903   inline long double
 904   round(long double __x)
 905   { return __builtin_roundl(__x); }
 906
 907   template<typename _Tp>
 908     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 909                                            double>::__type
 910     round(_Tp __x)
 911     { return __builtin_round(__x); }
 912
 913   inline float
 914   scalbln(float __x, long __ex)
 915   { return __builtin_scalblnf(__x, __ex); }
 916
 917   inline long double
 918   scalbln(long double __x, long __ex)
 919   { return __builtin_scalblnl(__x, __ex); }
 920
 921   template<typename _Tp>
 922     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 923                                            double>::__type
 924     scalbln(_Tp __x, long __ex)
 925     { return __builtin_scalbln(__x, __ex); }
 926
 927   inline float
 928   scalbn(float __x, int __ex)
 929   { return __builtin_scalbnf(__x, __ex); }
 930
 931   inline long double
 932   scalbn(long double __x, int __ex)
 933   { return __builtin_scalbnl(__x, __ex); }
 934
 935   template<typename _Tp>
 936     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 937                                            double>::__type
 938     scalbn(_Tp __x, int __ex)
 939     { return __builtin_scalbn(__x, __ex); }
 940
 941   using std::sin;
 942   using std::sinh;
 943   using std::sqrt;
 944   using std::tan;
 945   using std::tanh;
 946
 947   inline float
 948   tgamma(float __x)
 949   { return __builtin_tgammaf(__x); }
 950
 951   inline long double
 952   tgamma(long double __x)
 953   { return __builtin_tgammal(__x); }
 954
 955   template<typename _Tp>
 956     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 957                                            double>::__type
 958     tgamma(_Tp __x)
 959     { return __builtin_tgamma(__x); }
 960
 961   inline float
 962   trunc(float __x)
 963   { return __builtin_truncf(__x); }
 964
 965   inline long double
 966   trunc(long double __x)
 967   { return __builtin_truncl(__x); }
 968
 969   template<typename _Tp>
 970     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 971                                            double>::__type
 972     trunc(_Tp __x)
 973     { return __builtin_trunc(__x); }
 974
 975 #endif
 976 _GLIBCXX_END_NAMESPACE_VERSION
 977 }
 978 }
 979
 980 namespace std _GLIBCXX_VISIBILITY(default)
 981 {
 982 namespace tr1
 983 {
 984 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 985
 986   // DR 550. What should the return type of pow(float,int) be?
 987   // NB: C++0x and TR1 != C++03.
 988   inline double
 989   pow(double __x, double __y)
 990   { return std::pow(__x, __y); }
 991
 992   inline float
 993   pow(float __x, float __y)
 994   { return std::pow(__x, __y); }
 995
 996   inline long double
 997   pow(long double __x, long double __y)
 998   { return std::pow(__x, __y); }
 999
1000   template<typename _Tp, typename _Up>
1001     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1002     pow(_Tp __x, _Up __y)
1003     {
1004       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1005       return std::pow(__type(__x), __type(__y));
1006     }
1007
1008 _GLIBCXX_END_NAMESPACE_VERSION
1009 }
1010 }
1011
1012 #include <bits/stl_algobase.h>
1013 #include <limits>
1014 #include <tr1/type_traits>
1015
1016 #include <tr1/gamma.tcc>
1017 #include <tr1/bessel_function.tcc>
1018 #include <tr1/beta_function.tcc>
1019 #include <tr1/ell_integral.tcc>
1020 #include <tr1/exp_integral.tcc>
1021 #include <tr1/hypergeometric.tcc>
1022 #include <tr1/legendre_function.tcc>
1023 #include <tr1/modified_bessel_func.tcc>
1024 #include <tr1/poly_hermite.tcc>
1025 #include <tr1/poly_laguerre.tcc>
1026 #include <tr1/riemann_zeta.tcc>
1027
1028 namespace std _GLIBCXX_VISIBILITY(default)
1029 {
1030 namespace tr1
1031 {
1032 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1033
1034   /**
1035    * @defgroup tr1_math_spec_func Mathematical Special Functions
1036    * @ingroup numerics
1037    *
1038    * A collection of advanced mathematical special functions.
1039    * @{
1040    */
1041
1042   inline float
1043   assoc_laguerref(unsigned int __n, unsigned int __m, float __x)
1044   { return __detail::__assoc_laguerre<float>(__n, __m, __x); }
1045
1046   inline long double
1047   assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x)
1048   {
1049     return __detail::__assoc_laguerre<long double>(__n, __m, __x);
1050   }
1051
1052   ///  5.2.1.1  Associated Laguerre polynomials.
1053   template<typename _Tp>
1054     inline typename __gnu_cxx::__promote<_Tp>::__type
1055     assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
1056     {
1057       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1058       return __detail::__assoc_laguerre<__type>(__n, __m, __x);
1059     }
1060
1061   inline float
1062   assoc_legendref(unsigned int __l, unsigned int __m, float __x)
1063   { return __detail::__assoc_legendre_p<float>(__l, __m, __x); }
1064
1065   inline long double
1066   assoc_legendrel(unsigned int __l, unsigned int __m, long double __x)
1067   { return __detail::__assoc_legendre_p<long double>(__l, __m, __x); }
1068
1069   ///  5.2.1.2  Associated Legendre functions.
1070   template<typename _Tp>
1071     inline typename __gnu_cxx::__promote<_Tp>::__type
1072     assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
1073     {
1074       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1075       return __detail::__assoc_legendre_p<__type>(__l, __m, __x);
1076     }
1077
1078   inline float
1079   betaf(float __x, float __y)
1080   { return __detail::__beta<float>(__x, __y); }
1081
1082   inline long double
1083   betal(long double __x, long double __y)
1084   { return __detail::__beta<long double>(__x, __y); }
1085
1086   ///  5.2.1.3  Beta functions.
1087   template<typename _Tpx, typename _Tpy>
1088     inline typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type
1089     beta(_Tpx __x, _Tpy __y)
1090     {
1091       typedef typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type __type;
1092       return __detail::__beta<__type>(__x, __y);
1093     }
1094
1095   inline float
1096   comp_ellint_1f(float __k)
1097   { return __detail::__comp_ellint_1<float>(__k); }
1098
1099   inline long double
1100   comp_ellint_1l(long double __k)
1101   { return __detail::__comp_ellint_1<long double>(__k); }
1102
1103   ///  5.2.1.4  Complete elliptic integrals of the first kind.
1104   template<typename _Tp>
1105     inline typename __gnu_cxx::__promote<_Tp>::__type
1106     comp_ellint_1(_Tp __k)
1107     {
1108       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1109       return __detail::__comp_ellint_1<__type>(__k);
1110     }
1111
1112   inline float
1113   comp_ellint_2f(float __k)
1114   { return __detail::__comp_ellint_2<float>(__k); }
1115
1116   inline long double
1117   comp_ellint_2l(long double __k)
1118   { return __detail::__comp_ellint_2<long double>(__k); }
1119
1120   ///  5.2.1.5  Complete elliptic integrals of the second kind.
1121   template<typename _Tp>
1122     inline typename __gnu_cxx::__promote<_Tp>::__type
1123     comp_ellint_2(_Tp __k)
1124     {
1125       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1126       return __detail::__comp_ellint_2<__type>(__k);
1127     }
1128
1129   inline float
1130   comp_ellint_3f(float __k, float __nu)
1131   { return __detail::__comp_ellint_3<float>(__k, __nu); }
1132
1133   inline long double
1134   comp_ellint_3l(long double __k, long double __nu)
1135   { return __detail::__comp_ellint_3<long double>(__k, __nu); }
1136
1137   ///  5.2.1.6  Complete elliptic integrals of the third kind.
1138   template<typename _Tp, typename _Tpn>
1139     inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type
1140     comp_ellint_3(_Tp __k, _Tpn __nu)
1141     {
1142       typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type;
1143       return __detail::__comp_ellint_3<__type>(__k, __nu);
1144     }
1145
1146   inline float
1147   conf_hypergf(float __a, float __c, float __x)
1148   { return __detail::__conf_hyperg<float>(__a, __c, __x); }
1149
1150   inline long double
1151   conf_hypergl(long double __a, long double __c, long double __x)
1152   { return __detail::__conf_hyperg<long double>(__a, __c, __x); }
1153
1154   ///  5.2.1.7  Confluent hypergeometric functions.
1155   template<typename _Tpa, typename _Tpc, typename _Tp>
1156     inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type
1157     conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x)
1158     {
1159       typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type;
1160       return __detail::__conf_hyperg<__type>(__a, __c, __x);
1161     }
1162
1163   inline float
1164   cyl_bessel_if(float __nu, float __x)
1165   { return __detail::__cyl_bessel_i<float>(__nu, __x); }
1166
1167   inline long double
1168   cyl_bessel_il(long double __nu, long double __x)
1169   { return __detail::__cyl_bessel_i<long double>(__nu, __x); }
1170
1171   ///  5.2.1.8  Regular modified cylindrical Bessel functions.
1172   template<typename _Tpnu, typename _Tp>
1173     inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
1174     cyl_bessel_i(_Tpnu __nu, _Tp __x)
1175     {
1176       typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
1177       return __detail::__cyl_bessel_i<__type>(__nu, __x);
1178     }
1179
1180   inline float
1181   cyl_bessel_jf(float __nu, float __x)
1182   { return __detail::__cyl_bessel_j<float>(__nu, __x); }
1183
1184   inline long double
1185   cyl_bessel_jl(long double __nu, long double __x)
1186   { return __detail::__cyl_bessel_j<long double>(__nu, __x); }
1187
1188   ///  5.2.1.9  Cylindrical Bessel functions (of the first kind).
1189   template<typename _Tpnu, typename _Tp>
1190     inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
1191     cyl_bessel_j(_Tpnu __nu, _Tp __x)
1192     {
1193       typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
1194       return __detail::__cyl_bessel_j<__type>(__nu, __x);
1195     }
1196
1197   inline float
1198   cyl_bessel_kf(float __nu, float __x)
1199   { return __detail::__cyl_bessel_k<float>(__nu, __x); }
1200
1201   inline long double
1202   cyl_bessel_kl(long double __nu, long double __x)
1203   { return __detail::__cyl_bessel_k<long double>(__nu, __x); }
1204
1205   ///  5.2.1.10  Irregular modified cylindrical Bessel functions.
1206   template<typename _Tpnu, typename _Tp>
1207     inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
1208     cyl_bessel_k(_Tpnu __nu, _Tp __x)
1209     {
1210       typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
1211       return __detail::__cyl_bessel_k<__type>(__nu, __x);
1212     }
1213
1214   inline float
1215   cyl_neumannf(float __nu, float __x)
1216   { return __detail::__cyl_neumann_n<float>(__nu, __x); }
1217
1218   inline long double
1219   cyl_neumannl(long double __nu, long double __x)
1220   { return __detail::__cyl_neumann_n<long double>(__nu, __x); }
1221
1222   ///  5.2.1.11  Cylindrical Neumann functions.
1223   template<typename _Tpnu, typename _Tp>
1224     inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
1225     cyl_neumann(_Tpnu __nu, _Tp __x)
1226     {
1227       typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
1228       return __detail::__cyl_neumann_n<__type>(__nu, __x);
1229     }
1230
1231   inline float
1232   ellint_1f(float __k, float __phi)
1233   { return __detail::__ellint_1<float>(__k, __phi); }
1234
1235   inline long double
1236   ellint_1l(long double __k, long double __phi)
1237   { return __detail::__ellint_1<long double>(__k, __phi); }
1238
1239   ///  5.2.1.12  Incomplete elliptic integrals of the first kind.
1240   template<typename _Tp, typename _Tpp>
1241     inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
1242     ellint_1(_Tp __k, _Tpp __phi)
1243     {
1244       typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
1245       return __detail::__ellint_1<__type>(__k, __phi);
1246     }
1247
1248   inline float
1249   ellint_2f(float __k, float __phi)
1250   { return __detail::__ellint_2<float>(__k, __phi); }
1251
1252   inline long double
1253   ellint_2l(long double __k, long double __phi)
1254   { return __detail::__ellint_2<long double>(__k, __phi); }
1255
1256   ///  5.2.1.13  Incomplete elliptic integrals of the second kind.
1257   template<typename _Tp, typename _Tpp>
1258     inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
1259     ellint_2(_Tp __k, _Tpp __phi)
1260     {
1261       typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
1262       return __detail::__ellint_2<__type>(__k, __phi);
1263     }
1264
1265   inline float
1266   ellint_3f(float __k, float __nu, float __phi)
1267   { return __detail::__ellint_3<float>(__k, __nu, __phi); }
1268
1269   inline long double
1270   ellint_3l(long double __k, long double __nu, long double __phi)
1271   { return __detail::__ellint_3<long double>(__k, __nu, __phi); }
1272
1273   ///  5.2.1.14  Incomplete elliptic integrals of the third kind.
1274   template<typename _Tp, typename _Tpn, typename _Tpp>
1275     inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type
1276     ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
1277     {
1278       typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type;
1279       return __detail::__ellint_3<__type>(__k, __nu, __phi);
1280     }
1281
1282   inline float
1283   expintf(float __x)
1284   { return __detail::__expint<float>(__x); }
1285
1286   inline long double
1287   expintl(long double __x)
1288   { return __detail::__expint<long double>(__x); }
1289
1290   ///  5.2.1.15  Exponential integrals.
1291   template<typename _Tp>
1292     inline typename __gnu_cxx::__promote<_Tp>::__type
1293     expint(_Tp __x)
1294     {
1295       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1296       return __detail::__expint<__type>(__x);
1297     }
1298
1299   inline float
1300   hermitef(unsigned int __n, float __x)
1301   { return __detail::__poly_hermite<float>(__n, __x); }
1302
1303   inline long double
1304   hermitel(unsigned int __n, long double __x)
1305   { return __detail::__poly_hermite<long double>(__n, __x); }
1306
1307   ///  5.2.1.16  Hermite polynomials.
1308   template<typename _Tp>
1309     inline typename __gnu_cxx::__promote<_Tp>::__type
1310     hermite(unsigned int __n, _Tp __x)
1311     {
1312       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1313       return __detail::__poly_hermite<__type>(__n, __x);
1314     }
1315
1316   inline float
1317   hypergf(float __a, float __b, float __c, float __x)
1318   { return __detail::__hyperg<float>(__a, __b, __c, __x); }
1319
1320   inline long double
1321   hypergl(long double __a, long double __b, long double __c, long double __x)
1322   { return __detail::__hyperg<long double>(__a, __b, __c, __x); }
1323
1324   ///  5.2.1.17  Hypergeometric functions.
1325   template<typename _Tpa, typename _Tpb, typename _Tpc, typename _Tp>
1326     inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type
1327     hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x)
1328     {
1329       typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type __type;
1330       return __detail::__hyperg<__type>(__a, __b, __c, __x);
1331     }
1332
1333   inline float
1334   laguerref(unsigned int __n, float __x)
1335   { return __detail::__laguerre<float>(__n, __x); }
1336
1337   inline long double
1338   laguerrel(unsigned int __n, long double __x)
1339   { return __detail::__laguerre<long double>(__n, __x); }
1340
1341   ///  5.2.1.18  Laguerre polynomials.
1342   template<typename _Tp>
1343     inline typename __gnu_cxx::__promote<_Tp>::__type
1344     laguerre(unsigned int __n, _Tp __x)
1345     {
1346       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1347       return __detail::__laguerre<__type>(__n, __x);
1348     }
1349
1350   inline float
1351   legendref(unsigned int __n, float __x)
1352   { return __detail::__poly_legendre_p<float>(__n, __x); }
1353
1354   inline long double
1355   legendrel(unsigned int __n, long double __x)
1356   { return __detail::__poly_legendre_p<long double>(__n, __x); }
1357
1358   ///  5.2.1.19  Legendre polynomials.
1359   template<typename _Tp>
1360     inline typename __gnu_cxx::__promote<_Tp>::__type
1361     legendre(unsigned int __n, _Tp __x)
1362     {
1363       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1364       return __detail::__poly_legendre_p<__type>(__n, __x);
1365     }
1366
1367   inline float
1368   riemann_zetaf(float __x)
1369   { return __detail::__riemann_zeta<float>(__x); }
1370
1371   inline long double
1372   riemann_zetal(long double __x)
1373   { return __detail::__riemann_zeta<long double>(__x); }
1374
1375   ///  5.2.1.20  Riemann zeta function.
1376   template<typename _Tp>
1377     inline typename __gnu_cxx::__promote<_Tp>::__type
1378     riemann_zeta(_Tp __x)
1379     {
1380       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1381       return __detail::__riemann_zeta<__type>(__x);
1382     }
1383
1384   inline float
1385   sph_besself(unsigned int __n, float __x)
1386   { return __detail::__sph_bessel<float>(__n, __x); }
1387
1388   inline long double
1389   sph_bessell(unsigned int __n, long double __x)
1390   { return __detail::__sph_bessel<long double>(__n, __x); }
1391
1392   ///  5.2.1.21  Spherical Bessel functions.
1393   template<typename _Tp>
1394     inline typename __gnu_cxx::__promote<_Tp>::__type
1395     sph_bessel(unsigned int __n, _Tp __x)
1396     {
1397       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1398       return __detail::__sph_bessel<__type>(__n, __x);
1399     }
1400
1401   inline float
1402   sph_legendref(unsigned int __l, unsigned int __m, float __theta)
1403   { return __detail::__sph_legendre<float>(__l, __m, __theta); }
1404
1405   inline long double
1406   sph_legendrel(unsigned int __l, unsigned int __m, long double __theta)
1407   { return __detail::__sph_legendre<long double>(__l, __m, __theta); }
1408
1409   ///  5.2.1.22  Spherical associated Legendre functions.
1410   template<typename _Tp>
1411     inline typename __gnu_cxx::__promote<_Tp>::__type
1412     sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
1413     {
1414       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1415       return __detail::__sph_legendre<__type>(__l, __m, __theta);
1416     }
1417
1418   inline float
1419   sph_neumannf(unsigned int __n, float __x)
1420   { return __detail::__sph_neumann<float>(__n, __x); }
1421
1422   inline long double
1423   sph_neumannl(unsigned int __n, long double __x)
1424   { return __detail::__sph_neumann<long double>(__n, __x); }
1425
1426   ///  5.2.1.23  Spherical Neumann functions.
1427   template<typename _Tp>
1428     inline typename __gnu_cxx::__promote<_Tp>::__type
1429     sph_neumann(unsigned int __n, _Tp __x)
1430     {
1431       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1432       return __detail::__sph_neumann<__type>(__n, __x);
1433     }
1434
1435   /* @} */ // tr1_math_spec_func
1436 _GLIBCXX_END_NAMESPACE_VERSION
1437 }
1438 }
1439
1440 #endif // _GLIBCXX_TR1_CMATH