libstdc++-v3/include/c_global/cmath

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