1 // -*- C++ -*- C forwarding header. 2 3 // Copyright (C) 1997-2024 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/requires_hosted.h> 42 43 #include <bits/c++config.h> 44 #include <bits/cpp_type_traits.h> 45 #include <ext/type_traits.h> 46 #define _GLIBCXX_INCLUDE_NEXT_C_HEADERS 47 #include_next <math.h> 48 #undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS 49 #include <bits/std_abs.h> 50 51 #ifndef _GLIBCXX_CMATH 52 #define _GLIBCXX_CMATH 1 53 54 #define __glibcxx_want_hypot 55 #define __glibcxx_want_interpolate 56 #include <bits/version.h> 57 58 // Get rid of those macros defined in <math.h> in lieu of real functions. 59 #undef div 60 #undef acos 61 #undef asin 62 #undef atan 63 #undef atan2 64 #undef ceil 65 #undef cos 66 #undef cosh 67 #undef exp 68 #undef fabs 69 #undef floor 70 #undef fmod 71 #undef frexp 72 #undef ldexp 73 #undef log 74 #undef log10 75 #undef modf 76 #undef pow 77 #undef sin 78 #undef sinh 79 #undef sqrt 80 #undef tan 81 #undef tanh 82 83 extern "C++" 84 { 85 namespace std _GLIBCXX_VISIBILITY(default) 86 { 87 _GLIBCXX_BEGIN_NAMESPACE_VERSION 88 89 using ::acos; 90 91 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 92 inline _GLIBCXX_CONSTEXPR float 93 acos(float __x) 94 { return __builtin_acosf(__x); } 95 96 inline _GLIBCXX_CONSTEXPR long double 97 acos(long double __x) 98 { return __builtin_acosl(__x); } 99 #endif 100 101 template<typename _Tp> 102 inline _GLIBCXX_CONSTEXPR 103 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 104 double>::__type 105 acos(_Tp __x) 106 { return __builtin_acos(__x); } 107 108 using ::asin; 109 110 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 111 inline _GLIBCXX_CONSTEXPR float 112 asin(float __x) 113 { return __builtin_asinf(__x); } 114 115 inline _GLIBCXX_CONSTEXPR long double 116 asin(long double __x) 117 { return __builtin_asinl(__x); } 118 #endif 119 120 template<typename _Tp> 121 inline _GLIBCXX_CONSTEXPR 122 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 123 double>::__type 124 asin(_Tp __x) 125 { return __builtin_asin(__x); } 126 127 using ::atan; 128 129 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 130 inline _GLIBCXX_CONSTEXPR float 131 atan(float __x) 132 { return __builtin_atanf(__x); } 133 134 inline _GLIBCXX_CONSTEXPR long double 135 atan(long double __x) 136 { return __builtin_atanl(__x); } 137 #endif 138 139 template<typename _Tp> 140 inline _GLIBCXX_CONSTEXPR 141 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 142 double>::__type 143 atan(_Tp __x) 144 { return __builtin_atan(__x); } 145 146 using ::atan2; 147 148 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 149 inline _GLIBCXX_CONSTEXPR float 150 atan2(float __y, float __x) 151 { return __builtin_atan2f(__y, __x); } 152 153 inline _GLIBCXX_CONSTEXPR long double 154 atan2(long double __y, long double __x) 155 { return __builtin_atan2l(__y, __x); } 156 #endif 157 158 using ::ceil; 159 160 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 161 inline _GLIBCXX_CONSTEXPR float 162 ceil(float __x) 163 { return __builtin_ceilf(__x); } 164 165 inline _GLIBCXX_CONSTEXPR long double 166 ceil(long double __x) 167 { return __builtin_ceill(__x); } 168 #endif 169 170 template<typename _Tp> 171 inline _GLIBCXX_CONSTEXPR 172 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 173 double>::__type 174 ceil(_Tp __x) 175 { return __builtin_ceil(__x); } 176 177 using ::cos; 178 179 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 180 inline _GLIBCXX_CONSTEXPR float 181 cos(float __x) 182 { return __builtin_cosf(__x); } 183 184 inline _GLIBCXX_CONSTEXPR long double 185 cos(long double __x) 186 { return __builtin_cosl(__x); } 187 #endif 188 189 template<typename _Tp> 190 inline _GLIBCXX_CONSTEXPR 191 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 192 double>::__type 193 cos(_Tp __x) 194 { return __builtin_cos(__x); } 195 196 using ::cosh; 197 198 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 199 inline _GLIBCXX_CONSTEXPR float 200 cosh(float __x) 201 { return __builtin_coshf(__x); } 202 203 inline _GLIBCXX_CONSTEXPR long double 204 cosh(long double __x) 205 { return __builtin_coshl(__x); } 206 #endif 207 208 template<typename _Tp> 209 inline _GLIBCXX_CONSTEXPR 210 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 211 double>::__type 212 cosh(_Tp __x) 213 { return __builtin_cosh(__x); } 214 215 using ::exp; 216 217 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 218 inline _GLIBCXX_CONSTEXPR float 219 exp(float __x) 220 { return __builtin_expf(__x); } 221 222 inline _GLIBCXX_CONSTEXPR long double 223 exp(long double __x) 224 { return __builtin_expl(__x); } 225 #endif 226 227 template<typename _Tp> 228 inline _GLIBCXX_CONSTEXPR 229 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 230 double>::__type 231 exp(_Tp __x) 232 { return __builtin_exp(__x); } 233 234 using ::fabs; 235 236 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 237 inline _GLIBCXX_CONSTEXPR float 238 fabs(float __x) 239 { return __builtin_fabsf(__x); } 240 241 inline _GLIBCXX_CONSTEXPR long double 242 fabs(long double __x) 243 { return __builtin_fabsl(__x); } 244 #endif 245 246 template<typename _Tp> 247 inline _GLIBCXX_CONSTEXPR 248 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 249 double>::__type 250 fabs(_Tp __x) 251 { return __builtin_fabs(__x); } 252 253 using ::floor; 254 255 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 256 inline _GLIBCXX_CONSTEXPR float 257 floor(float __x) 258 { return __builtin_floorf(__x); } 259 260 inline _GLIBCXX_CONSTEXPR long double 261 floor(long double __x) 262 { return __builtin_floorl(__x); } 263 #endif 264 265 template<typename _Tp> 266 inline _GLIBCXX_CONSTEXPR 267 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 268 double>::__type 269 floor(_Tp __x) 270 { return __builtin_floor(__x); } 271 272 using ::fmod; 273 274 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 275 inline _GLIBCXX_CONSTEXPR float 276 fmod(float __x, float __y) 277 { return __builtin_fmodf(__x, __y); } 278 279 inline _GLIBCXX_CONSTEXPR long double 280 fmod(long double __x, long double __y) 281 { return __builtin_fmodl(__x, __y); } 282 #endif 283 284 using ::frexp; 285 286 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 287 inline float 288 frexp(float __x, int* __exp) 289 { return __builtin_frexpf(__x, __exp); } 290 291 inline long double 292 frexp(long double __x, int* __exp) 293 { return __builtin_frexpl(__x, __exp); } 294 #endif 295 296 template<typename _Tp> 297 inline _GLIBCXX_CONSTEXPR 298 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 299 double>::__type 300 frexp(_Tp __x, int* __exp) 301 { return __builtin_frexp(__x, __exp); } 302 303 using ::ldexp; 304 305 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 306 inline _GLIBCXX_CONSTEXPR float 307 ldexp(float __x, int __exp) 308 { return __builtin_ldexpf(__x, __exp); } 309 310 inline _GLIBCXX_CONSTEXPR long double 311 ldexp(long double __x, int __exp) 312 { return __builtin_ldexpl(__x, __exp); } 313 #endif 314 315 template<typename _Tp> 316 inline _GLIBCXX_CONSTEXPR 317 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 318 double>::__type 319 ldexp(_Tp __x, int __exp) 320 { return __builtin_ldexp(__x, __exp); } 321 322 using ::log; 323 324 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 325 inline _GLIBCXX_CONSTEXPR float 326 log(float __x) 327 { return __builtin_logf(__x); } 328 329 inline _GLIBCXX_CONSTEXPR long double 330 log(long double __x) 331 { return __builtin_logl(__x); } 332 #endif 333 334 template<typename _Tp> 335 inline _GLIBCXX_CONSTEXPR 336 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 337 double>::__type 338 log(_Tp __x) 339 { return __builtin_log(__x); } 340 341 using ::log10; 342 343 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 344 inline _GLIBCXX_CONSTEXPR float 345 log10(float __x) 346 { return __builtin_log10f(__x); } 347 348 inline _GLIBCXX_CONSTEXPR long double 349 log10(long double __x) 350 { return __builtin_log10l(__x); } 351 #endif 352 353 template<typename _Tp> 354 inline _GLIBCXX_CONSTEXPR 355 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 356 double>::__type 357 log10(_Tp __x) 358 { return __builtin_log10(__x); } 359 360 using ::modf; 361 362 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 363 inline float 364 modf(float __x, float* __iptr) 365 { return __builtin_modff(__x, __iptr); } 366 367 inline long double 368 modf(long double __x, long double* __iptr) 369 { return __builtin_modfl(__x, __iptr); } 370 #endif 371 372 using ::pow; 373 374 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 375 inline _GLIBCXX_CONSTEXPR float 376 pow(float __x, float __y) 377 { return __builtin_powf(__x, __y); } 378 379 inline _GLIBCXX_CONSTEXPR long double 380 pow(long double __x, long double __y) 381 { return __builtin_powl(__x, __y); } 382 383 #if __cplusplus < 201103L 384 // _GLIBCXX_RESOLVE_LIB_DEFECTS 385 // DR 550. What should the return type of pow(float,int) be? 386 inline double 387 pow(double __x, int __i) 388 { return __builtin_powi(__x, __i); } 389 390 inline float 391 pow(float __x, int __n) 392 { return __builtin_powif(__x, __n); } 393 394 inline long double 395 pow(long double __x, int __n) 396 { return __builtin_powil(__x, __n); } 397 #endif 398 #endif 399 400 using ::sin; 401 402 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 403 inline _GLIBCXX_CONSTEXPR float 404 sin(float __x) 405 { return __builtin_sinf(__x); } 406 407 inline _GLIBCXX_CONSTEXPR long double 408 sin(long double __x) 409 { return __builtin_sinl(__x); } 410 #endif 411 412 template<typename _Tp> 413 inline _GLIBCXX_CONSTEXPR 414 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 415 double>::__type 416 sin(_Tp __x) 417 { return __builtin_sin(__x); } 418 419 using ::sinh; 420 421 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 422 inline _GLIBCXX_CONSTEXPR float 423 sinh(float __x) 424 { return __builtin_sinhf(__x); } 425 426 inline _GLIBCXX_CONSTEXPR long double 427 sinh(long double __x) 428 { return __builtin_sinhl(__x); } 429 #endif 430 431 template<typename _Tp> 432 inline _GLIBCXX_CONSTEXPR 433 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 434 double>::__type 435 sinh(_Tp __x) 436 { return __builtin_sinh(__x); } 437 438 using ::sqrt; 439 440 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 441 inline _GLIBCXX_CONSTEXPR float 442 sqrt(float __x) 443 { return __builtin_sqrtf(__x); } 444 445 inline _GLIBCXX_CONSTEXPR long double 446 sqrt(long double __x) 447 { return __builtin_sqrtl(__x); } 448 #endif 449 450 template<typename _Tp> 451 inline _GLIBCXX_CONSTEXPR 452 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 453 double>::__type 454 sqrt(_Tp __x) 455 { return __builtin_sqrt(__x); } 456 457 using ::tan; 458 459 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 460 inline _GLIBCXX_CONSTEXPR float 461 tan(float __x) 462 { return __builtin_tanf(__x); } 463 464 inline _GLIBCXX_CONSTEXPR long double 465 tan(long double __x) 466 { return __builtin_tanl(__x); } 467 #endif 468 469 template<typename _Tp> 470 inline _GLIBCXX_CONSTEXPR 471 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 472 double>::__type 473 tan(_Tp __x) 474 { return __builtin_tan(__x); } 475 476 using ::tanh; 477 478 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO 479 inline _GLIBCXX_CONSTEXPR float 480 tanh(float __x) 481 { return __builtin_tanhf(__x); } 482 483 inline _GLIBCXX_CONSTEXPR long double 484 tanh(long double __x) 485 { return __builtin_tanhl(__x); } 486 #endif 487 488 template<typename _Tp> 489 inline _GLIBCXX_CONSTEXPR 490 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 491 double>::__type 492 tanh(_Tp __x) 493 { return __builtin_tanh(__x); } 494 495 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) 496 constexpr _Float16 497 acos(_Float16 __x) 498 { return _Float16(__builtin_acosf(__x)); } 499 500 constexpr _Float16 501 asin(_Float16 __x) 502 { return _Float16(__builtin_asinf(__x)); } 503 504 constexpr _Float16 505 atan(_Float16 __x) 506 { return _Float16(__builtin_atanf(__x)); } 507 508 constexpr _Float16 509 atan2(_Float16 __y, _Float16 __x) 510 { return _Float16(__builtin_atan2f(__y, __x)); } 511 512 constexpr _Float16 513 ceil(_Float16 __x) 514 { return _Float16(__builtin_ceilf(__x)); } 515 516 constexpr _Float16 517 cos(_Float16 __x) 518 { return _Float16(__builtin_cosf(__x)); } 519 520 constexpr _Float16 521 cosh(_Float16 __x) 522 { return _Float16(__builtin_coshf(__x)); } 523 524 constexpr _Float16 525 exp(_Float16 __x) 526 { return _Float16(__builtin_expf(__x)); } 527 528 constexpr _Float16 529 fabs(_Float16 __x) 530 { return _Float16(__builtin_fabsf(__x)); } 531 532 constexpr _Float16 533 floor(_Float16 __x) 534 { return _Float16(__builtin_floorf(__x)); } 535 536 constexpr _Float16 537 fmod(_Float16 __x, _Float16 __y) 538 { return _Float16(__builtin_fmodf(__x, __y)); } 539 540 inline _Float16 541 frexp(_Float16 __x, int* __exp) 542 { return _Float16(__builtin_frexpf(__x, __exp)); } 543 544 constexpr _Float16 545 ldexp(_Float16 __x, int __exp) 546 { return _Float16(__builtin_ldexpf(__x, __exp)); } 547 548 constexpr _Float16 549 log(_Float16 __x) 550 { return _Float16(__builtin_logf(__x)); } 551 552 constexpr _Float16 553 log10(_Float16 __x) 554 { return _Float16(__builtin_log10f(__x)); } 555 556 inline _Float16 557 modf(_Float16 __x, _Float16* __iptr) 558 { 559 float __i, __ret = __builtin_modff(__x, &__i); 560 *__iptr = _Float16(__i); 561 return _Float16(__ret); 562 } 563 564 constexpr _Float16 565 pow(_Float16 __x, _Float16 __y) 566 { return _Float16(__builtin_powf(__x, __y)); } 567 568 constexpr _Float16 569 sin(_Float16 __x) 570 { return _Float16(__builtin_sinf(__x)); } 571 572 constexpr _Float16 573 sinh(_Float16 __x) 574 { return _Float16(__builtin_sinhf(__x)); } 575 576 constexpr _Float16 577 sqrt(_Float16 __x) 578 { return _Float16(__builtin_sqrtf(__x)); } 579 580 constexpr _Float16 581 tan(_Float16 __x) 582 { return _Float16(__builtin_tanf(__x)); } 583 584 constexpr _Float16 585 tanh(_Float16 __x) 586 { return _Float16(__builtin_tanhf(__x)); } 587 #endif 588 589 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) 590 constexpr _Float32 591 acos(_Float32 __x) 592 { return __builtin_acosf(__x); } 593 594 constexpr _Float32 595 asin(_Float32 __x) 596 { return __builtin_asinf(__x); } 597 598 constexpr _Float32 599 atan(_Float32 __x) 600 { return __builtin_atanf(__x); } 601 602 constexpr _Float32 603 atan2(_Float32 __y, _Float32 __x) 604 { return __builtin_atan2f(__y, __x); } 605 606 constexpr _Float32 607 ceil(_Float32 __x) 608 { return __builtin_ceilf(__x); } 609 610 constexpr _Float32 611 cos(_Float32 __x) 612 { return __builtin_cosf(__x); } 613 614 constexpr _Float32 615 cosh(_Float32 __x) 616 { return __builtin_coshf(__x); } 617 618 constexpr _Float32 619 exp(_Float32 __x) 620 { return __builtin_expf(__x); } 621 622 constexpr _Float32 623 fabs(_Float32 __x) 624 { return __builtin_fabsf(__x); } 625 626 constexpr _Float32 627 floor(_Float32 __x) 628 { return __builtin_floorf(__x); } 629 630 constexpr _Float32 631 fmod(_Float32 __x, _Float32 __y) 632 { return __builtin_fmodf(__x, __y); } 633 634 inline _Float32 635 frexp(_Float32 __x, int* __exp) 636 { return __builtin_frexpf(__x, __exp); } 637 638 constexpr _Float32 639 ldexp(_Float32 __x, int __exp) 640 { return __builtin_ldexpf(__x, __exp); } 641 642 constexpr _Float32 643 log(_Float32 __x) 644 { return __builtin_logf(__x); } 645 646 constexpr _Float32 647 log10(_Float32 __x) 648 { return __builtin_log10f(__x); } 649 650 inline _Float32 651 modf(_Float32 __x, _Float32* __iptr) 652 { 653 float __i, __ret = __builtin_modff(__x, &__i); 654 *__iptr = __i; 655 return __ret; 656 } 657 658 constexpr _Float32 659 pow(_Float32 __x, _Float32 __y) 660 { return __builtin_powf(__x, __y); } 661 662 constexpr _Float32 663 sin(_Float32 __x) 664 { return __builtin_sinf(__x); } 665 666 constexpr _Float32 667 sinh(_Float32 __x) 668 { return __builtin_sinhf(__x); } 669 670 constexpr _Float32 671 sqrt(_Float32 __x) 672 { return __builtin_sqrtf(__x); } 673 674 constexpr _Float32 675 tan(_Float32 __x) 676 { return __builtin_tanf(__x); } 677 678 constexpr _Float32 679 tanh(_Float32 __x) 680 { return __builtin_tanhf(__x); } 681 #endif 682 683 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64) 684 constexpr _Float64 685 acos(_Float64 __x) 686 { return __builtin_acos(__x); } 687 688 constexpr _Float64 689 asin(_Float64 __x) 690 { return __builtin_asin(__x); } 691 692 constexpr _Float64 693 atan(_Float64 __x) 694 { return __builtin_atan(__x); } 695 696 constexpr _Float64 697 atan2(_Float64 __y, _Float64 __x) 698 { return __builtin_atan2(__y, __x); } 699 700 constexpr _Float64 701 ceil(_Float64 __x) 702 { return __builtin_ceil(__x); } 703 704 constexpr _Float64 705 cos(_Float64 __x) 706 { return __builtin_cos(__x); } 707 708 constexpr _Float64 709 cosh(_Float64 __x) 710 { return __builtin_cosh(__x); } 711 712 constexpr _Float64 713 exp(_Float64 __x) 714 { return __builtin_exp(__x); } 715 716 constexpr _Float64 717 fabs(_Float64 __x) 718 { return __builtin_fabs(__x); } 719 720 constexpr _Float64 721 floor(_Float64 __x) 722 { return __builtin_floor(__x); } 723 724 constexpr _Float64 725 fmod(_Float64 __x, _Float64 __y) 726 { return __builtin_fmod(__x, __y); } 727 728 inline _Float64 729 frexp(_Float64 __x, int* __exp) 730 { return __builtin_frexp(__x, __exp); } 731 732 constexpr _Float64 733 ldexp(_Float64 __x, int __exp) 734 { return __builtin_ldexp(__x, __exp); } 735 736 constexpr _Float64 737 log(_Float64 __x) 738 { return __builtin_log(__x); } 739 740 constexpr _Float64 741 log10(_Float64 __x) 742 { return __builtin_log10(__x); } 743 744 inline _Float64 745 modf(_Float64 __x, _Float64* __iptr) 746 { 747 double __i, __ret = __builtin_modf(__x, &__i); 748 *__iptr = __i; 749 return __ret; 750 } 751 752 constexpr _Float64 753 pow(_Float64 __x, _Float64 __y) 754 { return __builtin_pow(__x, __y); } 755 756 constexpr _Float64 757 sin(_Float64 __x) 758 { return __builtin_sin(__x); } 759 760 constexpr _Float64 761 sinh(_Float64 __x) 762 { return __builtin_sinh(__x); } 763 764 constexpr _Float64 765 sqrt(_Float64 __x) 766 { return __builtin_sqrt(__x); } 767 768 constexpr _Float64 769 tan(_Float64 __x) 770 { return __builtin_tan(__x); } 771 772 constexpr _Float64 773 tanh(_Float64 __x) 774 { return __builtin_tanh(__x); } 775 #endif 776 777 #if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) 778 constexpr _Float128 779 acos(_Float128 __x) 780 { return __builtin_acosl(__x); } 781 782 constexpr _Float128 783 asin(_Float128 __x) 784 { return __builtin_asinl(__x); } 785 786 constexpr _Float128 787 atan(_Float128 __x) 788 { return __builtin_atanl(__x); } 789 790 constexpr _Float128 791 atan2(_Float128 __y, _Float128 __x) 792 { return __builtin_atan2l(__y, __x); } 793 794 constexpr _Float128 795 ceil(_Float128 __x) 796 { return __builtin_ceill(__x); } 797 798 constexpr _Float128 799 cos(_Float128 __x) 800 { return __builtin_cosl(__x); } 801 802 constexpr _Float128 803 cosh(_Float128 __x) 804 { return __builtin_coshl(__x); } 805 806 constexpr _Float128 807 exp(_Float128 __x) 808 { return __builtin_expl(__x); } 809 810 constexpr _Float128 811 fabs(_Float128 __x) 812 { return __builtin_fabsl(__x); } 813 814 constexpr _Float128 815 floor(_Float128 __x) 816 { return __builtin_floorl(__x); } 817 818 constexpr _Float128 819 fmod(_Float128 __x, _Float128 __y) 820 { return __builtin_fmodl(__x, __y); } 821 822 inline _Float128 823 frexp(_Float128 __x, int* __exp) 824 { return __builtin_frexpl(__x, __exp); } 825 826 constexpr _Float128 827 ldexp(_Float128 __x, int __exp) 828 { return __builtin_ldexpl(__x, __exp); } 829 830 constexpr _Float128 831 log(_Float128 __x) 832 { return __builtin_logl(__x); } 833 834 constexpr _Float128 835 log10(_Float128 __x) 836 { return __builtin_log10l(__x); } 837 838 inline _Float128 839 modf(_Float128 __x, _Float128* __iptr) 840 { 841 long double __i, __ret = __builtin_modfl(__x, &__i); 842 *__iptr = __i; 843 return __ret; 844 } 845 846 constexpr _Float128 847 pow(_Float128 __x, _Float128 __y) 848 { return __builtin_powl(__x, __y); } 849 850 constexpr _Float128 851 sin(_Float128 __x) 852 { return __builtin_sinl(__x); } 853 854 constexpr _Float128 855 sinh(_Float128 __x) 856 { return __builtin_sinhl(__x); } 857 858 constexpr _Float128 859 sqrt(_Float128 __x) 860 { return __builtin_sqrtl(__x); } 861 862 constexpr _Float128 863 tan(_Float128 __x) 864 { return __builtin_tanl(__x); } 865 866 constexpr _Float128 867 tanh(_Float128 __x) 868 { return __builtin_tanhl(__x); } 869 #elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH) 870 constexpr _Float128 871 acos(_Float128 __x) 872 { return __builtin_acosf128(__x); } 873 874 constexpr _Float128 875 asin(_Float128 __x) 876 { return __builtin_asinf128(__x); } 877 878 constexpr _Float128 879 atan(_Float128 __x) 880 { return __builtin_atanf128(__x); } 881 882 constexpr _Float128 883 atan2(_Float128 __y, _Float128 __x) 884 { return __builtin_atan2f128(__y, __x); } 885 886 constexpr _Float128 887 ceil(_Float128 __x) 888 { return __builtin_ceilf128(__x); } 889 890 constexpr _Float128 891 cos(_Float128 __x) 892 { return __builtin_cosf128(__x); } 893 894 constexpr _Float128 895 cosh(_Float128 __x) 896 { return __builtin_coshf128(__x); } 897 898 constexpr _Float128 899 exp(_Float128 __x) 900 { return __builtin_expf128(__x); } 901 902 constexpr _Float128 903 fabs(_Float128 __x) 904 { return __builtin_fabsf128(__x); } 905 906 constexpr _Float128 907 floor(_Float128 __x) 908 { return __builtin_floorf128(__x); } 909 910 constexpr _Float128 911 fmod(_Float128 __x, _Float128 __y) 912 { return __builtin_fmodf128(__x, __y); } 913 914 inline _Float128 915 frexp(_Float128 __x, int* __exp) 916 { return __builtin_frexpf128(__x, __exp); } 917 918 constexpr _Float128 919 ldexp(_Float128 __x, int __exp) 920 { return __builtin_ldexpf128(__x, __exp); } 921 922 constexpr _Float128 923 log(_Float128 __x) 924 { return __builtin_logf128(__x); } 925 926 constexpr _Float128 927 log10(_Float128 __x) 928 { return __builtin_log10f128(__x); } 929 930 inline _Float128 931 modf(_Float128 __x, _Float128* __iptr) 932 { return __builtin_modff128(__x, __iptr); } 933 934 constexpr _Float128 935 pow(_Float128 __x, _Float128 __y) 936 { return __builtin_powf128(__x, __y); } 937 938 constexpr _Float128 939 sin(_Float128 __x) 940 { return __builtin_sinf128(__x); } 941 942 constexpr _Float128 943 sinh(_Float128 __x) 944 { return __builtin_sinhf128(__x); } 945 946 constexpr _Float128 947 sqrt(_Float128 __x) 948 { return __builtin_sqrtf128(__x); } 949 950 constexpr _Float128 951 tan(_Float128 __x) 952 { return __builtin_tanf128(__x); } 953 954 constexpr _Float128 955 tanh(_Float128 __x) 956 { return __builtin_tanhf128(__x); } 957 #endif 958 959 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) 960 constexpr __gnu_cxx::__bfloat16_t 961 acos(__gnu_cxx::__bfloat16_t __x) 962 { return __gnu_cxx::__bfloat16_t(__builtin_acosf(__x)); } 963 964 constexpr __gnu_cxx::__bfloat16_t 965 asin(__gnu_cxx::__bfloat16_t __x) 966 { return __gnu_cxx::__bfloat16_t(__builtin_asinf(__x)); } 967 968 constexpr __gnu_cxx::__bfloat16_t 969 atan(__gnu_cxx::__bfloat16_t __x) 970 { return __gnu_cxx::__bfloat16_t(__builtin_atanf(__x)); } 971 972 constexpr __gnu_cxx::__bfloat16_t 973 atan2(__gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __x) 974 { return __gnu_cxx::__bfloat16_t(__builtin_atan2f(__y, __x)); } 975 976 constexpr __gnu_cxx::__bfloat16_t 977 ceil(__gnu_cxx::__bfloat16_t __x) 978 { return __gnu_cxx::__bfloat16_t(__builtin_ceilf(__x)); } 979 980 constexpr __gnu_cxx::__bfloat16_t 981 cos(__gnu_cxx::__bfloat16_t __x) 982 { return __gnu_cxx::__bfloat16_t(__builtin_cosf(__x)); } 983 984 constexpr __gnu_cxx::__bfloat16_t 985 cosh(__gnu_cxx::__bfloat16_t __x) 986 { return __gnu_cxx::__bfloat16_t(__builtin_coshf(__x)); } 987 988 constexpr __gnu_cxx::__bfloat16_t 989 exp(__gnu_cxx::__bfloat16_t __x) 990 { return __gnu_cxx::__bfloat16_t(__builtin_expf(__x)); } 991 992 constexpr __gnu_cxx::__bfloat16_t 993 fabs(__gnu_cxx::__bfloat16_t __x) 994 { return __gnu_cxx::__bfloat16_t(__builtin_fabsf(__x)); } 995 996 constexpr __gnu_cxx::__bfloat16_t 997 floor(__gnu_cxx::__bfloat16_t __x) 998 { return __gnu_cxx::__bfloat16_t(__builtin_floorf(__x)); } 999 1000 constexpr __gnu_cxx::__bfloat16_t 1001 fmod(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 1002 { return __gnu_cxx::__bfloat16_t(__builtin_fmodf(__x, __y)); } 1003 1004 inline __gnu_cxx::__bfloat16_t 1005 frexp(__gnu_cxx::__bfloat16_t __x, int* __exp) 1006 { return __gnu_cxx::__bfloat16_t(__builtin_frexpf(__x, __exp)); } 1007 1008 constexpr __gnu_cxx::__bfloat16_t 1009 ldexp(__gnu_cxx::__bfloat16_t __x, int __exp) 1010 { return __gnu_cxx::__bfloat16_t(__builtin_ldexpf(__x, __exp)); } 1011 1012 constexpr __gnu_cxx::__bfloat16_t 1013 log(__gnu_cxx::__bfloat16_t __x) 1014 { return __gnu_cxx::__bfloat16_t(__builtin_logf(__x)); } 1015 1016 constexpr __gnu_cxx::__bfloat16_t 1017 log10(__gnu_cxx::__bfloat16_t __x) 1018 { return __gnu_cxx::__bfloat16_t(__builtin_log10f(__x)); } 1019 1020 inline __gnu_cxx::__bfloat16_t 1021 modf(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t* __iptr) 1022 { 1023 float __i, __ret = __builtin_modff(__x, &__i); 1024 *__iptr = __gnu_cxx::__bfloat16_t(__i); 1025 return __gnu_cxx::__bfloat16_t(__ret); 1026 } 1027 1028 constexpr __gnu_cxx::__bfloat16_t 1029 pow(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 1030 { return __gnu_cxx::__bfloat16_t(__builtin_powf(__x, __y)); } 1031 1032 constexpr __gnu_cxx::__bfloat16_t 1033 sin(__gnu_cxx::__bfloat16_t __x) 1034 { return __gnu_cxx::__bfloat16_t(__builtin_sinf(__x)); } 1035 1036 constexpr __gnu_cxx::__bfloat16_t 1037 sinh(__gnu_cxx::__bfloat16_t __x) 1038 { return __gnu_cxx::__bfloat16_t(__builtin_sinhf(__x)); } 1039 1040 constexpr __gnu_cxx::__bfloat16_t 1041 sqrt(__gnu_cxx::__bfloat16_t __x) 1042 { return __gnu_cxx::__bfloat16_t(__builtin_sqrtf(__x)); } 1043 1044 constexpr __gnu_cxx::__bfloat16_t 1045 tan(__gnu_cxx::__bfloat16_t __x) 1046 { return __gnu_cxx::__bfloat16_t(__builtin_tanf(__x)); } 1047 1048 constexpr __gnu_cxx::__bfloat16_t 1049 tanh(__gnu_cxx::__bfloat16_t __x) 1050 { return __gnu_cxx::__bfloat16_t(__builtin_tanhf(__x)); } 1051 #endif 1052 1053 template<typename _Tp, typename _Up> 1054 inline _GLIBCXX_CONSTEXPR 1055 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1056 atan2(_Tp __y, _Up __x) 1057 { 1058 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1059 return atan2(__type(__y), __type(__x)); 1060 } 1061 1062 template<typename _Tp, typename _Up> 1063 inline _GLIBCXX_CONSTEXPR 1064 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1065 fmod(_Tp __x, _Up __y) 1066 { 1067 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1068 return fmod(__type(__x), __type(__y)); 1069 } 1070 1071 template<typename _Tp, typename _Up> 1072 inline _GLIBCXX_CONSTEXPR 1073 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 1074 pow(_Tp __x, _Up __y) 1075 { 1076 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1077 return pow(__type(__x), __type(__y)); 1078 } 1079 1080 #if _GLIBCXX_USE_C99_MATH 1081 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC 1082 1083 // These are possible macros imported from C99-land. 1084 #undef fpclassify 1085 #undef isfinite 1086 #undef isinf 1087 #undef isnan 1088 #undef isnormal 1089 #undef signbit 1090 #undef isgreater 1091 #undef isgreaterequal 1092 #undef isless 1093 #undef islessequal 1094 #undef islessgreater 1095 #undef isunordered 1096 1097 #if __cplusplus >= 201103L 1098 1099 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1100 constexpr int 1101 fpclassify(float __x) 1102 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 1103 FP_SUBNORMAL, FP_ZERO, __x); } 1104 1105 constexpr int 1106 fpclassify(double __x) 1107 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 1108 FP_SUBNORMAL, FP_ZERO, __x); } 1109 1110 constexpr int 1111 fpclassify(long double __x) 1112 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 1113 FP_SUBNORMAL, FP_ZERO, __x); } 1114 #endif 1115 1116 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1117 template<typename _Tp> 1118 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1119 int>::__type 1120 fpclassify(_Tp __x) 1121 { return __x != 0 ? FP_NORMAL : FP_ZERO; } 1122 #endif 1123 1124 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1125 constexpr bool 1126 isfinite(float __x) 1127 { return __builtin_isfinite(__x); } 1128 1129 constexpr bool 1130 isfinite(double __x) 1131 { return __builtin_isfinite(__x); } 1132 1133 constexpr bool 1134 isfinite(long double __x) 1135 { return __builtin_isfinite(__x); } 1136 #endif 1137 1138 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1139 template<typename _Tp> 1140 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1141 bool>::__type 1142 isfinite(_Tp) 1143 { return true; } 1144 #endif 1145 1146 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1147 constexpr bool 1148 isinf(float __x) 1149 { return __builtin_isinf(__x); } 1150 1151 #if _GLIBCXX_HAVE_OBSOLETE_ISINF \ 1152 && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC 1153 using ::isinf; 1154 #else 1155 constexpr bool 1156 isinf(double __x) 1157 { return __builtin_isinf(__x); } 1158 #endif 1159 1160 constexpr bool 1161 isinf(long double __x) 1162 { return __builtin_isinf(__x); } 1163 #endif 1164 1165 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1166 template<typename _Tp> 1167 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1168 bool>::__type 1169 isinf(_Tp) 1170 { return false; } 1171 #endif 1172 1173 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1174 constexpr bool 1175 isnan(float __x) 1176 { return __builtin_isnan(__x); } 1177 1178 #if _GLIBCXX_HAVE_OBSOLETE_ISNAN \ 1179 && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC 1180 using ::isnan; 1181 #else 1182 constexpr bool 1183 isnan(double __x) 1184 { return __builtin_isnan(__x); } 1185 #endif 1186 1187 constexpr bool 1188 isnan(long double __x) 1189 { return __builtin_isnan(__x); } 1190 #endif 1191 1192 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1193 template<typename _Tp> 1194 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1195 bool>::__type 1196 isnan(_Tp) 1197 { return false; } 1198 #endif 1199 1200 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1201 constexpr bool 1202 isnormal(float __x) 1203 { return __builtin_isnormal(__x); } 1204 1205 constexpr bool 1206 isnormal(double __x) 1207 { return __builtin_isnormal(__x); } 1208 1209 constexpr bool 1210 isnormal(long double __x) 1211 { return __builtin_isnormal(__x); } 1212 #endif 1213 1214 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1215 template<typename _Tp> 1216 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1217 bool>::__type 1218 isnormal(_Tp __x) 1219 { return __x != 0 ? true : false; } 1220 #endif 1221 1222 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1223 // Note: middle-end/36757 is fixed, __builtin_signbit is type-generic. 1224 constexpr bool 1225 signbit(float __x) 1226 { return __builtin_signbit(__x); } 1227 1228 constexpr bool 1229 signbit(double __x) 1230 { return __builtin_signbit(__x); } 1231 1232 constexpr bool 1233 signbit(long double __x) 1234 { return __builtin_signbit(__x); } 1235 #endif 1236 1237 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1238 template<typename _Tp> 1239 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 1240 bool>::__type 1241 signbit(_Tp __x) 1242 { return __x < 0 ? true : false; } 1243 #endif 1244 1245 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1246 constexpr bool 1247 isgreater(float __x, float __y) 1248 { return __builtin_isgreater(__x, __y); } 1249 1250 constexpr bool 1251 isgreater(double __x, double __y) 1252 { return __builtin_isgreater(__x, __y); } 1253 1254 constexpr bool 1255 isgreater(long double __x, long double __y) 1256 { return __builtin_isgreater(__x, __y); } 1257 #endif 1258 1259 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1260 template<typename _Tp, typename _Up> 1261 constexpr typename 1262 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 1263 && __is_arithmetic<_Up>::__value), bool>::__type 1264 isgreater(_Tp __x, _Up __y) 1265 { 1266 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1267 return __builtin_isgreater(__type(__x), __type(__y)); 1268 } 1269 #endif 1270 1271 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1272 constexpr bool 1273 isgreaterequal(float __x, float __y) 1274 { return __builtin_isgreaterequal(__x, __y); } 1275 1276 constexpr bool 1277 isgreaterequal(double __x, double __y) 1278 { return __builtin_isgreaterequal(__x, __y); } 1279 1280 constexpr bool 1281 isgreaterequal(long double __x, long double __y) 1282 { return __builtin_isgreaterequal(__x, __y); } 1283 #endif 1284 1285 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1286 template<typename _Tp, typename _Up> 1287 constexpr typename 1288 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 1289 && __is_arithmetic<_Up>::__value), bool>::__type 1290 isgreaterequal(_Tp __x, _Up __y) 1291 { 1292 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1293 return __builtin_isgreaterequal(__type(__x), __type(__y)); 1294 } 1295 #endif 1296 1297 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1298 constexpr bool 1299 isless(float __x, float __y) 1300 { return __builtin_isless(__x, __y); } 1301 1302 constexpr bool 1303 isless(double __x, double __y) 1304 { return __builtin_isless(__x, __y); } 1305 1306 constexpr bool 1307 isless(long double __x, long double __y) 1308 { return __builtin_isless(__x, __y); } 1309 #endif 1310 1311 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1312 template<typename _Tp, typename _Up> 1313 constexpr typename 1314 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 1315 && __is_arithmetic<_Up>::__value), bool>::__type 1316 isless(_Tp __x, _Up __y) 1317 { 1318 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1319 return __builtin_isless(__type(__x), __type(__y)); 1320 } 1321 #endif 1322 1323 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1324 constexpr bool 1325 islessequal(float __x, float __y) 1326 { return __builtin_islessequal(__x, __y); } 1327 1328 constexpr bool 1329 islessequal(double __x, double __y) 1330 { return __builtin_islessequal(__x, __y); } 1331 1332 constexpr bool 1333 islessequal(long double __x, long double __y) 1334 { return __builtin_islessequal(__x, __y); } 1335 #endif 1336 1337 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1338 template<typename _Tp, typename _Up> 1339 constexpr typename 1340 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 1341 && __is_arithmetic<_Up>::__value), bool>::__type 1342 islessequal(_Tp __x, _Up __y) 1343 { 1344 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1345 return __builtin_islessequal(__type(__x), __type(__y)); 1346 } 1347 #endif 1348 1349 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1350 constexpr bool 1351 islessgreater(float __x, float __y) 1352 { return __builtin_islessgreater(__x, __y); } 1353 1354 constexpr bool 1355 islessgreater(double __x, double __y) 1356 { return __builtin_islessgreater(__x, __y); } 1357 1358 constexpr bool 1359 islessgreater(long double __x, long double __y) 1360 { return __builtin_islessgreater(__x, __y); } 1361 #endif 1362 1363 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1364 template<typename _Tp, typename _Up> 1365 constexpr typename 1366 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 1367 && __is_arithmetic<_Up>::__value), bool>::__type 1368 islessgreater(_Tp __x, _Up __y) 1369 { 1370 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1371 return __builtin_islessgreater(__type(__x), __type(__y)); 1372 } 1373 #endif 1374 1375 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1376 constexpr bool 1377 isunordered(float __x, float __y) 1378 { return __builtin_isunordered(__x, __y); } 1379 1380 constexpr bool 1381 isunordered(double __x, double __y) 1382 { return __builtin_isunordered(__x, __y); } 1383 1384 constexpr bool 1385 isunordered(long double __x, long double __y) 1386 { return __builtin_isunordered(__x, __y); } 1387 #endif 1388 1389 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1390 template<typename _Tp, typename _Up> 1391 constexpr typename 1392 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value 1393 && __is_arithmetic<_Up>::__value), bool>::__type 1394 isunordered(_Tp __x, _Up __y) 1395 { 1396 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 1397 return __builtin_isunordered(__type(__x), __type(__y)); 1398 } 1399 #endif 1400 1401 #else 1402 1403 template<typename _Tp> 1404 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 1405 int>::__type 1406 fpclassify(_Tp __f) 1407 { 1408 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1409 return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 1410 FP_SUBNORMAL, FP_ZERO, __type(__f)); 1411 } 1412 1413 template<typename _Tp> 1414 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 1415 int>::__type 1416 isfinite(_Tp __f) 1417 { 1418 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1419 return __builtin_isfinite(__type(__f)); 1420 } 1421 1422 template<typename _Tp> 1423 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 1424 int>::__type 1425 isinf(_Tp __f) 1426 { 1427 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1428 return __builtin_isinf(__type(__f)); 1429 } 1430 1431 template<typename _Tp> 1432 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 1433 int>::__type 1434 isnan(_Tp __f) 1435 { 1436 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1437 return __builtin_isnan(__type(__f)); 1438 } 1439 1440 template<typename _Tp> 1441 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 1442 int>::__type 1443 isnormal(_Tp __f) 1444 { 1445 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1446 return __builtin_isnormal(__type(__f)); 1447 } 1448 1449 template<typename _Tp> 1450 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 1451 int>::__type 1452 signbit(_Tp __f) 1453 { 1454 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1455 return __builtin_signbit(__type(__f)); 1456 } 1457 1458 template<typename _Tp> 1459 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 1460 int>::__type 1461 isgreater(_Tp __f1, _Tp __f2) 1462 { 1463 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1464 return __builtin_isgreater(__type(__f1), __type(__f2)); 1465 } 1466 1467 template<typename _Tp> 1468 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 1469 int>::__type 1470 isgreaterequal(_Tp __f1, _Tp __f2) 1471 { 1472 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1473 return __builtin_isgreaterequal(__type(__f1), __type(__f2)); 1474 } 1475 1476 template<typename _Tp> 1477 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 1478 int>::__type 1479 isless(_Tp __f1, _Tp __f2) 1480 { 1481 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1482 return __builtin_isless(__type(__f1), __type(__f2)); 1483 } 1484 1485 template<typename _Tp> 1486 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 1487 int>::__type 1488 islessequal(_Tp __f1, _Tp __f2) 1489 { 1490 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1491 return __builtin_islessequal(__type(__f1), __type(__f2)); 1492 } 1493 1494 template<typename _Tp> 1495 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 1496 int>::__type 1497 islessgreater(_Tp __f1, _Tp __f2) 1498 { 1499 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1500 return __builtin_islessgreater(__type(__f1), __type(__f2)); 1501 } 1502 1503 template<typename _Tp> 1504 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, 1505 int>::__type 1506 isunordered(_Tp __f1, _Tp __f2) 1507 { 1508 typedef typename __gnu_cxx::__promote<_Tp>::__type __type; 1509 return __builtin_isunordered(__type(__f1), __type(__f2)); 1510 } 1511 1512 #endif // C++11 1513 1514 #ifdef __STDCPP_FLOAT16_T__ 1515 constexpr int 1516 fpclassify(_Float16 __x) 1517 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 1518 FP_SUBNORMAL, FP_ZERO, __x); } 1519 1520 constexpr bool 1521 isfinite(_Float16 __x) 1522 { return __builtin_isfinite(__x); } 1523 1524 constexpr bool 1525 isinf(_Float16 __x) 1526 { return __builtin_isinf(__x); } 1527 1528 constexpr bool 1529 isnan(_Float16 __x) 1530 { return __builtin_isnan(__x); } 1531 1532 constexpr bool 1533 isnormal(_Float16 __x) 1534 { return __builtin_isnormal(__x); } 1535 1536 constexpr bool 1537 signbit(_Float16 __x) 1538 { return __builtin_signbit(__x); } 1539 1540 constexpr bool 1541 isgreater(_Float16 __x, _Float16 __y) 1542 { return __builtin_isgreater(__x, __y); } 1543 1544 constexpr bool 1545 isgreaterequal(_Float16 __x, _Float16 __y) 1546 { return __builtin_isgreaterequal(__x, __y); } 1547 1548 constexpr bool 1549 isless(_Float16 __x, _Float16 __y) 1550 { return __builtin_isless(__x, __y); } 1551 1552 constexpr bool 1553 islessequal(_Float16 __x, _Float16 __y) 1554 { return __builtin_islessequal(__x, __y); } 1555 1556 constexpr bool 1557 islessgreater(_Float16 __x, _Float16 __y) 1558 { return __builtin_islessgreater(__x, __y); } 1559 1560 constexpr bool 1561 isunordered(_Float16 __x, _Float16 __y) 1562 { return __builtin_isunordered(__x, __y); } 1563 #endif 1564 1565 #ifdef __STDCPP_FLOAT32_T__ 1566 constexpr int 1567 fpclassify(_Float32 __x) 1568 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 1569 FP_SUBNORMAL, FP_ZERO, __x); } 1570 1571 constexpr bool 1572 isfinite(_Float32 __x) 1573 { return __builtin_isfinite(__x); } 1574 1575 constexpr bool 1576 isinf(_Float32 __x) 1577 { return __builtin_isinf(__x); } 1578 1579 constexpr bool 1580 isnan(_Float32 __x) 1581 { return __builtin_isnan(__x); } 1582 1583 constexpr bool 1584 isnormal(_Float32 __x) 1585 { return __builtin_isnormal(__x); } 1586 1587 constexpr bool 1588 signbit(_Float32 __x) 1589 { return __builtin_signbit(__x); } 1590 1591 constexpr bool 1592 isgreater(_Float32 __x, _Float32 __y) 1593 { return __builtin_isgreater(__x, __y); } 1594 1595 constexpr bool 1596 isgreaterequal(_Float32 __x, _Float32 __y) 1597 { return __builtin_isgreaterequal(__x, __y); } 1598 1599 constexpr bool 1600 isless(_Float32 __x, _Float32 __y) 1601 { return __builtin_isless(__x, __y); } 1602 1603 constexpr bool 1604 islessequal(_Float32 __x, _Float32 __y) 1605 { return __builtin_islessequal(__x, __y); } 1606 1607 constexpr bool 1608 islessgreater(_Float32 __x, _Float32 __y) 1609 { return __builtin_islessgreater(__x, __y); } 1610 1611 constexpr bool 1612 isunordered(_Float32 __x, _Float32 __y) 1613 { return __builtin_isunordered(__x, __y); } 1614 #endif 1615 1616 #ifdef __STDCPP_FLOAT64_T__ 1617 constexpr int 1618 fpclassify(_Float64 __x) 1619 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 1620 FP_SUBNORMAL, FP_ZERO, __x); } 1621 1622 constexpr bool 1623 isfinite(_Float64 __x) 1624 { return __builtin_isfinite(__x); } 1625 1626 constexpr bool 1627 isinf(_Float64 __x) 1628 { return __builtin_isinf(__x); } 1629 1630 constexpr bool 1631 isnan(_Float64 __x) 1632 { return __builtin_isnan(__x); } 1633 1634 constexpr bool 1635 isnormal(_Float64 __x) 1636 { return __builtin_isnormal(__x); } 1637 1638 constexpr bool 1639 signbit(_Float64 __x) 1640 { return __builtin_signbit(__x); } 1641 1642 constexpr bool 1643 isgreater(_Float64 __x, _Float64 __y) 1644 { return __builtin_isgreater(__x, __y); } 1645 1646 constexpr bool 1647 isgreaterequal(_Float64 __x, _Float64 __y) 1648 { return __builtin_isgreaterequal(__x, __y); } 1649 1650 constexpr bool 1651 isless(_Float64 __x, _Float64 __y) 1652 { return __builtin_isless(__x, __y); } 1653 1654 constexpr bool 1655 islessequal(_Float64 __x, _Float64 __y) 1656 { return __builtin_islessequal(__x, __y); } 1657 1658 constexpr bool 1659 islessgreater(_Float64 __x, _Float64 __y) 1660 { return __builtin_islessgreater(__x, __y); } 1661 1662 constexpr bool 1663 isunordered(_Float64 __x, _Float64 __y) 1664 { return __builtin_isunordered(__x, __y); } 1665 #endif 1666 1667 #ifdef __STDCPP_FLOAT128_T__ 1668 constexpr int 1669 fpclassify(_Float128 __x) 1670 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 1671 FP_SUBNORMAL, FP_ZERO, __x); } 1672 1673 constexpr bool 1674 isfinite(_Float128 __x) 1675 { return __builtin_isfinite(__x); } 1676 1677 constexpr bool 1678 isinf(_Float128 __x) 1679 { return __builtin_isinf(__x); } 1680 1681 constexpr bool 1682 isnan(_Float128 __x) 1683 { return __builtin_isnan(__x); } 1684 1685 constexpr bool 1686 isnormal(_Float128 __x) 1687 { return __builtin_isnormal(__x); } 1688 1689 constexpr bool 1690 signbit(_Float128 __x) 1691 { return __builtin_signbit(__x); } 1692 1693 constexpr bool 1694 isgreater(_Float128 __x, _Float128 __y) 1695 { return __builtin_isgreater(__x, __y); } 1696 1697 constexpr bool 1698 isgreaterequal(_Float128 __x, _Float128 __y) 1699 { return __builtin_isgreaterequal(__x, __y); } 1700 1701 constexpr bool 1702 isless(_Float128 __x, _Float128 __y) 1703 { return __builtin_isless(__x, __y); } 1704 1705 constexpr bool 1706 islessequal(_Float128 __x, _Float128 __y) 1707 { return __builtin_islessequal(__x, __y); } 1708 1709 constexpr bool 1710 islessgreater(_Float128 __x, _Float128 __y) 1711 { return __builtin_islessgreater(__x, __y); } 1712 1713 constexpr bool 1714 isunordered(_Float128 __x, _Float128 __y) 1715 { return __builtin_isunordered(__x, __y); } 1716 #endif 1717 1718 #ifdef __STDCPP_BFLOAT16_T__ 1719 constexpr int 1720 fpclassify(__gnu_cxx::__bfloat16_t __x) 1721 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, 1722 FP_SUBNORMAL, FP_ZERO, __x); } 1723 1724 constexpr bool 1725 isfinite(__gnu_cxx::__bfloat16_t __x) 1726 { return __builtin_isfinite(__x); } 1727 1728 constexpr bool 1729 isinf(__gnu_cxx::__bfloat16_t __x) 1730 { return __builtin_isinf(__x); } 1731 1732 constexpr bool 1733 isnan(__gnu_cxx::__bfloat16_t __x) 1734 { return __builtin_isnan(__x); } 1735 1736 constexpr bool 1737 isnormal(__gnu_cxx::__bfloat16_t __x) 1738 { return __builtin_isnormal(__x); } 1739 1740 constexpr bool 1741 signbit(__gnu_cxx::__bfloat16_t __x) 1742 { return __builtin_signbit(__x); } 1743 1744 constexpr bool 1745 isgreater(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 1746 { return __builtin_isgreater(__x, __y); } 1747 1748 constexpr bool 1749 isgreaterequal(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 1750 { return __builtin_isgreaterequal(__x, __y); } 1751 1752 constexpr bool 1753 isless(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 1754 { return __builtin_isless(__x, __y); } 1755 1756 constexpr bool 1757 islessequal(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 1758 { return __builtin_islessequal(__x, __y); } 1759 1760 constexpr bool 1761 islessgreater(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 1762 { return __builtin_islessgreater(__x, __y); } 1763 1764 constexpr bool 1765 isunordered(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 1766 { return __builtin_isunordered(__x, __y); } 1767 #endif 1768 1769 #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */ 1770 #endif /* _GLIBCXX_USE_C99_MATH */ 1771 1772 #if __cplusplus >= 201103L 1773 1774 #undef acosf 1775 #undef acosl 1776 #undef asinf 1777 #undef asinl 1778 #undef atanf 1779 #undef atanl 1780 #undef atan2f 1781 #undef atan2l 1782 #undef ceilf 1783 #undef ceill 1784 #undef cosf 1785 #undef cosl 1786 #undef coshf 1787 #undef coshl 1788 #undef expf 1789 #undef expl 1790 #undef fabsf 1791 #undef fabsl 1792 #undef floorf 1793 #undef floorl 1794 #undef fmodf 1795 #undef fmodl 1796 #undef frexpf 1797 #undef frexpl 1798 #undef ldexpf 1799 #undef ldexpl 1800 #undef logf 1801 #undef logl 1802 #undef log10f 1803 #undef log10l 1804 #undef modff 1805 #undef modfl 1806 #undef powf 1807 #undef powl 1808 #undef sinf 1809 #undef sinl 1810 #undef sinhf 1811 #undef sinhl 1812 #undef sqrtf 1813 #undef sqrtl 1814 #undef tanf 1815 #undef tanl 1816 #undef tanhf 1817 #undef tanhl 1818 1819 #ifdef _GLIBCXX_HAVE_ACOSF 1820 using ::acosf; 1821 #endif 1822 #ifdef _GLIBCXX_HAVE_ACOSL 1823 using ::acosl; 1824 #endif 1825 1826 #ifdef _GLIBCXX_HAVE_ASINF 1827 using ::asinf; 1828 #endif 1829 #ifdef _GLIBCXX_HAVE_ASINL 1830 using ::asinl; 1831 #endif 1832 1833 #ifdef _GLIBCXX_HAVE_ATANF 1834 using ::atanf; 1835 #endif 1836 #ifdef _GLIBCXX_HAVE_ATANL 1837 using ::atanl; 1838 #endif 1839 1840 #ifdef _GLIBCXX_HAVE_ATAN2F 1841 using ::atan2f; 1842 #endif 1843 #ifdef _GLIBCXX_HAVE_ATAN2L 1844 using ::atan2l; 1845 #endif 1846 1847 #ifdef _GLIBCXX_HAVE_CEILF 1848 using ::ceilf; 1849 #endif 1850 #ifdef _GLIBCXX_HAVE_CEILL 1851 using ::ceill; 1852 #endif 1853 1854 #ifdef _GLIBCXX_HAVE_COSF 1855 using ::cosf; 1856 #endif 1857 #ifdef _GLIBCXX_HAVE_COSL 1858 using ::cosl; 1859 #endif 1860 1861 #ifdef _GLIBCXX_HAVE_COSHF 1862 using ::coshf; 1863 #endif 1864 #ifdef _GLIBCXX_HAVE_COSHL 1865 using ::coshl; 1866 #endif 1867 1868 #ifdef _GLIBCXX_HAVE_EXPF 1869 using ::expf; 1870 #endif 1871 #ifdef _GLIBCXX_HAVE_EXPL 1872 using ::expl; 1873 #endif 1874 1875 #ifdef _GLIBCXX_HAVE_FABSF 1876 using ::fabsf; 1877 #endif 1878 #ifdef _GLIBCXX_HAVE_FABSL 1879 using ::fabsl; 1880 #endif 1881 1882 #ifdef _GLIBCXX_HAVE_FLOORF 1883 using ::floorf; 1884 #endif 1885 #ifdef _GLIBCXX_HAVE_FLOORL 1886 using ::floorl; 1887 #endif 1888 1889 #ifdef _GLIBCXX_HAVE_FMODF 1890 using ::fmodf; 1891 #endif 1892 #ifdef _GLIBCXX_HAVE_FMODL 1893 using ::fmodl; 1894 #endif 1895 1896 #ifdef _GLIBCXX_HAVE_FREXPF 1897 using ::frexpf; 1898 #endif 1899 #ifdef _GLIBCXX_HAVE_FREXPL 1900 using ::frexpl; 1901 #endif 1902 1903 #ifdef _GLIBCXX_HAVE_LDEXPF 1904 using ::ldexpf; 1905 #endif 1906 #ifdef _GLIBCXX_HAVE_LDEXPL 1907 using ::ldexpl; 1908 #endif 1909 1910 #ifdef _GLIBCXX_HAVE_LOGF 1911 using ::logf; 1912 #endif 1913 #ifdef _GLIBCXX_HAVE_LOGL 1914 using ::logl; 1915 #endif 1916 1917 #ifdef _GLIBCXX_HAVE_LOG10F 1918 using ::log10f; 1919 #endif 1920 #ifdef _GLIBCXX_HAVE_LOG10L 1921 using ::log10l; 1922 #endif 1923 1924 #ifdef _GLIBCXX_HAVE_MODFF 1925 using ::modff; 1926 #endif 1927 #ifdef _GLIBCXX_HAVE_MODFL 1928 using ::modfl; 1929 #endif 1930 1931 #ifdef _GLIBCXX_HAVE_POWF 1932 using ::powf; 1933 #endif 1934 #ifdef _GLIBCXX_HAVE_POWL 1935 using ::powl; 1936 #endif 1937 1938 #ifdef _GLIBCXX_HAVE_SINF 1939 using ::sinf; 1940 #endif 1941 #ifdef _GLIBCXX_HAVE_SINL 1942 using ::sinl; 1943 #endif 1944 1945 #ifdef _GLIBCXX_HAVE_SINHF 1946 using ::sinhf; 1947 #endif 1948 #ifdef _GLIBCXX_HAVE_SINHL 1949 using ::sinhl; 1950 #endif 1951 1952 #ifdef _GLIBCXX_HAVE_SQRTF 1953 using ::sqrtf; 1954 #endif 1955 #ifdef _GLIBCXX_HAVE_SQRTL 1956 using ::sqrtl; 1957 #endif 1958 1959 #ifdef _GLIBCXX_HAVE_TANF 1960 using ::tanf; 1961 #endif 1962 #ifdef _GLIBCXX_HAVE_TANL 1963 using ::tanl; 1964 #endif 1965 1966 #ifdef _GLIBCXX_HAVE_TANHF 1967 using ::tanhf; 1968 #endif 1969 #ifdef _GLIBCXX_HAVE_TANHL 1970 using ::tanhl; 1971 #endif 1972 1973 #ifdef _GLIBCXX_USE_C99_MATH_FUNCS 1974 1975 #undef acosh 1976 #undef acoshf 1977 #undef acoshl 1978 #undef asinh 1979 #undef asinhf 1980 #undef asinhl 1981 #undef atanh 1982 #undef atanhf 1983 #undef atanhl 1984 #undef cbrt 1985 #undef cbrtf 1986 #undef cbrtl 1987 #undef copysign 1988 #undef copysignf 1989 #undef copysignl 1990 #undef erf 1991 #undef erff 1992 #undef erfl 1993 #undef erfc 1994 #undef erfcf 1995 #undef erfcl 1996 #undef exp2 1997 #undef exp2f 1998 #undef exp2l 1999 #undef expm1 2000 #undef expm1f 2001 #undef expm1l 2002 #undef fdim 2003 #undef fdimf 2004 #undef fdiml 2005 #undef fma 2006 #undef fmaf 2007 #undef fmal 2008 #undef fmax 2009 #undef fmaxf 2010 #undef fmaxl 2011 #undef fmin 2012 #undef fminf 2013 #undef fminl 2014 #undef hypot 2015 #undef hypotf 2016 #undef hypotl 2017 #undef ilogb 2018 #undef ilogbf 2019 #undef ilogbl 2020 #undef lgamma 2021 #undef lgammaf 2022 #undef lgammal 2023 #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS 2024 #undef llrint 2025 #undef llrintf 2026 #undef llrintl 2027 #undef llround 2028 #undef llroundf 2029 #undef llroundl 2030 #endif 2031 #undef log1p 2032 #undef log1pf 2033 #undef log1pl 2034 #undef log2 2035 #undef log2f 2036 #undef log2l 2037 #undef logb 2038 #undef logbf 2039 #undef logbl 2040 #undef lrint 2041 #undef lrintf 2042 #undef lrintl 2043 #undef lround 2044 #undef lroundf 2045 #undef lroundl 2046 #undef nan 2047 #undef nanf 2048 #undef nanl 2049 #undef nearbyint 2050 #undef nearbyintf 2051 #undef nearbyintl 2052 #undef nextafter 2053 #undef nextafterf 2054 #undef nextafterl 2055 #undef nexttoward 2056 #undef nexttowardf 2057 #undef nexttowardl 2058 #undef remainder 2059 #undef remainderf 2060 #undef remainderl 2061 #undef remquo 2062 #undef remquof 2063 #undef remquol 2064 #undef rint 2065 #undef rintf 2066 #undef rintl 2067 #undef round 2068 #undef roundf 2069 #undef roundl 2070 #undef scalbln 2071 #undef scalblnf 2072 #undef scalblnl 2073 #undef scalbn 2074 #undef scalbnf 2075 #undef scalbnl 2076 #undef tgamma 2077 #undef tgammaf 2078 #undef tgammal 2079 #undef trunc 2080 #undef truncf 2081 #undef truncl 2082 2083 #ifdef _GLIBCXX_HAVE_C99_FLT_EVAL_TYPES 2084 // types 2085 using ::double_t; 2086 using ::float_t; 2087 #endif 2088 2089 // functions 2090 using ::acosh; 2091 using ::acoshf; 2092 using ::acoshl; 2093 2094 using ::asinh; 2095 using ::asinhf; 2096 using ::asinhl; 2097 2098 using ::atanh; 2099 using ::atanhf; 2100 using ::atanhl; 2101 2102 using ::cbrt; 2103 using ::cbrtf; 2104 using ::cbrtl; 2105 2106 using ::copysign; 2107 using ::copysignf; 2108 using ::copysignl; 2109 2110 using ::erf; 2111 using ::erff; 2112 using ::erfl; 2113 2114 using ::erfc; 2115 using ::erfcf; 2116 using ::erfcl; 2117 2118 using ::exp2; 2119 using ::exp2f; 2120 using ::exp2l; 2121 2122 using ::expm1; 2123 using ::expm1f; 2124 using ::expm1l; 2125 2126 using ::fdim; 2127 using ::fdimf; 2128 using ::fdiml; 2129 2130 using ::fma; 2131 using ::fmaf; 2132 using ::fmal; 2133 2134 using ::fmax; 2135 using ::fmaxf; 2136 using ::fmaxl; 2137 2138 using ::fmin; 2139 using ::fminf; 2140 using ::fminl; 2141 2142 using ::hypot; 2143 using ::hypotf; 2144 using ::hypotl; 2145 2146 using ::ilogb; 2147 using ::ilogbf; 2148 using ::ilogbl; 2149 2150 using ::lgamma; 2151 using ::lgammaf; 2152 using ::lgammal; 2153 2154 #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS 2155 using ::llrint; 2156 using ::llrintf; 2157 using ::llrintl; 2158 2159 using ::llround; 2160 using ::llroundf; 2161 using ::llroundl; 2162 #endif 2163 2164 using ::log1p; 2165 using ::log1pf; 2166 using ::log1pl; 2167 2168 using ::log2; 2169 using ::log2f; 2170 using ::log2l; 2171 2172 using ::logb; 2173 using ::logbf; 2174 using ::logbl; 2175 2176 using ::lrint; 2177 using ::lrintf; 2178 using ::lrintl; 2179 2180 using ::lround; 2181 using ::lroundf; 2182 using ::lroundl; 2183 2184 using ::nan; 2185 using ::nanf; 2186 using ::nanl; 2187 2188 using ::nearbyint; 2189 using ::nearbyintf; 2190 using ::nearbyintl; 2191 2192 using ::nextafter; 2193 using ::nextafterf; 2194 using ::nextafterl; 2195 2196 using ::nexttoward; 2197 using ::nexttowardf; 2198 using ::nexttowardl; 2199 2200 using ::remainder; 2201 using ::remainderf; 2202 using ::remainderl; 2203 2204 using ::remquo; 2205 using ::remquof; 2206 using ::remquol; 2207 2208 using ::rint; 2209 using ::rintf; 2210 using ::rintl; 2211 2212 using ::round; 2213 using ::roundf; 2214 using ::roundl; 2215 2216 using ::scalbln; 2217 using ::scalblnf; 2218 using ::scalblnl; 2219 2220 using ::scalbn; 2221 using ::scalbnf; 2222 using ::scalbnl; 2223 2224 using ::tgamma; 2225 using ::tgammaf; 2226 using ::tgammal; 2227 2228 using ::trunc; 2229 using ::truncf; 2230 using ::truncl; 2231 2232 /// Additional overloads. 2233 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2234 constexpr float 2235 acosh(float __x) 2236 { return __builtin_acoshf(__x); } 2237 2238 constexpr long double 2239 acosh(long double __x) 2240 { return __builtin_acoshl(__x); } 2241 #endif 2242 2243 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2244 template<typename _Tp> 2245 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2246 double>::__type 2247 acosh(_Tp __x) 2248 { return __builtin_acosh(__x); } 2249 #endif 2250 2251 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2252 constexpr float 2253 asinh(float __x) 2254 { return __builtin_asinhf(__x); } 2255 2256 constexpr long double 2257 asinh(long double __x) 2258 { return __builtin_asinhl(__x); } 2259 #endif 2260 2261 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2262 template<typename _Tp> 2263 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2264 double>::__type 2265 asinh(_Tp __x) 2266 { return __builtin_asinh(__x); } 2267 #endif 2268 2269 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2270 constexpr float 2271 atanh(float __x) 2272 { return __builtin_atanhf(__x); } 2273 2274 constexpr long double 2275 atanh(long double __x) 2276 { return __builtin_atanhl(__x); } 2277 #endif 2278 2279 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2280 template<typename _Tp> 2281 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2282 double>::__type 2283 atanh(_Tp __x) 2284 { return __builtin_atanh(__x); } 2285 #endif 2286 2287 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2288 constexpr float 2289 cbrt(float __x) 2290 { return __builtin_cbrtf(__x); } 2291 2292 constexpr long double 2293 cbrt(long double __x) 2294 { return __builtin_cbrtl(__x); } 2295 #endif 2296 2297 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2298 template<typename _Tp> 2299 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2300 double>::__type 2301 cbrt(_Tp __x) 2302 { return __builtin_cbrt(__x); } 2303 #endif 2304 2305 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2306 constexpr float 2307 copysign(float __x, float __y) 2308 { return __builtin_copysignf(__x, __y); } 2309 2310 constexpr long double 2311 copysign(long double __x, long double __y) 2312 { return __builtin_copysignl(__x, __y); } 2313 #endif 2314 2315 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2316 constexpr float 2317 erf(float __x) 2318 { return __builtin_erff(__x); } 2319 2320 constexpr long double 2321 erf(long double __x) 2322 { return __builtin_erfl(__x); } 2323 #endif 2324 2325 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2326 template<typename _Tp> 2327 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2328 double>::__type 2329 erf(_Tp __x) 2330 { return __builtin_erf(__x); } 2331 #endif 2332 2333 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2334 constexpr float 2335 erfc(float __x) 2336 { return __builtin_erfcf(__x); } 2337 2338 constexpr long double 2339 erfc(long double __x) 2340 { return __builtin_erfcl(__x); } 2341 #endif 2342 2343 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2344 template<typename _Tp> 2345 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2346 double>::__type 2347 erfc(_Tp __x) 2348 { return __builtin_erfc(__x); } 2349 #endif 2350 2351 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2352 constexpr float 2353 exp2(float __x) 2354 { return __builtin_exp2f(__x); } 2355 2356 constexpr long double 2357 exp2(long double __x) 2358 { return __builtin_exp2l(__x); } 2359 #endif 2360 2361 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2362 template<typename _Tp> 2363 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2364 double>::__type 2365 exp2(_Tp __x) 2366 { return __builtin_exp2(__x); } 2367 #endif 2368 2369 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2370 constexpr float 2371 expm1(float __x) 2372 { return __builtin_expm1f(__x); } 2373 2374 constexpr long double 2375 expm1(long double __x) 2376 { return __builtin_expm1l(__x); } 2377 #endif 2378 2379 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2380 template<typename _Tp> 2381 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2382 double>::__type 2383 expm1(_Tp __x) 2384 { return __builtin_expm1(__x); } 2385 #endif 2386 2387 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2388 constexpr float 2389 fdim(float __x, float __y) 2390 { return __builtin_fdimf(__x, __y); } 2391 2392 constexpr long double 2393 fdim(long double __x, long double __y) 2394 { return __builtin_fdiml(__x, __y); } 2395 #endif 2396 2397 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2398 constexpr float 2399 fma(float __x, float __y, float __z) 2400 { return __builtin_fmaf(__x, __y, __z); } 2401 2402 constexpr long double 2403 fma(long double __x, long double __y, long double __z) 2404 { return __builtin_fmal(__x, __y, __z); } 2405 #endif 2406 2407 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2408 constexpr float 2409 fmax(float __x, float __y) 2410 { return __builtin_fmaxf(__x, __y); } 2411 2412 constexpr long double 2413 fmax(long double __x, long double __y) 2414 { return __builtin_fmaxl(__x, __y); } 2415 #endif 2416 2417 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2418 constexpr float 2419 fmin(float __x, float __y) 2420 { return __builtin_fminf(__x, __y); } 2421 2422 constexpr long double 2423 fmin(long double __x, long double __y) 2424 { return __builtin_fminl(__x, __y); } 2425 #endif 2426 2427 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2428 constexpr float 2429 hypot(float __x, float __y) 2430 { return __builtin_hypotf(__x, __y); } 2431 2432 constexpr long double 2433 hypot(long double __x, long double __y) 2434 { return __builtin_hypotl(__x, __y); } 2435 #endif 2436 2437 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2438 constexpr int 2439 ilogb(float __x) 2440 { return __builtin_ilogbf(__x); } 2441 2442 constexpr int 2443 ilogb(long double __x) 2444 { return __builtin_ilogbl(__x); } 2445 #endif 2446 2447 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2448 template<typename _Tp> 2449 constexpr 2450 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2451 int>::__type 2452 ilogb(_Tp __x) 2453 { return __builtin_ilogb(__x); } 2454 #endif 2455 2456 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2457 constexpr float 2458 lgamma(float __x) 2459 { return __builtin_lgammaf(__x); } 2460 2461 constexpr long double 2462 lgamma(long double __x) 2463 { return __builtin_lgammal(__x); } 2464 #endif 2465 2466 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2467 template<typename _Tp> 2468 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2469 double>::__type 2470 lgamma(_Tp __x) 2471 { return __builtin_lgamma(__x); } 2472 #endif 2473 2474 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2475 constexpr long long 2476 llrint(float __x) 2477 { return __builtin_llrintf(__x); } 2478 2479 constexpr long long 2480 llrint(long double __x) 2481 { return __builtin_llrintl(__x); } 2482 #endif 2483 2484 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2485 template<typename _Tp> 2486 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2487 long long>::__type 2488 llrint(_Tp __x) 2489 { return __builtin_llrint(__x); } 2490 #endif 2491 2492 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2493 constexpr long long 2494 llround(float __x) 2495 { return __builtin_llroundf(__x); } 2496 2497 constexpr long long 2498 llround(long double __x) 2499 { return __builtin_llroundl(__x); } 2500 #endif 2501 2502 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2503 template<typename _Tp> 2504 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2505 long long>::__type 2506 llround(_Tp __x) 2507 { return __builtin_llround(__x); } 2508 #endif 2509 2510 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2511 constexpr float 2512 log1p(float __x) 2513 { return __builtin_log1pf(__x); } 2514 2515 constexpr long double 2516 log1p(long double __x) 2517 { return __builtin_log1pl(__x); } 2518 #endif 2519 2520 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2521 template<typename _Tp> 2522 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2523 double>::__type 2524 log1p(_Tp __x) 2525 { return __builtin_log1p(__x); } 2526 #endif 2527 2528 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2529 // DR 568. 2530 constexpr float 2531 log2(float __x) 2532 { return __builtin_log2f(__x); } 2533 2534 constexpr long double 2535 log2(long double __x) 2536 { return __builtin_log2l(__x); } 2537 #endif 2538 2539 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2540 template<typename _Tp> 2541 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2542 double>::__type 2543 log2(_Tp __x) 2544 { return __builtin_log2(__x); } 2545 #endif 2546 2547 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2548 constexpr float 2549 logb(float __x) 2550 { return __builtin_logbf(__x); } 2551 2552 constexpr long double 2553 logb(long double __x) 2554 { return __builtin_logbl(__x); } 2555 #endif 2556 2557 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2558 template<typename _Tp> 2559 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2560 double>::__type 2561 logb(_Tp __x) 2562 { return __builtin_logb(__x); } 2563 #endif 2564 2565 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2566 constexpr long 2567 lrint(float __x) 2568 { return __builtin_lrintf(__x); } 2569 2570 constexpr long 2571 lrint(long double __x) 2572 { return __builtin_lrintl(__x); } 2573 #endif 2574 2575 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2576 template<typename _Tp> 2577 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2578 long>::__type 2579 lrint(_Tp __x) 2580 { return __builtin_lrint(__x); } 2581 #endif 2582 2583 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2584 constexpr long 2585 lround(float __x) 2586 { return __builtin_lroundf(__x); } 2587 2588 constexpr long 2589 lround(long double __x) 2590 { return __builtin_lroundl(__x); } 2591 #endif 2592 2593 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2594 template<typename _Tp> 2595 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2596 long>::__type 2597 lround(_Tp __x) 2598 { return __builtin_lround(__x); } 2599 #endif 2600 2601 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2602 constexpr float 2603 nearbyint(float __x) 2604 { return __builtin_nearbyintf(__x); } 2605 2606 constexpr long double 2607 nearbyint(long double __x) 2608 { return __builtin_nearbyintl(__x); } 2609 #endif 2610 2611 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2612 template<typename _Tp> 2613 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2614 double>::__type 2615 nearbyint(_Tp __x) 2616 { return __builtin_nearbyint(__x); } 2617 #endif 2618 2619 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2620 constexpr float 2621 nextafter(float __x, float __y) 2622 { return __builtin_nextafterf(__x, __y); } 2623 2624 constexpr long double 2625 nextafter(long double __x, long double __y) 2626 { return __builtin_nextafterl(__x, __y); } 2627 #endif 2628 2629 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2630 constexpr float 2631 nexttoward(float __x, long double __y) 2632 { return __builtin_nexttowardf(__x, __y); } 2633 2634 constexpr long double 2635 nexttoward(long double __x, long double __y) 2636 { return __builtin_nexttowardl(__x, __y); } 2637 #endif 2638 2639 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2640 template<typename _Tp> 2641 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2642 double>::__type 2643 nexttoward(_Tp __x, long double __y) 2644 { return __builtin_nexttoward(__x, __y); } 2645 #endif 2646 2647 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2648 constexpr float 2649 remainder(float __x, float __y) 2650 { return __builtin_remainderf(__x, __y); } 2651 2652 constexpr long double 2653 remainder(long double __x, long double __y) 2654 { return __builtin_remainderl(__x, __y); } 2655 #endif 2656 2657 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2658 inline float 2659 remquo(float __x, float __y, int* __pquo) 2660 { return __builtin_remquof(__x, __y, __pquo); } 2661 2662 inline long double 2663 remquo(long double __x, long double __y, int* __pquo) 2664 { return __builtin_remquol(__x, __y, __pquo); } 2665 #endif 2666 2667 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2668 constexpr float 2669 rint(float __x) 2670 { return __builtin_rintf(__x); } 2671 2672 constexpr long double 2673 rint(long double __x) 2674 { return __builtin_rintl(__x); } 2675 #endif 2676 2677 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2678 template<typename _Tp> 2679 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2680 double>::__type 2681 rint(_Tp __x) 2682 { return __builtin_rint(__x); } 2683 #endif 2684 2685 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2686 constexpr float 2687 round(float __x) 2688 { return __builtin_roundf(__x); } 2689 2690 constexpr long double 2691 round(long double __x) 2692 { return __builtin_roundl(__x); } 2693 #endif 2694 2695 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2696 template<typename _Tp> 2697 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2698 double>::__type 2699 round(_Tp __x) 2700 { return __builtin_round(__x); } 2701 #endif 2702 2703 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2704 constexpr float 2705 scalbln(float __x, long __ex) 2706 { return __builtin_scalblnf(__x, __ex); } 2707 2708 constexpr long double 2709 scalbln(long double __x, long __ex) 2710 { return __builtin_scalblnl(__x, __ex); } 2711 #endif 2712 2713 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2714 template<typename _Tp> 2715 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2716 double>::__type 2717 scalbln(_Tp __x, long __ex) 2718 { return __builtin_scalbln(__x, __ex); } 2719 #endif 2720 2721 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2722 constexpr float 2723 scalbn(float __x, int __ex) 2724 { return __builtin_scalbnf(__x, __ex); } 2725 2726 constexpr long double 2727 scalbn(long double __x, int __ex) 2728 { return __builtin_scalbnl(__x, __ex); } 2729 #endif 2730 2731 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2732 template<typename _Tp> 2733 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2734 double>::__type 2735 scalbn(_Tp __x, int __ex) 2736 { return __builtin_scalbn(__x, __ex); } 2737 #endif 2738 2739 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2740 constexpr float 2741 tgamma(float __x) 2742 { return __builtin_tgammaf(__x); } 2743 2744 constexpr long double 2745 tgamma(long double __x) 2746 { return __builtin_tgammal(__x); } 2747 #endif 2748 2749 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2750 template<typename _Tp> 2751 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2752 double>::__type 2753 tgamma(_Tp __x) 2754 { return __builtin_tgamma(__x); } 2755 #endif 2756 2757 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 2758 constexpr float 2759 trunc(float __x) 2760 { return __builtin_truncf(__x); } 2761 2762 constexpr long double 2763 trunc(long double __x) 2764 { return __builtin_truncl(__x); } 2765 #endif 2766 2767 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 2768 template<typename _Tp> 2769 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 2770 double>::__type 2771 trunc(_Tp __x) 2772 { return __builtin_trunc(__x); } 2773 #endif 2774 2775 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) 2776 constexpr _Float16 2777 acosh(_Float16 __x) 2778 { return _Float16(__builtin_acoshf(__x)); } 2779 2780 constexpr _Float16 2781 asinh(_Float16 __x) 2782 { return _Float16(__builtin_asinhf(__x)); } 2783 2784 constexpr _Float16 2785 atanh(_Float16 __x) 2786 { return _Float16(__builtin_atanhf(__x)); } 2787 2788 constexpr _Float16 2789 cbrt(_Float16 __x) 2790 { return _Float16(__builtin_cbrtf(__x)); } 2791 2792 constexpr _Float16 2793 copysign(_Float16 __x, _Float16 __y) 2794 { return __builtin_copysignf16(__x, __y); } 2795 2796 constexpr _Float16 2797 erf(_Float16 __x) 2798 { return _Float16(__builtin_erff(__x)); } 2799 2800 constexpr _Float16 2801 erfc(_Float16 __x) 2802 { return _Float16(__builtin_erfcf(__x)); } 2803 2804 constexpr _Float16 2805 exp2(_Float16 __x) 2806 { return _Float16(__builtin_exp2f(__x)); } 2807 2808 constexpr _Float16 2809 expm1(_Float16 __x) 2810 { return _Float16(__builtin_expm1f(__x)); } 2811 2812 constexpr _Float16 2813 fdim(_Float16 __x, _Float16 __y) 2814 { return _Float16(__builtin_fdimf(__x, __y)); } 2815 2816 constexpr _Float16 2817 fma(_Float16 __x, _Float16 __y, _Float16 __z) 2818 { return _Float16(__builtin_fmaf(__x, __y, __z)); } 2819 2820 constexpr _Float16 2821 fmax(_Float16 __x, _Float16 __y) 2822 { return _Float16(__builtin_fmaxf(__x, __y)); } 2823 2824 constexpr _Float16 2825 fmin(_Float16 __x, _Float16 __y) 2826 { return _Float16(__builtin_fminf(__x, __y)); } 2827 2828 constexpr _Float16 2829 hypot(_Float16 __x, _Float16 __y) 2830 { return _Float16(__builtin_hypotf(__x, __y)); } 2831 2832 constexpr int 2833 ilogb(_Float16 __x) 2834 { return __builtin_ilogbf(__x); } 2835 2836 constexpr _Float16 2837 lgamma(_Float16 __x) 2838 { return _Float16(__builtin_lgammaf(__x)); } 2839 2840 constexpr long long 2841 llrint(_Float16 __x) 2842 { return __builtin_llrintf(__x); } 2843 2844 constexpr long long 2845 llround(_Float16 __x) 2846 { return __builtin_llroundf(__x); } 2847 2848 constexpr _Float16 2849 log1p(_Float16 __x) 2850 { return _Float16(__builtin_log1pf(__x)); } 2851 2852 // DR 568. 2853 constexpr _Float16 2854 log2(_Float16 __x) 2855 { return _Float16(__builtin_log2f(__x)); } 2856 2857 constexpr _Float16 2858 logb(_Float16 __x) 2859 { return _Float16(__builtin_logbf(__x)); } 2860 2861 constexpr long 2862 lrint(_Float16 __x) 2863 { return __builtin_lrintf(__x); } 2864 2865 constexpr long 2866 lround(_Float16 __x) 2867 { return __builtin_lroundf(__x); } 2868 2869 constexpr _Float16 2870 nearbyint(_Float16 __x) 2871 { return _Float16(__builtin_nearbyintf(__x)); } 2872 2873 constexpr _Float16 2874 nextafter(_Float16 __x, _Float16 __y) 2875 { 2876 #if __cpp_if_consteval >= 202106L 2877 // Can't use if (std::__is_constant_evaluated()) here, as it 2878 // doesn't guarantee optimizing the body away at -O0 and 2879 // nothing defines nextafterf16. 2880 if consteval { return __builtin_nextafterf16(__x, __y); } 2881 #endif 2882 #ifdef __INT16_TYPE__ 2883 using __float16_int_type = __INT16_TYPE__; 2884 #else 2885 using __float16_int_type = short int; 2886 #endif 2887 __float16_int_type __hx, __hy, __ix, __iy; 2888 __builtin_memcpy(&__hx, &__x, sizeof(__x)); 2889 __builtin_memcpy(&__hy, &__y, sizeof(__x)); 2890 __ix = __hx & 0x7fff; // |x| 2891 __iy = __hy & 0x7fff; // |y| 2892 if (__ix > 0x7c00 || __iy > 0x7c00) // x or y is NaN 2893 return __x + __y; 2894 if (__x == __y) 2895 return __y; // x == y, return y 2896 if (__ix == 0) // x == 0 2897 { 2898 __hy = (__hy & 0x8000) | 1; // return +-__FLT16_DENORM_MIN__ 2899 __builtin_memcpy(&__x, &__hy, sizeof(__x)); 2900 __builtin_nextafterf(0.0f, 1.0f); // raise underflow 2901 return __x; 2902 } 2903 if (__hx >= 0) // x > 0 2904 { 2905 if (__hx > __hy) // x > y, x -= ulp 2906 --__hx; 2907 else // x < y, x += ulp 2908 ++__hx; 2909 } 2910 else // x < 0 2911 { 2912 if (__hy >= 0 || __hx > __hy) // x < y, x -= ulp 2913 --__hx; 2914 else // x > y, x += ulp 2915 ++__hx; 2916 } 2917 __hy = __hx & 0x7c00; 2918 if (__hy >= 0x7c00) 2919 __builtin_nextafterf(__FLT_MAX__, __builtin_inff()); // overflow 2920 else if (__hy < 0x0400) 2921 __builtin_nextafterf(__FLT_MIN__, 0.0f); // underflow 2922 __builtin_memcpy(&__x, &__hx, sizeof(__x)); 2923 return __x; 2924 } 2925 2926 constexpr _Float16 2927 remainder(_Float16 __x, _Float16 __y) 2928 { return _Float16(__builtin_remainderf(__x, __y)); } 2929 2930 inline _Float16 2931 remquo(_Float16 __x, _Float16 __y, int* __pquo) 2932 { return _Float16(__builtin_remquof(__x, __y, __pquo)); } 2933 2934 constexpr _Float16 2935 rint(_Float16 __x) 2936 { return _Float16(__builtin_rintf(__x)); } 2937 2938 constexpr _Float16 2939 round(_Float16 __x) 2940 { return _Float16(__builtin_roundf(__x)); } 2941 2942 constexpr _Float16 2943 scalbln(_Float16 __x, long __ex) 2944 { return _Float16(__builtin_scalblnf(__x, __ex)); } 2945 2946 constexpr _Float16 2947 scalbn(_Float16 __x, int __ex) 2948 { return _Float16(__builtin_scalbnf(__x, __ex)); } 2949 2950 constexpr _Float16 2951 tgamma(_Float16 __x) 2952 { return _Float16(__builtin_tgammaf(__x)); } 2953 2954 constexpr _Float16 2955 trunc(_Float16 __x) 2956 { return _Float16(__builtin_truncf(__x)); } 2957 #endif 2958 2959 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) 2960 constexpr _Float32 2961 acosh(_Float32 __x) 2962 { return __builtin_acoshf(__x); } 2963 2964 constexpr _Float32 2965 asinh(_Float32 __x) 2966 { return __builtin_asinhf(__x); } 2967 2968 constexpr _Float32 2969 atanh(_Float32 __x) 2970 { return __builtin_atanhf(__x); } 2971 2972 constexpr _Float32 2973 cbrt(_Float32 __x) 2974 { return __builtin_cbrtf(__x); } 2975 2976 constexpr _Float32 2977 copysign(_Float32 __x, _Float32 __y) 2978 { return __builtin_copysignf(__x, __y); } 2979 2980 constexpr _Float32 2981 erf(_Float32 __x) 2982 { return __builtin_erff(__x); } 2983 2984 constexpr _Float32 2985 erfc(_Float32 __x) 2986 { return __builtin_erfcf(__x); } 2987 2988 constexpr _Float32 2989 exp2(_Float32 __x) 2990 { return __builtin_exp2f(__x); } 2991 2992 constexpr _Float32 2993 expm1(_Float32 __x) 2994 { return __builtin_expm1f(__x); } 2995 2996 constexpr _Float32 2997 fdim(_Float32 __x, _Float32 __y) 2998 { return __builtin_fdimf(__x, __y); } 2999 3000 constexpr _Float32 3001 fma(_Float32 __x, _Float32 __y, _Float32 __z) 3002 { return __builtin_fmaf(__x, __y, __z); } 3003 3004 constexpr _Float32 3005 fmax(_Float32 __x, _Float32 __y) 3006 { return __builtin_fmaxf(__x, __y); } 3007 3008 constexpr _Float32 3009 fmin(_Float32 __x, _Float32 __y) 3010 { return __builtin_fminf(__x, __y); } 3011 3012 constexpr _Float32 3013 hypot(_Float32 __x, _Float32 __y) 3014 { return __builtin_hypotf(__x, __y); } 3015 3016 constexpr int 3017 ilogb(_Float32 __x) 3018 { return __builtin_ilogbf(__x); } 3019 3020 constexpr _Float32 3021 lgamma(_Float32 __x) 3022 { return __builtin_lgammaf(__x); } 3023 3024 constexpr long long 3025 llrint(_Float32 __x) 3026 { return __builtin_llrintf(__x); } 3027 3028 constexpr long long 3029 llround(_Float32 __x) 3030 { return __builtin_llroundf(__x); } 3031 3032 constexpr _Float32 3033 log1p(_Float32 __x) 3034 { return __builtin_log1pf(__x); } 3035 3036 // DR 568. 3037 constexpr _Float32 3038 log2(_Float32 __x) 3039 { return __builtin_log2f(__x); } 3040 3041 constexpr _Float32 3042 logb(_Float32 __x) 3043 { return __builtin_logbf(__x); } 3044 3045 constexpr long 3046 lrint(_Float32 __x) 3047 { return __builtin_lrintf(__x); } 3048 3049 constexpr long 3050 lround(_Float32 __x) 3051 { return __builtin_lroundf(__x); } 3052 3053 constexpr _Float32 3054 nearbyint(_Float32 __x) 3055 { return __builtin_nearbyintf(__x); } 3056 3057 constexpr _Float32 3058 nextafter(_Float32 __x, _Float32 __y) 3059 { return __builtin_nextafterf(__x, __y); } 3060 3061 constexpr _Float32 3062 remainder(_Float32 __x, _Float32 __y) 3063 { return __builtin_remainderf(__x, __y); } 3064 3065 inline _Float32 3066 remquo(_Float32 __x, _Float32 __y, int* __pquo) 3067 { return __builtin_remquof(__x, __y, __pquo); } 3068 3069 constexpr _Float32 3070 rint(_Float32 __x) 3071 { return __builtin_rintf(__x); } 3072 3073 constexpr _Float32 3074 round(_Float32 __x) 3075 { return __builtin_roundf(__x); } 3076 3077 constexpr _Float32 3078 scalbln(_Float32 __x, long __ex) 3079 { return __builtin_scalblnf(__x, __ex); } 3080 3081 constexpr _Float32 3082 scalbn(_Float32 __x, int __ex) 3083 { return __builtin_scalbnf(__x, __ex); } 3084 3085 constexpr _Float32 3086 tgamma(_Float32 __x) 3087 { return __builtin_tgammaf(__x); } 3088 3089 constexpr _Float32 3090 trunc(_Float32 __x) 3091 { return __builtin_truncf(__x); } 3092 #endif 3093 3094 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64) 3095 constexpr _Float64 3096 acosh(_Float64 __x) 3097 { return __builtin_acosh(__x); } 3098 3099 constexpr _Float64 3100 asinh(_Float64 __x) 3101 { return __builtin_asinh(__x); } 3102 3103 constexpr _Float64 3104 atanh(_Float64 __x) 3105 { return __builtin_atanh(__x); } 3106 3107 constexpr _Float64 3108 cbrt(_Float64 __x) 3109 { return __builtin_cbrt(__x); } 3110 3111 constexpr _Float64 3112 copysign(_Float64 __x, _Float64 __y) 3113 { return __builtin_copysign(__x, __y); } 3114 3115 constexpr _Float64 3116 erf(_Float64 __x) 3117 { return __builtin_erf(__x); } 3118 3119 constexpr _Float64 3120 erfc(_Float64 __x) 3121 { return __builtin_erfc(__x); } 3122 3123 constexpr _Float64 3124 exp2(_Float64 __x) 3125 { return __builtin_exp2(__x); } 3126 3127 constexpr _Float64 3128 expm1(_Float64 __x) 3129 { return __builtin_expm1(__x); } 3130 3131 constexpr _Float64 3132 fdim(_Float64 __x, _Float64 __y) 3133 { return __builtin_fdim(__x, __y); } 3134 3135 constexpr _Float64 3136 fma(_Float64 __x, _Float64 __y, _Float64 __z) 3137 { return __builtin_fma(__x, __y, __z); } 3138 3139 constexpr _Float64 3140 fmax(_Float64 __x, _Float64 __y) 3141 { return __builtin_fmax(__x, __y); } 3142 3143 constexpr _Float64 3144 fmin(_Float64 __x, _Float64 __y) 3145 { return __builtin_fmin(__x, __y); } 3146 3147 constexpr _Float64 3148 hypot(_Float64 __x, _Float64 __y) 3149 { return __builtin_hypot(__x, __y); } 3150 3151 constexpr int 3152 ilogb(_Float64 __x) 3153 { return __builtin_ilogb(__x); } 3154 3155 constexpr _Float64 3156 lgamma(_Float64 __x) 3157 { return __builtin_lgamma(__x); } 3158 3159 constexpr long long 3160 llrint(_Float64 __x) 3161 { return __builtin_llrint(__x); } 3162 3163 constexpr long long 3164 llround(_Float64 __x) 3165 { return __builtin_llround(__x); } 3166 3167 constexpr _Float64 3168 log1p(_Float64 __x) 3169 { return __builtin_log1p(__x); } 3170 3171 // DR 568. 3172 constexpr _Float64 3173 log2(_Float64 __x) 3174 { return __builtin_log2(__x); } 3175 3176 constexpr _Float64 3177 logb(_Float64 __x) 3178 { return __builtin_logb(__x); } 3179 3180 constexpr long 3181 lrint(_Float64 __x) 3182 { return __builtin_lrint(__x); } 3183 3184 constexpr long 3185 lround(_Float64 __x) 3186 { return __builtin_lround(__x); } 3187 3188 constexpr _Float64 3189 nearbyint(_Float64 __x) 3190 { return __builtin_nearbyint(__x); } 3191 3192 constexpr _Float64 3193 nextafter(_Float64 __x, _Float64 __y) 3194 { return __builtin_nextafter(__x, __y); } 3195 3196 constexpr _Float64 3197 remainder(_Float64 __x, _Float64 __y) 3198 { return __builtin_remainder(__x, __y); } 3199 3200 inline _Float64 3201 remquo(_Float64 __x, _Float64 __y, int* __pquo) 3202 { return __builtin_remquo(__x, __y, __pquo); } 3203 3204 constexpr _Float64 3205 rint(_Float64 __x) 3206 { return __builtin_rint(__x); } 3207 3208 constexpr _Float64 3209 round(_Float64 __x) 3210 { return __builtin_round(__x); } 3211 3212 constexpr _Float64 3213 scalbln(_Float64 __x, long __ex) 3214 { return __builtin_scalbln(__x, __ex); } 3215 3216 constexpr _Float64 3217 scalbn(_Float64 __x, int __ex) 3218 { return __builtin_scalbn(__x, __ex); } 3219 3220 constexpr _Float64 3221 tgamma(_Float64 __x) 3222 { return __builtin_tgamma(__x); } 3223 3224 constexpr _Float64 3225 trunc(_Float64 __x) 3226 { return __builtin_trunc(__x); } 3227 #endif 3228 3229 #if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) 3230 constexpr _Float128 3231 acosh(_Float128 __x) 3232 { return __builtin_acoshl(__x); } 3233 3234 constexpr _Float128 3235 asinh(_Float128 __x) 3236 { return __builtin_asinhl(__x); } 3237 3238 constexpr _Float128 3239 atanh(_Float128 __x) 3240 { return __builtin_atanhl(__x); } 3241 3242 constexpr _Float128 3243 cbrt(_Float128 __x) 3244 { return __builtin_cbrtl(__x); } 3245 3246 constexpr _Float128 3247 copysign(_Float128 __x, _Float128 __y) 3248 { return __builtin_copysignl(__x, __y); } 3249 3250 constexpr _Float128 3251 erf(_Float128 __x) 3252 { return __builtin_erfl(__x); } 3253 3254 constexpr _Float128 3255 erfc(_Float128 __x) 3256 { return __builtin_erfcl(__x); } 3257 3258 constexpr _Float128 3259 exp2(_Float128 __x) 3260 { return __builtin_exp2l(__x); } 3261 3262 constexpr _Float128 3263 expm1(_Float128 __x) 3264 { return __builtin_expm1l(__x); } 3265 3266 constexpr _Float128 3267 fdim(_Float128 __x, _Float128 __y) 3268 { return __builtin_fdiml(__x, __y); } 3269 3270 constexpr _Float128 3271 fma(_Float128 __x, _Float128 __y, _Float128 __z) 3272 { return __builtin_fmal(__x, __y, __z); } 3273 3274 constexpr _Float128 3275 fmax(_Float128 __x, _Float128 __y) 3276 { return __builtin_fmaxl(__x, __y); } 3277 3278 constexpr _Float128 3279 fmin(_Float128 __x, _Float128 __y) 3280 { return __builtin_fminl(__x, __y); } 3281 3282 constexpr _Float128 3283 hypot(_Float128 __x, _Float128 __y) 3284 { return __builtin_hypotl(__x, __y); } 3285 3286 constexpr int 3287 ilogb(_Float128 __x) 3288 { return __builtin_ilogbl(__x); } 3289 3290 constexpr _Float128 3291 lgamma(_Float128 __x) 3292 { return __builtin_lgammal(__x); } 3293 3294 constexpr long long 3295 llrint(_Float128 __x) 3296 { return __builtin_llrintl(__x); } 3297 3298 constexpr long long 3299 llround(_Float128 __x) 3300 { return __builtin_llroundl(__x); } 3301 3302 constexpr _Float128 3303 log1p(_Float128 __x) 3304 { return __builtin_log1pl(__x); } 3305 3306 // DR 568. 3307 constexpr _Float128 3308 log2(_Float128 __x) 3309 { return __builtin_log2l(__x); } 3310 3311 constexpr _Float128 3312 logb(_Float128 __x) 3313 { return __builtin_logbl(__x); } 3314 3315 constexpr long 3316 lrint(_Float128 __x) 3317 { return __builtin_lrintl(__x); } 3318 3319 constexpr long 3320 lround(_Float128 __x) 3321 { return __builtin_lroundl(__x); } 3322 3323 constexpr _Float128 3324 nearbyint(_Float128 __x) 3325 { return __builtin_nearbyintl(__x); } 3326 3327 constexpr _Float128 3328 nextafter(_Float128 __x, _Float128 __y) 3329 { return __builtin_nextafterl(__x, __y); } 3330 3331 constexpr _Float128 3332 remainder(_Float128 __x, _Float128 __y) 3333 { return __builtin_remainderl(__x, __y); } 3334 3335 inline _Float128 3336 remquo(_Float128 __x, _Float128 __y, int* __pquo) 3337 { return __builtin_remquol(__x, __y, __pquo); } 3338 3339 constexpr _Float128 3340 rint(_Float128 __x) 3341 { return __builtin_rintl(__x); } 3342 3343 constexpr _Float128 3344 round(_Float128 __x) 3345 { return __builtin_roundl(__x); } 3346 3347 constexpr _Float128 3348 scalbln(_Float128 __x, long __ex) 3349 { return __builtin_scalblnl(__x, __ex); } 3350 3351 constexpr _Float128 3352 scalbn(_Float128 __x, int __ex) 3353 { return __builtin_scalbnl(__x, __ex); } 3354 3355 constexpr _Float128 3356 tgamma(_Float128 __x) 3357 { return __builtin_tgammal(__x); } 3358 3359 constexpr _Float128 3360 trunc(_Float128 __x) 3361 { return __builtin_truncl(__x); } 3362 #elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH) 3363 constexpr _Float128 3364 acosh(_Float128 __x) 3365 { return __builtin_acoshf128(__x); } 3366 3367 constexpr _Float128 3368 asinh(_Float128 __x) 3369 { return __builtin_asinhf128(__x); } 3370 3371 constexpr _Float128 3372 atanh(_Float128 __x) 3373 { return __builtin_atanhf128(__x); } 3374 3375 constexpr _Float128 3376 cbrt(_Float128 __x) 3377 { return __builtin_cbrtf128(__x); } 3378 3379 constexpr _Float128 3380 copysign(_Float128 __x, _Float128 __y) 3381 { return __builtin_copysignf128(__x, __y); } 3382 3383 constexpr _Float128 3384 erf(_Float128 __x) 3385 { return __builtin_erff128(__x); } 3386 3387 constexpr _Float128 3388 erfc(_Float128 __x) 3389 { return __builtin_erfcf128(__x); } 3390 3391 constexpr _Float128 3392 exp2(_Float128 __x) 3393 { return __builtin_exp2f128(__x); } 3394 3395 constexpr _Float128 3396 expm1(_Float128 __x) 3397 { return __builtin_expm1f128(__x); } 3398 3399 constexpr _Float128 3400 fdim(_Float128 __x, _Float128 __y) 3401 { return __builtin_fdimf128(__x, __y); } 3402 3403 constexpr _Float128 3404 fma(_Float128 __x, _Float128 __y, _Float128 __z) 3405 { return __builtin_fmaf128(__x, __y, __z); } 3406 3407 constexpr _Float128 3408 fmax(_Float128 __x, _Float128 __y) 3409 { return __builtin_fmaxf128(__x, __y); } 3410 3411 constexpr _Float128 3412 fmin(_Float128 __x, _Float128 __y) 3413 { return __builtin_fminf128(__x, __y); } 3414 3415 constexpr _Float128 3416 hypot(_Float128 __x, _Float128 __y) 3417 { return __builtin_hypotf128(__x, __y); } 3418 3419 constexpr int 3420 ilogb(_Float128 __x) 3421 { return __builtin_ilogbf128(__x); } 3422 3423 constexpr _Float128 3424 lgamma(_Float128 __x) 3425 { return __builtin_lgammaf128(__x); } 3426 3427 constexpr long long 3428 llrint(_Float128 __x) 3429 { return __builtin_llrintf128(__x); } 3430 3431 constexpr long long 3432 llround(_Float128 __x) 3433 { return __builtin_llroundf128(__x); } 3434 3435 constexpr _Float128 3436 log1p(_Float128 __x) 3437 { return __builtin_log1pf128(__x); } 3438 3439 // DR 568. 3440 constexpr _Float128 3441 log2(_Float128 __x) 3442 { return __builtin_log2f128(__x); } 3443 3444 constexpr _Float128 3445 logb(_Float128 __x) 3446 { return __builtin_logbf128(__x); } 3447 3448 constexpr long 3449 lrint(_Float128 __x) 3450 { return __builtin_lrintf128(__x); } 3451 3452 constexpr long 3453 lround(_Float128 __x) 3454 { return __builtin_lroundf128(__x); } 3455 3456 constexpr _Float128 3457 nearbyint(_Float128 __x) 3458 { return __builtin_nearbyintf128(__x); } 3459 3460 constexpr _Float128 3461 nextafter(_Float128 __x, _Float128 __y) 3462 { return __builtin_nextafterf128(__x, __y); } 3463 3464 constexpr _Float128 3465 remainder(_Float128 __x, _Float128 __y) 3466 { return __builtin_remainderf128(__x, __y); } 3467 3468 inline _Float128 3469 remquo(_Float128 __x, _Float128 __y, int* __pquo) 3470 { return __builtin_remquof128(__x, __y, __pquo); } 3471 3472 constexpr _Float128 3473 rint(_Float128 __x) 3474 { return __builtin_rintf128(__x); } 3475 3476 constexpr _Float128 3477 round(_Float128 __x) 3478 { return __builtin_roundf128(__x); } 3479 3480 constexpr _Float128 3481 scalbln(_Float128 __x, long __ex) 3482 { return __builtin_scalblnf128(__x, __ex); } 3483 3484 constexpr _Float128 3485 scalbn(_Float128 __x, int __ex) 3486 { return __builtin_scalbnf128(__x, __ex); } 3487 3488 constexpr _Float128 3489 tgamma(_Float128 __x) 3490 { return __builtin_tgammaf128(__x); } 3491 3492 constexpr _Float128 3493 trunc(_Float128 __x) 3494 { return __builtin_truncf128(__x); } 3495 #endif 3496 3497 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) 3498 constexpr __gnu_cxx::__bfloat16_t 3499 acosh(__gnu_cxx::__bfloat16_t __x) 3500 { return __gnu_cxx::__bfloat16_t(__builtin_acoshf(__x)); } 3501 3502 constexpr __gnu_cxx::__bfloat16_t 3503 asinh(__gnu_cxx::__bfloat16_t __x) 3504 { return __gnu_cxx::__bfloat16_t(__builtin_asinhf(__x)); } 3505 3506 constexpr __gnu_cxx::__bfloat16_t 3507 atanh(__gnu_cxx::__bfloat16_t __x) 3508 { return __gnu_cxx::__bfloat16_t(__builtin_atanhf(__x)); } 3509 3510 constexpr __gnu_cxx::__bfloat16_t 3511 cbrt(__gnu_cxx::__bfloat16_t __x) 3512 { return __gnu_cxx::__bfloat16_t(__builtin_cbrtf(__x)); } 3513 3514 constexpr __gnu_cxx::__bfloat16_t 3515 copysign(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 3516 { return __gnu_cxx::__bfloat16_t(__builtin_copysignf(__x, __y)); } 3517 3518 constexpr __gnu_cxx::__bfloat16_t 3519 erf(__gnu_cxx::__bfloat16_t __x) 3520 { return __gnu_cxx::__bfloat16_t(__builtin_erff(__x)); } 3521 3522 constexpr __gnu_cxx::__bfloat16_t 3523 erfc(__gnu_cxx::__bfloat16_t __x) 3524 { return __gnu_cxx::__bfloat16_t(__builtin_erfcf(__x)); } 3525 3526 constexpr __gnu_cxx::__bfloat16_t 3527 exp2(__gnu_cxx::__bfloat16_t __x) 3528 { return __gnu_cxx::__bfloat16_t(__builtin_exp2f(__x)); } 3529 3530 constexpr __gnu_cxx::__bfloat16_t 3531 expm1(__gnu_cxx::__bfloat16_t __x) 3532 { return __gnu_cxx::__bfloat16_t(__builtin_expm1f(__x)); } 3533 3534 constexpr __gnu_cxx::__bfloat16_t 3535 fdim(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 3536 { return __gnu_cxx::__bfloat16_t(__builtin_fdimf(__x, __y)); } 3537 3538 constexpr __gnu_cxx::__bfloat16_t 3539 fma(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z) 3540 { return __gnu_cxx::__bfloat16_t(__builtin_fmaf(__x, __y, __z)); } 3541 3542 constexpr __gnu_cxx::__bfloat16_t 3543 fmax(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 3544 { return __gnu_cxx::__bfloat16_t(__builtin_fmaxf(__x, __y)); } 3545 3546 constexpr __gnu_cxx::__bfloat16_t 3547 fmin(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 3548 { return __gnu_cxx::__bfloat16_t(__builtin_fminf(__x, __y)); } 3549 3550 constexpr __gnu_cxx::__bfloat16_t 3551 hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 3552 { return __gnu_cxx::__bfloat16_t(__builtin_hypotf(__x, __y)); } 3553 3554 constexpr int 3555 ilogb(__gnu_cxx::__bfloat16_t __x) 3556 { return __builtin_ilogbf(__x); } 3557 3558 constexpr __gnu_cxx::__bfloat16_t 3559 lgamma(__gnu_cxx::__bfloat16_t __x) 3560 { return __gnu_cxx::__bfloat16_t(__builtin_lgammaf(__x)); } 3561 3562 constexpr long long 3563 llrint(__gnu_cxx::__bfloat16_t __x) 3564 { return __builtin_llrintf(__x); } 3565 3566 constexpr long long 3567 llround(__gnu_cxx::__bfloat16_t __x) 3568 { return __builtin_llroundf(__x); } 3569 3570 constexpr __gnu_cxx::__bfloat16_t 3571 log1p(__gnu_cxx::__bfloat16_t __x) 3572 { return __gnu_cxx::__bfloat16_t(__builtin_log1pf(__x)); } 3573 3574 // DR 568. 3575 constexpr __gnu_cxx::__bfloat16_t 3576 log2(__gnu_cxx::__bfloat16_t __x) 3577 { return __gnu_cxx::__bfloat16_t(__builtin_log2f(__x)); } 3578 3579 constexpr __gnu_cxx::__bfloat16_t 3580 logb(__gnu_cxx::__bfloat16_t __x) 3581 { return __gnu_cxx::__bfloat16_t(__builtin_logbf(__x)); } 3582 3583 constexpr long 3584 lrint(__gnu_cxx::__bfloat16_t __x) 3585 { return __builtin_lrintf(__x); } 3586 3587 constexpr long 3588 lround(__gnu_cxx::__bfloat16_t __x) 3589 { return __builtin_lroundf(__x); } 3590 3591 constexpr __gnu_cxx::__bfloat16_t 3592 nearbyint(__gnu_cxx::__bfloat16_t __x) 3593 { return __gnu_cxx::__bfloat16_t(__builtin_nearbyintf(__x)); } 3594 3595 constexpr __gnu_cxx::__bfloat16_t 3596 nextafter(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 3597 { 3598 #if __cpp_if_consteval >= 202106L 3599 // Can't use if (std::__is_constant_evaluated()) here, as it 3600 // doesn't guarantee optimizing the body away at -O0 and 3601 // nothing defines nextafterf16b. 3602 if consteval { return __builtin_nextafterf16b(__x, __y); } 3603 #endif 3604 #ifdef __INT16_TYPE__ 3605 using __bfloat16_int_type = __INT16_TYPE__; 3606 #else 3607 using __bfloat16_int_type = short int; 3608 #endif 3609 __bfloat16_int_type __hx, __hy, __ix, __iy; 3610 __builtin_memcpy(&__hx, &__x, sizeof(__x)); 3611 __builtin_memcpy(&__hy, &__y, sizeof(__x)); 3612 __ix = __hx & 0x7fff; // |x| 3613 __iy = __hy & 0x7fff; // |y| 3614 if (__ix > 0x7f80 || __iy > 0x7f80) // x or y is NaN 3615 return __x + __y; 3616 if (__x == __y) 3617 return __y; // x == y, return y 3618 if (__ix == 0) // x == 0 3619 { 3620 __hy = (__hy & 0x8000) | 1; // return +-__BFLT16_DENORM_MIN__ 3621 __builtin_memcpy(&__x, &__hy, sizeof(__x)); 3622 __builtin_nextafterf(0.0f, 1.0f); // raise underflow 3623 return __x; 3624 } 3625 if (__hx >= 0) // x > 0 3626 { 3627 if (__hx > __hy) // x > y, x -= ulp 3628 --__hx; 3629 else // x < y, x += ulp 3630 ++__hx; 3631 } 3632 else // x < 0 3633 { 3634 if (__hy >= 0 || __hx > __hy) // x < y, x -= ulp 3635 --__hx; 3636 else // x > y, x += ulp 3637 ++__hx; 3638 } 3639 __hy = __hx & 0x7f80; 3640 if (__hy >= 0x7f80) 3641 __builtin_nextafterf(__FLT_MAX__, __builtin_inff()); // overflow 3642 else if (__hy < 0x0080) 3643 __builtin_nextafterf(__FLT_MIN__, 0.0f); // underflow 3644 __builtin_memcpy(&__x, &__hx, sizeof(__x)); 3645 return __x; 3646 } 3647 3648 constexpr __gnu_cxx::__bfloat16_t 3649 remainder(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) 3650 { return __gnu_cxx::__bfloat16_t(__builtin_remainderf(__x, __y)); } 3651 3652 inline __gnu_cxx::__bfloat16_t 3653 remquo(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, int* __pquo) 3654 { return __gnu_cxx::__bfloat16_t(__builtin_remquof(__x, __y, __pquo)); } 3655 3656 constexpr __gnu_cxx::__bfloat16_t 3657 rint(__gnu_cxx::__bfloat16_t __x) 3658 { return __gnu_cxx::__bfloat16_t(__builtin_rintf(__x)); } 3659 3660 constexpr __gnu_cxx::__bfloat16_t 3661 round(__gnu_cxx::__bfloat16_t __x) 3662 { return __gnu_cxx::__bfloat16_t(__builtin_roundf(__x)); } 3663 3664 constexpr __gnu_cxx::__bfloat16_t 3665 scalbln(__gnu_cxx::__bfloat16_t __x, long __ex) 3666 { return __gnu_cxx::__bfloat16_t(__builtin_scalblnf(__x, __ex)); } 3667 3668 constexpr __gnu_cxx::__bfloat16_t 3669 scalbn(__gnu_cxx::__bfloat16_t __x, int __ex) 3670 { return __gnu_cxx::__bfloat16_t(__builtin_scalbnf(__x, __ex)); } 3671 3672 constexpr __gnu_cxx::__bfloat16_t 3673 tgamma(__gnu_cxx::__bfloat16_t __x) 3674 { return __gnu_cxx::__bfloat16_t(__builtin_tgammaf(__x)); } 3675 3676 constexpr __gnu_cxx::__bfloat16_t 3677 trunc(__gnu_cxx::__bfloat16_t __x) 3678 { return __gnu_cxx::__bfloat16_t(__builtin_truncf(__x)); } 3679 #endif 3680 3681 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 3682 template<typename _Tp, typename _Up> 3683 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 3684 copysign(_Tp __x, _Up __y) 3685 { 3686 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 3687 return copysign(__type(__x), __type(__y)); 3688 } 3689 3690 template<typename _Tp, typename _Up> 3691 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 3692 fdim(_Tp __x, _Up __y) 3693 { 3694 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 3695 return fdim(__type(__x), __type(__y)); 3696 } 3697 3698 template<typename _Tp, typename _Up> 3699 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 3700 fmax(_Tp __x, _Up __y) 3701 { 3702 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 3703 return fmax(__type(__x), __type(__y)); 3704 } 3705 3706 template<typename _Tp, typename _Up> 3707 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 3708 fmin(_Tp __x, _Up __y) 3709 { 3710 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 3711 return fmin(__type(__x), __type(__y)); 3712 } 3713 3714 template<typename _Tp, typename _Up> 3715 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 3716 hypot(_Tp __x, _Up __y) 3717 { 3718 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 3719 return hypot(__type(__x), __type(__y)); 3720 } 3721 3722 template<typename _Tp, typename _Up> 3723 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 3724 nextafter(_Tp __x, _Up __y) 3725 { 3726 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 3727 return nextafter(__type(__x), __type(__y)); 3728 } 3729 3730 template<typename _Tp, typename _Up> 3731 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 3732 remainder(_Tp __x, _Up __y) 3733 { 3734 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 3735 return remainder(__type(__x), __type(__y)); 3736 } 3737 3738 template<typename _Tp, typename _Up> 3739 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type 3740 remquo(_Tp __x, _Up __y, int* __pquo) 3741 { 3742 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; 3743 return remquo(__type(__x), __type(__y), __pquo); 3744 } 3745 3746 template<typename _Tp, typename _Up, typename _Vp> 3747 constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type 3748 fma(_Tp __x, _Up __y, _Vp __z) 3749 { 3750 typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; 3751 return fma(__type(__x), __type(__y), __type(__z)); 3752 } 3753 #endif 3754 3755 #endif // _GLIBCXX_USE_C99_MATH_FUNCS 3756 #endif // C++11 3757 3758 #ifdef __cpp_lib_hypot // C++ >= 17 && HOSTED 3759 // [c.math.hypot3], three-dimensional hypotenuse 3760 template<typename _Tp> 3761 inline _Tp 3762 __hypot3(_Tp __x, _Tp __y, _Tp __z) 3763 { 3764 __x = std::abs(__x); 3765 __y = std::abs(__y); 3766 __z = std::abs(__z); 3767 if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x) 3768 return __a * std::sqrt((__x / __a) * (__x / __a) 3769 + (__y / __a) * (__y / __a) 3770 + (__z / __a) * (__z / __a)); 3771 else 3772 return {}; 3773 } 3774 3775 inline float 3776 hypot(float __x, float __y, float __z) 3777 { return std::__hypot3<float>(__x, __y, __z); } 3778 3779 inline double 3780 hypot(double __x, double __y, double __z) 3781 { return std::__hypot3<double>(__x, __y, __z); } 3782 3783 inline long double 3784 hypot(long double __x, long double __y, long double __z) 3785 { return std::__hypot3<long double>(__x, __y, __z); } 3786 3787 template<typename _Tp, typename _Up, typename _Vp> 3788 typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type 3789 hypot(_Tp __x, _Up __y, _Vp __z) 3790 { 3791 using __type = typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type; 3792 return std::__hypot3<__type>(__x, __y, __z); 3793 } 3794 3795 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) 3796 inline _Float16 3797 hypot(_Float16 __x, _Float16 __y, _Float16 __z) 3798 { return std::__hypot3<_Float16>(__x, __y, __z); } 3799 #endif 3800 3801 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) 3802 inline _Float32 3803 hypot(_Float32 __x, _Float32 __y, _Float32 __z) 3804 { return std::__hypot3<_Float32>(__x, __y, __z); } 3805 #endif 3806 3807 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64) 3808 inline _Float64 3809 hypot(_Float64 __x, _Float64 __y, _Float64 __z) 3810 { return std::__hypot3<_Float64>(__x, __y, __z); } 3811 #endif 3812 3813 #if defined(__STDCPP_FLOAT128_T__) \ 3814 && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \ 3815 || defined(_GLIBCXX_HAVE_FLOAT128_MATH)) 3816 inline _Float128 3817 hypot(_Float128 __x, _Float128 __y, _Float128 __z) 3818 { return std::__hypot3<_Float128>(__x, __y, __z); } 3819 #endif 3820 3821 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) 3822 inline __gnu_cxx::__bfloat16_t 3823 hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z) 3824 { return std::__hypot3<__gnu_cxx::__bfloat16_t>(__x, __y, __z); } 3825 #endif 3826 3827 #endif // __cpp_lib_hypot 3828 3829 #ifdef __cpp_lib_interpolate // C++ >= 20 3830 // linear interpolation 3831 template<typename _Fp> 3832 constexpr _Fp 3833 __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept 3834 { 3835 if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0)) 3836 return __t * __b + (1 - __t) * __a; 3837 3838 if (__t == 1) 3839 return __b; // exact 3840 3841 // Exact at __t=0, monotonic except near __t=1, 3842 // bounded, determinate, and consistent: 3843 const _Fp __x = __a + __t * (__b - __a); 3844 return (__t > 1) == (__b > __a) 3845 ? (__b < __x ? __x : __b) 3846 : (__b > __x ? __x : __b); // monotonic near __t=1 3847 } 3848 3849 constexpr float 3850 lerp(float __a, float __b, float __t) noexcept 3851 { return std::__lerp(__a, __b, __t); } 3852 3853 constexpr double 3854 lerp(double __a, double __b, double __t) noexcept 3855 { return std::__lerp(__a, __b, __t); } 3856 3857 constexpr long double 3858 lerp(long double __a, long double __b, long double __t) noexcept 3859 { return std::__lerp(__a, __b, __t); } 3860 3861 template<typename _Tp, typename _Up, typename _Vp> 3862 constexpr __gnu_cxx::__promoted_t<_Tp, _Up, _Vp> 3863 lerp(_Tp __x, _Up __y, _Vp __z) noexcept 3864 { 3865 using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>; 3866 return std::__lerp<__type>(__x, __y, __z); 3867 } 3868 3869 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) 3870 inline _Float16 3871 lerp(_Float16 __x, _Float16 __y, _Float16 __z) noexcept 3872 { return std::__lerp<_Float16>(__x, __y, __z); } 3873 #endif 3874 3875 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) 3876 inline _Float32 3877 lerp(_Float32 __x, _Float32 __y, _Float32 __z) noexcept 3878 { return std::__lerp<_Float32>(__x, __y, __z); } 3879 #endif 3880 3881 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64) 3882 inline _Float64 3883 lerp(_Float64 __x, _Float64 __y, _Float64 __z) noexcept 3884 { return std::__lerp<_Float64>(__x, __y, __z); } 3885 #endif 3886 3887 #if defined(__STDCPP_FLOAT128_T__) \ 3888 && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \ 3889 || defined(_GLIBCXX_HAVE_FLOAT128_MATH)) 3890 inline _Float128 3891 lerp(_Float128 __x, _Float128 __y, _Float128 __z) noexcept 3892 { return std::__lerp<_Float128>(__x, __y, __z); } 3893 #endif 3894 3895 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) 3896 inline __gnu_cxx::__bfloat16_t 3897 lerp(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z) noexcept 3898 { return std::__lerp<__gnu_cxx::__bfloat16_t>(__x, __y, __z); } 3899 #endif 3900 #endif // __cpp_lib_interpolate 3901 3902 _GLIBCXX_END_NAMESPACE_VERSION 3903 } // namespace 3904 3905 #if _GLIBCXX_USE_STD_SPEC_FUNCS 3906 # include <bits/specfun.h> 3907 #endif 3908 3909 } // extern "C++" 3910 3911 #endif 3912
Indexes created Mon Oct 26 00:26:21 UTC 2026