From 8ca399b47021d9b48cf5f37a4a716d1f276e964b Mon Sep 17 00:00:00 2001 From: zovjsra <58198508+Zovjsra@users.noreply.github.com> Date: Mon, 12 Dec 2022 19:49:54 +0800 Subject: [PATCH] change readme --- Readme.md | 2 +- cmath.gcov | 1944 ++++++++++++++++++++++++++++++++++++++++++++++++ sphere.cc.gcov | 103 +++ 3 files changed, 2048 insertions(+), 1 deletion(-) create mode 100644 cmath.gcov create mode 100644 sphere.cc.gcov diff --git a/Readme.md b/Readme.md index 9a8ebde..8dcf712 100644 --- a/Readme.md +++ b/Readme.md @@ -25,7 +25,7 @@ cd unittest ## 練習內容 在 `src` 目錄中含有 `sphere` 物件的宣告及實作，但是這個程式碼中有一些邏輯錯誤，同學需完成以下步驟： -1. 編寫 unittest 使 sphere 程式碼覆蓋率達到 70% 以上 +1. 編寫 unittest 使 sphere 程式碼覆蓋率達到 80% 以上 2. 修改 `sphere.cc` 程式碼，使程式的邏輯完全正確 ## 覆蓋率計算 diff --git a/cmath.gcov b/cmath.gcov new file mode 100644 index 0000000..63be454 --- /dev/null +++ b/cmath.gcov @@ -0,0 +1,1944 @@ + -: 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 diff --git a/sphere.cc.gcov b/sphere.cc.gcov new file mode 100644 index 0000000..df2f123 --- /dev/null +++ b/sphere.cc.gcov @@ -0,0 +1,103 @@ + -: 0:Source:/Users/chenyuehon/gitRepos/gtest_exercise/src/sphere.cc + -: 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:#include "sphere.h" + -: 2: + -: 3:#include + -: 4:#include + -: 5:using namespace std; + -: 6: + 1*: 7:Sphere::Sphere() { + 1*: 8: this->orig_x = 0.0; + 1*: 9: this->orig_y = 0.0; + 1*: 10: this->orig_z = 0.0; + 1*: 11: this->radius = 0.0; + 1*: 12:} +------------------ +_ZN6SphereC1Ev: + 1: 7:Sphere::Sphere() { + 1: 8: this->orig_x = 0.0; + 1: 9: this->orig_y = 0.0; + 1: 10: this->orig_z = 0.0; + 1: 11: this->radius = 0.0; + 1: 12:} +------------------ +_ZN6SphereC2Ev: + #####: 7:Sphere::Sphere() { + #####: 8: this->orig_x = 0.0; + #####: 9: this->orig_y = 0.0; + #####: 10: this->orig_z = 0.0; + #####: 11: this->radius = 0.0; + #####: 12:} +------------------ + -: 13: + 1*: 14:Sphere::Sphere(float ox, float oy, float oz, float rad) { + 1*: 15: this->orig_x = ox; + 1*: 16: this->orig_y = oy; + 1*: 17: this->orig_z = oz; + 1*: 18: if (rad >= 0) + 1*: 19: this->radius = rad; + -: 20: else + #####: 21: this->radius = 0; + 1*: 22:} +------------------ +_ZN6SphereC1Effff: + 1: 14:Sphere::Sphere(float ox, float oy, float oz, float rad) { + 1: 15: this->orig_x = ox; + 1: 16: this->orig_y = oy; + 1: 17: this->orig_z = oz; + 1: 18: if (rad >= 0) + 1: 19: this->radius = rad; + -: 20: else + #####: 21: this->radius = 0; + 1: 22:} +------------------ +_ZN6SphereC2Effff: + #####: 14:Sphere::Sphere(float ox, float oy, float oz, float rad) { + #####: 15: this->orig_x = ox; + #####: 16: this->orig_y = oy; + #####: 17: this->orig_z = oz; + #####: 18: if (rad >= 0) + #####: 19: this->radius = rad; + -: 20: else + #####: 21: this->radius = 0; + #####: 22:} +------------------ + -: 23: + 6: 24:float* Sphere::getOrigin() { + 6: 25: float* result = new float[3]{this->orig_x, this->orig_y, this->orig_z}; + 6: 26: return result; + -: 27:} + -: 28: + 2: 29:float Sphere::getRadius() { + 2: 30: return this->radius; + -: 31:} + -: 32: + 1: 33:void Sphere::setOrigin(float ox, float oy, float oz) { + 1: 34: this->orig_x = ox; + 1: 35: this->orig_y = oy; + 1: 36: this->orig_z = oy; + 1: 37:} + -: 38: + 1: 39:void Sphere::setRadius(float rad) { + 1: 40: this->radius = 0; + 1: 41:} + -: 42: + #####: 43:bool Sphere::intersect(Sphere& other) { + #####: 44: float dist = sqrt(pow(this->orig_x - other.orig_x, 2) + pow(this->orig_y - other.orig_y, 2) + pow(this->orig_z - other.orig_z, 2)); + #####: 45: return true; + -: 46:} + -: 47: + #####: 48:float Sphere::SurfaceArea() { + #####: 49: return 4 * M_PI * pow(this->radius, 2); + -: 50:} + -: 51: + #####: 52:float Sphere::Volume() { + #####: 53: return (4 / 3) * M_PI * pow(this->radius, 2); + -: 54:} + -: 55: + #####: 56:ostream& operator<<(ostream& os, const Sphere& sphere) { + #####: 57: os << "[( " << sphere.orig_x << ", " << sphere.orig_y << ", " << sphere.orig_z << "), " << sphere.radius << "]"; + #####: 58: return os; + -: 59:}