libstdc++-v3/include/c_global/cmath

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