libstdc++-v3/include/c_global/cmath

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