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 // <http://www.gnu.org/licenses/>. 24 25 /** @file include/cmath 26 * This is a Standard C++ Library file. You should @c \#include this file 27 * in your programs, rather than any of the @a *.h implementation files. 28 * 29 * This is the C++ version of the Standard C Library header @c math.h, 30 * and its contents are (mostly) the same as that header, but are all 31 * contained in the namespace @c std (except for names which are defined 32 * as macros in C). 33 */ 34 35 // 36 // ISO C++ 14882: 26.5 C library 37 // 38 39 #pragma GCC system_header 40 41 #include <bits/c++config.h> 42 #include <bits/cpp_type_traits.h> 43 #include <ext/type_traits.h> 44 #define _GLIBCXX_INCLUDE_NEXT_C_HEADERS 45 #include_next <math.h> 46 #undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS 47 #include <bits/std_abs.h> 48 49 #ifndef _GLIBCXX_CMATH 50 #define _GLIBCXX_CMATH 1 51 52 // Get rid of those macros defined in <math.h> in lieu of real functions. 53 #undef div 54 #undef acos 55 #undef asin 56 #undef atan 57 #undef atan2 58 #undef ceil 59 #undef cos 60 #undef cosh 61 #undef exp 62 #undef fabs 63 #undef floor 64 #undef fmod 65 #undef frexp 66 #undef ldexp 67 #undef log 68 #undef log10 69 #undef modf 70 #undef pow 71 #undef sin 72 #undef sinh 73 #undef sqrt 74 #undef tan 75 #undef tanh 76 77 extern "C++" 78 { 79 namespace std _GLIBCXX_VISIBILITY(default) 80 { 81 _GLIBCXX_BEGIN_NAMESPACE_VERSION 82 83 using ::acos; 84 85 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 86 inline _GLIBCXX_CONSTEXPR float 87 acos(float __x) 88 { return __builtin_acosf(__x); } 89 90 inline _GLIBCXX_CONSTEXPR long double 91 acos(long double __x) 92 { return __builtin_acosl(__x); } 93 #endif 94 95 template<typename _Tp> 96 inline _GLIBCXX_CONSTEXPR 97 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 98 double>::__type 99 acos(_Tp __x) 100 { return __builtin_acos(__x); } 101 102 using ::asin; 103 104 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 105 inline _GLIBCXX_CONSTEXPR float 106 asin(float __x) 107 { return __builtin_asinf(__x); } 108 109 inline _GLIBCXX_CONSTEXPR long double 110 asin(long double __x) 111 { return __builtin_asinl(__x); } 112 #endif 113 114 template<typename _Tp> 115 inline _GLIBCXX_CONSTEXPR 116 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 117 double>::__type 118 asin(_Tp __x) 119 { return __builtin_asin(__x); } 120 121 using ::atan; 122 123 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 124 inline _GLIBCXX_CONSTEXPR float 125 atan(float __x) 126 { return __builtin_atanf(__x); } 127 128 inline _GLIBCXX_CONSTEXPR long double 129 atan(long double __x) 130 { return __builtin_atanl(__x); } 131 #endif 132 133 template<typename _Tp> 134 inline _GLIBCXX_CONSTEXPR 135 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 136 double>::__type 137 atan(_Tp __x) 138 { return __builtin_atan(__x); } 139 140 using ::atan2; 141 142 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 143 inline _GLIBCXX_CONSTEXPR float 144 atan2(float __y, float __x) 145 { return __builtin_atan2f(__y, __x); } 146 147 inline _GLIBCXX_CONSTEXPR long double 148 atan2(long double __y, long double __x) 149 { return __builtin_atan2l(__y, __x); } 150 #endif 151 152 template<typename _Tp, typename _Up> 153 inline _GLIBCXX_CONSTEXPR 154 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 155 atan2(_Tp __y, _Up __x) 156 { 157 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 158 return atan2(__type(__y), __type(__x)); 159 } 160 161 using ::ceil; 162 163 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 164 inline _GLIBCXX_CONSTEXPR float 165 ceil(float __x) 166 { return __builtin_ceilf(__x); } 167 168 inline _GLIBCXX_CONSTEXPR long double 169 ceil(long double __x) 170 { return __builtin_ceill(__x); } 171 #endif 172 173 template<typename _Tp> 174 inline _GLIBCXX_CONSTEXPR 175 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 176 double>::__type 177 ceil(_Tp __x) 178 { return __builtin_ceil(__x); } 179 180 using ::cos; 181 182 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 183 inline _GLIBCXX_CONSTEXPR float 184 cos(float __x) 185 { return __builtin_cosf(__x); } 186 187 inline _GLIBCXX_CONSTEXPR long double 188 cos(long double __x) 189 { return __builtin_cosl(__x); } 190 #endif 191 192 template<typename _Tp> 193 inline _GLIBCXX_CONSTEXPR 194 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 195 double>::__type 196 cos(_Tp __x) 197 { return __builtin_cos(__x); } 198 199 using ::cosh; 200 201 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 202 inline _GLIBCXX_CONSTEXPR float 203 cosh(float __x) 204 { return __builtin_coshf(__x); } 205 206 inline _GLIBCXX_CONSTEXPR long double 207 cosh(long double __x) 208 { return __builtin_coshl(__x); } 209 #endif 210 211 template<typename _Tp> 212 inline _GLIBCXX_CONSTEXPR 213 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 214 double>::__type 215 cosh(_Tp __x) 216 { return __builtin_cosh(__x); } 217 218 using ::exp; 219 220 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 221 inline _GLIBCXX_CONSTEXPR float 222 exp(float __x) 223 { return __builtin_expf(__x); } 224 225 inline _GLIBCXX_CONSTEXPR long double 226 exp(long double __x) 227 { return __builtin_expl(__x); } 228 #endif 229 230 template<typename _Tp> 231 inline _GLIBCXX_CONSTEXPR 232 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 233 double>::__type 234 exp(_Tp __x) 235 { return __builtin_exp(__x); } 236 237 using ::fabs; 238 239 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 240 inline _GLIBCXX_CONSTEXPR float 241 fabs(float __x) 242 { return __builtin_fabsf(__x); } 243 244 inline _GLIBCXX_CONSTEXPR long double 245 fabs(long double __x) 246 { return __builtin_fabsl(__x); } 247 #endif 248 249 template<typename _Tp> 250 inline _GLIBCXX_CONSTEXPR 251 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 252 double>::__type 253 fabs(_Tp __x) 254 { return __builtin_fabs(__x); } 255 256 using ::floor; 257 258 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 259 inline _GLIBCXX_CONSTEXPR float 260 floor(float __x) 261 { return __builtin_floorf(__x); } 262 263 inline _GLIBCXX_CONSTEXPR long double 264 floor(long double __x) 265 { return __builtin_floorl(__x); } 266 #endif 267 268 template<typename _Tp> 269 inline _GLIBCXX_CONSTEXPR 270 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 271 double>::__type 272 floor(_Tp __x) 273 { return __builtin_floor(__x); } 274 275 using ::fmod; 276 277 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 278 inline _GLIBCXX_CONSTEXPR float 279 fmod(float __x, float __y) 280 { return __builtin_fmodf(__x, __y); } 281 282 inline _GLIBCXX_CONSTEXPR long double 283 fmod(long double __x, long double __y) 284 { return __builtin_fmodl(__x, __y); } 285 #endif 286 287 template<typename _Tp, typename _Up> 288 inline _GLIBCXX_CONSTEXPR 289 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 290 fmod(_Tp __x, _Up __y) 291 { 292 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 293 return fmod(__type(__x), __type(__y)); 294 } 295 296 using ::frexp; 297 298 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 299 inline float 300 frexp(float __x, int* __exp) 301 { return __builtin_frexpf(__x, __exp); } 302 303 inline long double 304 frexp(long double __x, int* __exp) 305 { return __builtin_frexpl(__x, __exp); } 306 #endif 307 308 template<typename _Tp> 309 inline _GLIBCXX_CONSTEXPR 310 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 311 double>::__type 312 frexp(_Tp __x, int* __exp) 313 { return __builtin_frexp(__x, __exp); } 314 315 using ::ldexp; 316 317 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 318 inline _GLIBCXX_CONSTEXPR float 319 ldexp(float __x, int __exp) 320 { return __builtin_ldexpf(__x, __exp); } 321 322 inline _GLIBCXX_CONSTEXPR long double 323 ldexp(long double __x, int __exp) 324 { return __builtin_ldexpl(__x, __exp); } 325 #endif 326 327 template<typename _Tp> 328 inline _GLIBCXX_CONSTEXPR 329 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 330 double>::__type 331 ldexp(_Tp __x, int __exp) 332 { return __builtin_ldexp(__x, __exp); } 333 334 using ::log; 335 336 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 337 inline _GLIBCXX_CONSTEXPR float 338 log(float __x) 339 { return __builtin_logf(__x); } 340 341 inline _GLIBCXX_CONSTEXPR long double 342 log(long double __x) 343 { return __builtin_logl(__x); } 344 #endif 345 346 template<typename _Tp> 347 inline _GLIBCXX_CONSTEXPR 348 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 349 double>::__type 350 log(_Tp __x) 351 { return __builtin_log(__x); } 352 353 using ::log10; 354 355 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 356 inline _GLIBCXX_CONSTEXPR float 357 log10(float __x) 358 { return __builtin_log10f(__x); } 359 360 inline _GLIBCXX_CONSTEXPR long double 361 log10(long double __x) 362 { return __builtin_log10l(__x); } 363 #endif 364 365 template<typename _Tp> 366 inline _GLIBCXX_CONSTEXPR 367 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 368 double>::__type 369 log10(_Tp __x) 370 { return __builtin_log10(__x); } 371 372 using ::modf; 373 374 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 375 inline float 376 modf(float __x, float* __iptr) 377 { return __builtin_modff(__x, __iptr); } 378 379 inline long double 380 modf(long double __x, long double* __iptr) 381 { return __builtin_modfl(__x, __iptr); } 382 #endif 383 384 using ::pow; 385 386 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 387 inline _GLIBCXX_CONSTEXPR float 388 pow(float __x, float __y) 389 { return __builtin_powf(__x, __y); } 390 391 inline _GLIBCXX_CONSTEXPR long double 392 pow(long double __x, long double __y) 393 { return __builtin_powl(__x, __y); } 394 395 #if __cplusplus < 201103L 396 // _GLIBCXX_RESOLVE_LIB_DEFECTS 397 // DR 550. What should the return type of pow(float,int) be? 398 inline double 399 pow(double __x, int __i) 400 { return __builtin_powi(__x, __i); } 401 402 inline float 403 pow(float __x, int __n) 404 { return __builtin_powif(__x, __n); } 405 406 inline long double 407 pow(long double __x, int __n) 408 { return __builtin_powil(__x, __n); } 409 #endif 410 #endif 411 412 template<typename _Tp, typename _Up> 413 inline _GLIBCXX_CONSTEXPR 414 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 415 pow(_Tp __x, _Up __y) 416 { 417 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 418 return pow(__type(__x), __type(__y)); 419 } 420 421 using ::sin; 422 423 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 424 inline _GLIBCXX_CONSTEXPR float 425 sin(float __x) 426 { return __builtin_sinf(__x); } 427 428 inline _GLIBCXX_CONSTEXPR long double 429 sin(long double __x) 430 { return __builtin_sinl(__x); } 431 #endif 432 433 template<typename _Tp> 434 inline _GLIBCXX_CONSTEXPR 435 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 436 double>::__type 437 sin(_Tp __x) 438 { return __builtin_sin(__x); } 439 440 using ::sinh; 441 442 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 443 inline _GLIBCXX_CONSTEXPR float 444 sinh(float __x) 445 { return __builtin_sinhf(__x); } 446 447 inline _GLIBCXX_CONSTEXPR long double 448 sinh(long double __x) 449 { return __builtin_sinhl(__x); } 450 #endif 451 452 template<typename _Tp> 453 inline _GLIBCXX_CONSTEXPR 454 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 455 double>::__type 456 sinh(_Tp __x) 457 { return __builtin_sinh(__x); } 458 459 using ::sqrt; 460 461 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 462 inline _GLIBCXX_CONSTEXPR float 463 sqrt(float __x) 464 { return __builtin_sqrtf(__x); } 465 466 inline _GLIBCXX_CONSTEXPR long double 467 sqrt(long double __x) 468 { return __builtin_sqrtl(__x); } 469 #endif 470 471 template<typename _Tp> 472 inline _GLIBCXX_CONSTEXPR 473 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 474 double>::__type 475 sqrt(_Tp __x) 476 { return __builtin_sqrt(__x); } 477 478 using ::tan; 479 480 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 481 inline _GLIBCXX_CONSTEXPR float 482 tan(float __x) 483 { return __builtin_tanf(__x); } 484 485 inline _GLIBCXX_CONSTEXPR long double 486 tan(long double __x) 487 { return __builtin_tanl(__x); } 488 #endif 489 490 template<typename _Tp> 491 inline _GLIBCXX_CONSTEXPR 492 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 493 double>::__type 494 tan(_Tp __x) 495 { return __builtin_tan(__x); } 496 497 using ::tanh; 498 499 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 500 inline _GLIBCXX_CONSTEXPR float 501 tanh(float __x) 502 { return __builtin_tanhf(__x); } 503 504 inline _GLIBCXX_CONSTEXPR long double 505 tanh(long double __x) 506 { return __builtin_tanhl(__x); } 507 #endif 508 509 template<typename _Tp> 510 inline _GLIBCXX_CONSTEXPR 511 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 512 double>::__type 513 tanh(_Tp __x) 514 { return __builtin_tanh(__x); } 515 516 #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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp, typename _Up> 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<typename _Tp, typename _Up> 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<typename _Tp, typename _Up> 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<typename _Tp, typename _Up> 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<typename _Tp, typename _Up> 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<typename _Tp, typename _Up> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp, typename _Up> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp, typename _Up> 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<typename _Tp, typename _Up, typename _Vp> 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<typename _Tp, typename _Up> 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<typename _Tp, typename _Up> 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<typename _Tp, typename _Up> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp, typename _Up> 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<typename _Tp> 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<typename _Tp, typename _Up> 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<typename _Tp, typename _Up> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<typename _Tp> 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<float>(__x, __y, __z); } 1870 1871 inline double 1872 hypot(double __x, double __y, double __z) 1873 { return std::__hypot3<double>(__x, __y, __z); } 1874 1875 inline long double 1876 hypot(long double __x, long double __y, long double __z) 1877 { return std::__hypot3<long double>(__x, __y, __z); } 1878 1879 template<typename _Tp, typename _Up, typename _Vp> 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<typename _Fp> 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<typename _Tp, typename _Up, typename _Vp> 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 <bits/specfun.h> 1936 #endif 1937 1938 } // extern "C++" 1939 1940 #endif 1941
Indexes created Sat Oct 24 00:25:45 UTC 2026