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