libstdc++-v3/include/c_global/cmath

   1 // -*- C++ -*- C forwarding header.
   2
   3 // Copyright (C) 1997-2024 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/requires_hosted.h>
  42
  43 #include <bits/c++config.h>
  44 #include <bits/cpp_type_traits.h>
  45 #include <ext/type_traits.h>
  46 #define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
  47 #include_next <math.h>
  48 #undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS
  49 #include <bits/std_abs.h>
  50
  51 #ifndef _GLIBCXX_CMATH
  52 #define _GLIBCXX_CMATH 1
  53
  54 #define __glibcxx_want_hypot
  55 #define __glibcxx_want_interpolate
  56 #include <bits/version.h>
  57
  58 // Get rid of those macros defined in <math.h> in lieu of real functions.
  59 #undef div
  60 #undef acos
  61 #undef asin
  62 #undef atan
  63 #undef atan2
  64 #undef ceil
  65 #undef cos
  66 #undef cosh
  67 #undef exp
  68 #undef fabs
  69 #undef floor
  70 #undef fmod
  71 #undef frexp
  72 #undef ldexp
  73 #undef log
  74 #undef log10
  75 #undef modf
  76 #undef pow
  77 #undef sin
  78 #undef sinh
  79 #undef sqrt
  80 #undef tan
  81 #undef tanh
  82
  83 extern "C++"
  84 {
  85 namespace std _GLIBCXX_VISIBILITY(default)
  86 {
  87 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  88
  89   using ::acos;
  90
  91 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
  92   inline _GLIBCXX_CONSTEXPR float
  93   acos(float __x)
  94   { return __builtin_acosf(__x); }
  95
  96   inline _GLIBCXX_CONSTEXPR long double
  97   acos(long double __x)
  98   { return __builtin_acosl(__x); }
  99 #endif
 100
 101   template<typename _Tp>
 102     inline _GLIBCXX_CONSTEXPR
 103     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 104                                     double>::__type
 105     acos(_Tp __x)
 106     { return __builtin_acos(__x); }
 107
 108   using ::asin;
 109
 110 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 111   inline _GLIBCXX_CONSTEXPR float
 112   asin(float __x)
 113   { return __builtin_asinf(__x); }
 114
 115   inline _GLIBCXX_CONSTEXPR long double
 116   asin(long double __x)
 117   { return __builtin_asinl(__x); }
 118 #endif
 119
 120   template<typename _Tp>
 121     inline _GLIBCXX_CONSTEXPR
 122     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 123                                     double>::__type
 124     asin(_Tp __x)
 125     { return __builtin_asin(__x); }
 126
 127   using ::atan;
 128
 129 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 130   inline _GLIBCXX_CONSTEXPR float
 131   atan(float __x)
 132   { return __builtin_atanf(__x); }
 133
 134   inline _GLIBCXX_CONSTEXPR long double
 135   atan(long double __x)
 136   { return __builtin_atanl(__x); }
 137 #endif
 138
 139   template<typename _Tp>
 140     inline _GLIBCXX_CONSTEXPR
 141     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 142                                     double>::__type
 143     atan(_Tp __x)
 144     { return __builtin_atan(__x); }
 145
 146   using ::atan2;
 147
 148 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 149   inline _GLIBCXX_CONSTEXPR float
 150   atan2(float __y, float __x)
 151   { return __builtin_atan2f(__y, __x); }
 152
 153   inline _GLIBCXX_CONSTEXPR long double
 154   atan2(long double __y, long double __x)
 155   { return __builtin_atan2l(__y, __x); }
 156 #endif
 157
 158   using ::ceil;
 159
 160 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 161   inline _GLIBCXX_CONSTEXPR float
 162   ceil(float __x)
 163   { return __builtin_ceilf(__x); }
 164
 165   inline _GLIBCXX_CONSTEXPR long double
 166   ceil(long double __x)
 167   { return __builtin_ceill(__x); }
 168 #endif
 169
 170   template<typename _Tp>
 171     inline _GLIBCXX_CONSTEXPR
 172     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 173                                     double>::__type
 174     ceil(_Tp __x)
 175     { return __builtin_ceil(__x); }
 176
 177   using ::cos;
 178
 179 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 180   inline _GLIBCXX_CONSTEXPR float
 181   cos(float __x)
 182   { return __builtin_cosf(__x); }
 183
 184   inline _GLIBCXX_CONSTEXPR long double
 185   cos(long double __x)
 186   { return __builtin_cosl(__x); }
 187 #endif
 188
 189   template<typename _Tp>
 190     inline _GLIBCXX_CONSTEXPR
 191     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 192                                     double>::__type
 193     cos(_Tp __x)
 194     { return __builtin_cos(__x); }
 195
 196   using ::cosh;
 197
 198 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 199   inline _GLIBCXX_CONSTEXPR float
 200   cosh(float __x)
 201   { return __builtin_coshf(__x); }
 202
 203   inline _GLIBCXX_CONSTEXPR long double
 204   cosh(long double __x)
 205   { return __builtin_coshl(__x); }
 206 #endif
 207
 208   template<typename _Tp>
 209     inline _GLIBCXX_CONSTEXPR
 210     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 211                                     double>::__type
 212     cosh(_Tp __x)
 213     { return __builtin_cosh(__x); }
 214
 215   using ::exp;
 216
 217 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 218   inline _GLIBCXX_CONSTEXPR float
 219   exp(float __x)
 220   { return __builtin_expf(__x); }
 221
 222   inline _GLIBCXX_CONSTEXPR long double
 223   exp(long double __x)
 224   { return __builtin_expl(__x); }
 225 #endif
 226
 227   template<typename _Tp>
 228     inline _GLIBCXX_CONSTEXPR
 229     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 230                                     double>::__type
 231     exp(_Tp __x)
 232     { return __builtin_exp(__x); }
 233
 234   using ::fabs;
 235
 236 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 237   inline _GLIBCXX_CONSTEXPR float
 238   fabs(float __x)
 239   { return __builtin_fabsf(__x); }
 240
 241   inline _GLIBCXX_CONSTEXPR long double
 242   fabs(long double __x)
 243   { return __builtin_fabsl(__x); }
 244 #endif
 245
 246   template<typename _Tp>
 247     inline _GLIBCXX_CONSTEXPR
 248     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 249                                     double>::__type
 250     fabs(_Tp __x)
 251     { return __builtin_fabs(__x); }
 252
 253   using ::floor;
 254
 255 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 256   inline _GLIBCXX_CONSTEXPR float
 257   floor(float __x)
 258   { return __builtin_floorf(__x); }
 259
 260   inline _GLIBCXX_CONSTEXPR long double
 261   floor(long double __x)
 262   { return __builtin_floorl(__x); }
 263 #endif
 264
 265   template<typename _Tp>
 266     inline _GLIBCXX_CONSTEXPR
 267     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 268                                     double>::__type
 269     floor(_Tp __x)
 270     { return __builtin_floor(__x); }
 271
 272   using ::fmod;
 273
 274 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 275   inline _GLIBCXX_CONSTEXPR float
 276   fmod(float __x, float __y)
 277   { return __builtin_fmodf(__x, __y); }
 278
 279   inline _GLIBCXX_CONSTEXPR long double
 280   fmod(long double __x, long double __y)
 281   { return __builtin_fmodl(__x, __y); }
 282 #endif
 283
 284   using ::frexp;
 285
 286 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 287   inline float
 288   frexp(float __x, int* __exp)
 289   { return __builtin_frexpf(__x, __exp); }
 290
 291   inline long double
 292   frexp(long double __x, int* __exp)
 293   { return __builtin_frexpl(__x, __exp); }
 294 #endif
 295
 296   template<typename _Tp>
 297     inline _GLIBCXX_CONSTEXPR
 298     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 299                                     double>::__type
 300     frexp(_Tp __x, int* __exp)
 301     { return __builtin_frexp(__x, __exp); }
 302
 303   using ::ldexp;
 304
 305 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 306   inline _GLIBCXX_CONSTEXPR float
 307   ldexp(float __x, int __exp)
 308   { return __builtin_ldexpf(__x, __exp); }
 309
 310   inline _GLIBCXX_CONSTEXPR long double
 311   ldexp(long double __x, int __exp)
 312   { return __builtin_ldexpl(__x, __exp); }
 313 #endif
 314
 315   template<typename _Tp>
 316     inline _GLIBCXX_CONSTEXPR
 317     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 318                                     double>::__type
 319     ldexp(_Tp __x, int __exp)
 320     { return __builtin_ldexp(__x, __exp); }
 321
 322   using ::log;
 323
 324 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 325   inline _GLIBCXX_CONSTEXPR float
 326   log(float __x)
 327   { return __builtin_logf(__x); }
 328
 329   inline _GLIBCXX_CONSTEXPR long double
 330   log(long double __x)
 331   { return __builtin_logl(__x); }
 332 #endif
 333
 334   template<typename _Tp>
 335     inline _GLIBCXX_CONSTEXPR
 336     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 337                                     double>::__type
 338     log(_Tp __x)
 339     { return __builtin_log(__x); }
 340
 341   using ::log10;
 342
 343 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 344   inline _GLIBCXX_CONSTEXPR float
 345   log10(float __x)
 346   { return __builtin_log10f(__x); }
 347
 348   inline _GLIBCXX_CONSTEXPR long double
 349   log10(long double __x)
 350   { return __builtin_log10l(__x); }
 351 #endif
 352
 353   template<typename _Tp>
 354     inline _GLIBCXX_CONSTEXPR
 355     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 356                                     double>::__type
 357     log10(_Tp __x)
 358     { return __builtin_log10(__x); }
 359
 360   using ::modf;
 361
 362 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 363   inline float
 364   modf(float __x, float* __iptr)
 365   { return __builtin_modff(__x, __iptr); }
 366
 367   inline long double
 368   modf(long double __x, long double* __iptr)
 369   { return __builtin_modfl(__x, __iptr); }
 370 #endif
 371
 372   using ::pow;
 373
 374 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 375   inline _GLIBCXX_CONSTEXPR float
 376   pow(float __x, float __y)
 377   { return __builtin_powf(__x, __y); }
 378
 379   inline _GLIBCXX_CONSTEXPR long double
 380   pow(long double __x, long double __y)
 381   { return __builtin_powl(__x, __y); }
 382
 383 #if __cplusplus < 201103L
 384   // _GLIBCXX_RESOLVE_LIB_DEFECTS
 385   // DR 550. What should the return type of pow(float,int) be?
 386   inline double
 387   pow(double __x, int __i)
 388   { return __builtin_powi(__x, __i); }
 389
 390   inline float
 391   pow(float __x, int __n)
 392   { return __builtin_powif(__x, __n); }
 393
 394   inline long double
 395   pow(long double __x, int __n)
 396   { return __builtin_powil(__x, __n); }
 397 #endif
 398 #endif
 399
 400   using ::sin;
 401
 402 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 403   inline _GLIBCXX_CONSTEXPR float
 404   sin(float __x)
 405   { return __builtin_sinf(__x); }
 406
 407   inline _GLIBCXX_CONSTEXPR long double
 408   sin(long double __x)
 409   { return __builtin_sinl(__x); }
 410 #endif
 411
 412   template<typename _Tp>
 413     inline _GLIBCXX_CONSTEXPR
 414     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 415                                     double>::__type
 416     sin(_Tp __x)
 417     { return __builtin_sin(__x); }
 418
 419   using ::sinh;
 420
 421 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 422   inline _GLIBCXX_CONSTEXPR float
 423   sinh(float __x)
 424   { return __builtin_sinhf(__x); }
 425
 426   inline _GLIBCXX_CONSTEXPR long double
 427   sinh(long double __x)
 428   { return __builtin_sinhl(__x); }
 429 #endif
 430
 431   template<typename _Tp>
 432     inline _GLIBCXX_CONSTEXPR
 433     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 434                                     double>::__type
 435     sinh(_Tp __x)
 436     { return __builtin_sinh(__x); }
 437
 438   using ::sqrt;
 439
 440 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 441   inline _GLIBCXX_CONSTEXPR float
 442   sqrt(float __x)
 443   { return __builtin_sqrtf(__x); }
 444
 445   inline _GLIBCXX_CONSTEXPR long double
 446   sqrt(long double __x)
 447   { return __builtin_sqrtl(__x); }
 448 #endif
 449
 450   template<typename _Tp>
 451     inline _GLIBCXX_CONSTEXPR
 452     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 453                                     double>::__type
 454     sqrt(_Tp __x)
 455     { return __builtin_sqrt(__x); }
 456
 457   using ::tan;
 458
 459 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 460   inline _GLIBCXX_CONSTEXPR float
 461   tan(float __x)
 462   { return __builtin_tanf(__x); }
 463
 464   inline _GLIBCXX_CONSTEXPR long double
 465   tan(long double __x)
 466   { return __builtin_tanl(__x); }
 467 #endif
 468
 469   template<typename _Tp>
 470     inline _GLIBCXX_CONSTEXPR
 471     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 472                                     double>::__type
 473     tan(_Tp __x)
 474     { return __builtin_tan(__x); }
 475
 476   using ::tanh;
 477
 478 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
 479   inline _GLIBCXX_CONSTEXPR float
 480   tanh(float __x)
 481   { return __builtin_tanhf(__x); }
 482
 483   inline _GLIBCXX_CONSTEXPR long double
 484   tanh(long double __x)
 485   { return __builtin_tanhl(__x); }
 486 #endif
 487
 488   template<typename _Tp>
 489     inline _GLIBCXX_CONSTEXPR
 490     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 491                                     double>::__type
 492     tanh(_Tp __x)
 493     { return __builtin_tanh(__x); }
 494
 495 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
 496   constexpr _Float16
 497   acos(_Float16 __x)
 498   { return _Float16(__builtin_acosf(__x)); }
 499
 500   constexpr _Float16
 501   asin(_Float16 __x)
 502   { return _Float16(__builtin_asinf(__x)); }
 503
 504   constexpr _Float16
 505   atan(_Float16 __x)
 506   { return _Float16(__builtin_atanf(__x)); }
 507
 508   constexpr _Float16
 509   atan2(_Float16 __y, _Float16 __x)
 510   { return _Float16(__builtin_atan2f(__y, __x)); }
 511
 512   constexpr _Float16
 513   ceil(_Float16 __x)
 514   { return _Float16(__builtin_ceilf(__x)); }
 515
 516   constexpr _Float16
 517   cos(_Float16 __x)
 518   { return _Float16(__builtin_cosf(__x)); }
 519
 520   constexpr _Float16
 521   cosh(_Float16 __x)
 522   { return _Float16(__builtin_coshf(__x)); }
 523
 524   constexpr _Float16
 525   exp(_Float16 __x)
 526   { return _Float16(__builtin_expf(__x)); }
 527
 528   constexpr _Float16
 529   fabs(_Float16 __x)
 530   { return _Float16(__builtin_fabsf(__x)); }
 531
 532   constexpr _Float16
 533   floor(_Float16 __x)
 534   { return _Float16(__builtin_floorf(__x)); }
 535
 536   constexpr _Float16
 537   fmod(_Float16 __x, _Float16 __y)
 538   { return _Float16(__builtin_fmodf(__x, __y)); }
 539
 540   inline _Float16
 541   frexp(_Float16 __x, int* __exp)
 542   { return _Float16(__builtin_frexpf(__x, __exp)); }
 543
 544   constexpr _Float16
 545   ldexp(_Float16 __x, int __exp)
 546   { return _Float16(__builtin_ldexpf(__x, __exp)); }
 547
 548   constexpr _Float16
 549   log(_Float16 __x)
 550   { return _Float16(__builtin_logf(__x)); }
 551
 552   constexpr _Float16
 553   log10(_Float16 __x)
 554   { return _Float16(__builtin_log10f(__x)); }
 555
 556   inline _Float16
 557   modf(_Float16 __x, _Float16* __iptr)
 558   {
 559     float __i, __ret = __builtin_modff(__x, &__i);
 560     *__iptr = _Float16(__i);
 561     return _Float16(__ret);
 562   }
 563
 564   constexpr _Float16
 565   pow(_Float16 __x, _Float16 __y)
 566   { return _Float16(__builtin_powf(__x, __y)); }
 567
 568   constexpr _Float16
 569   sin(_Float16 __x)
 570   { return _Float16(__builtin_sinf(__x)); }
 571
 572   constexpr _Float16
 573   sinh(_Float16 __x)
 574   { return _Float16(__builtin_sinhf(__x)); }
 575
 576   constexpr _Float16
 577   sqrt(_Float16 __x)
 578   { return _Float16(__builtin_sqrtf(__x)); }
 579
 580   constexpr _Float16
 581   tan(_Float16 __x)
 582   { return _Float16(__builtin_tanf(__x)); }
 583
 584   constexpr _Float16
 585   tanh(_Float16 __x)
 586   { return _Float16(__builtin_tanhf(__x)); }
 587 #endif
 588
 589 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
 590   constexpr _Float32
 591   acos(_Float32 __x)
 592   { return __builtin_acosf(__x); }
 593
 594   constexpr _Float32
 595   asin(_Float32 __x)
 596   { return __builtin_asinf(__x); }
 597
 598   constexpr _Float32
 599   atan(_Float32 __x)
 600   { return __builtin_atanf(__x); }
 601
 602   constexpr _Float32
 603   atan2(_Float32 __y, _Float32 __x)
 604   { return __builtin_atan2f(__y, __x); }
 605
 606   constexpr _Float32
 607   ceil(_Float32 __x)
 608   { return __builtin_ceilf(__x); }
 609
 610   constexpr _Float32
 611   cos(_Float32 __x)
 612   { return __builtin_cosf(__x); }
 613
 614   constexpr _Float32
 615   cosh(_Float32 __x)
 616   { return __builtin_coshf(__x); }
 617
 618   constexpr _Float32
 619   exp(_Float32 __x)
 620   { return __builtin_expf(__x); }
 621
 622   constexpr _Float32
 623   fabs(_Float32 __x)
 624   { return __builtin_fabsf(__x); }
 625
 626   constexpr _Float32
 627   floor(_Float32 __x)
 628   { return __builtin_floorf(__x); }
 629
 630   constexpr _Float32
 631   fmod(_Float32 __x, _Float32 __y)
 632   { return __builtin_fmodf(__x, __y); }
 633
 634   inline _Float32
 635   frexp(_Float32 __x, int* __exp)
 636   { return __builtin_frexpf(__x, __exp); }
 637
 638   constexpr _Float32
 639   ldexp(_Float32 __x, int __exp)
 640   { return __builtin_ldexpf(__x, __exp); }
 641
 642   constexpr _Float32
 643   log(_Float32 __x)
 644   { return __builtin_logf(__x); }
 645
 646   constexpr _Float32
 647   log10(_Float32 __x)
 648   { return __builtin_log10f(__x); }
 649
 650   inline _Float32
 651   modf(_Float32 __x, _Float32* __iptr)
 652   {
 653     float __i, __ret = __builtin_modff(__x, &__i);
 654     *__iptr = __i;
 655     return __ret;
 656   }
 657
 658   constexpr _Float32
 659   pow(_Float32 __x, _Float32 __y)
 660   { return __builtin_powf(__x, __y); }
 661
 662   constexpr _Float32
 663   sin(_Float32 __x)
 664   { return __builtin_sinf(__x); }
 665
 666   constexpr _Float32
 667   sinh(_Float32 __x)
 668   { return __builtin_sinhf(__x); }
 669
 670   constexpr _Float32
 671   sqrt(_Float32 __x)
 672   { return __builtin_sqrtf(__x); }
 673
 674   constexpr _Float32
 675   tan(_Float32 __x)
 676   { return __builtin_tanf(__x); }
 677
 678   constexpr _Float32
 679   tanh(_Float32 __x)
 680   { return __builtin_tanhf(__x); }
 681 #endif
 682
 683 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
 684   constexpr _Float64
 685   acos(_Float64 __x)
 686   { return __builtin_acos(__x); }
 687
 688   constexpr _Float64
 689   asin(_Float64 __x)
 690   { return __builtin_asin(__x); }
 691
 692   constexpr _Float64
 693   atan(_Float64 __x)
 694   { return __builtin_atan(__x); }
 695
 696   constexpr _Float64
 697   atan2(_Float64 __y, _Float64 __x)
 698   { return __builtin_atan2(__y, __x); }
 699
 700   constexpr _Float64
 701   ceil(_Float64 __x)
 702   { return __builtin_ceil(__x); }
 703
 704   constexpr _Float64
 705   cos(_Float64 __x)
 706   { return __builtin_cos(__x); }
 707
 708   constexpr _Float64
 709   cosh(_Float64 __x)
 710   { return __builtin_cosh(__x); }
 711
 712   constexpr _Float64
 713   exp(_Float64 __x)
 714   { return __builtin_exp(__x); }
 715
 716   constexpr _Float64
 717   fabs(_Float64 __x)
 718   { return __builtin_fabs(__x); }
 719
 720   constexpr _Float64
 721   floor(_Float64 __x)
 722   { return __builtin_floor(__x); }
 723
 724   constexpr _Float64
 725   fmod(_Float64 __x, _Float64 __y)
 726   { return __builtin_fmod(__x, __y); }
 727
 728   inline _Float64
 729   frexp(_Float64 __x, int* __exp)
 730   { return __builtin_frexp(__x, __exp); }
 731
 732   constexpr _Float64
 733   ldexp(_Float64 __x, int __exp)
 734   { return __builtin_ldexp(__x, __exp); }
 735
 736   constexpr _Float64
 737   log(_Float64 __x)
 738   { return __builtin_log(__x); }
 739
 740   constexpr _Float64
 741   log10(_Float64 __x)
 742   { return __builtin_log10(__x); }
 743
 744   inline _Float64
 745   modf(_Float64 __x, _Float64* __iptr)
 746   {
 747     double __i, __ret = __builtin_modf(__x, &__i);
 748     *__iptr = __i;
 749     return __ret;
 750   }
 751
 752   constexpr _Float64
 753   pow(_Float64 __x, _Float64 __y)
 754   { return __builtin_pow(__x, __y); }
 755
 756   constexpr _Float64
 757   sin(_Float64 __x)
 758   { return __builtin_sin(__x); }
 759
 760   constexpr _Float64
 761   sinh(_Float64 __x)
 762   { return __builtin_sinh(__x); }
 763
 764   constexpr _Float64
 765   sqrt(_Float64 __x)
 766   { return __builtin_sqrt(__x); }
 767
 768   constexpr _Float64
 769   tan(_Float64 __x)
 770   { return __builtin_tan(__x); }
 771
 772   constexpr _Float64
 773   tanh(_Float64 __x)
 774   { return __builtin_tanh(__x); }
 775 #endif
 776
 777 #if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
 778   constexpr _Float128
 779   acos(_Float128 __x)
 780   { return __builtin_acosl(__x); }
 781
 782   constexpr _Float128
 783   asin(_Float128 __x)
 784   { return __builtin_asinl(__x); }
 785
 786   constexpr _Float128
 787   atan(_Float128 __x)
 788   { return __builtin_atanl(__x); }
 789
 790   constexpr _Float128
 791   atan2(_Float128 __y, _Float128 __x)
 792   { return __builtin_atan2l(__y, __x); }
 793
 794   constexpr _Float128
 795   ceil(_Float128 __x)
 796   { return __builtin_ceill(__x); }
 797
 798   constexpr _Float128
 799   cos(_Float128 __x)
 800   { return __builtin_cosl(__x); }
 801
 802   constexpr _Float128
 803   cosh(_Float128 __x)
 804   { return __builtin_coshl(__x); }
 805
 806   constexpr _Float128
 807   exp(_Float128 __x)
 808   { return __builtin_expl(__x); }
 809
 810   constexpr _Float128
 811   fabs(_Float128 __x)
 812   { return __builtin_fabsl(__x); }
 813
 814   constexpr _Float128
 815   floor(_Float128 __x)
 816   { return __builtin_floorl(__x); }
 817
 818   constexpr _Float128
 819   fmod(_Float128 __x, _Float128 __y)
 820   { return __builtin_fmodl(__x, __y); }
 821
 822   inline _Float128
 823   frexp(_Float128 __x, int* __exp)
 824   { return __builtin_frexpl(__x, __exp); }
 825
 826   constexpr _Float128
 827   ldexp(_Float128 __x, int __exp)
 828   { return __builtin_ldexpl(__x, __exp); }
 829
 830   constexpr _Float128
 831   log(_Float128 __x)
 832   { return __builtin_logl(__x); }
 833
 834   constexpr _Float128
 835   log10(_Float128 __x)
 836   { return __builtin_log10l(__x); }
 837
 838   inline _Float128
 839   modf(_Float128 __x, _Float128* __iptr)
 840   {
 841     long double __i, __ret = __builtin_modfl(__x, &__i);
 842     *__iptr = __i;
 843     return __ret;
 844   }
 845
 846   constexpr _Float128
 847   pow(_Float128 __x, _Float128 __y)
 848   { return __builtin_powl(__x, __y); }
 849
 850   constexpr _Float128
 851   sin(_Float128 __x)
 852   { return __builtin_sinl(__x); }
 853
 854   constexpr _Float128
 855   sinh(_Float128 __x)
 856   { return __builtin_sinhl(__x); }
 857
 858   constexpr _Float128
 859   sqrt(_Float128 __x)
 860   { return __builtin_sqrtl(__x); }
 861
 862   constexpr _Float128
 863   tan(_Float128 __x)
 864   { return __builtin_tanl(__x); }
 865
 866   constexpr _Float128
 867   tanh(_Float128 __x)
 868   { return __builtin_tanhl(__x); }
 869 #elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
 870   constexpr _Float128
 871   acos(_Float128 __x)
 872   { return __builtin_acosf128(__x); }
 873
 874   constexpr _Float128
 875   asin(_Float128 __x)
 876   { return __builtin_asinf128(__x); }
 877
 878   constexpr _Float128
 879   atan(_Float128 __x)
 880   { return __builtin_atanf128(__x); }
 881
 882   constexpr _Float128
 883   atan2(_Float128 __y, _Float128 __x)
 884   { return __builtin_atan2f128(__y, __x); }
 885
 886   constexpr _Float128
 887   ceil(_Float128 __x)
 888   { return __builtin_ceilf128(__x); }
 889
 890   constexpr _Float128
 891   cos(_Float128 __x)
 892   { return __builtin_cosf128(__x); }
 893
 894   constexpr _Float128
 895   cosh(_Float128 __x)
 896   { return __builtin_coshf128(__x); }
 897
 898   constexpr _Float128
 899   exp(_Float128 __x)
 900   { return __builtin_expf128(__x); }
 901
 902   constexpr _Float128
 903   fabs(_Float128 __x)
 904   { return __builtin_fabsf128(__x); }
 905
 906   constexpr _Float128
 907   floor(_Float128 __x)
 908   { return __builtin_floorf128(__x); }
 909
 910   constexpr _Float128
 911   fmod(_Float128 __x, _Float128 __y)
 912   { return __builtin_fmodf128(__x, __y); }
 913
 914   inline _Float128
 915   frexp(_Float128 __x, int* __exp)
 916   { return __builtin_frexpf128(__x, __exp); }
 917
 918   constexpr _Float128
 919   ldexp(_Float128 __x, int __exp)
 920   { return __builtin_ldexpf128(__x, __exp); }
 921
 922   constexpr _Float128
 923   log(_Float128 __x)
 924   { return __builtin_logf128(__x); }
 925
 926   constexpr _Float128
 927   log10(_Float128 __x)
 928   { return __builtin_log10f128(__x); }
 929
 930   inline _Float128
 931   modf(_Float128 __x, _Float128* __iptr)
 932   { return __builtin_modff128(__x, __iptr); }
 933
 934   constexpr _Float128
 935   pow(_Float128 __x, _Float128 __y)
 936   { return __builtin_powf128(__x, __y); }
 937
 938   constexpr _Float128
 939   sin(_Float128 __x)
 940   { return __builtin_sinf128(__x); }
 941
 942   constexpr _Float128
 943   sinh(_Float128 __x)
 944   { return __builtin_sinhf128(__x); }
 945
 946   constexpr _Float128
 947   sqrt(_Float128 __x)
 948   { return __builtin_sqrtf128(__x); }
 949
 950   constexpr _Float128
 951   tan(_Float128 __x)
 952   { return __builtin_tanf128(__x); }
 953
 954   constexpr _Float128
 955   tanh(_Float128 __x)
 956   { return __builtin_tanhf128(__x); }
 957 #endif
 958
 959 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
 960   constexpr __gnu_cxx::__bfloat16_t
 961   acos(__gnu_cxx::__bfloat16_t __x)
 962   { return __gnu_cxx::__bfloat16_t(__builtin_acosf(__x)); }
 963
 964   constexpr __gnu_cxx::__bfloat16_t
 965   asin(__gnu_cxx::__bfloat16_t __x)
 966   { return __gnu_cxx::__bfloat16_t(__builtin_asinf(__x)); }
 967
 968   constexpr __gnu_cxx::__bfloat16_t
 969   atan(__gnu_cxx::__bfloat16_t __x)
 970   { return __gnu_cxx::__bfloat16_t(__builtin_atanf(__x)); }
 971
 972   constexpr __gnu_cxx::__bfloat16_t
 973   atan2(__gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __x)
 974   { return __gnu_cxx::__bfloat16_t(__builtin_atan2f(__y, __x)); }
 975
 976   constexpr __gnu_cxx::__bfloat16_t
 977   ceil(__gnu_cxx::__bfloat16_t __x)
 978   { return __gnu_cxx::__bfloat16_t(__builtin_ceilf(__x)); }
 979
 980   constexpr __gnu_cxx::__bfloat16_t
 981   cos(__gnu_cxx::__bfloat16_t __x)
 982   { return __gnu_cxx::__bfloat16_t(__builtin_cosf(__x)); }
 983
 984   constexpr __gnu_cxx::__bfloat16_t
 985   cosh(__gnu_cxx::__bfloat16_t __x)
 986   { return __gnu_cxx::__bfloat16_t(__builtin_coshf(__x)); }
 987
 988   constexpr __gnu_cxx::__bfloat16_t
 989   exp(__gnu_cxx::__bfloat16_t __x)
 990   { return __gnu_cxx::__bfloat16_t(__builtin_expf(__x)); }
 991
 992   constexpr __gnu_cxx::__bfloat16_t
 993   fabs(__gnu_cxx::__bfloat16_t __x)
 994   { return __gnu_cxx::__bfloat16_t(__builtin_fabsf(__x)); }
 995
 996   constexpr __gnu_cxx::__bfloat16_t
 997   floor(__gnu_cxx::__bfloat16_t __x)
 998   { return __gnu_cxx::__bfloat16_t(__builtin_floorf(__x)); }
 999
1000   constexpr __gnu_cxx::__bfloat16_t
1001   fmod(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1002   { return __gnu_cxx::__bfloat16_t(__builtin_fmodf(__x, __y)); }
1003
1004   inline __gnu_cxx::__bfloat16_t
1005   frexp(__gnu_cxx::__bfloat16_t __x, int* __exp)
1006   { return __gnu_cxx::__bfloat16_t(__builtin_frexpf(__x, __exp)); }
1007
1008   constexpr __gnu_cxx::__bfloat16_t
1009   ldexp(__gnu_cxx::__bfloat16_t __x, int __exp)
1010   { return __gnu_cxx::__bfloat16_t(__builtin_ldexpf(__x, __exp)); }
1011
1012   constexpr __gnu_cxx::__bfloat16_t
1013   log(__gnu_cxx::__bfloat16_t __x)
1014   { return __gnu_cxx::__bfloat16_t(__builtin_logf(__x)); }
1015
1016   constexpr __gnu_cxx::__bfloat16_t
1017   log10(__gnu_cxx::__bfloat16_t __x)
1018   { return __gnu_cxx::__bfloat16_t(__builtin_log10f(__x)); }
1019
1020   inline __gnu_cxx::__bfloat16_t
1021   modf(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t* __iptr)
1022   {
1023     float __i, __ret = __builtin_modff(__x, &__i);
1024     *__iptr = __gnu_cxx::__bfloat16_t(__i);
1025     return __gnu_cxx::__bfloat16_t(__ret);
1026   }
1027
1028   constexpr __gnu_cxx::__bfloat16_t
1029   pow(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1030   { return __gnu_cxx::__bfloat16_t(__builtin_powf(__x, __y)); }
1031
1032   constexpr __gnu_cxx::__bfloat16_t
1033   sin(__gnu_cxx::__bfloat16_t __x)
1034   { return __gnu_cxx::__bfloat16_t(__builtin_sinf(__x)); }
1035
1036   constexpr __gnu_cxx::__bfloat16_t
1037   sinh(__gnu_cxx::__bfloat16_t __x)
1038   { return __gnu_cxx::__bfloat16_t(__builtin_sinhf(__x)); }
1039
1040   constexpr __gnu_cxx::__bfloat16_t
1041   sqrt(__gnu_cxx::__bfloat16_t __x)
1042   { return __gnu_cxx::__bfloat16_t(__builtin_sqrtf(__x)); }
1043
1044   constexpr __gnu_cxx::__bfloat16_t
1045   tan(__gnu_cxx::__bfloat16_t __x)
1046   { return __gnu_cxx::__bfloat16_t(__builtin_tanf(__x)); }
1047
1048   constexpr __gnu_cxx::__bfloat16_t
1049   tanh(__gnu_cxx::__bfloat16_t __x)
1050   { return __gnu_cxx::__bfloat16_t(__builtin_tanhf(__x)); }
1051 #endif
1052
1053   template<typename _Tp, typename _Up>
1054     inline _GLIBCXX_CONSTEXPR
1055     typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1056     atan2(_Tp __y, _Up __x)
1057     {
1058       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1059       return atan2(__type(__y), __type(__x));
1060     }
1061
1062   template<typename _Tp, typename _Up>
1063     inline _GLIBCXX_CONSTEXPR
1064     typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1065     fmod(_Tp __x, _Up __y)
1066     {
1067       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1068       return fmod(__type(__x), __type(__y));
1069     }
1070
1071   template<typename _Tp, typename _Up>
1072     inline _GLIBCXX_CONSTEXPR
1073     typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1074     pow(_Tp __x, _Up __y)
1075     {
1076       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1077       return pow(__type(__x), __type(__y));
1078     }
1079
1080 #if _GLIBCXX_USE_C99_MATH
1081 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
1082
1083 // These are possible macros imported from C99-land.
1084 #undef fpclassify
1085 #undef isfinite
1086 #undef isinf
1087 #undef isnan
1088 #undef isnormal
1089 #undef signbit
1090 #undef isgreater
1091 #undef isgreaterequal
1092 #undef isless
1093 #undef islessequal
1094 #undef islessgreater
1095 #undef isunordered
1096
1097 #if __cplusplus >= 201103L
1098
1099 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1100   constexpr int
1101   fpclassify(float __x)
1102   { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1103                                 FP_SUBNORMAL, FP_ZERO, __x); }
1104
1105   constexpr int
1106   fpclassify(double __x)
1107   { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1108                                 FP_SUBNORMAL, FP_ZERO, __x); }
1109
1110   constexpr int
1111   fpclassify(long double __x)
1112   { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1113                                 FP_SUBNORMAL, FP_ZERO, __x); }
1114 #endif
1115
1116 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1117   template<typename _Tp>
1118     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1119                                               int>::__type
1120     fpclassify(_Tp __x)
1121     { return __x != 0 ? FP_NORMAL : FP_ZERO; }
1122 #endif
1123
1124 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1125   constexpr bool
1126   isfinite(float __x)
1127   { return __builtin_isfinite(__x); }
1128
1129   constexpr bool
1130   isfinite(double __x)
1131   { return __builtin_isfinite(__x); }
1132
1133   constexpr bool
1134   isfinite(long double __x)
1135   { return __builtin_isfinite(__x); }
1136 #endif
1137
1138 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1139   template<typename _Tp>
1140     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1141                                               bool>::__type
1142     isfinite(_Tp)
1143     { return true; }
1144 #endif
1145
1146 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1147   constexpr bool
1148   isinf(float __x)
1149   { return __builtin_isinf(__x); }
1150
1151 #if _GLIBCXX_HAVE_OBSOLETE_ISINF \
1152   && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
1153   using ::isinf;
1154 #else
1155   constexpr bool
1156   isinf(double __x)
1157   { return __builtin_isinf(__x); }
1158 #endif
1159
1160   constexpr bool
1161   isinf(long double __x)
1162   { return __builtin_isinf(__x); }
1163 #endif
1164
1165 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1166   template<typename _Tp>
1167     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1168                                               bool>::__type
1169     isinf(_Tp)
1170     { return false; }
1171 #endif
1172
1173 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1174   constexpr bool
1175   isnan(float __x)
1176   { return __builtin_isnan(__x); }
1177
1178 #if _GLIBCXX_HAVE_OBSOLETE_ISNAN \
1179   && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
1180   using ::isnan;
1181 #else
1182   constexpr bool
1183   isnan(double __x)
1184   { return __builtin_isnan(__x); }
1185 #endif
1186
1187   constexpr bool
1188   isnan(long double __x)
1189   { return __builtin_isnan(__x); }
1190 #endif
1191
1192 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1193   template<typename _Tp>
1194     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1195                                               bool>::__type
1196     isnan(_Tp)
1197     { return false; }
1198 #endif
1199
1200 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1201   constexpr bool
1202   isnormal(float __x)
1203   { return __builtin_isnormal(__x); }
1204
1205   constexpr bool
1206   isnormal(double __x)
1207   { return __builtin_isnormal(__x); }
1208
1209   constexpr bool
1210   isnormal(long double __x)
1211   { return __builtin_isnormal(__x); }
1212 #endif
1213
1214 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1215   template<typename _Tp>
1216     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1217                                               bool>::__type
1218     isnormal(_Tp __x)
1219     { return __x != 0 ? true : false; }
1220 #endif
1221
1222 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1223   // Note: middle-end/36757 is fixed, __builtin_signbit is type-generic.
1224   constexpr bool
1225   signbit(float __x)
1226   { return __builtin_signbit(__x); }
1227
1228   constexpr bool
1229   signbit(double __x)
1230   { return __builtin_signbit(__x); }
1231
1232   constexpr bool
1233   signbit(long double __x)
1234   { return __builtin_signbit(__x); }
1235 #endif
1236
1237 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1238   template<typename _Tp>
1239     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1240                                               bool>::__type
1241     signbit(_Tp __x)
1242     { return __x < 0 ? true : false; }
1243 #endif
1244
1245 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1246   constexpr bool
1247   isgreater(float __x, float __y)
1248   { return __builtin_isgreater(__x, __y); }
1249
1250   constexpr bool
1251   isgreater(double __x, double __y)
1252   { return __builtin_isgreater(__x, __y); }
1253
1254   constexpr bool
1255   isgreater(long double __x, long double __y)
1256   { return __builtin_isgreater(__x, __y); }
1257 #endif
1258
1259 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1260   template<typename _Tp, typename _Up>
1261     constexpr typename
1262     __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1263                             && __is_arithmetic<_Up>::__value), bool>::__type
1264     isgreater(_Tp __x, _Up __y)
1265     {
1266       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1267       return __builtin_isgreater(__type(__x), __type(__y));
1268     }
1269 #endif
1270
1271 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1272   constexpr bool
1273   isgreaterequal(float __x, float __y)
1274   { return __builtin_isgreaterequal(__x, __y); }
1275
1276   constexpr bool
1277   isgreaterequal(double __x, double __y)
1278   { return __builtin_isgreaterequal(__x, __y); }
1279
1280   constexpr bool
1281   isgreaterequal(long double __x, long double __y)
1282   { return __builtin_isgreaterequal(__x, __y); }
1283 #endif
1284
1285 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1286   template<typename _Tp, typename _Up>
1287     constexpr typename
1288     __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1289                             && __is_arithmetic<_Up>::__value), bool>::__type
1290     isgreaterequal(_Tp __x, _Up __y)
1291     {
1292       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1293       return __builtin_isgreaterequal(__type(__x), __type(__y));
1294     }
1295 #endif
1296
1297 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1298   constexpr bool
1299   isless(float __x, float __y)
1300   { return __builtin_isless(__x, __y); }
1301
1302   constexpr bool
1303   isless(double __x, double __y)
1304   { return __builtin_isless(__x, __y); }
1305
1306   constexpr bool
1307   isless(long double __x, long double __y)
1308   { return __builtin_isless(__x, __y); }
1309 #endif
1310
1311 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1312   template<typename _Tp, typename _Up>
1313     constexpr typename
1314     __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1315                             && __is_arithmetic<_Up>::__value), bool>::__type
1316     isless(_Tp __x, _Up __y)
1317     {
1318       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1319       return __builtin_isless(__type(__x), __type(__y));
1320     }
1321 #endif
1322
1323 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1324   constexpr bool
1325   islessequal(float __x, float __y)
1326   { return __builtin_islessequal(__x, __y); }
1327
1328   constexpr bool
1329   islessequal(double __x, double __y)
1330   { return __builtin_islessequal(__x, __y); }
1331
1332   constexpr bool
1333   islessequal(long double __x, long double __y)
1334   { return __builtin_islessequal(__x, __y); }
1335 #endif
1336
1337 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1338   template<typename _Tp, typename _Up>
1339     constexpr typename
1340     __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1341                             && __is_arithmetic<_Up>::__value), bool>::__type
1342     islessequal(_Tp __x, _Up __y)
1343     {
1344       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1345       return __builtin_islessequal(__type(__x), __type(__y));
1346     }
1347 #endif
1348
1349 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1350   constexpr bool
1351   islessgreater(float __x, float __y)
1352   { return __builtin_islessgreater(__x, __y); }
1353
1354   constexpr bool
1355   islessgreater(double __x, double __y)
1356   { return __builtin_islessgreater(__x, __y); }
1357
1358   constexpr bool
1359   islessgreater(long double __x, long double __y)
1360   { return __builtin_islessgreater(__x, __y); }
1361 #endif
1362
1363 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1364   template<typename _Tp, typename _Up>
1365     constexpr typename
1366     __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1367                             && __is_arithmetic<_Up>::__value), bool>::__type
1368     islessgreater(_Tp __x, _Up __y)
1369     {
1370       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1371       return __builtin_islessgreater(__type(__x), __type(__y));
1372     }
1373 #endif
1374
1375 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1376   constexpr bool
1377   isunordered(float __x, float __y)
1378   { return __builtin_isunordered(__x, __y); }
1379
1380   constexpr bool
1381   isunordered(double __x, double __y)
1382   { return __builtin_isunordered(__x, __y); }
1383
1384   constexpr bool
1385   isunordered(long double __x, long double __y)
1386   { return __builtin_isunordered(__x, __y); }
1387 #endif
1388
1389 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1390   template<typename _Tp, typename _Up>
1391     constexpr typename
1392     __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1393                             && __is_arithmetic<_Up>::__value), bool>::__type
1394     isunordered(_Tp __x, _Up __y)
1395     {
1396       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1397       return __builtin_isunordered(__type(__x), __type(__y));
1398     }
1399 #endif
1400
1401 #else
1402
1403   template<typename _Tp>
1404     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1405                                            int>::__type
1406     fpclassify(_Tp __f)
1407     {
1408       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1409       return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1410                                   FP_SUBNORMAL, FP_ZERO, __type(__f));
1411     }
1412
1413   template<typename _Tp>
1414     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1415                                            int>::__type
1416     isfinite(_Tp __f)
1417     {
1418       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1419       return __builtin_isfinite(__type(__f));
1420     }
1421
1422   template<typename _Tp>
1423     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1424                                            int>::__type
1425     isinf(_Tp __f)
1426     {
1427       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1428       return __builtin_isinf(__type(__f));
1429     }
1430
1431   template<typename _Tp>
1432     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1433                                            int>::__type
1434     isnan(_Tp __f)
1435     {
1436       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1437       return __builtin_isnan(__type(__f));
1438     }
1439
1440   template<typename _Tp>
1441     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1442                                            int>::__type
1443     isnormal(_Tp __f)
1444     {
1445       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1446       return __builtin_isnormal(__type(__f));
1447     }
1448
1449   template<typename _Tp>
1450     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1451                                            int>::__type
1452     signbit(_Tp __f)
1453     {
1454       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1455       return __builtin_signbit(__type(__f));
1456     }
1457
1458   template<typename _Tp>
1459     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1460                                            int>::__type
1461     isgreater(_Tp __f1, _Tp __f2)
1462     {
1463       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1464       return __builtin_isgreater(__type(__f1), __type(__f2));
1465     }
1466
1467   template<typename _Tp>
1468     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1469                                            int>::__type
1470     isgreaterequal(_Tp __f1, _Tp __f2)
1471     {
1472       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1473       return __builtin_isgreaterequal(__type(__f1), __type(__f2));
1474     }
1475
1476   template<typename _Tp>
1477     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1478                                            int>::__type
1479     isless(_Tp __f1, _Tp __f2)
1480     {
1481       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1482       return __builtin_isless(__type(__f1), __type(__f2));
1483     }
1484
1485   template<typename _Tp>
1486     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1487                                            int>::__type
1488     islessequal(_Tp __f1, _Tp __f2)
1489     {
1490       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1491       return __builtin_islessequal(__type(__f1), __type(__f2));
1492     }
1493
1494   template<typename _Tp>
1495     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1496                                            int>::__type
1497     islessgreater(_Tp __f1, _Tp __f2)
1498     {
1499       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1500       return __builtin_islessgreater(__type(__f1), __type(__f2));
1501     }
1502
1503   template<typename _Tp>
1504     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1505                                            int>::__type
1506     isunordered(_Tp __f1, _Tp __f2)
1507     {
1508       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1509       return __builtin_isunordered(__type(__f1), __type(__f2));
1510     }
1511
1512 #endif // C++11
1513
1514 #ifdef __STDCPP_FLOAT16_T__
1515   constexpr int
1516   fpclassify(_Float16 __x)
1517   { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1518                                 FP_SUBNORMAL, FP_ZERO, __x); }
1519
1520   constexpr bool
1521   isfinite(_Float16 __x)
1522   { return __builtin_isfinite(__x); }
1523
1524   constexpr bool
1525   isinf(_Float16 __x)
1526   { return __builtin_isinf(__x); }
1527
1528   constexpr bool
1529   isnan(_Float16 __x)
1530   { return __builtin_isnan(__x); }
1531
1532   constexpr bool
1533   isnormal(_Float16 __x)
1534   { return __builtin_isnormal(__x); }
1535
1536   constexpr bool
1537   signbit(_Float16 __x)
1538   { return __builtin_signbit(__x); }
1539
1540   constexpr bool
1541   isgreater(_Float16 __x, _Float16 __y)
1542   { return __builtin_isgreater(__x, __y); }
1543
1544   constexpr bool
1545   isgreaterequal(_Float16 __x, _Float16 __y)
1546   { return __builtin_isgreaterequal(__x, __y); }
1547
1548   constexpr bool
1549   isless(_Float16 __x, _Float16 __y)
1550   { return __builtin_isless(__x, __y); }
1551
1552   constexpr bool
1553   islessequal(_Float16 __x, _Float16 __y)
1554   { return __builtin_islessequal(__x, __y); }
1555
1556   constexpr bool
1557   islessgreater(_Float16 __x, _Float16 __y)
1558   { return __builtin_islessgreater(__x, __y); }
1559
1560   constexpr bool
1561   isunordered(_Float16 __x, _Float16 __y)
1562   { return __builtin_isunordered(__x, __y); }
1563 #endif
1564
1565 #ifdef __STDCPP_FLOAT32_T__
1566   constexpr int
1567   fpclassify(_Float32 __x)
1568   { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1569                                 FP_SUBNORMAL, FP_ZERO, __x); }
1570
1571   constexpr bool
1572   isfinite(_Float32 __x)
1573   { return __builtin_isfinite(__x); }
1574
1575   constexpr bool
1576   isinf(_Float32 __x)
1577   { return __builtin_isinf(__x); }
1578
1579   constexpr bool
1580   isnan(_Float32 __x)
1581   { return __builtin_isnan(__x); }
1582
1583   constexpr bool
1584   isnormal(_Float32 __x)
1585   { return __builtin_isnormal(__x); }
1586
1587   constexpr bool
1588   signbit(_Float32 __x)
1589   { return __builtin_signbit(__x); }
1590
1591   constexpr bool
1592   isgreater(_Float32 __x, _Float32 __y)
1593   { return __builtin_isgreater(__x, __y); }
1594
1595   constexpr bool
1596   isgreaterequal(_Float32 __x, _Float32 __y)
1597   { return __builtin_isgreaterequal(__x, __y); }
1598
1599   constexpr bool
1600   isless(_Float32 __x, _Float32 __y)
1601   { return __builtin_isless(__x, __y); }
1602
1603   constexpr bool
1604   islessequal(_Float32 __x, _Float32 __y)
1605   { return __builtin_islessequal(__x, __y); }
1606
1607   constexpr bool
1608   islessgreater(_Float32 __x, _Float32 __y)
1609   { return __builtin_islessgreater(__x, __y); }
1610
1611   constexpr bool
1612   isunordered(_Float32 __x, _Float32 __y)
1613   { return __builtin_isunordered(__x, __y); }
1614 #endif
1615
1616 #ifdef __STDCPP_FLOAT64_T__
1617   constexpr int
1618   fpclassify(_Float64 __x)
1619   { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1620                                 FP_SUBNORMAL, FP_ZERO, __x); }
1621
1622   constexpr bool
1623   isfinite(_Float64 __x)
1624   { return __builtin_isfinite(__x); }
1625
1626   constexpr bool
1627   isinf(_Float64 __x)
1628   { return __builtin_isinf(__x); }
1629
1630   constexpr bool
1631   isnan(_Float64 __x)
1632   { return __builtin_isnan(__x); }
1633
1634   constexpr bool
1635   isnormal(_Float64 __x)
1636   { return __builtin_isnormal(__x); }
1637
1638   constexpr bool
1639   signbit(_Float64 __x)
1640   { return __builtin_signbit(__x); }
1641
1642   constexpr bool
1643   isgreater(_Float64 __x, _Float64 __y)
1644   { return __builtin_isgreater(__x, __y); }
1645
1646   constexpr bool
1647   isgreaterequal(_Float64 __x, _Float64 __y)
1648   { return __builtin_isgreaterequal(__x, __y); }
1649
1650   constexpr bool
1651   isless(_Float64 __x, _Float64 __y)
1652   { return __builtin_isless(__x, __y); }
1653
1654   constexpr bool
1655   islessequal(_Float64 __x, _Float64 __y)
1656   { return __builtin_islessequal(__x, __y); }
1657
1658   constexpr bool
1659   islessgreater(_Float64 __x, _Float64 __y)
1660   { return __builtin_islessgreater(__x, __y); }
1661
1662   constexpr bool
1663   isunordered(_Float64 __x, _Float64 __y)
1664   { return __builtin_isunordered(__x, __y); }
1665 #endif
1666
1667 #ifdef __STDCPP_FLOAT128_T__
1668   constexpr int
1669   fpclassify(_Float128 __x)
1670   { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1671                                 FP_SUBNORMAL, FP_ZERO, __x); }
1672
1673   constexpr bool
1674   isfinite(_Float128 __x)
1675   { return __builtin_isfinite(__x); }
1676
1677   constexpr bool
1678   isinf(_Float128 __x)
1679   { return __builtin_isinf(__x); }
1680
1681   constexpr bool
1682   isnan(_Float128 __x)
1683   { return __builtin_isnan(__x); }
1684
1685   constexpr bool
1686   isnormal(_Float128 __x)
1687   { return __builtin_isnormal(__x); }
1688
1689   constexpr bool
1690   signbit(_Float128 __x)
1691   { return __builtin_signbit(__x); }
1692
1693   constexpr bool
1694   isgreater(_Float128 __x, _Float128 __y)
1695   { return __builtin_isgreater(__x, __y); }
1696
1697   constexpr bool
1698   isgreaterequal(_Float128 __x, _Float128 __y)
1699   { return __builtin_isgreaterequal(__x, __y); }
1700
1701   constexpr bool
1702   isless(_Float128 __x, _Float128 __y)
1703   { return __builtin_isless(__x, __y); }
1704
1705   constexpr bool
1706   islessequal(_Float128 __x, _Float128 __y)
1707   { return __builtin_islessequal(__x, __y); }
1708
1709   constexpr bool
1710   islessgreater(_Float128 __x, _Float128 __y)
1711   { return __builtin_islessgreater(__x, __y); }
1712
1713   constexpr bool
1714   isunordered(_Float128 __x, _Float128 __y)
1715   { return __builtin_isunordered(__x, __y); }
1716 #endif
1717
1718 #ifdef __STDCPP_BFLOAT16_T__
1719   constexpr int
1720   fpclassify(__gnu_cxx::__bfloat16_t __x)
1721   { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1722                                 FP_SUBNORMAL, FP_ZERO, __x); }
1723
1724   constexpr bool
1725   isfinite(__gnu_cxx::__bfloat16_t __x)
1726   { return __builtin_isfinite(__x); }
1727
1728   constexpr bool
1729   isinf(__gnu_cxx::__bfloat16_t __x)
1730   { return __builtin_isinf(__x); }
1731
1732   constexpr bool
1733   isnan(__gnu_cxx::__bfloat16_t __x)
1734   { return __builtin_isnan(__x); }
1735
1736   constexpr bool
1737   isnormal(__gnu_cxx::__bfloat16_t __x)
1738   { return __builtin_isnormal(__x); }
1739
1740   constexpr bool
1741   signbit(__gnu_cxx::__bfloat16_t __x)
1742   { return __builtin_signbit(__x); }
1743
1744   constexpr bool
1745   isgreater(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1746   { return __builtin_isgreater(__x, __y); }
1747
1748   constexpr bool
1749   isgreaterequal(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1750   { return __builtin_isgreaterequal(__x, __y); }
1751
1752   constexpr bool
1753   isless(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1754   { return __builtin_isless(__x, __y); }
1755
1756   constexpr bool
1757   islessequal(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1758   { return __builtin_islessequal(__x, __y); }
1759
1760   constexpr bool
1761   islessgreater(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1762   { return __builtin_islessgreater(__x, __y); }
1763
1764   constexpr bool
1765   isunordered(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1766   { return __builtin_isunordered(__x, __y); }
1767 #endif
1768
1769 #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
1770 #endif /* _GLIBCXX_USE_C99_MATH */
1771
1772 #if __cplusplus >= 201103L
1773
1774 #undef acosf
1775 #undef acosl
1776 #undef asinf
1777 #undef asinl
1778 #undef atanf
1779 #undef atanl
1780 #undef atan2f
1781 #undef atan2l
1782 #undef ceilf
1783 #undef ceill
1784 #undef cosf
1785 #undef cosl
1786 #undef coshf
1787 #undef coshl
1788 #undef expf
1789 #undef expl
1790 #undef fabsf
1791 #undef fabsl
1792 #undef floorf
1793 #undef floorl
1794 #undef fmodf
1795 #undef fmodl
1796 #undef frexpf
1797 #undef frexpl
1798 #undef ldexpf
1799 #undef ldexpl
1800 #undef logf
1801 #undef logl
1802 #undef log10f
1803 #undef log10l
1804 #undef modff
1805 #undef modfl
1806 #undef powf
1807 #undef powl
1808 #undef sinf
1809 #undef sinl
1810 #undef sinhf
1811 #undef sinhl
1812 #undef sqrtf
1813 #undef sqrtl
1814 #undef tanf
1815 #undef tanl
1816 #undef tanhf
1817 #undef tanhl
1818
1819 #ifdef _GLIBCXX_HAVE_ACOSF
1820   using ::acosf;
1821 #endif
1822 #ifdef _GLIBCXX_HAVE_ACOSL
1823   using ::acosl;
1824 #endif
1825
1826 #ifdef _GLIBCXX_HAVE_ASINF
1827   using ::asinf;
1828 #endif
1829 #ifdef _GLIBCXX_HAVE_ASINL
1830   using ::asinl;
1831 #endif
1832
1833 #ifdef _GLIBCXX_HAVE_ATANF
1834   using ::atanf;
1835 #endif
1836 #ifdef _GLIBCXX_HAVE_ATANL
1837   using ::atanl;
1838 #endif
1839
1840 #ifdef _GLIBCXX_HAVE_ATAN2F
1841   using ::atan2f;
1842 #endif
1843 #ifdef _GLIBCXX_HAVE_ATAN2L
1844   using ::atan2l;
1845 #endif
1846
1847 #ifdef _GLIBCXX_HAVE_CEILF
1848   using ::ceilf;
1849 #endif
1850 #ifdef _GLIBCXX_HAVE_CEILL
1851   using ::ceill;
1852 #endif
1853
1854 #ifdef _GLIBCXX_HAVE_COSF
1855   using ::cosf;
1856 #endif
1857 #ifdef _GLIBCXX_HAVE_COSL
1858   using ::cosl;
1859 #endif
1860
1861 #ifdef _GLIBCXX_HAVE_COSHF
1862   using ::coshf;
1863 #endif
1864 #ifdef _GLIBCXX_HAVE_COSHL
1865   using ::coshl;
1866 #endif
1867
1868 #ifdef _GLIBCXX_HAVE_EXPF
1869   using ::expf;
1870 #endif
1871 #ifdef _GLIBCXX_HAVE_EXPL
1872   using ::expl;
1873 #endif
1874
1875 #ifdef _GLIBCXX_HAVE_FABSF
1876   using ::fabsf;
1877 #endif
1878 #ifdef _GLIBCXX_HAVE_FABSL
1879   using ::fabsl;
1880 #endif
1881
1882 #ifdef _GLIBCXX_HAVE_FLOORF
1883   using ::floorf;
1884 #endif
1885 #ifdef _GLIBCXX_HAVE_FLOORL
1886   using ::floorl;
1887 #endif
1888
1889 #ifdef _GLIBCXX_HAVE_FMODF
1890   using ::fmodf;
1891 #endif
1892 #ifdef _GLIBCXX_HAVE_FMODL
1893   using ::fmodl;
1894 #endif
1895
1896 #ifdef _GLIBCXX_HAVE_FREXPF
1897   using ::frexpf;
1898 #endif
1899 #ifdef _GLIBCXX_HAVE_FREXPL
1900   using ::frexpl;
1901 #endif
1902
1903 #ifdef _GLIBCXX_HAVE_LDEXPF
1904   using ::ldexpf;
1905 #endif
1906 #ifdef _GLIBCXX_HAVE_LDEXPL
1907   using ::ldexpl;
1908 #endif
1909
1910 #ifdef _GLIBCXX_HAVE_LOGF
1911   using ::logf;
1912 #endif
1913 #ifdef _GLIBCXX_HAVE_LOGL
1914   using ::logl;
1915 #endif
1916
1917 #ifdef _GLIBCXX_HAVE_LOG10F
1918   using ::log10f;
1919 #endif
1920 #ifdef _GLIBCXX_HAVE_LOG10L
1921   using ::log10l;
1922 #endif
1923
1924 #ifdef _GLIBCXX_HAVE_MODFF
1925   using ::modff;
1926 #endif
1927 #ifdef _GLIBCXX_HAVE_MODFL
1928   using ::modfl;
1929 #endif
1930
1931 #ifdef _GLIBCXX_HAVE_POWF
1932   using ::powf;
1933 #endif
1934 #ifdef _GLIBCXX_HAVE_POWL
1935   using ::powl;
1936 #endif
1937
1938 #ifdef _GLIBCXX_HAVE_SINF
1939   using ::sinf;
1940 #endif
1941 #ifdef _GLIBCXX_HAVE_SINL
1942   using ::sinl;
1943 #endif
1944
1945 #ifdef _GLIBCXX_HAVE_SINHF
1946   using ::sinhf;
1947 #endif
1948 #ifdef _GLIBCXX_HAVE_SINHL
1949   using ::sinhl;
1950 #endif
1951
1952 #ifdef _GLIBCXX_HAVE_SQRTF
1953   using ::sqrtf;
1954 #endif
1955 #ifdef _GLIBCXX_HAVE_SQRTL
1956   using ::sqrtl;
1957 #endif
1958
1959 #ifdef _GLIBCXX_HAVE_TANF
1960   using ::tanf;
1961 #endif
1962 #ifdef _GLIBCXX_HAVE_TANL
1963   using ::tanl;
1964 #endif
1965
1966 #ifdef _GLIBCXX_HAVE_TANHF
1967   using ::tanhf;
1968 #endif
1969 #ifdef _GLIBCXX_HAVE_TANHL
1970   using ::tanhl;
1971 #endif
1972
1973 #ifdef _GLIBCXX_USE_C99_MATH_FUNCS
1974
1975 #undef acosh
1976 #undef acoshf
1977 #undef acoshl
1978 #undef asinh
1979 #undef asinhf
1980 #undef asinhl
1981 #undef atanh
1982 #undef atanhf
1983 #undef atanhl
1984 #undef cbrt
1985 #undef cbrtf
1986 #undef cbrtl
1987 #undef copysign
1988 #undef copysignf
1989 #undef copysignl
1990 #undef erf
1991 #undef erff
1992 #undef erfl
1993 #undef erfc
1994 #undef erfcf
1995 #undef erfcl
1996 #undef exp2
1997 #undef exp2f
1998 #undef exp2l
1999 #undef expm1
2000 #undef expm1f
2001 #undef expm1l
2002 #undef fdim
2003 #undef fdimf
2004 #undef fdiml
2005 #undef fma
2006 #undef fmaf
2007 #undef fmal
2008 #undef fmax
2009 #undef fmaxf
2010 #undef fmaxl
2011 #undef fmin
2012 #undef fminf
2013 #undef fminl
2014 #undef hypot
2015 #undef hypotf
2016 #undef hypotl
2017 #undef ilogb
2018 #undef ilogbf
2019 #undef ilogbl
2020 #undef lgamma
2021 #undef lgammaf
2022 #undef lgammal
2023 #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
2024 #undef llrint
2025 #undef llrintf
2026 #undef llrintl
2027 #undef llround
2028 #undef llroundf
2029 #undef llroundl
2030 #endif
2031 #undef log1p
2032 #undef log1pf
2033 #undef log1pl
2034 #undef log2
2035 #undef log2f
2036 #undef log2l
2037 #undef logb
2038 #undef logbf
2039 #undef logbl
2040 #undef lrint
2041 #undef lrintf
2042 #undef lrintl
2043 #undef lround
2044 #undef lroundf
2045 #undef lroundl
2046 #undef nan
2047 #undef nanf
2048 #undef nanl
2049 #undef nearbyint
2050 #undef nearbyintf
2051 #undef nearbyintl
2052 #undef nextafter
2053 #undef nextafterf
2054 #undef nextafterl
2055 #undef nexttoward
2056 #undef nexttowardf
2057 #undef nexttowardl
2058 #undef remainder
2059 #undef remainderf
2060 #undef remainderl
2061 #undef remquo
2062 #undef remquof
2063 #undef remquol
2064 #undef rint
2065 #undef rintf
2066 #undef rintl
2067 #undef round
2068 #undef roundf
2069 #undef roundl
2070 #undef scalbln
2071 #undef scalblnf
2072 #undef scalblnl
2073 #undef scalbn
2074 #undef scalbnf
2075 #undef scalbnl
2076 #undef tgamma
2077 #undef tgammaf
2078 #undef tgammal
2079 #undef trunc
2080 #undef truncf
2081 #undef truncl
2082
2083 #ifdef _GLIBCXX_HAVE_C99_FLT_EVAL_TYPES
2084   // types
2085   using ::double_t;
2086   using ::float_t;
2087 #endif
2088
2089   // functions
2090   using ::acosh;
2091   using ::acoshf;
2092   using ::acoshl;
2093
2094   using ::asinh;
2095   using ::asinhf;
2096   using ::asinhl;
2097
2098   using ::atanh;
2099   using ::atanhf;
2100   using ::atanhl;
2101
2102   using ::cbrt;
2103   using ::cbrtf;
2104   using ::cbrtl;
2105
2106   using ::copysign;
2107   using ::copysignf;
2108   using ::copysignl;
2109
2110   using ::erf;
2111   using ::erff;
2112   using ::erfl;
2113
2114   using ::erfc;
2115   using ::erfcf;
2116   using ::erfcl;
2117
2118   using ::exp2;
2119   using ::exp2f;
2120   using ::exp2l;
2121
2122   using ::expm1;
2123   using ::expm1f;
2124   using ::expm1l;
2125
2126   using ::fdim;
2127   using ::fdimf;
2128   using ::fdiml;
2129
2130   using ::fma;
2131   using ::fmaf;
2132   using ::fmal;
2133
2134   using ::fmax;
2135   using ::fmaxf;
2136   using ::fmaxl;
2137
2138   using ::fmin;
2139   using ::fminf;
2140   using ::fminl;
2141
2142   using ::hypot;
2143   using ::hypotf;
2144   using ::hypotl;
2145
2146   using ::ilogb;
2147   using ::ilogbf;
2148   using ::ilogbl;
2149
2150   using ::lgamma;
2151   using ::lgammaf;
2152   using ::lgammal;
2153
2154 #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
2155   using ::llrint;
2156   using ::llrintf;
2157   using ::llrintl;
2158
2159   using ::llround;
2160   using ::llroundf;
2161   using ::llroundl;
2162 #endif
2163
2164   using ::log1p;
2165   using ::log1pf;
2166   using ::log1pl;
2167
2168   using ::log2;
2169   using ::log2f;
2170   using ::log2l;
2171
2172   using ::logb;
2173   using ::logbf;
2174   using ::logbl;
2175
2176   using ::lrint;
2177   using ::lrintf;
2178   using ::lrintl;
2179
2180   using ::lround;
2181   using ::lroundf;
2182   using ::lroundl;
2183
2184   using ::nan;
2185   using ::nanf;
2186   using ::nanl;
2187
2188   using ::nearbyint;
2189   using ::nearbyintf;
2190   using ::nearbyintl;
2191
2192   using ::nextafter;
2193   using ::nextafterf;
2194   using ::nextafterl;
2195
2196   using ::nexttoward;
2197   using ::nexttowardf;
2198   using ::nexttowardl;
2199
2200   using ::remainder;
2201   using ::remainderf;
2202   using ::remainderl;
2203
2204   using ::remquo;
2205   using ::remquof;
2206   using ::remquol;
2207
2208   using ::rint;
2209   using ::rintf;
2210   using ::rintl;
2211
2212   using ::round;
2213   using ::roundf;
2214   using ::roundl;
2215
2216   using ::scalbln;
2217   using ::scalblnf;
2218   using ::scalblnl;
2219
2220   using ::scalbn;
2221   using ::scalbnf;
2222   using ::scalbnl;
2223
2224   using ::tgamma;
2225   using ::tgammaf;
2226   using ::tgammal;
2227
2228   using ::trunc;
2229   using ::truncf;
2230   using ::truncl;
2231
2232   /// Additional overloads.
2233 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2234   constexpr float
2235   acosh(float __x)
2236   { return __builtin_acoshf(__x); }
2237
2238   constexpr long double
2239   acosh(long double __x)
2240   { return __builtin_acoshl(__x); }
2241 #endif
2242
2243 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2244   template<typename _Tp>
2245     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2246                                               double>::__type
2247     acosh(_Tp __x)
2248     { return __builtin_acosh(__x); }
2249 #endif
2250
2251 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2252   constexpr float
2253   asinh(float __x)
2254   { return __builtin_asinhf(__x); }
2255
2256   constexpr long double
2257   asinh(long double __x)
2258   { return __builtin_asinhl(__x); }
2259 #endif
2260
2261 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2262   template<typename _Tp>
2263     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2264                                               double>::__type
2265     asinh(_Tp __x)
2266     { return __builtin_asinh(__x); }
2267 #endif
2268
2269 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2270   constexpr float
2271   atanh(float __x)
2272   { return __builtin_atanhf(__x); }
2273
2274   constexpr long double
2275   atanh(long double __x)
2276   { return __builtin_atanhl(__x); }
2277 #endif
2278
2279 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2280   template<typename _Tp>
2281     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2282                                               double>::__type
2283     atanh(_Tp __x)
2284     { return __builtin_atanh(__x); }
2285 #endif
2286
2287 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2288   constexpr float
2289   cbrt(float __x)
2290   { return __builtin_cbrtf(__x); }
2291
2292   constexpr long double
2293   cbrt(long double __x)
2294   { return __builtin_cbrtl(__x); }
2295 #endif
2296
2297 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2298   template<typename _Tp>
2299     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2300                                               double>::__type
2301     cbrt(_Tp __x)
2302     { return __builtin_cbrt(__x); }
2303 #endif
2304
2305 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2306   constexpr float
2307   copysign(float __x, float __y)
2308   { return __builtin_copysignf(__x, __y); }
2309
2310   constexpr long double
2311   copysign(long double __x, long double __y)
2312   { return __builtin_copysignl(__x, __y); }
2313 #endif
2314
2315 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2316   constexpr float
2317   erf(float __x)
2318   { return __builtin_erff(__x); }
2319
2320   constexpr long double
2321   erf(long double __x)
2322   { return __builtin_erfl(__x); }
2323 #endif
2324
2325 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2326   template<typename _Tp>
2327     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2328                                               double>::__type
2329     erf(_Tp __x)
2330     { return __builtin_erf(__x); }
2331 #endif
2332
2333 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2334   constexpr float
2335   erfc(float __x)
2336   { return __builtin_erfcf(__x); }
2337
2338   constexpr long double
2339   erfc(long double __x)
2340   { return __builtin_erfcl(__x); }
2341 #endif
2342
2343 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2344   template<typename _Tp>
2345     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2346                                               double>::__type
2347     erfc(_Tp __x)
2348     { return __builtin_erfc(__x); }
2349 #endif
2350
2351 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2352   constexpr float
2353   exp2(float __x)
2354   { return __builtin_exp2f(__x); }
2355
2356   constexpr long double
2357   exp2(long double __x)
2358   { return __builtin_exp2l(__x); }
2359 #endif
2360
2361 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2362   template<typename _Tp>
2363     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2364                                               double>::__type
2365     exp2(_Tp __x)
2366     { return __builtin_exp2(__x); }
2367 #endif
2368
2369 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2370   constexpr float
2371   expm1(float __x)
2372   { return __builtin_expm1f(__x); }
2373
2374   constexpr long double
2375   expm1(long double __x)
2376   { return __builtin_expm1l(__x); }
2377 #endif
2378
2379 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2380   template<typename _Tp>
2381     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2382                                               double>::__type
2383     expm1(_Tp __x)
2384     { return __builtin_expm1(__x); }
2385 #endif
2386
2387 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2388   constexpr float
2389   fdim(float __x, float __y)
2390   { return __builtin_fdimf(__x, __y); }
2391
2392   constexpr long double
2393   fdim(long double __x, long double __y)
2394   { return __builtin_fdiml(__x, __y); }
2395 #endif
2396
2397 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2398   constexpr float
2399   fma(float __x, float __y, float __z)
2400   { return __builtin_fmaf(__x, __y, __z); }
2401
2402   constexpr long double
2403   fma(long double __x, long double __y, long double __z)
2404   { return __builtin_fmal(__x, __y, __z); }
2405 #endif
2406
2407 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2408   constexpr float
2409   fmax(float __x, float __y)
2410   { return __builtin_fmaxf(__x, __y); }
2411
2412   constexpr long double
2413   fmax(long double __x, long double __y)
2414   { return __builtin_fmaxl(__x, __y); }
2415 #endif
2416
2417 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2418   constexpr float
2419   fmin(float __x, float __y)
2420   { return __builtin_fminf(__x, __y); }
2421
2422   constexpr long double
2423   fmin(long double __x, long double __y)
2424   { return __builtin_fminl(__x, __y); }
2425 #endif
2426
2427 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2428   constexpr float
2429   hypot(float __x, float __y)
2430   { return __builtin_hypotf(__x, __y); }
2431
2432   constexpr long double
2433   hypot(long double __x, long double __y)
2434   { return __builtin_hypotl(__x, __y); }
2435 #endif
2436
2437 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2438   constexpr int
2439   ilogb(float __x)
2440   { return __builtin_ilogbf(__x); }
2441
2442   constexpr int
2443   ilogb(long double __x)
2444   { return __builtin_ilogbl(__x); }
2445 #endif
2446
2447 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2448   template<typename _Tp>
2449     constexpr
2450     typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2451                                     int>::__type
2452     ilogb(_Tp __x)
2453     { return __builtin_ilogb(__x); }
2454 #endif
2455
2456 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2457   constexpr float
2458   lgamma(float __x)
2459   { return __builtin_lgammaf(__x); }
2460
2461   constexpr long double
2462   lgamma(long double __x)
2463   { return __builtin_lgammal(__x); }
2464 #endif
2465
2466 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2467   template<typename _Tp>
2468     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2469                                               double>::__type
2470     lgamma(_Tp __x)
2471     { return __builtin_lgamma(__x); }
2472 #endif
2473
2474 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2475   constexpr long long
2476   llrint(float __x)
2477   { return __builtin_llrintf(__x); }
2478
2479   constexpr long long
2480   llrint(long double __x)
2481   { return __builtin_llrintl(__x); }
2482 #endif
2483
2484 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2485   template<typename _Tp>
2486     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2487                                               long long>::__type
2488     llrint(_Tp __x)
2489     { return __builtin_llrint(__x); }
2490 #endif
2491
2492 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2493   constexpr long long
2494   llround(float __x)
2495   { return __builtin_llroundf(__x); }
2496
2497   constexpr long long
2498   llround(long double __x)
2499   { return __builtin_llroundl(__x); }
2500 #endif
2501
2502 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2503   template<typename _Tp>
2504     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2505                                               long long>::__type
2506     llround(_Tp __x)
2507     { return __builtin_llround(__x); }
2508 #endif
2509
2510 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2511   constexpr float
2512   log1p(float __x)
2513   { return __builtin_log1pf(__x); }
2514
2515   constexpr long double
2516   log1p(long double __x)
2517   { return __builtin_log1pl(__x); }
2518 #endif
2519
2520 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2521   template<typename _Tp>
2522     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2523                                               double>::__type
2524     log1p(_Tp __x)
2525     { return __builtin_log1p(__x); }
2526 #endif
2527
2528 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2529   // DR 568.
2530   constexpr float
2531   log2(float __x)
2532   { return __builtin_log2f(__x); }
2533
2534   constexpr long double
2535   log2(long double __x)
2536   { return __builtin_log2l(__x); }
2537 #endif
2538
2539 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2540   template<typename _Tp>
2541     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2542                                               double>::__type
2543     log2(_Tp __x)
2544     { return __builtin_log2(__x); }
2545 #endif
2546
2547 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2548   constexpr float
2549   logb(float __x)
2550   { return __builtin_logbf(__x); }
2551
2552   constexpr long double
2553   logb(long double __x)
2554   { return __builtin_logbl(__x); }
2555 #endif
2556
2557 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2558   template<typename _Tp>
2559     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2560                                               double>::__type
2561     logb(_Tp __x)
2562     { return __builtin_logb(__x); }
2563 #endif
2564
2565 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2566   constexpr long
2567   lrint(float __x)
2568   { return __builtin_lrintf(__x); }
2569
2570   constexpr long
2571   lrint(long double __x)
2572   { return __builtin_lrintl(__x); }
2573 #endif
2574
2575 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2576   template<typename _Tp>
2577     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2578                                               long>::__type
2579     lrint(_Tp __x)
2580     { return __builtin_lrint(__x); }
2581 #endif
2582
2583 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2584   constexpr long
2585   lround(float __x)
2586   { return __builtin_lroundf(__x); }
2587
2588   constexpr long
2589   lround(long double __x)
2590   { return __builtin_lroundl(__x); }
2591 #endif
2592
2593 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2594   template<typename _Tp>
2595     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2596                                               long>::__type
2597     lround(_Tp __x)
2598     { return __builtin_lround(__x); }
2599 #endif
2600
2601 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2602   constexpr float
2603   nearbyint(float __x)
2604   { return __builtin_nearbyintf(__x); }
2605
2606   constexpr long double
2607   nearbyint(long double __x)
2608   { return __builtin_nearbyintl(__x); }
2609 #endif
2610
2611 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2612   template<typename _Tp>
2613     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2614                                               double>::__type
2615     nearbyint(_Tp __x)
2616     { return __builtin_nearbyint(__x); }
2617 #endif
2618
2619 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2620   constexpr float
2621   nextafter(float __x, float __y)
2622   { return __builtin_nextafterf(__x, __y); }
2623
2624   constexpr long double
2625   nextafter(long double __x, long double __y)
2626   { return __builtin_nextafterl(__x, __y); }
2627 #endif
2628
2629 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2630   constexpr float
2631   nexttoward(float __x, long double __y)
2632   { return __builtin_nexttowardf(__x, __y); }
2633
2634   constexpr long double
2635   nexttoward(long double __x, long double __y)
2636   { return __builtin_nexttowardl(__x, __y); }
2637 #endif
2638
2639 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2640   template<typename _Tp>
2641     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2642                                               double>::__type
2643     nexttoward(_Tp __x, long double __y)
2644     { return __builtin_nexttoward(__x, __y); }
2645 #endif
2646
2647 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2648   constexpr float
2649   remainder(float __x, float __y)
2650   { return __builtin_remainderf(__x, __y); }
2651
2652   constexpr long double
2653   remainder(long double __x, long double __y)
2654   { return __builtin_remainderl(__x, __y); }
2655 #endif
2656
2657 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2658   inline float
2659   remquo(float __x, float __y, int* __pquo)
2660   { return __builtin_remquof(__x, __y, __pquo); }
2661
2662   inline long double
2663   remquo(long double __x, long double __y, int* __pquo)
2664   { return __builtin_remquol(__x, __y, __pquo); }
2665 #endif
2666
2667 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2668   constexpr float
2669   rint(float __x)
2670   { return __builtin_rintf(__x); }
2671
2672   constexpr long double
2673   rint(long double __x)
2674   { return __builtin_rintl(__x); }
2675 #endif
2676
2677 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2678   template<typename _Tp>
2679     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2680                                               double>::__type
2681     rint(_Tp __x)
2682     { return __builtin_rint(__x); }
2683 #endif
2684
2685 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2686   constexpr float
2687   round(float __x)
2688   { return __builtin_roundf(__x); }
2689
2690   constexpr long double
2691   round(long double __x)
2692   { return __builtin_roundl(__x); }
2693 #endif
2694
2695 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2696   template<typename _Tp>
2697     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2698                                               double>::__type
2699     round(_Tp __x)
2700     { return __builtin_round(__x); }
2701 #endif
2702
2703 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2704   constexpr float
2705   scalbln(float __x, long __ex)
2706   { return __builtin_scalblnf(__x, __ex); }
2707
2708   constexpr long double
2709   scalbln(long double __x, long __ex)
2710   { return __builtin_scalblnl(__x, __ex); }
2711 #endif
2712
2713 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2714   template<typename _Tp>
2715     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2716                                               double>::__type
2717     scalbln(_Tp __x, long __ex)
2718     { return __builtin_scalbln(__x, __ex); }
2719 #endif
2720
2721 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2722   constexpr float
2723   scalbn(float __x, int __ex)
2724   { return __builtin_scalbnf(__x, __ex); }
2725
2726   constexpr long double
2727   scalbn(long double __x, int __ex)
2728   { return __builtin_scalbnl(__x, __ex); }
2729 #endif
2730
2731 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2732   template<typename _Tp>
2733     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2734                                               double>::__type
2735     scalbn(_Tp __x, int __ex)
2736     { return __builtin_scalbn(__x, __ex); }
2737 #endif
2738
2739 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2740   constexpr float
2741   tgamma(float __x)
2742   { return __builtin_tgammaf(__x); }
2743
2744   constexpr long double
2745   tgamma(long double __x)
2746   { return __builtin_tgammal(__x); }
2747 #endif
2748
2749 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2750   template<typename _Tp>
2751     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2752                                               double>::__type
2753     tgamma(_Tp __x)
2754     { return __builtin_tgamma(__x); }
2755 #endif
2756
2757 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2758   constexpr float
2759   trunc(float __x)
2760   { return __builtin_truncf(__x); }
2761
2762   constexpr long double
2763   trunc(long double __x)
2764   { return __builtin_truncl(__x); }
2765 #endif
2766
2767 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2768   template<typename _Tp>
2769     constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2770                                               double>::__type
2771     trunc(_Tp __x)
2772     { return __builtin_trunc(__x); }
2773 #endif
2774
2775 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2776   constexpr _Float16
2777   acosh(_Float16 __x)
2778   { return _Float16(__builtin_acoshf(__x)); }
2779
2780   constexpr _Float16
2781   asinh(_Float16 __x)
2782   { return _Float16(__builtin_asinhf(__x)); }
2783
2784   constexpr _Float16
2785   atanh(_Float16 __x)
2786   { return _Float16(__builtin_atanhf(__x)); }
2787
2788   constexpr _Float16
2789   cbrt(_Float16 __x)
2790   { return _Float16(__builtin_cbrtf(__x)); }
2791
2792   constexpr _Float16
2793   copysign(_Float16 __x, _Float16 __y)
2794   { return __builtin_copysignf16(__x, __y); }
2795
2796   constexpr _Float16
2797   erf(_Float16 __x)
2798   { return _Float16(__builtin_erff(__x)); }
2799
2800   constexpr _Float16
2801   erfc(_Float16 __x)
2802   { return _Float16(__builtin_erfcf(__x)); }
2803
2804   constexpr _Float16
2805   exp2(_Float16 __x)
2806   { return _Float16(__builtin_exp2f(__x)); }
2807
2808   constexpr _Float16
2809   expm1(_Float16 __x)
2810   { return _Float16(__builtin_expm1f(__x)); }
2811
2812   constexpr _Float16
2813   fdim(_Float16 __x, _Float16 __y)
2814   { return _Float16(__builtin_fdimf(__x, __y)); }
2815
2816   constexpr _Float16
2817   fma(_Float16 __x, _Float16 __y, _Float16 __z)
2818   { return _Float16(__builtin_fmaf(__x, __y, __z)); }
2819
2820   constexpr _Float16
2821   fmax(_Float16 __x, _Float16 __y)
2822   { return _Float16(__builtin_fmaxf(__x, __y)); }
2823
2824   constexpr _Float16
2825   fmin(_Float16 __x, _Float16 __y)
2826   { return _Float16(__builtin_fminf(__x, __y)); }
2827
2828   constexpr _Float16
2829   hypot(_Float16 __x, _Float16 __y)
2830   { return _Float16(__builtin_hypotf(__x, __y)); }
2831
2832   constexpr int
2833   ilogb(_Float16 __x)
2834   { return _Float16(__builtin_ilogbf(__x)); }
2835
2836   constexpr _Float16
2837   lgamma(_Float16 __x)
2838   { return _Float16(__builtin_lgammaf(__x)); }
2839
2840   constexpr long long
2841   llrint(_Float16 __x)
2842   { return _Float16(__builtin_llrintf(__x)); }
2843
2844   constexpr long long
2845   llround(_Float16 __x)
2846   { return _Float16(__builtin_llroundf(__x)); }
2847
2848   constexpr _Float16
2849   log1p(_Float16 __x)
2850   { return _Float16(__builtin_log1pf(__x)); }
2851
2852   // DR 568.
2853   constexpr _Float16
2854   log2(_Float16 __x)
2855   { return _Float16(__builtin_log2f(__x)); }
2856
2857   constexpr _Float16
2858   logb(_Float16 __x)
2859   { return _Float16(__builtin_logbf(__x)); }
2860
2861   constexpr long
2862   lrint(_Float16 __x)
2863   { return _Float16(__builtin_lrintf(__x)); }
2864
2865   constexpr long
2866   lround(_Float16 __x)
2867   { return _Float16(__builtin_lroundf(__x)); }
2868
2869   constexpr _Float16
2870   nearbyint(_Float16 __x)
2871   { return _Float16(__builtin_nearbyintf(__x)); }
2872
2873   constexpr _Float16
2874   nextafter(_Float16 __x, _Float16 __y)
2875   {
2876     if (std::__is_constant_evaluated())
2877       return __builtin_nextafterf16(__x, __y);
2878 #ifdef __INT16_TYPE__
2879     using __float16_int_type = __INT16_TYPE__;
2880 #else
2881     using __float16_int_type = short int;
2882 #endif
2883     __float16_int_type __hx, __hy, __ix, __iy;
2884     __builtin_memcpy(&__hx, &__x, sizeof(__x));
2885     __builtin_memcpy(&__hy, &__y, sizeof(__x));
2886     __ix = __hx & 0x7fff;       // |x|
2887     __iy = __hy & 0x7fff;       // |y|
2888     if (__ix > 0x7c00 || __iy > 0x7c00) // x or y is NaN
2889       return __x + __y;
2890     if (__x == __y)
2891       return __y;               // x == y, return y
2892     if (__ix == 0)              // x == 0
2893       {
2894         __hy = (__hy & 0x8000) | 1;     // return +-__FLT16_DENORM_MIN__
2895         __builtin_memcpy(&__x, &__hy, sizeof(__x));
2896         __builtin_nextafterf(0.0f, 1.0f);       // raise underflow
2897         return __x;
2898       }
2899     if (__hx >= 0)              // x > 0
2900       {
2901         if (__hx > __hy)        // x > y, x -= ulp
2902           --__hx;
2903         else                    // x < y, x += ulp
2904           ++__hx;
2905       }
2906     else                        // x < 0
2907       {
2908         if (__hy >= 0 || __hx > __hy)   // x < y, x -= ulp
2909           --__hx;
2910         else                    // x > y, x += ulp
2911           ++__hx;
2912       }
2913     __hy = __hx & 0x7c00;
2914     if (__hy >= 0x7c00)
2915       __builtin_nextafterf(__FLT_MAX__, __builtin_inff());      // overflow
2916     else if (__hy < 0x0400)
2917       __builtin_nextafterf(__FLT_MIN__, 0.0f);  // underflow
2918     __builtin_memcpy(&__x, &__hx, sizeof(__x));
2919     return __x;
2920   }
2921
2922   constexpr _Float16
2923   remainder(_Float16 __x, _Float16 __y)
2924   { return _Float16(__builtin_remainderf(__x, __y)); }
2925
2926   inline _Float16
2927   remquo(_Float16 __x, _Float16 __y, int* __pquo)
2928   { return _Float16(__builtin_remquof(__x, __y, __pquo)); }
2929
2930   constexpr _Float16
2931   rint(_Float16 __x)
2932   { return _Float16(__builtin_rintf(__x)); }
2933
2934   constexpr _Float16
2935   round(_Float16 __x)
2936   { return _Float16(__builtin_roundf(__x)); }
2937
2938   constexpr _Float16
2939   scalbln(_Float16 __x, long __ex)
2940   { return _Float16(__builtin_scalblnf(__x, __ex)); }
2941
2942   constexpr _Float16
2943   scalbn(_Float16 __x, int __ex)
2944   { return _Float16(__builtin_scalbnf(__x, __ex)); }
2945
2946   constexpr _Float16
2947   tgamma(_Float16 __x)
2948   { return _Float16(__builtin_tgammaf(__x)); }
2949
2950   constexpr _Float16
2951   trunc(_Float16 __x)
2952   { return _Float16(__builtin_truncf(__x)); }
2953 #endif
2954
2955 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2956   constexpr _Float32
2957   acosh(_Float32 __x)
2958   { return __builtin_acoshf(__x); }
2959
2960   constexpr _Float32
2961   asinh(_Float32 __x)
2962   { return __builtin_asinhf(__x); }
2963
2964   constexpr _Float32
2965   atanh(_Float32 __x)
2966   { return __builtin_atanhf(__x); }
2967
2968   constexpr _Float32
2969   cbrt(_Float32 __x)
2970   { return __builtin_cbrtf(__x); }
2971
2972   constexpr _Float32
2973   copysign(_Float32 __x, _Float32 __y)
2974   { return __builtin_copysignf(__x, __y); }
2975
2976   constexpr _Float32
2977   erf(_Float32 __x)
2978   { return __builtin_erff(__x); }
2979
2980   constexpr _Float32
2981   erfc(_Float32 __x)
2982   { return __builtin_erfcf(__x); }
2983
2984   constexpr _Float32
2985   exp2(_Float32 __x)
2986   { return __builtin_exp2f(__x); }
2987
2988   constexpr _Float32
2989   expm1(_Float32 __x)
2990   { return __builtin_expm1f(__x); }
2991
2992   constexpr _Float32
2993   fdim(_Float32 __x, _Float32 __y)
2994   { return __builtin_fdimf(__x, __y); }
2995
2996   constexpr _Float32
2997   fma(_Float32 __x, _Float32 __y, _Float32 __z)
2998   { return __builtin_fmaf(__x, __y, __z); }
2999
3000   constexpr _Float32
3001   fmax(_Float32 __x, _Float32 __y)
3002   { return __builtin_fmaxf(__x, __y); }
3003
3004   constexpr _Float32
3005   fmin(_Float32 __x, _Float32 __y)
3006   { return __builtin_fminf(__x, __y); }
3007
3008   constexpr _Float32
3009   hypot(_Float32 __x, _Float32 __y)
3010   { return __builtin_hypotf(__x, __y); }
3011
3012   constexpr int
3013   ilogb(_Float32 __x)
3014   { return __builtin_ilogbf(__x); }
3015
3016   constexpr _Float32
3017   lgamma(_Float32 __x)
3018   { return __builtin_lgammaf(__x); }
3019
3020   constexpr long long
3021   llrint(_Float32 __x)
3022   { return __builtin_llrintf(__x); }
3023
3024   constexpr long long
3025   llround(_Float32 __x)
3026   { return __builtin_llroundf(__x); }
3027
3028   constexpr _Float32
3029   log1p(_Float32 __x)
3030   { return __builtin_log1pf(__x); }
3031
3032   // DR 568.
3033   constexpr _Float32
3034   log2(_Float32 __x)
3035   { return __builtin_log2f(__x); }
3036
3037   constexpr _Float32
3038   logb(_Float32 __x)
3039   { return __builtin_logbf(__x); }
3040
3041   constexpr long
3042   lrint(_Float32 __x)
3043   { return __builtin_lrintf(__x); }
3044
3045   constexpr long
3046   lround(_Float32 __x)
3047   { return __builtin_lroundf(__x); }
3048
3049   constexpr _Float32
3050   nearbyint(_Float32 __x)
3051   { return __builtin_nearbyintf(__x); }
3052
3053   constexpr _Float32
3054   nextafter(_Float32 __x, _Float32 __y)
3055   { return __builtin_nextafterf(__x, __y); }
3056
3057   constexpr _Float32
3058   remainder(_Float32 __x, _Float32 __y)
3059   { return __builtin_remainderf(__x, __y); }
3060
3061   inline _Float32
3062   remquo(_Float32 __x, _Float32 __y, int* __pquo)
3063   { return __builtin_remquof(__x, __y, __pquo); }
3064
3065   constexpr _Float32
3066   rint(_Float32 __x)
3067   { return __builtin_rintf(__x); }
3068
3069   constexpr _Float32
3070   round(_Float32 __x)
3071   { return __builtin_roundf(__x); }
3072
3073   constexpr _Float32
3074   scalbln(_Float32 __x, long __ex)
3075   { return __builtin_scalblnf(__x, __ex); }
3076
3077   constexpr _Float32
3078   scalbn(_Float32 __x, int __ex)
3079   { return __builtin_scalbnf(__x, __ex); }
3080
3081   constexpr _Float32
3082   tgamma(_Float32 __x)
3083   { return __builtin_tgammaf(__x); }
3084
3085   constexpr _Float32
3086   trunc(_Float32 __x)
3087   { return __builtin_truncf(__x); }
3088 #endif
3089
3090 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3091   constexpr _Float64
3092   acosh(_Float64 __x)
3093   { return __builtin_acosh(__x); }
3094
3095   constexpr _Float64
3096   asinh(_Float64 __x)
3097   { return __builtin_asinh(__x); }
3098
3099   constexpr _Float64
3100   atanh(_Float64 __x)
3101   { return __builtin_atanh(__x); }
3102
3103   constexpr _Float64
3104   cbrt(_Float64 __x)
3105   { return __builtin_cbrt(__x); }
3106
3107   constexpr _Float64
3108   copysign(_Float64 __x, _Float64 __y)
3109   { return __builtin_copysign(__x, __y); }
3110
3111   constexpr _Float64
3112   erf(_Float64 __x)
3113   { return __builtin_erf(__x); }
3114
3115   constexpr _Float64
3116   erfc(_Float64 __x)
3117   { return __builtin_erfc(__x); }
3118
3119   constexpr _Float64
3120   exp2(_Float64 __x)
3121   { return __builtin_exp2(__x); }
3122
3123   constexpr _Float64
3124   expm1(_Float64 __x)
3125   { return __builtin_expm1(__x); }
3126
3127   constexpr _Float64
3128   fdim(_Float64 __x, _Float64 __y)
3129   { return __builtin_fdim(__x, __y); }
3130
3131   constexpr _Float64
3132   fma(_Float64 __x, _Float64 __y, _Float64 __z)
3133   { return __builtin_fma(__x, __y, __z); }
3134
3135   constexpr _Float64
3136   fmax(_Float64 __x, _Float64 __y)
3137   { return __builtin_fmax(__x, __y); }
3138
3139   constexpr _Float64
3140   fmin(_Float64 __x, _Float64 __y)
3141   { return __builtin_fmin(__x, __y); }
3142
3143   constexpr _Float64
3144   hypot(_Float64 __x, _Float64 __y)
3145   { return __builtin_hypot(__x, __y); }
3146
3147   constexpr int
3148   ilogb(_Float64 __x)
3149   { return __builtin_ilogb(__x); }
3150
3151   constexpr _Float64
3152   lgamma(_Float64 __x)
3153   { return __builtin_lgamma(__x); }
3154
3155   constexpr long long
3156   llrint(_Float64 __x)
3157   { return __builtin_llrint(__x); }
3158
3159   constexpr long long
3160   llround(_Float64 __x)
3161   { return __builtin_llround(__x); }
3162
3163   constexpr _Float64
3164   log1p(_Float64 __x)
3165   { return __builtin_log1p(__x); }
3166
3167   // DR 568.
3168   constexpr _Float64
3169   log2(_Float64 __x)
3170   { return __builtin_log2(__x); }
3171
3172   constexpr _Float64
3173   logb(_Float64 __x)
3174   { return __builtin_logb(__x); }
3175
3176   constexpr long
3177   lrint(_Float64 __x)
3178   { return __builtin_lrint(__x); }
3179
3180   constexpr long
3181   lround(_Float64 __x)
3182   { return __builtin_lround(__x); }
3183
3184   constexpr _Float64
3185   nearbyint(_Float64 __x)
3186   { return __builtin_nearbyint(__x); }
3187
3188   constexpr _Float64
3189   nextafter(_Float64 __x, _Float64 __y)
3190   { return __builtin_nextafter(__x, __y); }
3191
3192   constexpr _Float64
3193   remainder(_Float64 __x, _Float64 __y)
3194   { return __builtin_remainder(__x, __y); }
3195
3196   inline _Float64
3197   remquo(_Float64 __x, _Float64 __y, int* __pquo)
3198   { return __builtin_remquo(__x, __y, __pquo); }
3199
3200   constexpr _Float64
3201   rint(_Float64 __x)
3202   { return __builtin_rint(__x); }
3203
3204   constexpr _Float64
3205   round(_Float64 __x)
3206   { return __builtin_round(__x); }
3207
3208   constexpr _Float64
3209   scalbln(_Float64 __x, long __ex)
3210   { return __builtin_scalbln(__x, __ex); }
3211
3212   constexpr _Float64
3213   scalbn(_Float64 __x, int __ex)
3214   { return __builtin_scalbn(__x, __ex); }
3215
3216   constexpr _Float64
3217   tgamma(_Float64 __x)
3218   { return __builtin_tgamma(__x); }
3219
3220   constexpr _Float64
3221   trunc(_Float64 __x)
3222   { return __builtin_trunc(__x); }
3223 #endif
3224
3225 #if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
3226   constexpr _Float128
3227   acosh(_Float128 __x)
3228   { return __builtin_acoshl(__x); }
3229
3230   constexpr _Float128
3231   asinh(_Float128 __x)
3232   { return __builtin_asinhl(__x); }
3233
3234   constexpr _Float128
3235   atanh(_Float128 __x)
3236   { return __builtin_atanhl(__x); }
3237
3238   constexpr _Float128
3239   cbrt(_Float128 __x)
3240   { return __builtin_cbrtl(__x); }
3241
3242   constexpr _Float128
3243   copysign(_Float128 __x, _Float128 __y)
3244   { return __builtin_copysignl(__x, __y); }
3245
3246   constexpr _Float128
3247   erf(_Float128 __x)
3248   { return __builtin_erfl(__x); }
3249
3250   constexpr _Float128
3251   erfc(_Float128 __x)
3252   { return __builtin_erfcl(__x); }
3253
3254   constexpr _Float128
3255   exp2(_Float128 __x)
3256   { return __builtin_exp2l(__x); }
3257
3258   constexpr _Float128
3259   expm1(_Float128 __x)
3260   { return __builtin_expm1l(__x); }
3261
3262   constexpr _Float128
3263   fdim(_Float128 __x, _Float128 __y)
3264   { return __builtin_fdiml(__x, __y); }
3265
3266   constexpr _Float128
3267   fma(_Float128 __x, _Float128 __y, _Float128 __z)
3268   { return __builtin_fmal(__x, __y, __z); }
3269
3270   constexpr _Float128
3271   fmax(_Float128 __x, _Float128 __y)
3272   { return __builtin_fmaxl(__x, __y); }
3273
3274   constexpr _Float128
3275   fmin(_Float128 __x, _Float128 __y)
3276   { return __builtin_fminl(__x, __y); }
3277
3278   constexpr _Float128
3279   hypot(_Float128 __x, _Float128 __y)
3280   { return __builtin_hypotl(__x, __y); }
3281
3282   constexpr int
3283   ilogb(_Float128 __x)
3284   { return __builtin_ilogbl(__x); }
3285
3286   constexpr _Float128
3287   lgamma(_Float128 __x)
3288   { return __builtin_lgammal(__x); }
3289
3290   constexpr long long
3291   llrint(_Float128 __x)
3292   { return __builtin_llrintl(__x); }
3293
3294   constexpr long long
3295   llround(_Float128 __x)
3296   { return __builtin_llroundl(__x); }
3297
3298   constexpr _Float128
3299   log1p(_Float128 __x)
3300   { return __builtin_log1pl(__x); }
3301
3302   // DR 568.
3303   constexpr _Float128
3304   log2(_Float128 __x)
3305   { return __builtin_log2l(__x); }
3306
3307   constexpr _Float128
3308   logb(_Float128 __x)
3309   { return __builtin_logbl(__x); }
3310
3311   constexpr long
3312   lrint(_Float128 __x)
3313   { return __builtin_lrintl(__x); }
3314
3315   constexpr long
3316   lround(_Float128 __x)
3317   { return __builtin_lroundl(__x); }
3318
3319   constexpr _Float128
3320   nearbyint(_Float128 __x)
3321   { return __builtin_nearbyintl(__x); }
3322
3323   constexpr _Float128
3324   nextafter(_Float128 __x, _Float128 __y)
3325   { return __builtin_nextafterl(__x, __y); }
3326
3327   constexpr _Float128
3328   remainder(_Float128 __x, _Float128 __y)
3329   { return __builtin_remainderl(__x, __y); }
3330
3331   inline _Float128
3332   remquo(_Float128 __x, _Float128 __y, int* __pquo)
3333   { return __builtin_remquol(__x, __y, __pquo); }
3334
3335   constexpr _Float128
3336   rint(_Float128 __x)
3337   { return __builtin_rintl(__x); }
3338
3339   constexpr _Float128
3340   round(_Float128 __x)
3341   { return __builtin_roundl(__x); }
3342
3343   constexpr _Float128
3344   scalbln(_Float128 __x, long __ex)
3345   { return __builtin_scalblnl(__x, __ex); }
3346
3347   constexpr _Float128
3348   scalbn(_Float128 __x, int __ex)
3349   { return __builtin_scalbnl(__x, __ex); }
3350
3351   constexpr _Float128
3352   tgamma(_Float128 __x)
3353   { return __builtin_tgammal(__x); }
3354
3355   constexpr _Float128
3356   trunc(_Float128 __x)
3357   { return __builtin_truncl(__x); }
3358 #elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
3359   constexpr _Float128
3360   acosh(_Float128 __x)
3361   { return __builtin_acoshf128(__x); }
3362
3363   constexpr _Float128
3364   asinh(_Float128 __x)
3365   { return __builtin_asinhf128(__x); }
3366
3367   constexpr _Float128
3368   atanh(_Float128 __x)
3369   { return __builtin_atanhf128(__x); }
3370
3371   constexpr _Float128
3372   cbrt(_Float128 __x)
3373   { return __builtin_cbrtf128(__x); }
3374
3375   constexpr _Float128
3376   copysign(_Float128 __x, _Float128 __y)
3377   { return __builtin_copysignf128(__x, __y); }
3378
3379   constexpr _Float128
3380   erf(_Float128 __x)
3381   { return __builtin_erff128(__x); }
3382
3383   constexpr _Float128
3384   erfc(_Float128 __x)
3385   { return __builtin_erfcf128(__x); }
3386
3387   constexpr _Float128
3388   exp2(_Float128 __x)
3389   { return __builtin_exp2f128(__x); }
3390
3391   constexpr _Float128
3392   expm1(_Float128 __x)
3393   { return __builtin_expm1f128(__x); }
3394
3395   constexpr _Float128
3396   fdim(_Float128 __x, _Float128 __y)
3397   { return __builtin_fdimf128(__x, __y); }
3398
3399   constexpr _Float128
3400   fma(_Float128 __x, _Float128 __y, _Float128 __z)
3401   { return __builtin_fmaf128(__x, __y, __z); }
3402
3403   constexpr _Float128
3404   fmax(_Float128 __x, _Float128 __y)
3405   { return __builtin_fmaxf128(__x, __y); }
3406
3407   constexpr _Float128
3408   fmin(_Float128 __x, _Float128 __y)
3409   { return __builtin_fminf128(__x, __y); }
3410
3411   constexpr _Float128
3412   hypot(_Float128 __x, _Float128 __y)
3413   { return __builtin_hypotf128(__x, __y); }
3414
3415   constexpr int
3416   ilogb(_Float128 __x)
3417   { return __builtin_ilogbf128(__x); }
3418
3419   constexpr _Float128
3420   lgamma(_Float128 __x)
3421   { return __builtin_lgammaf128(__x); }
3422
3423   constexpr long long
3424   llrint(_Float128 __x)
3425   { return __builtin_llrintf128(__x); }
3426
3427   constexpr long long
3428   llround(_Float128 __x)
3429   { return __builtin_llroundf128(__x); }
3430
3431   constexpr _Float128
3432   log1p(_Float128 __x)
3433   { return __builtin_log1pf128(__x); }
3434
3435   // DR 568.
3436   constexpr _Float128
3437   log2(_Float128 __x)
3438   { return __builtin_log2f128(__x); }
3439
3440   constexpr _Float128
3441   logb(_Float128 __x)
3442   { return __builtin_logbf128(__x); }
3443
3444   constexpr long
3445   lrint(_Float128 __x)
3446   { return __builtin_lrintf128(__x); }
3447
3448   constexpr long
3449   lround(_Float128 __x)
3450   { return __builtin_lroundf128(__x); }
3451
3452   constexpr _Float128
3453   nearbyint(_Float128 __x)
3454   { return __builtin_nearbyintf128(__x); }
3455
3456   constexpr _Float128
3457   nextafter(_Float128 __x, _Float128 __y)
3458   { return __builtin_nextafterf128(__x, __y); }
3459
3460   constexpr _Float128
3461   remainder(_Float128 __x, _Float128 __y)
3462   { return __builtin_remainderf128(__x, __y); }
3463
3464   inline _Float128
3465   remquo(_Float128 __x, _Float128 __y, int* __pquo)
3466   { return __builtin_remquof128(__x, __y, __pquo); }
3467
3468   constexpr _Float128
3469   rint(_Float128 __x)
3470   { return __builtin_rintf128(__x); }
3471
3472   constexpr _Float128
3473   round(_Float128 __x)
3474   { return __builtin_roundf128(__x); }
3475
3476   constexpr _Float128
3477   scalbln(_Float128 __x, long __ex)
3478   { return __builtin_scalblnf128(__x, __ex); }
3479
3480   constexpr _Float128
3481   scalbn(_Float128 __x, int __ex)
3482   { return __builtin_scalbnf128(__x, __ex); }
3483
3484   constexpr _Float128
3485   tgamma(_Float128 __x)
3486   { return __builtin_tgammaf128(__x); }
3487
3488   constexpr _Float128
3489   trunc(_Float128 __x)
3490   { return __builtin_truncf128(__x); }
3491 #endif
3492
3493 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3494   constexpr __gnu_cxx::__bfloat16_t
3495   acosh(__gnu_cxx::__bfloat16_t __x)
3496   { return __gnu_cxx::__bfloat16_t(__builtin_acoshf(__x)); }
3497
3498   constexpr __gnu_cxx::__bfloat16_t
3499   asinh(__gnu_cxx::__bfloat16_t __x)
3500   { return __gnu_cxx::__bfloat16_t(__builtin_asinhf(__x)); }
3501
3502   constexpr __gnu_cxx::__bfloat16_t
3503   atanh(__gnu_cxx::__bfloat16_t __x)
3504   { return __gnu_cxx::__bfloat16_t(__builtin_atanhf(__x)); }
3505
3506   constexpr __gnu_cxx::__bfloat16_t
3507   cbrt(__gnu_cxx::__bfloat16_t __x)
3508   { return __gnu_cxx::__bfloat16_t(__builtin_cbrtf(__x)); }
3509
3510   constexpr __gnu_cxx::__bfloat16_t
3511   copysign(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3512   { return __gnu_cxx::__bfloat16_t(__builtin_copysignf(__x, __y)); }
3513
3514   constexpr __gnu_cxx::__bfloat16_t
3515   erf(__gnu_cxx::__bfloat16_t __x)
3516   { return __gnu_cxx::__bfloat16_t(__builtin_erff(__x)); }
3517
3518   constexpr __gnu_cxx::__bfloat16_t
3519   erfc(__gnu_cxx::__bfloat16_t __x)
3520   { return __gnu_cxx::__bfloat16_t(__builtin_erfcf(__x)); }
3521
3522   constexpr __gnu_cxx::__bfloat16_t
3523   exp2(__gnu_cxx::__bfloat16_t __x)
3524   { return __gnu_cxx::__bfloat16_t(__builtin_exp2f(__x)); }
3525
3526   constexpr __gnu_cxx::__bfloat16_t
3527   expm1(__gnu_cxx::__bfloat16_t __x)
3528   { return __gnu_cxx::__bfloat16_t(__builtin_expm1f(__x)); }
3529
3530   constexpr __gnu_cxx::__bfloat16_t
3531   fdim(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3532   { return __gnu_cxx::__bfloat16_t(__builtin_fdimf(__x, __y)); }
3533
3534   constexpr __gnu_cxx::__bfloat16_t
3535   fma(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z)
3536   { return __gnu_cxx::__bfloat16_t(__builtin_fmaf(__x, __y, __z)); }
3537
3538   constexpr __gnu_cxx::__bfloat16_t
3539   fmax(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3540   { return __gnu_cxx::__bfloat16_t(__builtin_fmaxf(__x, __y)); }
3541
3542   constexpr __gnu_cxx::__bfloat16_t
3543   fmin(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3544   { return __gnu_cxx::__bfloat16_t(__builtin_fminf(__x, __y)); }
3545
3546   constexpr __gnu_cxx::__bfloat16_t
3547   hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3548   { return __gnu_cxx::__bfloat16_t(__builtin_hypotf(__x, __y)); }
3549
3550   constexpr int
3551   ilogb(__gnu_cxx::__bfloat16_t __x)
3552   { return __gnu_cxx::__bfloat16_t(__builtin_ilogbf(__x)); }
3553
3554   constexpr __gnu_cxx::__bfloat16_t
3555   lgamma(__gnu_cxx::__bfloat16_t __x)
3556   { return __gnu_cxx::__bfloat16_t(__builtin_lgammaf(__x)); }
3557
3558   constexpr long long
3559   llrint(__gnu_cxx::__bfloat16_t __x)
3560   { return __gnu_cxx::__bfloat16_t(__builtin_llrintf(__x)); }
3561
3562   constexpr long long
3563   llround(__gnu_cxx::__bfloat16_t __x)
3564   { return __gnu_cxx::__bfloat16_t(__builtin_llroundf(__x)); }
3565
3566   constexpr __gnu_cxx::__bfloat16_t
3567   log1p(__gnu_cxx::__bfloat16_t __x)
3568   { return __gnu_cxx::__bfloat16_t(__builtin_log1pf(__x)); }
3569
3570   // DR 568.
3571   constexpr __gnu_cxx::__bfloat16_t
3572   log2(__gnu_cxx::__bfloat16_t __x)
3573   { return __gnu_cxx::__bfloat16_t(__builtin_log2f(__x)); }
3574
3575   constexpr __gnu_cxx::__bfloat16_t
3576   logb(__gnu_cxx::__bfloat16_t __x)
3577   { return __gnu_cxx::__bfloat16_t(__builtin_logbf(__x)); }
3578
3579   constexpr long
3580   lrint(__gnu_cxx::__bfloat16_t __x)
3581   { return __gnu_cxx::__bfloat16_t(__builtin_lrintf(__x)); }
3582
3583   constexpr long
3584   lround(__gnu_cxx::__bfloat16_t __x)
3585   { return __gnu_cxx::__bfloat16_t(__builtin_lroundf(__x)); }
3586
3587   constexpr __gnu_cxx::__bfloat16_t
3588   nearbyint(__gnu_cxx::__bfloat16_t __x)
3589   { return __gnu_cxx::__bfloat16_t(__builtin_nearbyintf(__x)); }
3590
3591   constexpr __gnu_cxx::__bfloat16_t
3592   nextafter(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3593   {
3594     if (std::__is_constant_evaluated())
3595       return __builtin_nextafterf16b(__x, __y);
3596 #ifdef __INT16_TYPE__
3597     using __bfloat16_int_type = __INT16_TYPE__;
3598 #else
3599     using __bfloat16_int_type = short int;
3600 #endif
3601     __bfloat16_int_type __hx, __hy, __ix, __iy;
3602     __builtin_memcpy(&__hx, &__x, sizeof(__x));
3603     __builtin_memcpy(&__hy, &__y, sizeof(__x));
3604     __ix = __hx & 0x7fff;       // |x|
3605     __iy = __hy & 0x7fff;       // |y|
3606     if (__ix > 0x7f80 || __iy > 0x7f80) // x or y is NaN
3607       return __x + __y;
3608     if (__x == __y)
3609       return __y;               // x == y, return y
3610     if (__ix == 0)              // x == 0
3611       {
3612         __hy = (__hy & 0x8000) | 1;     // return +-__BFLT16_DENORM_MIN__
3613         __builtin_memcpy(&__x, &__hy, sizeof(__x));
3614         __builtin_nextafterf(0.0f, 1.0f);       // raise underflow
3615         return __x;
3616       }
3617     if (__hx >= 0)              // x > 0
3618       {
3619         if (__hx > __hy)        // x > y, x -= ulp
3620           --__hx;
3621         else                    // x < y, x += ulp
3622           ++__hx;
3623       }
3624     else                        // x < 0
3625       {
3626         if (__hy >= 0 || __hx > __hy)   // x < y, x -= ulp
3627           --__hx;
3628         else                    // x > y, x += ulp
3629           ++__hx;
3630       }
3631     __hy = __hx & 0x7f80;
3632     if (__hy >= 0x7f80)
3633       __builtin_nextafterf(__FLT_MAX__, __builtin_inff());      // overflow
3634     else if (__hy < 0x0080)
3635       __builtin_nextafterf(__FLT_MIN__, 0.0f);  // underflow
3636     __builtin_memcpy(&__x, &__hx, sizeof(__x));
3637     return __x;
3638   }
3639
3640   constexpr __gnu_cxx::__bfloat16_t
3641   remainder(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3642   { return __gnu_cxx::__bfloat16_t(__builtin_remainderf(__x, __y)); }
3643
3644   inline __gnu_cxx::__bfloat16_t
3645   remquo(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, int* __pquo)
3646   { return __gnu_cxx::__bfloat16_t(__builtin_remquof(__x, __y, __pquo)); }
3647
3648   constexpr __gnu_cxx::__bfloat16_t
3649   rint(__gnu_cxx::__bfloat16_t __x)
3650   { return __gnu_cxx::__bfloat16_t(__builtin_rintf(__x)); }
3651
3652   constexpr __gnu_cxx::__bfloat16_t
3653   round(__gnu_cxx::__bfloat16_t __x)
3654   { return __gnu_cxx::__bfloat16_t(__builtin_roundf(__x)); }
3655
3656   constexpr __gnu_cxx::__bfloat16_t
3657   scalbln(__gnu_cxx::__bfloat16_t __x, long __ex)
3658   { return __gnu_cxx::__bfloat16_t(__builtin_scalblnf(__x, __ex)); }
3659
3660   constexpr __gnu_cxx::__bfloat16_t
3661   scalbn(__gnu_cxx::__bfloat16_t __x, int __ex)
3662   { return __gnu_cxx::__bfloat16_t(__builtin_scalbnf(__x, __ex)); }
3663
3664   constexpr __gnu_cxx::__bfloat16_t
3665   tgamma(__gnu_cxx::__bfloat16_t __x)
3666   { return __gnu_cxx::__bfloat16_t(__builtin_tgammaf(__x)); }
3667
3668   constexpr __gnu_cxx::__bfloat16_t
3669   trunc(__gnu_cxx::__bfloat16_t __x)
3670   { return __gnu_cxx::__bfloat16_t(__builtin_truncf(__x)); }
3671 #endif
3672
3673 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
3674   template<typename _Tp, typename _Up>
3675     constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3676     copysign(_Tp __x, _Up __y)
3677     {
3678       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3679       return copysign(__type(__x), __type(__y));
3680     }
3681
3682   template<typename _Tp, typename _Up>
3683     constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3684     fdim(_Tp __x, _Up __y)
3685     {
3686       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3687       return fdim(__type(__x), __type(__y));
3688     }
3689
3690   template<typename _Tp, typename _Up>
3691     constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3692     fmax(_Tp __x, _Up __y)
3693     {
3694       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3695       return fmax(__type(__x), __type(__y));
3696     }
3697
3698   template<typename _Tp, typename _Up>
3699     constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3700     fmin(_Tp __x, _Up __y)
3701     {
3702       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3703       return fmin(__type(__x), __type(__y));
3704     }
3705
3706   template<typename _Tp, typename _Up>
3707     constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3708     hypot(_Tp __x, _Up __y)
3709     {
3710       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3711       return hypot(__type(__x), __type(__y));
3712     }
3713
3714   template<typename _Tp, typename _Up>
3715     constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3716     nextafter(_Tp __x, _Up __y)
3717     {
3718       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3719       return nextafter(__type(__x), __type(__y));
3720     }
3721
3722   template<typename _Tp, typename _Up>
3723     constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3724     remainder(_Tp __x, _Up __y)
3725     {
3726       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3727       return remainder(__type(__x), __type(__y));
3728     }
3729
3730   template<typename _Tp, typename _Up>
3731     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3732     remquo(_Tp __x, _Up __y, int* __pquo)
3733     {
3734       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3735       return remquo(__type(__x), __type(__y), __pquo);
3736     }
3737
3738   template<typename _Tp, typename _Up, typename _Vp>
3739     constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
3740     fma(_Tp __x, _Up __y, _Vp __z)
3741     {
3742       typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
3743       return fma(__type(__x), __type(__y), __type(__z));
3744     }
3745 #endif
3746
3747 #endif // _GLIBCXX_USE_C99_MATH_FUNCS
3748 #endif // C++11
3749
3750 #ifdef __cpp_lib_hypot // C++ >= 17 && HOSTED
3751   // [c.math.hypot3], three-dimensional hypotenuse
3752   template<typename _Tp>
3753     inline _Tp
3754     __hypot3(_Tp __x, _Tp __y, _Tp __z)
3755     {
3756       __x = std::abs(__x);
3757       __y = std::abs(__y);
3758       __z = std::abs(__z);
3759       if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
3760         return __a * std::sqrt((__x / __a) * (__x / __a)
3761                                + (__y / __a) * (__y / __a)
3762                                + (__z / __a) * (__z / __a));
3763       else
3764         return {};
3765     }
3766
3767   inline float
3768   hypot(float __x, float __y, float __z)
3769   { return std::__hypot3<float>(__x, __y, __z); }
3770
3771   inline double
3772   hypot(double __x, double __y, double __z)
3773   { return std::__hypot3<double>(__x, __y, __z); }
3774
3775   inline long double
3776   hypot(long double __x, long double __y, long double __z)
3777   { return std::__hypot3<long double>(__x, __y, __z); }
3778
3779   template<typename _Tp, typename _Up, typename _Vp>
3780     __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
3781     hypot(_Tp __x, _Up __y, _Vp __z)
3782     {
3783       using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
3784       return std::__hypot3<__type>(__x, __y, __z);
3785     }
3786
3787 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3788   inline _Float16
3789   hypot(_Float16 __x, _Float16 __y, _Float16 __z)
3790   { return std::__hypot3<_Float16>(__x, __y, __z); }
3791 #endif
3792
3793 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3794   inline _Float32
3795   hypot(_Float32 __x, _Float32 __y, _Float32 __z)
3796   { return std::__hypot3<_Float32>(__x, __y, __z); }
3797 #endif
3798
3799 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3800   inline _Float64
3801   hypot(_Float64 __x, _Float64 __y, _Float64 __z)
3802   { return std::__hypot3<_Float64>(__x, __y, __z); }
3803 #endif
3804
3805 #if defined(__STDCPP_FLOAT128_T__) \
3806     && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \
3807         || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
3808   inline _Float128
3809   hypot(_Float128 __x, _Float128 __y, _Float128 __z)
3810   { return std::__hypot3<_Float128>(__x, __y, __z); }
3811 #endif
3812
3813 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3814   inline __gnu_cxx::__bfloat16_t
3815   hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z)
3816   { return std::__hypot3<__gnu_cxx::__bfloat16_t>(__x, __y, __z); }
3817 #endif
3818
3819 #endif // __cpp_lib_hypot
3820
3821 #ifdef __cpp_lib_interpolate // C++ >= 20
3822   // linear interpolation
3823   template<typename _Fp>
3824     constexpr _Fp
3825     __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept
3826     {
3827       if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
3828         return __t * __b + (1 - __t) * __a;
3829
3830       if (__t == 1)
3831         return __b;                        // exact
3832
3833       // Exact at __t=0, monotonic except near __t=1,
3834       // bounded, determinate, and consistent:
3835       const _Fp __x = __a + __t * (__b - __a);
3836       return (__t > 1) == (__b > __a)
3837         ? (__b < __x ? __x : __b)
3838         : (__b > __x ? __x : __b);  // monotonic near __t=1
3839     }
3840
3841   constexpr float
3842   lerp(float __a, float __b, float __t) noexcept
3843   { return std::__lerp(__a, __b, __t); }
3844
3845   constexpr double
3846   lerp(double __a, double __b, double __t) noexcept
3847   { return std::__lerp(__a, __b, __t); }
3848
3849   constexpr long double
3850   lerp(long double __a, long double __b, long double __t) noexcept
3851   { return std::__lerp(__a, __b, __t); }
3852
3853   template<typename _Tp, typename _Up, typename _Vp>
3854     constexpr __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
3855     lerp(_Tp __x, _Up __y, _Vp __z) noexcept
3856     {
3857       using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
3858       return std::__lerp<__type>(__x, __y, __z);
3859     }
3860
3861 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3862   inline _Float16
3863   lerp(_Float16 __x, _Float16 __y, _Float16 __z) noexcept
3864   { return std::__lerp<_Float16>(__x, __y, __z); }
3865 #endif
3866
3867 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3868   inline _Float32
3869   lerp(_Float32 __x, _Float32 __y, _Float32 __z) noexcept
3870   { return std::__lerp<_Float32>(__x, __y, __z); }
3871 #endif
3872
3873 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3874   inline _Float64
3875   lerp(_Float64 __x, _Float64 __y, _Float64 __z) noexcept
3876   { return std::__lerp<_Float64>(__x, __y, __z); }
3877 #endif
3878
3879 #if defined(__STDCPP_FLOAT128_T__) \
3880     && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \
3881         || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
3882   inline _Float128
3883   lerp(_Float128 __x, _Float128 __y, _Float128 __z) noexcept
3884   { return std::__lerp<_Float128>(__x, __y, __z); }
3885 #endif
3886
3887 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3888   inline __gnu_cxx::__bfloat16_t
3889   lerp(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z) noexcept
3890   { return std::__lerp<__gnu_cxx::__bfloat16_t>(__x, __y, __z); }
3891 #endif
3892 #endif // __cpp_lib_interpolate
3893
3894 _GLIBCXX_END_NAMESPACE_VERSION
3895 } // namespace
3896
3897 #if _GLIBCXX_USE_STD_SPEC_FUNCS
3898 #  include <bits/specfun.h>
3899 #endif
3900
3901 } // extern "C++"
3902
3903 #endif