diff --git a/cmath.gcov b/cmath.gcov
deleted file mode 100644
index 63be454..0000000
--- a/cmath.gcov
+++ /dev/null
@@ -1,1944 +0,0 @@
- -: 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