libstdc++-v3/include/c_global/cmath

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