From cd382b414c2253a3551aa76bc5093c54bd9d5bf5 Mon Sep 17 00:00:00 2001 From: yhchen <106703003@g.nccu.edu.tw> Date: Mon, 12 Dec 2022 20:21:40 +0800 Subject: [PATCH] =?UTF-8?q?=E5=88=AA=E9=99=A4=E3=80=8Ccmath.gcov=E3=80=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- cmath.gcov | 1944 ---------------------------------------------------- 1 file changed, 1944 deletions(-) delete mode 100644 cmath.gcov 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