-: 0:Source:/opt/homebrew/Cellar/gcc/12.2.0/include/c++/12/cmath
-: 0:Graph:/Users/chenyuehon/gitRepos/gtest_exercise/build/src/CMakeFiles/sphere.dir/sphere.cc.gcno
-: 0:Data:/Users/chenyuehon/gitRepos/gtest_exercise/build/src/CMakeFiles/sphere.dir/sphere.cc.gcda
-: 0:Runs:1
-: 1:// -*- C++ -*- C forwarding header.
-: 2:
-: 3:// Copyright (C) 1997-2022 Free Software Foundation, Inc.
-: 4://
-: 5:// This file is part of the GNU ISO C++ Library. This library is free
-: 6:// software; you can redistribute it and/or modify it under the
-: 7:// terms of the GNU General Public License as published by the
-: 8:// Free Software Foundation; either version 3, or (at your option)
-: 9:// any later version.
-: 10:
-: 11:// This library is distributed in the hope that it will be useful,
-: 12:// but WITHOUT ANY WARRANTY; without even the implied warranty of
-: 13:// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-: 14:// GNU General Public License for more details.
-: 15:
-: 16:// Under Section 7 of GPL version 3, you are granted additional
-: 17:// permissions described in the GCC Runtime Library Exception, version
-: 18:// 3.1, as published by the Free Software Foundation.
-: 19:
-: 20:// You should have received a copy of the GNU General Public License and
-: 21:// a copy of the GCC Runtime Library Exception along with this program;
-: 22:// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
-: 23:// .
-: 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
-: 42:#include
-: 43:#include
-: 44:#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
-: 45:#include_next
-: 46:#undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS
-: 47:#include
-: 48:
-: 49:#ifndef _GLIBCXX_CMATH
-: 50:#define _GLIBCXX_CMATH 1
-: 51:
-: 52:// Get rid of those macros defined in 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 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
-: 510: inline _GLIBCXX_CONSTEXPR
-: 511: typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 512: double>::__type
-: 513: tanh(_Tp __x)
-: 514: { return __builtin_tanh(__x); }
-: 515:
-: 516:#if _GLIBCXX_USE_C99_MATH
-: 517:#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
-: 518:
-: 519:// These are possible macros imported from C99-land.
-: 520:#undef fpclassify
-: 521:#undef isfinite
-: 522:#undef isinf
-: 523:#undef isnan
-: 524:#undef isnormal
-: 525:#undef signbit
-: 526:#undef isgreater
-: 527:#undef isgreaterequal
-: 528:#undef isless
-: 529:#undef islessequal
-: 530:#undef islessgreater
-: 531:#undef isunordered
-: 532:
-: 533:#if __cplusplus >= 201103L
-: 534:
-: 535:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 536: constexpr int
-: 537: fpclassify(float __x)
-: 538: { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
-: 539: FP_SUBNORMAL, FP_ZERO, __x); }
-: 540:
-: 541: constexpr int
-: 542: fpclassify(double __x)
-: 543: { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
-: 544: FP_SUBNORMAL, FP_ZERO, __x); }
-: 545:
-: 546: constexpr int
-: 547: fpclassify(long double __x)
-: 548: { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
-: 549: FP_SUBNORMAL, FP_ZERO, __x); }
-: 550:#endif
-: 551:
-: 552:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 553: template
-: 554: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 555: int>::__type
-: 556: fpclassify(_Tp __x)
-: 557: { return __x != 0 ? FP_NORMAL : FP_ZERO; }
-: 558:#endif
-: 559:
-: 560:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 561: constexpr bool
-: 562: isfinite(float __x)
-: 563: { return __builtin_isfinite(__x); }
-: 564:
-: 565: constexpr bool
-: 566: isfinite(double __x)
-: 567: { return __builtin_isfinite(__x); }
-: 568:
-: 569: constexpr bool
-: 570: isfinite(long double __x)
-: 571: { return __builtin_isfinite(__x); }
-: 572:#endif
-: 573:
-: 574:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 575: template
-: 576: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 577: bool>::__type
-: 578: isfinite(_Tp __x)
-: 579: { return true; }
-: 580:#endif
-: 581:
-: 582:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 583: constexpr bool
-: 584: isinf(float __x)
-: 585: { return __builtin_isinf(__x); }
-: 586:
-: 587:#if _GLIBCXX_HAVE_OBSOLETE_ISINF \
-: 588: && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
-: 589: using ::isinf;
-: 590:#else
-: 591: constexpr bool
-: 592: isinf(double __x)
-: 593: { return __builtin_isinf(__x); }
-: 594:#endif
-: 595:
-: 596: constexpr bool
-: 597: isinf(long double __x)
-: 598: { return __builtin_isinf(__x); }
-: 599:#endif
-: 600:
-: 601:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 602: template
-: 603: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 604: bool>::__type
-: 605: isinf(_Tp __x)
-: 606: { return false; }
-: 607:#endif
-: 608:
-: 609:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 610: constexpr bool
-: 611: isnan(float __x)
-: 612: { return __builtin_isnan(__x); }
-: 613:
-: 614:#if _GLIBCXX_HAVE_OBSOLETE_ISNAN \
-: 615: && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
-: 616: using ::isnan;
-: 617:#else
-: 618: constexpr bool
-: 619: isnan(double __x)
-: 620: { return __builtin_isnan(__x); }
-: 621:#endif
-: 622:
-: 623: constexpr bool
-: 624: isnan(long double __x)
-: 625: { return __builtin_isnan(__x); }
-: 626:#endif
-: 627:
-: 628:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 629: template
-: 630: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 631: bool>::__type
-: 632: isnan(_Tp __x)
-: 633: { return false; }
-: 634:#endif
-: 635:
-: 636:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 637: constexpr bool
-: 638: isnormal(float __x)
-: 639: { return __builtin_isnormal(__x); }
-: 640:
-: 641: constexpr bool
-: 642: isnormal(double __x)
-: 643: { return __builtin_isnormal(__x); }
-: 644:
-: 645: constexpr bool
-: 646: isnormal(long double __x)
-: 647: { return __builtin_isnormal(__x); }
-: 648:#endif
-: 649:
-: 650:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 651: template
-: 652: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 653: bool>::__type
-: 654: isnormal(_Tp __x)
-: 655: { return __x != 0 ? true : false; }
-: 656:#endif
-: 657:
-: 658:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 659: // Note: middle-end/36757 is fixed, __builtin_signbit is type-generic.
-: 660: constexpr bool
-: 661: signbit(float __x)
-: 662: { return __builtin_signbit(__x); }
-: 663:
-: 664: constexpr bool
-: 665: signbit(double __x)
-: 666: { return __builtin_signbit(__x); }
-: 667:
-: 668: constexpr bool
-: 669: signbit(long double __x)
-: 670: { return __builtin_signbit(__x); }
-: 671:#endif
-: 672:
-: 673:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 674: template
-: 675: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 676: bool>::__type
-: 677: signbit(_Tp __x)
-: 678: { return __x < 0 ? true : false; }
-: 679:#endif
-: 680:
-: 681:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 682: constexpr bool
-: 683: isgreater(float __x, float __y)
-: 684: { return __builtin_isgreater(__x, __y); }
-: 685:
-: 686: constexpr bool
-: 687: isgreater(double __x, double __y)
-: 688: { return __builtin_isgreater(__x, __y); }
-: 689:
-: 690: constexpr bool
-: 691: isgreater(long double __x, long double __y)
-: 692: { return __builtin_isgreater(__x, __y); }
-: 693:#endif
-: 694:
-: 695:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 696: template
-: 697: constexpr typename
-: 698: __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
-: 699: && __is_arithmetic<_Up>::__value), bool>::__type
-: 700: isgreater(_Tp __x, _Up __y)
-: 701: {
-: 702: typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-: 703: return __builtin_isgreater(__type(__x), __type(__y));
-: 704: }
-: 705:#endif
-: 706:
-: 707:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 708: constexpr bool
-: 709: isgreaterequal(float __x, float __y)
-: 710: { return __builtin_isgreaterequal(__x, __y); }
-: 711:
-: 712: constexpr bool
-: 713: isgreaterequal(double __x, double __y)
-: 714: { return __builtin_isgreaterequal(__x, __y); }
-: 715:
-: 716: constexpr bool
-: 717: isgreaterequal(long double __x, long double __y)
-: 718: { return __builtin_isgreaterequal(__x, __y); }
-: 719:#endif
-: 720:
-: 721:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 722: template
-: 723: constexpr typename
-: 724: __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
-: 725: && __is_arithmetic<_Up>::__value), bool>::__type
-: 726: isgreaterequal(_Tp __x, _Up __y)
-: 727: {
-: 728: typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-: 729: return __builtin_isgreaterequal(__type(__x), __type(__y));
-: 730: }
-: 731:#endif
-: 732:
-: 733:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 734: constexpr bool
-: 735: isless(float __x, float __y)
-: 736: { return __builtin_isless(__x, __y); }
-: 737:
-: 738: constexpr bool
-: 739: isless(double __x, double __y)
-: 740: { return __builtin_isless(__x, __y); }
-: 741:
-: 742: constexpr bool
-: 743: isless(long double __x, long double __y)
-: 744: { return __builtin_isless(__x, __y); }
-: 745:#endif
-: 746:
-: 747:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 748: template
-: 749: constexpr typename
-: 750: __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
-: 751: && __is_arithmetic<_Up>::__value), bool>::__type
-: 752: isless(_Tp __x, _Up __y)
-: 753: {
-: 754: typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-: 755: return __builtin_isless(__type(__x), __type(__y));
-: 756: }
-: 757:#endif
-: 758:
-: 759:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 760: constexpr bool
-: 761: islessequal(float __x, float __y)
-: 762: { return __builtin_islessequal(__x, __y); }
-: 763:
-: 764: constexpr bool
-: 765: islessequal(double __x, double __y)
-: 766: { return __builtin_islessequal(__x, __y); }
-: 767:
-: 768: constexpr bool
-: 769: islessequal(long double __x, long double __y)
-: 770: { return __builtin_islessequal(__x, __y); }
-: 771:#endif
-: 772:
-: 773:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 774: template
-: 775: constexpr typename
-: 776: __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
-: 777: && __is_arithmetic<_Up>::__value), bool>::__type
-: 778: islessequal(_Tp __x, _Up __y)
-: 779: {
-: 780: typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-: 781: return __builtin_islessequal(__type(__x), __type(__y));
-: 782: }
-: 783:#endif
-: 784:
-: 785:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 786: constexpr bool
-: 787: islessgreater(float __x, float __y)
-: 788: { return __builtin_islessgreater(__x, __y); }
-: 789:
-: 790: constexpr bool
-: 791: islessgreater(double __x, double __y)
-: 792: { return __builtin_islessgreater(__x, __y); }
-: 793:
-: 794: constexpr bool
-: 795: islessgreater(long double __x, long double __y)
-: 796: { return __builtin_islessgreater(__x, __y); }
-: 797:#endif
-: 798:
-: 799:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 800: template
-: 801: constexpr typename
-: 802: __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
-: 803: && __is_arithmetic<_Up>::__value), bool>::__type
-: 804: islessgreater(_Tp __x, _Up __y)
-: 805: {
-: 806: typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-: 807: return __builtin_islessgreater(__type(__x), __type(__y));
-: 808: }
-: 809:#endif
-: 810:
-: 811:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 812: constexpr bool
-: 813: isunordered(float __x, float __y)
-: 814: { return __builtin_isunordered(__x, __y); }
-: 815:
-: 816: constexpr bool
-: 817: isunordered(double __x, double __y)
-: 818: { return __builtin_isunordered(__x, __y); }
-: 819:
-: 820: constexpr bool
-: 821: isunordered(long double __x, long double __y)
-: 822: { return __builtin_isunordered(__x, __y); }
-: 823:#endif
-: 824:
-: 825:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 826: template
-: 827: constexpr typename
-: 828: __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
-: 829: && __is_arithmetic<_Up>::__value), bool>::__type
-: 830: isunordered(_Tp __x, _Up __y)
-: 831: {
-: 832: typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-: 833: return __builtin_isunordered(__type(__x), __type(__y));
-: 834: }
-: 835:#endif
-: 836:
-: 837:#else
-: 838:
-: 839: template
-: 840: inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-: 841: int>::__type
-: 842: fpclassify(_Tp __f)
-: 843: {
-: 844: typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-: 845: return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
-: 846: FP_SUBNORMAL, FP_ZERO, __type(__f));
-: 847: }
-: 848:
-: 849: template
-: 850: inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-: 851: int>::__type
-: 852: isfinite(_Tp __f)
-: 853: {
-: 854: typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-: 855: return __builtin_isfinite(__type(__f));
-: 856: }
-: 857:
-: 858: template
-: 859: inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-: 860: int>::__type
-: 861: isinf(_Tp __f)
-: 862: {
-: 863: typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-: 864: return __builtin_isinf(__type(__f));
-: 865: }
-: 866:
-: 867: template
-: 868: inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-: 869: int>::__type
-: 870: isnan(_Tp __f)
-: 871: {
-: 872: typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-: 873: return __builtin_isnan(__type(__f));
-: 874: }
-: 875:
-: 876: template
-: 877: inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-: 878: int>::__type
-: 879: isnormal(_Tp __f)
-: 880: {
-: 881: typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-: 882: return __builtin_isnormal(__type(__f));
-: 883: }
-: 884:
-: 885: template
-: 886: inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-: 887: int>::__type
-: 888: signbit(_Tp __f)
-: 889: {
-: 890: typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-: 891: return __builtin_signbit(__type(__f));
-: 892: }
-: 893:
-: 894: template
-: 895: inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-: 896: int>::__type
-: 897: isgreater(_Tp __f1, _Tp __f2)
-: 898: {
-: 899: typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-: 900: return __builtin_isgreater(__type(__f1), __type(__f2));
-: 901: }
-: 902:
-: 903: template
-: 904: inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-: 905: int>::__type
-: 906: isgreaterequal(_Tp __f1, _Tp __f2)
-: 907: {
-: 908: typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-: 909: return __builtin_isgreaterequal(__type(__f1), __type(__f2));
-: 910: }
-: 911:
-: 912: template
-: 913: inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-: 914: int>::__type
-: 915: isless(_Tp __f1, _Tp __f2)
-: 916: {
-: 917: typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-: 918: return __builtin_isless(__type(__f1), __type(__f2));
-: 919: }
-: 920:
-: 921: template
-: 922: inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-: 923: int>::__type
-: 924: islessequal(_Tp __f1, _Tp __f2)
-: 925: {
-: 926: typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-: 927: return __builtin_islessequal(__type(__f1), __type(__f2));
-: 928: }
-: 929:
-: 930: template
-: 931: inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-: 932: int>::__type
-: 933: islessgreater(_Tp __f1, _Tp __f2)
-: 934: {
-: 935: typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-: 936: return __builtin_islessgreater(__type(__f1), __type(__f2));
-: 937: }
-: 938:
-: 939: template
-: 940: inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
-: 941: int>::__type
-: 942: isunordered(_Tp __f1, _Tp __f2)
-: 943: {
-: 944: typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
-: 945: return __builtin_isunordered(__type(__f1), __type(__f2));
-: 946: }
-: 947:
-: 948:#endif // C++11
-: 949:#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
-: 950:#endif /* _GLIBCXX_USE_C99_MATH */
-: 951:
-: 952:#if __cplusplus >= 201103L
-: 953:
-: 954:#ifdef _GLIBCXX_USE_C99_MATH_TR1
-: 955:
-: 956:#undef acosh
-: 957:#undef acoshf
-: 958:#undef acoshl
-: 959:#undef asinh
-: 960:#undef asinhf
-: 961:#undef asinhl
-: 962:#undef atanh
-: 963:#undef atanhf
-: 964:#undef atanhl
-: 965:#undef cbrt
-: 966:#undef cbrtf
-: 967:#undef cbrtl
-: 968:#undef copysign
-: 969:#undef copysignf
-: 970:#undef copysignl
-: 971:#undef erf
-: 972:#undef erff
-: 973:#undef erfl
-: 974:#undef erfc
-: 975:#undef erfcf
-: 976:#undef erfcl
-: 977:#undef exp2
-: 978:#undef exp2f
-: 979:#undef exp2l
-: 980:#undef expm1
-: 981:#undef expm1f
-: 982:#undef expm1l
-: 983:#undef fdim
-: 984:#undef fdimf
-: 985:#undef fdiml
-: 986:#undef fma
-: 987:#undef fmaf
-: 988:#undef fmal
-: 989:#undef fmax
-: 990:#undef fmaxf
-: 991:#undef fmaxl
-: 992:#undef fmin
-: 993:#undef fminf
-: 994:#undef fminl
-: 995:#undef hypot
-: 996:#undef hypotf
-: 997:#undef hypotl
-: 998:#undef ilogb
-: 999:#undef ilogbf
-: 1000:#undef ilogbl
-: 1001:#undef lgamma
-: 1002:#undef lgammaf
-: 1003:#undef lgammal
-: 1004:#ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
-: 1005:#undef llrint
-: 1006:#undef llrintf
-: 1007:#undef llrintl
-: 1008:#undef llround
-: 1009:#undef llroundf
-: 1010:#undef llroundl
-: 1011:#endif
-: 1012:#undef log1p
-: 1013:#undef log1pf
-: 1014:#undef log1pl
-: 1015:#undef log2
-: 1016:#undef log2f
-: 1017:#undef log2l
-: 1018:#undef logb
-: 1019:#undef logbf
-: 1020:#undef logbl
-: 1021:#undef lrint
-: 1022:#undef lrintf
-: 1023:#undef lrintl
-: 1024:#undef lround
-: 1025:#undef lroundf
-: 1026:#undef lroundl
-: 1027:#undef nan
-: 1028:#undef nanf
-: 1029:#undef nanl
-: 1030:#undef nearbyint
-: 1031:#undef nearbyintf
-: 1032:#undef nearbyintl
-: 1033:#undef nextafter
-: 1034:#undef nextafterf
-: 1035:#undef nextafterl
-: 1036:#undef nexttoward
-: 1037:#undef nexttowardf
-: 1038:#undef nexttowardl
-: 1039:#undef remainder
-: 1040:#undef remainderf
-: 1041:#undef remainderl
-: 1042:#undef remquo
-: 1043:#undef remquof
-: 1044:#undef remquol
-: 1045:#undef rint
-: 1046:#undef rintf
-: 1047:#undef rintl
-: 1048:#undef round
-: 1049:#undef roundf
-: 1050:#undef roundl
-: 1051:#undef scalbln
-: 1052:#undef scalblnf
-: 1053:#undef scalblnl
-: 1054:#undef scalbn
-: 1055:#undef scalbnf
-: 1056:#undef scalbnl
-: 1057:#undef tgamma
-: 1058:#undef tgammaf
-: 1059:#undef tgammal
-: 1060:#undef trunc
-: 1061:#undef truncf
-: 1062:#undef truncl
-: 1063:
-: 1064: // types
-: 1065: using ::double_t;
-: 1066: using ::float_t;
-: 1067:
-: 1068: // functions
-: 1069: using ::acosh;
-: 1070: using ::acoshf;
-: 1071: using ::acoshl;
-: 1072:
-: 1073: using ::asinh;
-: 1074: using ::asinhf;
-: 1075: using ::asinhl;
-: 1076:
-: 1077: using ::atanh;
-: 1078: using ::atanhf;
-: 1079: using ::atanhl;
-: 1080:
-: 1081: using ::cbrt;
-: 1082: using ::cbrtf;
-: 1083: using ::cbrtl;
-: 1084:
-: 1085: using ::copysign;
-: 1086: using ::copysignf;
-: 1087: using ::copysignl;
-: 1088:
-: 1089: using ::erf;
-: 1090: using ::erff;
-: 1091: using ::erfl;
-: 1092:
-: 1093: using ::erfc;
-: 1094: using ::erfcf;
-: 1095: using ::erfcl;
-: 1096:
-: 1097: using ::exp2;
-: 1098: using ::exp2f;
-: 1099: using ::exp2l;
-: 1100:
-: 1101: using ::expm1;
-: 1102: using ::expm1f;
-: 1103: using ::expm1l;
-: 1104:
-: 1105: using ::fdim;
-: 1106: using ::fdimf;
-: 1107: using ::fdiml;
-: 1108:
-: 1109: using ::fma;
-: 1110: using ::fmaf;
-: 1111: using ::fmal;
-: 1112:
-: 1113: using ::fmax;
-: 1114: using ::fmaxf;
-: 1115: using ::fmaxl;
-: 1116:
-: 1117: using ::fmin;
-: 1118: using ::fminf;
-: 1119: using ::fminl;
-: 1120:
-: 1121: using ::hypot;
-: 1122: using ::hypotf;
-: 1123: using ::hypotl;
-: 1124:
-: 1125: using ::ilogb;
-: 1126: using ::ilogbf;
-: 1127: using ::ilogbl;
-: 1128:
-: 1129: using ::lgamma;
-: 1130: using ::lgammaf;
-: 1131: using ::lgammal;
-: 1132:
-: 1133:#ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
-: 1134: using ::llrint;
-: 1135: using ::llrintf;
-: 1136: using ::llrintl;
-: 1137:
-: 1138: using ::llround;
-: 1139: using ::llroundf;
-: 1140: using ::llroundl;
-: 1141:#endif
-: 1142:
-: 1143: using ::log1p;
-: 1144: using ::log1pf;
-: 1145: using ::log1pl;
-: 1146:
-: 1147: using ::log2;
-: 1148: using ::log2f;
-: 1149: using ::log2l;
-: 1150:
-: 1151: using ::logb;
-: 1152: using ::logbf;
-: 1153: using ::logbl;
-: 1154:
-: 1155: using ::lrint;
-: 1156: using ::lrintf;
-: 1157: using ::lrintl;
-: 1158:
-: 1159: using ::lround;
-: 1160: using ::lroundf;
-: 1161: using ::lroundl;
-: 1162:
-: 1163: using ::nan;
-: 1164: using ::nanf;
-: 1165: using ::nanl;
-: 1166:
-: 1167: using ::nearbyint;
-: 1168: using ::nearbyintf;
-: 1169: using ::nearbyintl;
-: 1170:
-: 1171: using ::nextafter;
-: 1172: using ::nextafterf;
-: 1173: using ::nextafterl;
-: 1174:
-: 1175: using ::nexttoward;
-: 1176: using ::nexttowardf;
-: 1177: using ::nexttowardl;
-: 1178:
-: 1179: using ::remainder;
-: 1180: using ::remainderf;
-: 1181: using ::remainderl;
-: 1182:
-: 1183: using ::remquo;
-: 1184: using ::remquof;
-: 1185: using ::remquol;
-: 1186:
-: 1187: using ::rint;
-: 1188: using ::rintf;
-: 1189: using ::rintl;
-: 1190:
-: 1191: using ::round;
-: 1192: using ::roundf;
-: 1193: using ::roundl;
-: 1194:
-: 1195: using ::scalbln;
-: 1196: using ::scalblnf;
-: 1197: using ::scalblnl;
-: 1198:
-: 1199: using ::scalbn;
-: 1200: using ::scalbnf;
-: 1201: using ::scalbnl;
-: 1202:
-: 1203: using ::tgamma;
-: 1204: using ::tgammaf;
-: 1205: using ::tgammal;
-: 1206:
-: 1207: using ::trunc;
-: 1208: using ::truncf;
-: 1209: using ::truncl;
-: 1210:
-: 1211: /// Additional overloads.
-: 1212:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1213: constexpr float
-: 1214: acosh(float __x)
-: 1215: { return __builtin_acoshf(__x); }
-: 1216:
-: 1217: constexpr long double
-: 1218: acosh(long double __x)
-: 1219: { return __builtin_acoshl(__x); }
-: 1220:#endif
-: 1221:
-: 1222:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1223: template
-: 1224: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1225: double>::__type
-: 1226: acosh(_Tp __x)
-: 1227: { return __builtin_acosh(__x); }
-: 1228:#endif
-: 1229:
-: 1230:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1231: constexpr float
-: 1232: asinh(float __x)
-: 1233: { return __builtin_asinhf(__x); }
-: 1234:
-: 1235: constexpr long double
-: 1236: asinh(long double __x)
-: 1237: { return __builtin_asinhl(__x); }
-: 1238:#endif
-: 1239:
-: 1240:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1241: template
-: 1242: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1243: double>::__type
-: 1244: asinh(_Tp __x)
-: 1245: { return __builtin_asinh(__x); }
-: 1246:#endif
-: 1247:
-: 1248:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1249: constexpr float
-: 1250: atanh(float __x)
-: 1251: { return __builtin_atanhf(__x); }
-: 1252:
-: 1253: constexpr long double
-: 1254: atanh(long double __x)
-: 1255: { return __builtin_atanhl(__x); }
-: 1256:#endif
-: 1257:
-: 1258:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1259: template
-: 1260: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1261: double>::__type
-: 1262: atanh(_Tp __x)
-: 1263: { return __builtin_atanh(__x); }
-: 1264:#endif
-: 1265:
-: 1266:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1267: constexpr float
-: 1268: cbrt(float __x)
-: 1269: { return __builtin_cbrtf(__x); }
-: 1270:
-: 1271: constexpr long double
-: 1272: cbrt(long double __x)
-: 1273: { return __builtin_cbrtl(__x); }
-: 1274:#endif
-: 1275:
-: 1276:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1277: template
-: 1278: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1279: double>::__type
-: 1280: cbrt(_Tp __x)
-: 1281: { return __builtin_cbrt(__x); }
-: 1282:#endif
-: 1283:
-: 1284:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1285: constexpr float
-: 1286: copysign(float __x, float __y)
-: 1287: { return __builtin_copysignf(__x, __y); }
-: 1288:
-: 1289: constexpr long double
-: 1290: copysign(long double __x, long double __y)
-: 1291: { return __builtin_copysignl(__x, __y); }
-: 1292:#endif
-: 1293:
-: 1294:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1295: template
-: 1296: constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-: 1297: copysign(_Tp __x, _Up __y)
-: 1298: {
-: 1299: typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-: 1300: return copysign(__type(__x), __type(__y));
-: 1301: }
-: 1302:#endif
-: 1303:
-: 1304:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1305: constexpr float
-: 1306: erf(float __x)
-: 1307: { return __builtin_erff(__x); }
-: 1308:
-: 1309: constexpr long double
-: 1310: erf(long double __x)
-: 1311: { return __builtin_erfl(__x); }
-: 1312:#endif
-: 1313:
-: 1314:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1315: template
-: 1316: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1317: double>::__type
-: 1318: erf(_Tp __x)
-: 1319: { return __builtin_erf(__x); }
-: 1320:#endif
-: 1321:
-: 1322:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1323: constexpr float
-: 1324: erfc(float __x)
-: 1325: { return __builtin_erfcf(__x); }
-: 1326:
-: 1327: constexpr long double
-: 1328: erfc(long double __x)
-: 1329: { return __builtin_erfcl(__x); }
-: 1330:#endif
-: 1331:
-: 1332:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1333: template
-: 1334: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1335: double>::__type
-: 1336: erfc(_Tp __x)
-: 1337: { return __builtin_erfc(__x); }
-: 1338:#endif
-: 1339:
-: 1340:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1341: constexpr float
-: 1342: exp2(float __x)
-: 1343: { return __builtin_exp2f(__x); }
-: 1344:
-: 1345: constexpr long double
-: 1346: exp2(long double __x)
-: 1347: { return __builtin_exp2l(__x); }
-: 1348:#endif
-: 1349:
-: 1350:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1351: template
-: 1352: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1353: double>::__type
-: 1354: exp2(_Tp __x)
-: 1355: { return __builtin_exp2(__x); }
-: 1356:#endif
-: 1357:
-: 1358:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1359: constexpr float
-: 1360: expm1(float __x)
-: 1361: { return __builtin_expm1f(__x); }
-: 1362:
-: 1363: constexpr long double
-: 1364: expm1(long double __x)
-: 1365: { return __builtin_expm1l(__x); }
-: 1366:#endif
-: 1367:
-: 1368:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1369: template
-: 1370: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1371: double>::__type
-: 1372: expm1(_Tp __x)
-: 1373: { return __builtin_expm1(__x); }
-: 1374:#endif
-: 1375:
-: 1376:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1377: constexpr float
-: 1378: fdim(float __x, float __y)
-: 1379: { return __builtin_fdimf(__x, __y); }
-: 1380:
-: 1381: constexpr long double
-: 1382: fdim(long double __x, long double __y)
-: 1383: { return __builtin_fdiml(__x, __y); }
-: 1384:#endif
-: 1385:
-: 1386:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1387: template
-: 1388: constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-: 1389: fdim(_Tp __x, _Up __y)
-: 1390: {
-: 1391: typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-: 1392: return fdim(__type(__x), __type(__y));
-: 1393: }
-: 1394:#endif
-: 1395:
-: 1396:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1397: constexpr float
-: 1398: fma(float __x, float __y, float __z)
-: 1399: { return __builtin_fmaf(__x, __y, __z); }
-: 1400:
-: 1401: constexpr long double
-: 1402: fma(long double __x, long double __y, long double __z)
-: 1403: { return __builtin_fmal(__x, __y, __z); }
-: 1404:#endif
-: 1405:
-: 1406:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1407: template
-: 1408: constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
-: 1409: fma(_Tp __x, _Up __y, _Vp __z)
-: 1410: {
-: 1411: typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
-: 1412: return fma(__type(__x), __type(__y), __type(__z));
-: 1413: }
-: 1414:#endif
-: 1415:
-: 1416:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1417: constexpr float
-: 1418: fmax(float __x, float __y)
-: 1419: { return __builtin_fmaxf(__x, __y); }
-: 1420:
-: 1421: constexpr long double
-: 1422: fmax(long double __x, long double __y)
-: 1423: { return __builtin_fmaxl(__x, __y); }
-: 1424:#endif
-: 1425:
-: 1426:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1427: template
-: 1428: constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-: 1429: fmax(_Tp __x, _Up __y)
-: 1430: {
-: 1431: typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-: 1432: return fmax(__type(__x), __type(__y));
-: 1433: }
-: 1434:#endif
-: 1435:
-: 1436:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1437: constexpr float
-: 1438: fmin(float __x, float __y)
-: 1439: { return __builtin_fminf(__x, __y); }
-: 1440:
-: 1441: constexpr long double
-: 1442: fmin(long double __x, long double __y)
-: 1443: { return __builtin_fminl(__x, __y); }
-: 1444:#endif
-: 1445:
-: 1446:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1447: template
-: 1448: constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-: 1449: fmin(_Tp __x, _Up __y)
-: 1450: {
-: 1451: typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-: 1452: return fmin(__type(__x), __type(__y));
-: 1453: }
-: 1454:#endif
-: 1455:
-: 1456:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1457: constexpr float
-: 1458: hypot(float __x, float __y)
-: 1459: { return __builtin_hypotf(__x, __y); }
-: 1460:
-: 1461: constexpr long double
-: 1462: hypot(long double __x, long double __y)
-: 1463: { return __builtin_hypotl(__x, __y); }
-: 1464:#endif
-: 1465:
-: 1466:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1467: template
-: 1468: constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-: 1469: hypot(_Tp __x, _Up __y)
-: 1470: {
-: 1471: typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-: 1472: return hypot(__type(__x), __type(__y));
-: 1473: }
-: 1474:#endif
-: 1475:
-: 1476:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1477: constexpr int
-: 1478: ilogb(float __x)
-: 1479: { return __builtin_ilogbf(__x); }
-: 1480:
-: 1481: constexpr int
-: 1482: ilogb(long double __x)
-: 1483: { return __builtin_ilogbl(__x); }
-: 1484:#endif
-: 1485:
-: 1486:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1487: template
-: 1488: constexpr
-: 1489: typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1490: int>::__type
-: 1491: ilogb(_Tp __x)
-: 1492: { return __builtin_ilogb(__x); }
-: 1493:#endif
-: 1494:
-: 1495:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1496: constexpr float
-: 1497: lgamma(float __x)
-: 1498: { return __builtin_lgammaf(__x); }
-: 1499:
-: 1500: constexpr long double
-: 1501: lgamma(long double __x)
-: 1502: { return __builtin_lgammal(__x); }
-: 1503:#endif
-: 1504:
-: 1505:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1506: template
-: 1507: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1508: double>::__type
-: 1509: lgamma(_Tp __x)
-: 1510: { return __builtin_lgamma(__x); }
-: 1511:#endif
-: 1512:
-: 1513:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1514: constexpr long long
-: 1515: llrint(float __x)
-: 1516: { return __builtin_llrintf(__x); }
-: 1517:
-: 1518: constexpr long long
-: 1519: llrint(long double __x)
-: 1520: { return __builtin_llrintl(__x); }
-: 1521:#endif
-: 1522:
-: 1523:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1524: template
-: 1525: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1526: long long>::__type
-: 1527: llrint(_Tp __x)
-: 1528: { return __builtin_llrint(__x); }
-: 1529:#endif
-: 1530:
-: 1531:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1532: constexpr long long
-: 1533: llround(float __x)
-: 1534: { return __builtin_llroundf(__x); }
-: 1535:
-: 1536: constexpr long long
-: 1537: llround(long double __x)
-: 1538: { return __builtin_llroundl(__x); }
-: 1539:#endif
-: 1540:
-: 1541:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1542: template
-: 1543: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1544: long long>::__type
-: 1545: llround(_Tp __x)
-: 1546: { return __builtin_llround(__x); }
-: 1547:#endif
-: 1548:
-: 1549:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1550: constexpr float
-: 1551: log1p(float __x)
-: 1552: { return __builtin_log1pf(__x); }
-: 1553:
-: 1554: constexpr long double
-: 1555: log1p(long double __x)
-: 1556: { return __builtin_log1pl(__x); }
-: 1557:#endif
-: 1558:
-: 1559:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1560: template
-: 1561: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1562: double>::__type
-: 1563: log1p(_Tp __x)
-: 1564: { return __builtin_log1p(__x); }
-: 1565:#endif
-: 1566:
-: 1567:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1568: // DR 568.
-: 1569: constexpr float
-: 1570: log2(float __x)
-: 1571: { return __builtin_log2f(__x); }
-: 1572:
-: 1573: constexpr long double
-: 1574: log2(long double __x)
-: 1575: { return __builtin_log2l(__x); }
-: 1576:#endif
-: 1577:
-: 1578:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1579: template
-: 1580: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1581: double>::__type
-: 1582: log2(_Tp __x)
-: 1583: { return __builtin_log2(__x); }
-: 1584:#endif
-: 1585:
-: 1586:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1587: constexpr float
-: 1588: logb(float __x)
-: 1589: { return __builtin_logbf(__x); }
-: 1590:
-: 1591: constexpr long double
-: 1592: logb(long double __x)
-: 1593: { return __builtin_logbl(__x); }
-: 1594:#endif
-: 1595:
-: 1596:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1597: template
-: 1598: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1599: double>::__type
-: 1600: logb(_Tp __x)
-: 1601: { return __builtin_logb(__x); }
-: 1602:#endif
-: 1603:
-: 1604:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1605: constexpr long
-: 1606: lrint(float __x)
-: 1607: { return __builtin_lrintf(__x); }
-: 1608:
-: 1609: constexpr long
-: 1610: lrint(long double __x)
-: 1611: { return __builtin_lrintl(__x); }
-: 1612:#endif
-: 1613:
-: 1614:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1615: template
-: 1616: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1617: long>::__type
-: 1618: lrint(_Tp __x)
-: 1619: { return __builtin_lrint(__x); }
-: 1620:#endif
-: 1621:
-: 1622:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1623: constexpr long
-: 1624: lround(float __x)
-: 1625: { return __builtin_lroundf(__x); }
-: 1626:
-: 1627: constexpr long
-: 1628: lround(long double __x)
-: 1629: { return __builtin_lroundl(__x); }
-: 1630:#endif
-: 1631:
-: 1632:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1633: template
-: 1634: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1635: long>::__type
-: 1636: lround(_Tp __x)
-: 1637: { return __builtin_lround(__x); }
-: 1638:#endif
-: 1639:
-: 1640:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1641: constexpr float
-: 1642: nearbyint(float __x)
-: 1643: { return __builtin_nearbyintf(__x); }
-: 1644:
-: 1645: constexpr long double
-: 1646: nearbyint(long double __x)
-: 1647: { return __builtin_nearbyintl(__x); }
-: 1648:#endif
-: 1649:
-: 1650:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1651: template
-: 1652: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1653: double>::__type
-: 1654: nearbyint(_Tp __x)
-: 1655: { return __builtin_nearbyint(__x); }
-: 1656:#endif
-: 1657:
-: 1658:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1659: constexpr float
-: 1660: nextafter(float __x, float __y)
-: 1661: { return __builtin_nextafterf(__x, __y); }
-: 1662:
-: 1663: constexpr long double
-: 1664: nextafter(long double __x, long double __y)
-: 1665: { return __builtin_nextafterl(__x, __y); }
-: 1666:#endif
-: 1667:
-: 1668:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1669: template
-: 1670: constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-: 1671: nextafter(_Tp __x, _Up __y)
-: 1672: {
-: 1673: typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-: 1674: return nextafter(__type(__x), __type(__y));
-: 1675: }
-: 1676:#endif
-: 1677:
-: 1678:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1679: constexpr float
-: 1680: nexttoward(float __x, long double __y)
-: 1681: { return __builtin_nexttowardf(__x, __y); }
-: 1682:
-: 1683: constexpr long double
-: 1684: nexttoward(long double __x, long double __y)
-: 1685: { return __builtin_nexttowardl(__x, __y); }
-: 1686:#endif
-: 1687:
-: 1688:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1689: template
-: 1690: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1691: double>::__type
-: 1692: nexttoward(_Tp __x, long double __y)
-: 1693: { return __builtin_nexttoward(__x, __y); }
-: 1694:#endif
-: 1695:
-: 1696:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1697: constexpr float
-: 1698: remainder(float __x, float __y)
-: 1699: { return __builtin_remainderf(__x, __y); }
-: 1700:
-: 1701: constexpr long double
-: 1702: remainder(long double __x, long double __y)
-: 1703: { return __builtin_remainderl(__x, __y); }
-: 1704:#endif
-: 1705:
-: 1706:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1707: template
-: 1708: constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-: 1709: remainder(_Tp __x, _Up __y)
-: 1710: {
-: 1711: typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-: 1712: return remainder(__type(__x), __type(__y));
-: 1713: }
-: 1714:#endif
-: 1715:
-: 1716:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1717: inline float
-: 1718: remquo(float __x, float __y, int* __pquo)
-: 1719: { return __builtin_remquof(__x, __y, __pquo); }
-: 1720:
-: 1721: inline long double
-: 1722: remquo(long double __x, long double __y, int* __pquo)
-: 1723: { return __builtin_remquol(__x, __y, __pquo); }
-: 1724:#endif
-: 1725:
-: 1726:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1727: template
-: 1728: inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
-: 1729: remquo(_Tp __x, _Up __y, int* __pquo)
-: 1730: {
-: 1731: typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
-: 1732: return remquo(__type(__x), __type(__y), __pquo);
-: 1733: }
-: 1734:#endif
-: 1735:
-: 1736:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1737: constexpr float
-: 1738: rint(float __x)
-: 1739: { return __builtin_rintf(__x); }
-: 1740:
-: 1741: constexpr long double
-: 1742: rint(long double __x)
-: 1743: { return __builtin_rintl(__x); }
-: 1744:#endif
-: 1745:
-: 1746:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1747: template
-: 1748: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1749: double>::__type
-: 1750: rint(_Tp __x)
-: 1751: { return __builtin_rint(__x); }
-: 1752:#endif
-: 1753:
-: 1754:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1755: constexpr float
-: 1756: round(float __x)
-: 1757: { return __builtin_roundf(__x); }
-: 1758:
-: 1759: constexpr long double
-: 1760: round(long double __x)
-: 1761: { return __builtin_roundl(__x); }
-: 1762:#endif
-: 1763:
-: 1764:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1765: template
-: 1766: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1767: double>::__type
-: 1768: round(_Tp __x)
-: 1769: { return __builtin_round(__x); }
-: 1770:#endif
-: 1771:
-: 1772:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1773: constexpr float
-: 1774: scalbln(float __x, long __ex)
-: 1775: { return __builtin_scalblnf(__x, __ex); }
-: 1776:
-: 1777: constexpr long double
-: 1778: scalbln(long double __x, long __ex)
-: 1779: { return __builtin_scalblnl(__x, __ex); }
-: 1780:#endif
-: 1781:
-: 1782:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1783: template
-: 1784: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1785: double>::__type
-: 1786: scalbln(_Tp __x, long __ex)
-: 1787: { return __builtin_scalbln(__x, __ex); }
-: 1788:#endif
-: 1789:
-: 1790:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1791: constexpr float
-: 1792: scalbn(float __x, int __ex)
-: 1793: { return __builtin_scalbnf(__x, __ex); }
-: 1794:
-: 1795: constexpr long double
-: 1796: scalbn(long double __x, int __ex)
-: 1797: { return __builtin_scalbnl(__x, __ex); }
-: 1798:#endif
-: 1799:
-: 1800:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1801: template
-: 1802: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1803: double>::__type
-: 1804: scalbn(_Tp __x, int __ex)
-: 1805: { return __builtin_scalbn(__x, __ex); }
-: 1806:#endif
-: 1807:
-: 1808:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1809: constexpr float
-: 1810: tgamma(float __x)
-: 1811: { return __builtin_tgammaf(__x); }
-: 1812:
-: 1813: constexpr long double
-: 1814: tgamma(long double __x)
-: 1815: { return __builtin_tgammal(__x); }
-: 1816:#endif
-: 1817:
-: 1818:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1819: template
-: 1820: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1821: double>::__type
-: 1822: tgamma(_Tp __x)
-: 1823: { return __builtin_tgamma(__x); }
-: 1824:#endif
-: 1825:
-: 1826:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
-: 1827: constexpr float
-: 1828: trunc(float __x)
-: 1829: { return __builtin_truncf(__x); }
-: 1830:
-: 1831: constexpr long double
-: 1832: trunc(long double __x)
-: 1833: { return __builtin_truncl(__x); }
-: 1834:#endif
-: 1835:
-: 1836:#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
-: 1837: template
-: 1838: constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
-: 1839: double>::__type
-: 1840: trunc(_Tp __x)
-: 1841: { return __builtin_trunc(__x); }
-: 1842:#endif
-: 1843:
-: 1844:#endif // _GLIBCXX_USE_C99_MATH_TR1
-: 1845:#endif // C++11
-: 1846:
-: 1847:#if __cplusplus >= 201703L
-: 1848:
-: 1849: // [c.math.hypot3], three-dimensional hypotenuse
-: 1850:#define __cpp_lib_hypot 201603L
-: 1851:
-: 1852: template
-: 1853: inline _Tp
-: 1854: __hypot3(_Tp __x, _Tp __y, _Tp __z)
-: 1855: {
-: 1856: __x = std::abs(__x);
-: 1857: __y = std::abs(__y);
-: 1858: __z = std::abs(__z);
-: 1859: if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
-: 1860: return __a * std::sqrt((__x / __a) * (__x / __a)
-: 1861: + (__y / __a) * (__y / __a)
-: 1862: + (__z / __a) * (__z / __a));
-: 1863: else
-: 1864: return {};
-: 1865: }
-: 1866:
-: 1867: inline float
-: 1868: hypot(float __x, float __y, float __z)
-: 1869: { return std::__hypot3(__x, __y, __z); }
-: 1870:
-: 1871: inline double
-: 1872: hypot(double __x, double __y, double __z)
-: 1873: { return std::__hypot3(__x, __y, __z); }
-: 1874:
-: 1875: inline long double
-: 1876: hypot(long double __x, long double __y, long double __z)
-: 1877: { return std::__hypot3(__x, __y, __z); }
-: 1878:
-: 1879: template
-: 1880: __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
-: 1881: hypot(_Tp __x, _Up __y, _Vp __z)
-: 1882: {
-: 1883: using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
-: 1884: return std::__hypot3<__type>(__x, __y, __z);
-: 1885: }
-: 1886:#endif // C++17
-: 1887:
-: 1888:#if __cplusplus >= 202002L
-: 1889: // linear interpolation
-: 1890:# define __cpp_lib_interpolate 201902L
-: 1891:
-: 1892: template
-: 1893: constexpr _Fp
-: 1894: __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept
-: 1895: {
-: 1896: if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
-: 1897: return __t * __b + (1 - __t) * __a;
-: 1898:
-: 1899: if (__t == 1)
-: 1900: return __b; // exact
-: 1901:
-: 1902: // Exact at __t=0, monotonic except near __t=1,
-: 1903: // bounded, determinate, and consistent:
-: 1904: const _Fp __x = __a + __t * (__b - __a);
-: 1905: return (__t > 1) == (__b > __a)
-: 1906: ? (__b < __x ? __x : __b)
-: 1907: : (__b > __x ? __x : __b); // monotonic near __t=1
-: 1908: }
-: 1909:
-: 1910: constexpr float
-: 1911: lerp(float __a, float __b, float __t) noexcept
-: 1912: { return std::__lerp(__a, __b, __t); }
-: 1913:
-: 1914: constexpr double
-: 1915: lerp(double __a, double __b, double __t) noexcept
-: 1916: { return std::__lerp(__a, __b, __t); }
-: 1917:
-: 1918: constexpr long double
-: 1919: lerp(long double __a, long double __b, long double __t) noexcept
-: 1920: { return std::__lerp(__a, __b, __t); }
-: 1921:
-: 1922: template
-: 1923: constexpr __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
-: 1924: lerp(_Tp __x, _Up __y, _Vp __z) noexcept
-: 1925: {
-: 1926: using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
-: 1927: return std::__lerp<__type>(__x, __y, __z);
-: 1928: }
-: 1929:#endif // C++20
-: 1930:
-: 1931:_GLIBCXX_END_NAMESPACE_VERSION
-: 1932:} // namespace
-: 1933:
-: 1934:#if _GLIBCXX_USE_STD_SPEC_FUNCS
-: 1935:# include
-: 1936:#endif
-: 1937:
-: 1938:} // extern "C++"
-: 1939:
-: 1940:#endif