1 // -*- C++ -*- 2 //===----------------------------------------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef _LIBCPP_MATH_H 11 #define _LIBCPP_MATH_H 12 13 /* 14 math.h synopsis 15 16 Macros: 17 18 HUGE_VAL 19 HUGE_VALF // C99 20 HUGE_VALL // C99 21 INFINITY // C99 22 NAN // C99 23 FP_INFINITE // C99 24 FP_NAN // C99 25 FP_NORMAL // C99 26 FP_SUBNORMAL // C99 27 FP_ZERO // C99 28 FP_FAST_FMA // C99 29 FP_FAST_FMAF // C99 30 FP_FAST_FMAL // C99 31 FP_ILOGB0 // C99 32 FP_ILOGBNAN // C99 33 MATH_ERRNO // C99 34 MATH_ERREXCEPT // C99 35 math_errhandling // C99 36 37 Types: 38 39 float_t // C99 40 double_t // C99 41 42 // C90 43 44 floating_point abs(floating_point x); 45 46 floating_point acos (arithmetic x); 47 float acosf(float x); 48 long double acosl(long double x); 49 50 floating_point asin (arithmetic x); 51 float asinf(float x); 52 long double asinl(long double x); 53 54 floating_point atan (arithmetic x); 55 float atanf(float x); 56 long double atanl(long double x); 57 58 floating_point atan2 (arithmetic y, arithmetic x); 59 float atan2f(float y, float x); 60 long double atan2l(long double y, long double x); 61 62 floating_point ceil (arithmetic x); 63 float ceilf(float x); 64 long double ceill(long double x); 65 66 floating_point cos (arithmetic x); 67 float cosf(float x); 68 long double cosl(long double x); 69 70 floating_point cosh (arithmetic x); 71 float coshf(float x); 72 long double coshl(long double x); 73 74 floating_point exp (arithmetic x); 75 float expf(float x); 76 long double expl(long double x); 77 78 floating_point fabs (arithmetic x); 79 float fabsf(float x); 80 long double fabsl(long double x); 81 82 floating_point floor (arithmetic x); 83 float floorf(float x); 84 long double floorl(long double x); 85 86 floating_point fmod (arithmetic x, arithmetic y); 87 float fmodf(float x, float y); 88 long double fmodl(long double x, long double y); 89 90 floating_point frexp (arithmetic value, int* exp); 91 float frexpf(float value, int* exp); 92 long double frexpl(long double value, int* exp); 93 94 floating_point ldexp (arithmetic value, int exp); 95 float ldexpf(float value, int exp); 96 long double ldexpl(long double value, int exp); 97 98 floating_point log (arithmetic x); 99 float logf(float x); 100 long double logl(long double x); 101 102 floating_point log10 (arithmetic x); 103 float log10f(float x); 104 long double log10l(long double x); 105 106 floating_point modf (floating_point value, floating_point* iptr); 107 float modff(float value, float* iptr); 108 long double modfl(long double value, long double* iptr); 109 110 floating_point pow (arithmetic x, arithmetic y); 111 float powf(float x, float y); 112 long double powl(long double x, long double y); 113 114 floating_point sin (arithmetic x); 115 float sinf(float x); 116 long double sinl(long double x); 117 118 floating_point sinh (arithmetic x); 119 float sinhf(float x); 120 long double sinhl(long double x); 121 122 floating_point sqrt (arithmetic x); 123 float sqrtf(float x); 124 long double sqrtl(long double x); 125 126 floating_point tan (arithmetic x); 127 float tanf(float x); 128 long double tanl(long double x); 129 130 floating_point tanh (arithmetic x); 131 float tanhf(float x); 132 long double tanhl(long double x); 133 134 // C99 135 136 bool signbit(arithmetic x); 137 138 int fpclassify(arithmetic x); 139 140 bool isfinite(arithmetic x); 141 bool isinf(arithmetic x); 142 bool isnan(arithmetic x); 143 bool isnormal(arithmetic x); 144 145 bool isgreater(arithmetic x, arithmetic y); 146 bool isgreaterequal(arithmetic x, arithmetic y); 147 bool isless(arithmetic x, arithmetic y); 148 bool islessequal(arithmetic x, arithmetic y); 149 bool islessgreater(arithmetic x, arithmetic y); 150 bool isunordered(arithmetic x, arithmetic y); 151 152 floating_point acosh (arithmetic x); 153 float acoshf(float x); 154 long double acoshl(long double x); 155 156 floating_point asinh (arithmetic x); 157 float asinhf(float x); 158 long double asinhl(long double x); 159 160 floating_point atanh (arithmetic x); 161 float atanhf(float x); 162 long double atanhl(long double x); 163 164 floating_point cbrt (arithmetic x); 165 float cbrtf(float x); 166 long double cbrtl(long double x); 167 168 floating_point copysign (arithmetic x, arithmetic y); 169 float copysignf(float x, float y); 170 long double copysignl(long double x, long double y); 171 172 floating_point erf (arithmetic x); 173 float erff(float x); 174 long double erfl(long double x); 175 176 floating_point erfc (arithmetic x); 177 float erfcf(float x); 178 long double erfcl(long double x); 179 180 floating_point exp2 (arithmetic x); 181 float exp2f(float x); 182 long double exp2l(long double x); 183 184 floating_point expm1 (arithmetic x); 185 float expm1f(float x); 186 long double expm1l(long double x); 187 188 floating_point fdim (arithmetic x, arithmetic y); 189 float fdimf(float x, float y); 190 long double fdiml(long double x, long double y); 191 192 floating_point fma (arithmetic x, arithmetic y, arithmetic z); 193 float fmaf(float x, float y, float z); 194 long double fmal(long double x, long double y, long double z); 195 196 floating_point fmax (arithmetic x, arithmetic y); 197 float fmaxf(float x, float y); 198 long double fmaxl(long double x, long double y); 199 200 floating_point fmin (arithmetic x, arithmetic y); 201 float fminf(float x, float y); 202 long double fminl(long double x, long double y); 203 204 floating_point hypot (arithmetic x, arithmetic y); 205 float hypotf(float x, float y); 206 long double hypotl(long double x, long double y); 207 208 int ilogb (arithmetic x); 209 int ilogbf(float x); 210 int ilogbl(long double x); 211 212 floating_point lgamma (arithmetic x); 213 float lgammaf(float x); 214 long double lgammal(long double x); 215 216 long long llrint (arithmetic x); 217 long long llrintf(float x); 218 long long llrintl(long double x); 219 220 long long llround (arithmetic x); 221 long long llroundf(float x); 222 long long llroundl(long double x); 223 224 floating_point log1p (arithmetic x); 225 float log1pf(float x); 226 long double log1pl(long double x); 227 228 floating_point log2 (arithmetic x); 229 float log2f(float x); 230 long double log2l(long double x); 231 232 floating_point logb (arithmetic x); 233 float logbf(float x); 234 long double logbl(long double x); 235 236 long lrint (arithmetic x); 237 long lrintf(float x); 238 long lrintl(long double x); 239 240 long lround (arithmetic x); 241 long lroundf(float x); 242 long lroundl(long double x); 243 244 double nan (const char* str); 245 float nanf(const char* str); 246 long double nanl(const char* str); 247 248 floating_point nearbyint (arithmetic x); 249 float nearbyintf(float x); 250 long double nearbyintl(long double x); 251 252 floating_point nextafter (arithmetic x, arithmetic y); 253 float nextafterf(float x, float y); 254 long double nextafterl(long double x, long double y); 255 256 floating_point nexttoward (arithmetic x, long double y); 257 float nexttowardf(float x, long double y); 258 long double nexttowardl(long double x, long double y); 259 260 floating_point remainder (arithmetic x, arithmetic y); 261 float remainderf(float x, float y); 262 long double remainderl(long double x, long double y); 263 264 floating_point remquo (arithmetic x, arithmetic y, int* pquo); 265 float remquof(float x, float y, int* pquo); 266 long double remquol(long double x, long double y, int* pquo); 267 268 floating_point rint (arithmetic x); 269 float rintf(float x); 270 long double rintl(long double x); 271 272 floating_point round (arithmetic x); 273 float roundf(float x); 274 long double roundl(long double x); 275 276 floating_point scalbln (arithmetic x, long ex); 277 float scalblnf(float x, long ex); 278 long double scalblnl(long double x, long ex); 279 280 floating_point scalbn (arithmetic x, int ex); 281 float scalbnf(float x, int ex); 282 long double scalbnl(long double x, int ex); 283 284 floating_point tgamma (arithmetic x); 285 float tgammaf(float x); 286 long double tgammal(long double x); 287 288 floating_point trunc (arithmetic x); 289 float truncf(float x); 290 long double truncl(long double x); 291 292 */ 293 294 #include <__config> 295 296 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 297 #pragma GCC system_header 298 #endif 299 300 #include_next <math.h> 301 302 #ifdef __cplusplus 303 304 // We support including .h headers inside 'extern "C"' contexts, so switch 305 // back to C++ linkage before including these C++ headers. 306 extern "C++" { 307 308 #include <limits> 309 #include <stdlib.h> 310 #include <type_traits> 311 312 // signbit 313 314 #ifdef signbit 315 316 template <class _A1> 317 _LIBCPP_INLINE_VISIBILITY 318 bool 319 __libcpp_signbit(_A1 __lcpp_x) _NOEXCEPT 320 { 321 #if __has_builtin(__builtin_signbit) 322 return __builtin_signbit(__lcpp_x); 323 #else 324 return signbit(__lcpp_x); 325 #endif 326 } 327 328 #undef signbit 329 330 template <class _A1> 331 inline _LIBCPP_INLINE_VISIBILITY 332 typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type 333 signbit(_A1 __lcpp_x) _NOEXCEPT 334 { 335 return __libcpp_signbit((typename std::__promote<_A1>::type)__lcpp_x); 336 } 337 338 template <class _A1> 339 inline _LIBCPP_INLINE_VISIBILITY 340 typename std::enable_if< 341 std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type 342 signbit(_A1 __lcpp_x) _NOEXCEPT 343 { return __lcpp_x < 0; } 344 345 template <class _A1> 346 inline _LIBCPP_INLINE_VISIBILITY 347 typename std::enable_if< 348 std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type 349 signbit(_A1) _NOEXCEPT 350 { return false; } 351 352 #elif defined(_LIBCPP_MSVCRT) 353 354 template <typename _A1> 355 inline _LIBCPP_INLINE_VISIBILITY 356 typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type 357 signbit(_A1 __lcpp_x) _NOEXCEPT 358 { 359 return ::signbit(static_cast<typename std::__promote<_A1>::type>(__lcpp_x)); 360 } 361 362 template <class _A1> 363 inline _LIBCPP_INLINE_VISIBILITY 364 typename std::enable_if< 365 std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type 366 signbit(_A1 __lcpp_x) _NOEXCEPT 367 { return __lcpp_x < 0; } 368 369 template <class _A1> 370 inline _LIBCPP_INLINE_VISIBILITY 371 typename std::enable_if< 372 std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type 373 signbit(_A1) _NOEXCEPT 374 { return false; } 375 376 #endif // signbit 377 378 // fpclassify 379 380 #ifdef fpclassify 381 382 template <class _A1> 383 _LIBCPP_INLINE_VISIBILITY 384 int 385 __libcpp_fpclassify(_A1 __lcpp_x) _NOEXCEPT 386 { 387 #if __has_builtin(__builtin_fpclassify) 388 return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, 389 FP_ZERO, __lcpp_x); 390 #else 391 return fpclassify(__lcpp_x); 392 #endif 393 } 394 395 #undef fpclassify 396 397 template <class _A1> 398 inline _LIBCPP_INLINE_VISIBILITY 399 typename std::enable_if<std::is_floating_point<_A1>::value, int>::type 400 fpclassify(_A1 __lcpp_x) _NOEXCEPT 401 { 402 return __libcpp_fpclassify((typename std::__promote<_A1>::type)__lcpp_x); 403 } 404 405 template <class _A1> 406 inline _LIBCPP_INLINE_VISIBILITY 407 typename std::enable_if<std::is_integral<_A1>::value, int>::type 408 fpclassify(_A1 __lcpp_x) _NOEXCEPT 409 { return __lcpp_x == 0 ? FP_ZERO : FP_NORMAL; } 410 411 #elif defined(_LIBCPP_MSVCRT) 412 413 template <typename _A1> 414 inline _LIBCPP_INLINE_VISIBILITY 415 typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type 416 fpclassify(_A1 __lcpp_x) _NOEXCEPT 417 { 418 return ::fpclassify(static_cast<typename std::__promote<_A1>::type>(__lcpp_x)); 419 } 420 421 template <class _A1> 422 inline _LIBCPP_INLINE_VISIBILITY 423 typename std::enable_if<std::is_integral<_A1>::value, int>::type 424 fpclassify(_A1 __lcpp_x) _NOEXCEPT 425 { return __lcpp_x == 0 ? FP_ZERO : FP_NORMAL; } 426 427 #endif // fpclassify 428 429 // isfinite 430 431 #ifdef isfinite 432 433 template <class _A1> 434 _LIBCPP_INLINE_VISIBILITY 435 bool 436 __libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT 437 { 438 #if __has_builtin(__builtin_isfinite) 439 return __builtin_isfinite(__lcpp_x); 440 #else 441 return isfinite(__lcpp_x); 442 #endif 443 } 444 445 #undef isfinite 446 447 template <class _A1> 448 inline _LIBCPP_INLINE_VISIBILITY 449 typename std::enable_if< 450 std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity, 451 bool>::type 452 isfinite(_A1 __lcpp_x) _NOEXCEPT 453 { 454 return __libcpp_isfinite((typename std::__promote<_A1>::type)__lcpp_x); 455 } 456 457 template <class _A1> 458 inline _LIBCPP_INLINE_VISIBILITY 459 typename std::enable_if< 460 std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity, 461 bool>::type 462 isfinite(_A1) _NOEXCEPT 463 { return true; } 464 465 #endif // isfinite 466 467 // isinf 468 469 #ifdef isinf 470 471 template <class _A1> 472 _LIBCPP_INLINE_VISIBILITY 473 bool 474 __libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT 475 { 476 #if __has_builtin(__builtin_isinf) 477 return __builtin_isinf(__lcpp_x); 478 #else 479 return isinf(__lcpp_x); 480 #endif 481 } 482 483 #undef isinf 484 485 template <class _A1> 486 inline _LIBCPP_INLINE_VISIBILITY 487 typename std::enable_if< 488 std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity, 489 bool>::type 490 isinf(_A1 __lcpp_x) _NOEXCEPT 491 { 492 return __libcpp_isinf((typename std::__promote<_A1>::type)__lcpp_x); 493 } 494 495 template <class _A1> 496 inline _LIBCPP_INLINE_VISIBILITY 497 typename std::enable_if< 498 std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity, 499 bool>::type 500 isinf(_A1) _NOEXCEPT 501 { return false; } 502 503 #ifdef _LIBCPP_PREFERRED_OVERLOAD 504 inline _LIBCPP_INLINE_VISIBILITY 505 bool 506 isinf(float __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); } 507 508 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD 509 bool 510 isinf(double __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); } 511 512 inline _LIBCPP_INLINE_VISIBILITY 513 bool 514 isinf(long double __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); } 515 #endif 516 517 #endif // isinf 518 519 // isnan 520 521 #ifdef isnan 522 523 template <class _A1> 524 _LIBCPP_INLINE_VISIBILITY 525 bool 526 __libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT 527 { 528 #if __has_builtin(__builtin_isnan) 529 return __builtin_isnan(__lcpp_x); 530 #else 531 return isnan(__lcpp_x); 532 #endif 533 } 534 535 #undef isnan 536 537 template <class _A1> 538 inline _LIBCPP_INLINE_VISIBILITY 539 typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type 540 isnan(_A1 __lcpp_x) _NOEXCEPT 541 { 542 return __libcpp_isnan((typename std::__promote<_A1>::type)__lcpp_x); 543 } 544 545 template <class _A1> 546 inline _LIBCPP_INLINE_VISIBILITY 547 typename std::enable_if<std::is_integral<_A1>::value, bool>::type 548 isnan(_A1) _NOEXCEPT 549 { return false; } 550 551 #ifdef _LIBCPP_PREFERRED_OVERLOAD 552 inline _LIBCPP_INLINE_VISIBILITY 553 bool 554 isnan(float __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); } 555 556 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD 557 bool 558 isnan(double __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); } 559 560 inline _LIBCPP_INLINE_VISIBILITY 561 bool 562 isnan(long double __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); } 563 #endif 564 565 #endif // isnan 566 567 // isnormal 568 569 #ifdef isnormal 570 571 template <class _A1> 572 _LIBCPP_INLINE_VISIBILITY 573 bool 574 __libcpp_isnormal(_A1 __lcpp_x) _NOEXCEPT 575 { 576 #if __has_builtin(__builtin_isnormal) 577 return __builtin_isnormal(__lcpp_x); 578 #else 579 return isnormal(__lcpp_x); 580 #endif 581 } 582 583 #undef isnormal 584 585 template <class _A1> 586 inline _LIBCPP_INLINE_VISIBILITY 587 typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type 588 isnormal(_A1 __lcpp_x) _NOEXCEPT 589 { 590 return __libcpp_isnormal((typename std::__promote<_A1>::type)__lcpp_x); 591 } 592 593 template <class _A1> 594 inline _LIBCPP_INLINE_VISIBILITY 595 typename std::enable_if<std::is_integral<_A1>::value, bool>::type 596 isnormal(_A1 __lcpp_x) _NOEXCEPT 597 { return __lcpp_x != 0; } 598 599 #endif // isnormal 600 601 // isgreater 602 603 #ifdef isgreater 604 605 template <class _A1, class _A2> 606 _LIBCPP_INLINE_VISIBILITY 607 bool 608 __libcpp_isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 609 { 610 return isgreater(__lcpp_x, __lcpp_y); 611 } 612 613 #undef isgreater 614 615 template <class _A1, class _A2> 616 inline _LIBCPP_INLINE_VISIBILITY 617 typename std::enable_if 618 < 619 std::is_arithmetic<_A1>::value && 620 std::is_arithmetic<_A2>::value, 621 bool 622 >::type 623 isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 624 { 625 typedef typename std::__promote<_A1, _A2>::type type; 626 return __libcpp_isgreater((type)__lcpp_x, (type)__lcpp_y); 627 } 628 629 #endif // isgreater 630 631 // isgreaterequal 632 633 #ifdef isgreaterequal 634 635 template <class _A1, class _A2> 636 _LIBCPP_INLINE_VISIBILITY 637 bool 638 __libcpp_isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 639 { 640 return isgreaterequal(__lcpp_x, __lcpp_y); 641 } 642 643 #undef isgreaterequal 644 645 template <class _A1, class _A2> 646 inline _LIBCPP_INLINE_VISIBILITY 647 typename std::enable_if 648 < 649 std::is_arithmetic<_A1>::value && 650 std::is_arithmetic<_A2>::value, 651 bool 652 >::type 653 isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 654 { 655 typedef typename std::__promote<_A1, _A2>::type type; 656 return __libcpp_isgreaterequal((type)__lcpp_x, (type)__lcpp_y); 657 } 658 659 #endif // isgreaterequal 660 661 // isless 662 663 #ifdef isless 664 665 template <class _A1, class _A2> 666 _LIBCPP_INLINE_VISIBILITY 667 bool 668 __libcpp_isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 669 { 670 return isless(__lcpp_x, __lcpp_y); 671 } 672 673 #undef isless 674 675 template <class _A1, class _A2> 676 inline _LIBCPP_INLINE_VISIBILITY 677 typename std::enable_if 678 < 679 std::is_arithmetic<_A1>::value && 680 std::is_arithmetic<_A2>::value, 681 bool 682 >::type 683 isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 684 { 685 typedef typename std::__promote<_A1, _A2>::type type; 686 return __libcpp_isless((type)__lcpp_x, (type)__lcpp_y); 687 } 688 689 #endif // isless 690 691 // islessequal 692 693 #ifdef islessequal 694 695 template <class _A1, class _A2> 696 _LIBCPP_INLINE_VISIBILITY 697 bool 698 __libcpp_islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 699 { 700 return islessequal(__lcpp_x, __lcpp_y); 701 } 702 703 #undef islessequal 704 705 template <class _A1, class _A2> 706 inline _LIBCPP_INLINE_VISIBILITY 707 typename std::enable_if 708 < 709 std::is_arithmetic<_A1>::value && 710 std::is_arithmetic<_A2>::value, 711 bool 712 >::type 713 islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 714 { 715 typedef typename std::__promote<_A1, _A2>::type type; 716 return __libcpp_islessequal((type)__lcpp_x, (type)__lcpp_y); 717 } 718 719 #endif // islessequal 720 721 // islessgreater 722 723 #ifdef islessgreater 724 725 template <class _A1, class _A2> 726 _LIBCPP_INLINE_VISIBILITY 727 bool 728 __libcpp_islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 729 { 730 return islessgreater(__lcpp_x, __lcpp_y); 731 } 732 733 #undef islessgreater 734 735 template <class _A1, class _A2> 736 inline _LIBCPP_INLINE_VISIBILITY 737 typename std::enable_if 738 < 739 std::is_arithmetic<_A1>::value && 740 std::is_arithmetic<_A2>::value, 741 bool 742 >::type 743 islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 744 { 745 typedef typename std::__promote<_A1, _A2>::type type; 746 return __libcpp_islessgreater((type)__lcpp_x, (type)__lcpp_y); 747 } 748 749 #endif // islessgreater 750 751 // isunordered 752 753 #ifdef isunordered 754 755 template <class _A1, class _A2> 756 _LIBCPP_INLINE_VISIBILITY 757 bool 758 __libcpp_isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 759 { 760 return isunordered(__lcpp_x, __lcpp_y); 761 } 762 763 #undef isunordered 764 765 template <class _A1, class _A2> 766 inline _LIBCPP_INLINE_VISIBILITY 767 typename std::enable_if 768 < 769 std::is_arithmetic<_A1>::value && 770 std::is_arithmetic<_A2>::value, 771 bool 772 >::type 773 isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 774 { 775 typedef typename std::__promote<_A1, _A2>::type type; 776 return __libcpp_isunordered((type)__lcpp_x, (type)__lcpp_y); 777 } 778 779 #endif // isunordered 780 781 // abs 782 // 783 // handled in stdlib.h 784 785 // div 786 // 787 // handled in stdlib.h 788 789 // acos 790 791 #if !(defined(_AIX) || defined(__sun__)) 792 inline _LIBCPP_INLINE_VISIBILITY float acos(float __lcpp_x) _NOEXCEPT {return ::acosf(__lcpp_x);} 793 inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __lcpp_x) _NOEXCEPT {return ::acosl(__lcpp_x);} 794 #endif 795 796 template <class _A1> 797 inline _LIBCPP_INLINE_VISIBILITY 798 typename std::enable_if<std::is_integral<_A1>::value, double>::type 799 acos(_A1 __lcpp_x) _NOEXCEPT {return ::acos((double)__lcpp_x);} 800 801 // asin 802 803 #if !(defined(_AIX) || defined(__sun__)) 804 inline _LIBCPP_INLINE_VISIBILITY float asin(float __lcpp_x) _NOEXCEPT {return ::asinf(__lcpp_x);} 805 inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __lcpp_x) _NOEXCEPT {return ::asinl(__lcpp_x);} 806 #endif 807 808 template <class _A1> 809 inline _LIBCPP_INLINE_VISIBILITY 810 typename std::enable_if<std::is_integral<_A1>::value, double>::type 811 asin(_A1 __lcpp_x) _NOEXCEPT {return ::asin((double)__lcpp_x);} 812 813 // atan 814 815 #if !(defined(_AIX) || defined(__sun__)) 816 inline _LIBCPP_INLINE_VISIBILITY float atan(float __lcpp_x) _NOEXCEPT {return ::atanf(__lcpp_x);} 817 inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __lcpp_x) _NOEXCEPT {return ::atanl(__lcpp_x);} 818 #endif 819 820 template <class _A1> 821 inline _LIBCPP_INLINE_VISIBILITY 822 typename std::enable_if<std::is_integral<_A1>::value, double>::type 823 atan(_A1 __lcpp_x) _NOEXCEPT {return ::atan((double)__lcpp_x);} 824 825 // atan2 826 827 #if !(defined(_AIX) || defined(__sun__)) 828 inline _LIBCPP_INLINE_VISIBILITY float atan2(float __lcpp_y, float __lcpp_x) _NOEXCEPT {return ::atan2f(__lcpp_y, __lcpp_x);} 829 inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __lcpp_y, long double __lcpp_x) _NOEXCEPT {return ::atan2l(__lcpp_y, __lcpp_x);} 830 #endif 831 832 template <class _A1, class _A2> 833 inline _LIBCPP_INLINE_VISIBILITY 834 typename std::__enable_if_t 835 < 836 std::is_arithmetic<_A1>::value && 837 std::is_arithmetic<_A2>::value, 838 std::__promote<_A1, _A2> 839 >::type 840 atan2(_A1 __lcpp_y, _A2 __lcpp_x) _NOEXCEPT 841 { 842 typedef typename std::__promote<_A1, _A2>::type __result_type; 843 static_assert((!(std::_IsSame<_A1, __result_type>::value && 844 std::_IsSame<_A2, __result_type>::value)), ""); 845 return ::atan2((__result_type)__lcpp_y, (__result_type)__lcpp_x); 846 } 847 848 // ceil 849 850 #if !(defined(_AIX) || defined(__sun__)) 851 inline _LIBCPP_INLINE_VISIBILITY float ceil(float __lcpp_x) _NOEXCEPT {return ::ceilf(__lcpp_x);} 852 inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __lcpp_x) _NOEXCEPT {return ::ceill(__lcpp_x);} 853 #endif 854 855 template <class _A1> 856 inline _LIBCPP_INLINE_VISIBILITY 857 typename std::enable_if<std::is_integral<_A1>::value, double>::type 858 ceil(_A1 __lcpp_x) _NOEXCEPT {return ::ceil((double)__lcpp_x);} 859 860 // cos 861 862 #if !(defined(_AIX) || defined(__sun__)) 863 inline _LIBCPP_INLINE_VISIBILITY float cos(float __lcpp_x) _NOEXCEPT {return ::cosf(__lcpp_x);} 864 inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __lcpp_x) _NOEXCEPT {return ::cosl(__lcpp_x);} 865 #endif 866 867 template <class _A1> 868 inline _LIBCPP_INLINE_VISIBILITY 869 typename std::enable_if<std::is_integral<_A1>::value, double>::type 870 cos(_A1 __lcpp_x) _NOEXCEPT {return ::cos((double)__lcpp_x);} 871 872 // cosh 873 874 #if !(defined(_AIX) || defined(__sun__)) 875 inline _LIBCPP_INLINE_VISIBILITY float cosh(float __lcpp_x) _NOEXCEPT {return ::coshf(__lcpp_x);} 876 inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __lcpp_x) _NOEXCEPT {return ::coshl(__lcpp_x);} 877 #endif 878 879 template <class _A1> 880 inline _LIBCPP_INLINE_VISIBILITY 881 typename std::enable_if<std::is_integral<_A1>::value, double>::type 882 cosh(_A1 __lcpp_x) _NOEXCEPT {return ::cosh((double)__lcpp_x);} 883 884 // exp 885 886 #if !(defined(_AIX) || defined(__sun__)) 887 inline _LIBCPP_INLINE_VISIBILITY float exp(float __lcpp_x) _NOEXCEPT {return ::expf(__lcpp_x);} 888 inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __lcpp_x) _NOEXCEPT {return ::expl(__lcpp_x);} 889 #endif 890 891 template <class _A1> 892 inline _LIBCPP_INLINE_VISIBILITY 893 typename std::enable_if<std::is_integral<_A1>::value, double>::type 894 exp(_A1 __lcpp_x) _NOEXCEPT {return ::exp((double)__lcpp_x);} 895 896 // fabs 897 898 #if !(defined(_AIX) || defined(__sun__)) 899 inline _LIBCPP_INLINE_VISIBILITY float fabs(float __lcpp_x) _NOEXCEPT {return ::fabsf(__lcpp_x);} 900 inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __lcpp_x) _NOEXCEPT {return ::fabsl(__lcpp_x);} 901 #endif 902 903 template <class _A1> 904 inline _LIBCPP_INLINE_VISIBILITY 905 typename std::enable_if<std::is_integral<_A1>::value, double>::type 906 fabs(_A1 __lcpp_x) _NOEXCEPT {return ::fabs((double)__lcpp_x);} 907 908 // floor 909 910 #if !(defined(_AIX) || defined(__sun__)) 911 inline _LIBCPP_INLINE_VISIBILITY float floor(float __lcpp_x) _NOEXCEPT {return ::floorf(__lcpp_x);} 912 inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __lcpp_x) _NOEXCEPT {return ::floorl(__lcpp_x);} 913 #endif 914 915 template <class _A1> 916 inline _LIBCPP_INLINE_VISIBILITY 917 typename std::enable_if<std::is_integral<_A1>::value, double>::type 918 floor(_A1 __lcpp_x) _NOEXCEPT {return ::floor((double)__lcpp_x);} 919 920 // fmod 921 922 #if !(defined(_AIX) || defined(__sun__)) 923 inline _LIBCPP_INLINE_VISIBILITY float fmod(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fmodf(__lcpp_x, __lcpp_y);} 924 inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fmodl(__lcpp_x, __lcpp_y);} 925 #endif 926 927 template <class _A1, class _A2> 928 inline _LIBCPP_INLINE_VISIBILITY 929 typename std::__enable_if_t 930 < 931 std::is_arithmetic<_A1>::value && 932 std::is_arithmetic<_A2>::value, 933 std::__promote<_A1, _A2> 934 >::type 935 fmod(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 936 { 937 typedef typename std::__promote<_A1, _A2>::type __result_type; 938 static_assert((!(std::_IsSame<_A1, __result_type>::value && 939 std::_IsSame<_A2, __result_type>::value)), ""); 940 return ::fmod((__result_type)__lcpp_x, (__result_type)__lcpp_y); 941 } 942 943 // frexp 944 945 #if !(defined(_AIX) || defined(__sun__)) 946 inline _LIBCPP_INLINE_VISIBILITY float frexp(float __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexpf(__lcpp_x, __lcpp_e);} 947 inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexpl(__lcpp_x, __lcpp_e);} 948 #endif 949 950 template <class _A1> 951 inline _LIBCPP_INLINE_VISIBILITY 952 typename std::enable_if<std::is_integral<_A1>::value, double>::type 953 frexp(_A1 __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexp((double)__lcpp_x, __lcpp_e);} 954 955 // ldexp 956 957 #if !(defined(_AIX) || defined(__sun__)) 958 inline _LIBCPP_INLINE_VISIBILITY float ldexp(float __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexpf(__lcpp_x, __lcpp_e);} 959 inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexpl(__lcpp_x, __lcpp_e);} 960 #endif 961 962 template <class _A1> 963 inline _LIBCPP_INLINE_VISIBILITY 964 typename std::enable_if<std::is_integral<_A1>::value, double>::type 965 ldexp(_A1 __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexp((double)__lcpp_x, __lcpp_e);} 966 967 // log 968 969 #if !(defined(_AIX) || defined(__sun__)) 970 inline _LIBCPP_INLINE_VISIBILITY float log(float __lcpp_x) _NOEXCEPT {return ::logf(__lcpp_x);} 971 inline _LIBCPP_INLINE_VISIBILITY long double log(long double __lcpp_x) _NOEXCEPT {return ::logl(__lcpp_x);} 972 #endif 973 974 template <class _A1> 975 inline _LIBCPP_INLINE_VISIBILITY 976 typename std::enable_if<std::is_integral<_A1>::value, double>::type 977 log(_A1 __lcpp_x) _NOEXCEPT {return ::log((double)__lcpp_x);} 978 979 // log10 980 981 #if !(defined(_AIX) || defined(__sun__)) 982 inline _LIBCPP_INLINE_VISIBILITY float log10(float __lcpp_x) _NOEXCEPT {return ::log10f(__lcpp_x);} 983 inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __lcpp_x) _NOEXCEPT {return ::log10l(__lcpp_x);} 984 #endif 985 986 template <class _A1> 987 inline _LIBCPP_INLINE_VISIBILITY 988 typename std::enable_if<std::is_integral<_A1>::value, double>::type 989 log10(_A1 __lcpp_x) _NOEXCEPT {return ::log10((double)__lcpp_x);} 990 991 // modf 992 993 #if !(defined(_AIX) || defined(__sun__)) 994 inline _LIBCPP_INLINE_VISIBILITY float modf(float __lcpp_x, float* __lcpp_y) _NOEXCEPT {return ::modff(__lcpp_x, __lcpp_y);} 995 inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __lcpp_x, long double* __lcpp_y) _NOEXCEPT {return ::modfl(__lcpp_x, __lcpp_y);} 996 #endif 997 998 // pow 999 1000 #if !(defined(_AIX) || defined(__sun__)) 1001 inline _LIBCPP_INLINE_VISIBILITY float pow(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::powf(__lcpp_x, __lcpp_y);} 1002 inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::powl(__lcpp_x, __lcpp_y);} 1003 #endif 1004 1005 template <class _A1, class _A2> 1006 inline _LIBCPP_INLINE_VISIBILITY 1007 typename std::__enable_if_t 1008 < 1009 std::is_arithmetic<_A1>::value && 1010 std::is_arithmetic<_A2>::value, 1011 std::__promote<_A1, _A2> 1012 >::type 1013 pow(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 1014 { 1015 typedef typename std::__promote<_A1, _A2>::type __result_type; 1016 static_assert((!(std::_IsSame<_A1, __result_type>::value && 1017 std::_IsSame<_A2, __result_type>::value)), ""); 1018 return ::pow((__result_type)__lcpp_x, (__result_type)__lcpp_y); 1019 } 1020 1021 // sin 1022 1023 #if !(defined(_AIX) || defined(__sun__)) 1024 inline _LIBCPP_INLINE_VISIBILITY float sin(float __lcpp_x) _NOEXCEPT {return ::sinf(__lcpp_x);} 1025 inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __lcpp_x) _NOEXCEPT {return ::sinl(__lcpp_x);} 1026 #endif 1027 1028 template <class _A1> 1029 inline _LIBCPP_INLINE_VISIBILITY 1030 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1031 sin(_A1 __lcpp_x) _NOEXCEPT {return ::sin((double)__lcpp_x);} 1032 1033 // sinh 1034 1035 #if !(defined(_AIX) || defined(__sun__)) 1036 inline _LIBCPP_INLINE_VISIBILITY float sinh(float __lcpp_x) _NOEXCEPT {return ::sinhf(__lcpp_x);} 1037 inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __lcpp_x) _NOEXCEPT {return ::sinhl(__lcpp_x);} 1038 #endif 1039 1040 template <class _A1> 1041 inline _LIBCPP_INLINE_VISIBILITY 1042 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1043 sinh(_A1 __lcpp_x) _NOEXCEPT {return ::sinh((double)__lcpp_x);} 1044 1045 // sqrt 1046 1047 #if !(defined(_AIX) || defined(__sun__)) 1048 inline _LIBCPP_INLINE_VISIBILITY float sqrt(float __lcpp_x) _NOEXCEPT {return ::sqrtf(__lcpp_x);} 1049 inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __lcpp_x) _NOEXCEPT {return ::sqrtl(__lcpp_x);} 1050 #endif 1051 1052 template <class _A1> 1053 inline _LIBCPP_INLINE_VISIBILITY 1054 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1055 sqrt(_A1 __lcpp_x) _NOEXCEPT {return ::sqrt((double)__lcpp_x);} 1056 1057 // tan 1058 1059 #if !(defined(_AIX) || defined(__sun__)) 1060 inline _LIBCPP_INLINE_VISIBILITY float tan(float __lcpp_x) _NOEXCEPT {return ::tanf(__lcpp_x);} 1061 inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __lcpp_x) _NOEXCEPT {return ::tanl(__lcpp_x);} 1062 #endif 1063 1064 template <class _A1> 1065 inline _LIBCPP_INLINE_VISIBILITY 1066 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1067 tan(_A1 __lcpp_x) _NOEXCEPT {return ::tan((double)__lcpp_x);} 1068 1069 // tanh 1070 1071 #if !(defined(_AIX) || defined(__sun__)) 1072 inline _LIBCPP_INLINE_VISIBILITY float tanh(float __lcpp_x) _NOEXCEPT {return ::tanhf(__lcpp_x);} 1073 inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __lcpp_x) _NOEXCEPT {return ::tanhl(__lcpp_x);} 1074 #endif 1075 1076 template <class _A1> 1077 inline _LIBCPP_INLINE_VISIBILITY 1078 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1079 tanh(_A1 __lcpp_x) _NOEXCEPT {return ::tanh((double)__lcpp_x);} 1080 1081 // acosh 1082 1083 inline _LIBCPP_INLINE_VISIBILITY float acosh(float __lcpp_x) _NOEXCEPT {return ::acoshf(__lcpp_x);} 1084 inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __lcpp_x) _NOEXCEPT {return ::acoshl(__lcpp_x);} 1085 1086 template <class _A1> 1087 inline _LIBCPP_INLINE_VISIBILITY 1088 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1089 acosh(_A1 __lcpp_x) _NOEXCEPT {return ::acosh((double)__lcpp_x);} 1090 1091 // asinh 1092 1093 inline _LIBCPP_INLINE_VISIBILITY float asinh(float __lcpp_x) _NOEXCEPT {return ::asinhf(__lcpp_x);} 1094 inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __lcpp_x) _NOEXCEPT {return ::asinhl(__lcpp_x);} 1095 1096 template <class _A1> 1097 inline _LIBCPP_INLINE_VISIBILITY 1098 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1099 asinh(_A1 __lcpp_x) _NOEXCEPT {return ::asinh((double)__lcpp_x);} 1100 1101 // atanh 1102 1103 inline _LIBCPP_INLINE_VISIBILITY float atanh(float __lcpp_x) _NOEXCEPT {return ::atanhf(__lcpp_x);} 1104 inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __lcpp_x) _NOEXCEPT {return ::atanhl(__lcpp_x);} 1105 1106 template <class _A1> 1107 inline _LIBCPP_INLINE_VISIBILITY 1108 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1109 atanh(_A1 __lcpp_x) _NOEXCEPT {return ::atanh((double)__lcpp_x);} 1110 1111 // cbrt 1112 1113 inline _LIBCPP_INLINE_VISIBILITY float cbrt(float __lcpp_x) _NOEXCEPT {return ::cbrtf(__lcpp_x);} 1114 inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __lcpp_x) _NOEXCEPT {return ::cbrtl(__lcpp_x);} 1115 1116 template <class _A1> 1117 inline _LIBCPP_INLINE_VISIBILITY 1118 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1119 cbrt(_A1 __lcpp_x) _NOEXCEPT {return ::cbrt((double)__lcpp_x);} 1120 1121 // copysign 1122 1123 #if __has_builtin(__builtin_copysignf) 1124 _LIBCPP_CONSTEXPR 1125 #endif 1126 inline _LIBCPP_INLINE_VISIBILITY float __libcpp_copysign(float __lcpp_x, float __lcpp_y) _NOEXCEPT { 1127 #if __has_builtin(__builtin_copysignf) 1128 return __builtin_copysignf(__lcpp_x, __lcpp_y); 1129 #else 1130 return ::copysignf(__lcpp_x, __lcpp_y); 1131 #endif 1132 } 1133 1134 #if __has_builtin(__builtin_copysign) 1135 _LIBCPP_CONSTEXPR 1136 #endif 1137 inline _LIBCPP_INLINE_VISIBILITY double __libcpp_copysign(double __lcpp_x, double __lcpp_y) _NOEXCEPT { 1138 #if __has_builtin(__builtin_copysign) 1139 return __builtin_copysign(__lcpp_x, __lcpp_y); 1140 #else 1141 return ::copysign(__lcpp_x, __lcpp_y); 1142 #endif 1143 } 1144 1145 #if __has_builtin(__builtin_copysignl) 1146 _LIBCPP_CONSTEXPR 1147 #endif 1148 inline _LIBCPP_INLINE_VISIBILITY long double __libcpp_copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT { 1149 #if __has_builtin(__builtin_copysignl) 1150 return __builtin_copysignl(__lcpp_x, __lcpp_y); 1151 #else 1152 return ::copysignl(__lcpp_x, __lcpp_y); 1153 #endif 1154 } 1155 1156 template <class _A1, class _A2> 1157 #if __has_builtin(__builtin_copysign) 1158 _LIBCPP_CONSTEXPR 1159 #endif 1160 inline _LIBCPP_INLINE_VISIBILITY 1161 typename std::__enable_if_t 1162 < 1163 std::is_arithmetic<_A1>::value && 1164 std::is_arithmetic<_A2>::value, 1165 std::__promote<_A1, _A2> 1166 >::type 1167 __libcpp_copysign(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT { 1168 typedef typename std::__promote<_A1, _A2>::type __result_type; 1169 static_assert((!(std::_IsSame<_A1, __result_type>::value && 1170 std::_IsSame<_A2, __result_type>::value)), ""); 1171 #if __has_builtin(__builtin_copysign) 1172 return __builtin_copysign((__result_type)__lcpp_x, (__result_type)__lcpp_y); 1173 #else 1174 return ::copysign((__result_type)__lcpp_x, (__result_type)__lcpp_y); 1175 #endif 1176 } 1177 1178 inline _LIBCPP_INLINE_VISIBILITY float copysign(float __lcpp_x, float __lcpp_y) _NOEXCEPT { 1179 return ::__libcpp_copysign(__lcpp_x, __lcpp_y); 1180 } 1181 1182 inline _LIBCPP_INLINE_VISIBILITY long double copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT { 1183 return ::__libcpp_copysign(__lcpp_x, __lcpp_y); 1184 } 1185 1186 template <class _A1, class _A2> 1187 inline _LIBCPP_INLINE_VISIBILITY 1188 typename std::__enable_if_t 1189 < 1190 std::is_arithmetic<_A1>::value && 1191 std::is_arithmetic<_A2>::value, 1192 std::__promote<_A1, _A2> 1193 >::type 1194 copysign(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT { 1195 return ::__libcpp_copysign(__lcpp_x, __lcpp_y); 1196 } 1197 1198 // erf 1199 1200 inline _LIBCPP_INLINE_VISIBILITY float erf(float __lcpp_x) _NOEXCEPT {return ::erff(__lcpp_x);} 1201 inline _LIBCPP_INLINE_VISIBILITY long double erf(long double __lcpp_x) _NOEXCEPT {return ::erfl(__lcpp_x);} 1202 1203 template <class _A1> 1204 inline _LIBCPP_INLINE_VISIBILITY 1205 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1206 erf(_A1 __lcpp_x) _NOEXCEPT {return ::erf((double)__lcpp_x);} 1207 1208 // erfc 1209 1210 inline _LIBCPP_INLINE_VISIBILITY float erfc(float __lcpp_x) _NOEXCEPT {return ::erfcf(__lcpp_x);} 1211 inline _LIBCPP_INLINE_VISIBILITY long double erfc(long double __lcpp_x) _NOEXCEPT {return ::erfcl(__lcpp_x);} 1212 1213 template <class _A1> 1214 inline _LIBCPP_INLINE_VISIBILITY 1215 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1216 erfc(_A1 __lcpp_x) _NOEXCEPT {return ::erfc((double)__lcpp_x);} 1217 1218 // exp2 1219 1220 inline _LIBCPP_INLINE_VISIBILITY float exp2(float __lcpp_x) _NOEXCEPT {return ::exp2f(__lcpp_x);} 1221 inline _LIBCPP_INLINE_VISIBILITY long double exp2(long double __lcpp_x) _NOEXCEPT {return ::exp2l(__lcpp_x);} 1222 1223 template <class _A1> 1224 inline _LIBCPP_INLINE_VISIBILITY 1225 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1226 exp2(_A1 __lcpp_x) _NOEXCEPT {return ::exp2((double)__lcpp_x);} 1227 1228 // expm1 1229 1230 inline _LIBCPP_INLINE_VISIBILITY float expm1(float __lcpp_x) _NOEXCEPT {return ::expm1f(__lcpp_x);} 1231 inline _LIBCPP_INLINE_VISIBILITY long double expm1(long double __lcpp_x) _NOEXCEPT {return ::expm1l(__lcpp_x);} 1232 1233 template <class _A1> 1234 inline _LIBCPP_INLINE_VISIBILITY 1235 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1236 expm1(_A1 __lcpp_x) _NOEXCEPT {return ::expm1((double)__lcpp_x);} 1237 1238 // fdim 1239 1240 inline _LIBCPP_INLINE_VISIBILITY float fdim(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fdimf(__lcpp_x, __lcpp_y);} 1241 inline _LIBCPP_INLINE_VISIBILITY long double fdim(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fdiml(__lcpp_x, __lcpp_y);} 1242 1243 template <class _A1, class _A2> 1244 inline _LIBCPP_INLINE_VISIBILITY 1245 typename std::__enable_if_t 1246 < 1247 std::is_arithmetic<_A1>::value && 1248 std::is_arithmetic<_A2>::value, 1249 std::__promote<_A1, _A2> 1250 >::type 1251 fdim(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 1252 { 1253 typedef typename std::__promote<_A1, _A2>::type __result_type; 1254 static_assert((!(std::_IsSame<_A1, __result_type>::value && 1255 std::_IsSame<_A2, __result_type>::value)), ""); 1256 return ::fdim((__result_type)__lcpp_x, (__result_type)__lcpp_y); 1257 } 1258 1259 // fma 1260 1261 inline _LIBCPP_INLINE_VISIBILITY float fma(float __lcpp_x, float __lcpp_y, float __lcpp_z) _NOEXCEPT 1262 { 1263 #if __has_builtin(__builtin_fmaf) 1264 return __builtin_fmaf(__lcpp_x, __lcpp_y, __lcpp_z); 1265 #else 1266 return ::fmaf(__lcpp_x, __lcpp_y, __lcpp_z); 1267 #endif 1268 } 1269 inline _LIBCPP_INLINE_VISIBILITY long double fma(long double __lcpp_x, long double __lcpp_y, long double __lcpp_z) _NOEXCEPT 1270 { 1271 #if __has_builtin(__builtin_fmal) 1272 return __builtin_fmal(__lcpp_x, __lcpp_y, __lcpp_z); 1273 #else 1274 return ::fmal(__lcpp_x, __lcpp_y, __lcpp_z); 1275 #endif 1276 } 1277 1278 template <class _A1, class _A2, class _A3> 1279 inline _LIBCPP_INLINE_VISIBILITY 1280 typename std::__enable_if_t 1281 < 1282 std::is_arithmetic<_A1>::value && 1283 std::is_arithmetic<_A2>::value && 1284 std::is_arithmetic<_A3>::value, 1285 std::__promote<_A1, _A2, _A3> 1286 >::type 1287 fma(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT 1288 { 1289 typedef typename std::__promote<_A1, _A2, _A3>::type __result_type; 1290 static_assert((!(std::_IsSame<_A1, __result_type>::value && 1291 std::_IsSame<_A2, __result_type>::value && 1292 std::_IsSame<_A3, __result_type>::value)), ""); 1293 #if __has_builtin(__builtin_fma) 1294 return __builtin_fma((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z); 1295 #else 1296 return ::fma((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z); 1297 #endif 1298 } 1299 1300 // fmax 1301 1302 inline _LIBCPP_INLINE_VISIBILITY float fmax(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fmaxf(__lcpp_x, __lcpp_y);} 1303 inline _LIBCPP_INLINE_VISIBILITY long double fmax(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fmaxl(__lcpp_x, __lcpp_y);} 1304 1305 template <class _A1, class _A2> 1306 inline _LIBCPP_INLINE_VISIBILITY 1307 typename std::__enable_if_t 1308 < 1309 std::is_arithmetic<_A1>::value && 1310 std::is_arithmetic<_A2>::value, 1311 std::__promote<_A1, _A2> 1312 >::type 1313 fmax(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 1314 { 1315 typedef typename std::__promote<_A1, _A2>::type __result_type; 1316 static_assert((!(std::_IsSame<_A1, __result_type>::value && 1317 std::_IsSame<_A2, __result_type>::value)), ""); 1318 return ::fmax((__result_type)__lcpp_x, (__result_type)__lcpp_y); 1319 } 1320 1321 // fmin 1322 1323 inline _LIBCPP_INLINE_VISIBILITY float fmin(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fminf(__lcpp_x, __lcpp_y);} 1324 inline _LIBCPP_INLINE_VISIBILITY long double fmin(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fminl(__lcpp_x, __lcpp_y);} 1325 1326 template <class _A1, class _A2> 1327 inline _LIBCPP_INLINE_VISIBILITY 1328 typename std::__enable_if_t 1329 < 1330 std::is_arithmetic<_A1>::value && 1331 std::is_arithmetic<_A2>::value, 1332 std::__promote<_A1, _A2> 1333 >::type 1334 fmin(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 1335 { 1336 typedef typename std::__promote<_A1, _A2>::type __result_type; 1337 static_assert((!(std::_IsSame<_A1, __result_type>::value && 1338 std::_IsSame<_A2, __result_type>::value)), ""); 1339 return ::fmin((__result_type)__lcpp_x, (__result_type)__lcpp_y); 1340 } 1341 1342 // hypot 1343 1344 inline _LIBCPP_INLINE_VISIBILITY float hypot(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::hypotf(__lcpp_x, __lcpp_y);} 1345 inline _LIBCPP_INLINE_VISIBILITY long double hypot(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::hypotl(__lcpp_x, __lcpp_y);} 1346 1347 template <class _A1, class _A2> 1348 inline _LIBCPP_INLINE_VISIBILITY 1349 typename std::__enable_if_t 1350 < 1351 std::is_arithmetic<_A1>::value && 1352 std::is_arithmetic<_A2>::value, 1353 std::__promote<_A1, _A2> 1354 >::type 1355 hypot(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 1356 { 1357 typedef typename std::__promote<_A1, _A2>::type __result_type; 1358 static_assert((!(std::_IsSame<_A1, __result_type>::value && 1359 std::_IsSame<_A2, __result_type>::value)), ""); 1360 return ::hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y); 1361 } 1362 1363 // ilogb 1364 1365 inline _LIBCPP_INLINE_VISIBILITY int ilogb(float __lcpp_x) _NOEXCEPT {return ::ilogbf(__lcpp_x);} 1366 inline _LIBCPP_INLINE_VISIBILITY int ilogb(long double __lcpp_x) _NOEXCEPT {return ::ilogbl(__lcpp_x);} 1367 1368 template <class _A1> 1369 inline _LIBCPP_INLINE_VISIBILITY 1370 typename std::enable_if<std::is_integral<_A1>::value, int>::type 1371 ilogb(_A1 __lcpp_x) _NOEXCEPT {return ::ilogb((double)__lcpp_x);} 1372 1373 // lgamma 1374 1375 inline _LIBCPP_INLINE_VISIBILITY float lgamma(float __lcpp_x) _NOEXCEPT {return ::lgammaf(__lcpp_x);} 1376 inline _LIBCPP_INLINE_VISIBILITY long double lgamma(long double __lcpp_x) _NOEXCEPT {return ::lgammal(__lcpp_x);} 1377 1378 template <class _A1> 1379 inline _LIBCPP_INLINE_VISIBILITY 1380 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1381 lgamma(_A1 __lcpp_x) _NOEXCEPT {return ::lgamma((double)__lcpp_x);} 1382 1383 // llrint 1384 1385 inline _LIBCPP_INLINE_VISIBILITY long long llrint(float __lcpp_x) _NOEXCEPT 1386 { 1387 #if __has_builtin(__builtin_llrintf) 1388 return __builtin_llrintf(__lcpp_x); 1389 #else 1390 return ::llrintf(__lcpp_x); 1391 #endif 1392 } 1393 inline _LIBCPP_INLINE_VISIBILITY long long llrint(long double __lcpp_x) _NOEXCEPT 1394 { 1395 #if __has_builtin(__builtin_llrintl) 1396 return __builtin_llrintl(__lcpp_x); 1397 #else 1398 return ::llrintl(__lcpp_x); 1399 #endif 1400 } 1401 1402 template <class _A1> 1403 inline _LIBCPP_INLINE_VISIBILITY 1404 typename std::enable_if<std::is_integral<_A1>::value, long long>::type 1405 llrint(_A1 __lcpp_x) _NOEXCEPT 1406 { 1407 #if __has_builtin(__builtin_llrint) 1408 return __builtin_llrint((double)__lcpp_x); 1409 #else 1410 return ::llrint((double)__lcpp_x); 1411 #endif 1412 } 1413 1414 // llround 1415 1416 inline _LIBCPP_INLINE_VISIBILITY long long llround(float __lcpp_x) _NOEXCEPT 1417 { 1418 #if __has_builtin(__builtin_llroundf) 1419 return __builtin_llroundf(__lcpp_x); 1420 #else 1421 return ::llroundf(__lcpp_x); 1422 #endif 1423 } 1424 inline _LIBCPP_INLINE_VISIBILITY long long llround(long double __lcpp_x) _NOEXCEPT 1425 { 1426 #if __has_builtin(__builtin_llroundl) 1427 return __builtin_llroundl(__lcpp_x); 1428 #else 1429 return ::llroundl(__lcpp_x); 1430 #endif 1431 } 1432 1433 template <class _A1> 1434 inline _LIBCPP_INLINE_VISIBILITY 1435 typename std::enable_if<std::is_integral<_A1>::value, long long>::type 1436 llround(_A1 __lcpp_x) _NOEXCEPT 1437 { 1438 #if __has_builtin(__builtin_llround) 1439 return __builtin_llround((double)__lcpp_x); 1440 #else 1441 return ::llround((double)__lcpp_x); 1442 #endif 1443 } 1444 1445 // log1p 1446 1447 inline _LIBCPP_INLINE_VISIBILITY float log1p(float __lcpp_x) _NOEXCEPT {return ::log1pf(__lcpp_x);} 1448 inline _LIBCPP_INLINE_VISIBILITY long double log1p(long double __lcpp_x) _NOEXCEPT {return ::log1pl(__lcpp_x);} 1449 1450 template <class _A1> 1451 inline _LIBCPP_INLINE_VISIBILITY 1452 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1453 log1p(_A1 __lcpp_x) _NOEXCEPT {return ::log1p((double)__lcpp_x);} 1454 1455 // log2 1456 1457 inline _LIBCPP_INLINE_VISIBILITY float log2(float __lcpp_x) _NOEXCEPT {return ::log2f(__lcpp_x);} 1458 inline _LIBCPP_INLINE_VISIBILITY long double log2(long double __lcpp_x) _NOEXCEPT {return ::log2l(__lcpp_x);} 1459 1460 template <class _A1> 1461 inline _LIBCPP_INLINE_VISIBILITY 1462 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1463 log2(_A1 __lcpp_x) _NOEXCEPT {return ::log2((double)__lcpp_x);} 1464 1465 // logb 1466 1467 inline _LIBCPP_INLINE_VISIBILITY float logb(float __lcpp_x) _NOEXCEPT {return ::logbf(__lcpp_x);} 1468 inline _LIBCPP_INLINE_VISIBILITY long double logb(long double __lcpp_x) _NOEXCEPT {return ::logbl(__lcpp_x);} 1469 1470 template <class _A1> 1471 inline _LIBCPP_INLINE_VISIBILITY 1472 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1473 logb(_A1 __lcpp_x) _NOEXCEPT {return ::logb((double)__lcpp_x);} 1474 1475 // lrint 1476 1477 inline _LIBCPP_INLINE_VISIBILITY long lrint(float __lcpp_x) _NOEXCEPT 1478 { 1479 #if __has_builtin(__builtin_lrintf) 1480 return __builtin_lrintf(__lcpp_x); 1481 #else 1482 return ::lrintf(__lcpp_x); 1483 #endif 1484 } 1485 inline _LIBCPP_INLINE_VISIBILITY long lrint(long double __lcpp_x) _NOEXCEPT 1486 { 1487 #if __has_builtin(__builtin_lrintl) 1488 return __builtin_lrintl(__lcpp_x); 1489 #else 1490 return ::lrintl(__lcpp_x); 1491 #endif 1492 } 1493 1494 template <class _A1> 1495 inline _LIBCPP_INLINE_VISIBILITY 1496 typename std::enable_if<std::is_integral<_A1>::value, long>::type 1497 lrint(_A1 __lcpp_x) _NOEXCEPT 1498 { 1499 #if __has_builtin(__builtin_lrint) 1500 return __builtin_lrint((double)__lcpp_x); 1501 #else 1502 return ::lrint((double)__lcpp_x); 1503 #endif 1504 } 1505 1506 // lround 1507 1508 inline _LIBCPP_INLINE_VISIBILITY long lround(float __lcpp_x) _NOEXCEPT 1509 { 1510 #if __has_builtin(__builtin_lroundf) 1511 return __builtin_lroundf(__lcpp_x); 1512 #else 1513 return ::lroundf(__lcpp_x); 1514 #endif 1515 } 1516 inline _LIBCPP_INLINE_VISIBILITY long lround(long double __lcpp_x) _NOEXCEPT 1517 { 1518 #if __has_builtin(__builtin_lroundl) 1519 return __builtin_lroundl(__lcpp_x); 1520 #else 1521 return ::lroundl(__lcpp_x); 1522 #endif 1523 } 1524 1525 template <class _A1> 1526 inline _LIBCPP_INLINE_VISIBILITY 1527 typename std::enable_if<std::is_integral<_A1>::value, long>::type 1528 lround(_A1 __lcpp_x) _NOEXCEPT 1529 { 1530 #if __has_builtin(__builtin_lround) 1531 return __builtin_lround((double)__lcpp_x); 1532 #else 1533 return ::lround((double)__lcpp_x); 1534 #endif 1535 } 1536 1537 // nan 1538 1539 // nearbyint 1540 1541 inline _LIBCPP_INLINE_VISIBILITY float nearbyint(float __lcpp_x) _NOEXCEPT {return ::nearbyintf(__lcpp_x);} 1542 inline _LIBCPP_INLINE_VISIBILITY long double nearbyint(long double __lcpp_x) _NOEXCEPT {return ::nearbyintl(__lcpp_x);} 1543 1544 template <class _A1> 1545 inline _LIBCPP_INLINE_VISIBILITY 1546 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1547 nearbyint(_A1 __lcpp_x) _NOEXCEPT {return ::nearbyint((double)__lcpp_x);} 1548 1549 // nextafter 1550 1551 inline _LIBCPP_INLINE_VISIBILITY float nextafter(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::nextafterf(__lcpp_x, __lcpp_y);} 1552 inline _LIBCPP_INLINE_VISIBILITY long double nextafter(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nextafterl(__lcpp_x, __lcpp_y);} 1553 1554 template <class _A1, class _A2> 1555 inline _LIBCPP_INLINE_VISIBILITY 1556 typename std::__enable_if_t 1557 < 1558 std::is_arithmetic<_A1>::value && 1559 std::is_arithmetic<_A2>::value, 1560 std::__promote<_A1, _A2> 1561 >::type 1562 nextafter(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 1563 { 1564 typedef typename std::__promote<_A1, _A2>::type __result_type; 1565 static_assert((!(std::_IsSame<_A1, __result_type>::value && 1566 std::_IsSame<_A2, __result_type>::value)), ""); 1567 return ::nextafter((__result_type)__lcpp_x, (__result_type)__lcpp_y); 1568 } 1569 1570 // nexttoward 1571 1572 inline _LIBCPP_INLINE_VISIBILITY float nexttoward(float __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttowardf(__lcpp_x, __lcpp_y);} 1573 inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttowardl(__lcpp_x, __lcpp_y);} 1574 1575 template <class _A1> 1576 inline _LIBCPP_INLINE_VISIBILITY 1577 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1578 nexttoward(_A1 __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttoward((double)__lcpp_x, __lcpp_y);} 1579 1580 // remainder 1581 1582 inline _LIBCPP_INLINE_VISIBILITY float remainder(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::remainderf(__lcpp_x, __lcpp_y);} 1583 inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::remainderl(__lcpp_x, __lcpp_y);} 1584 1585 template <class _A1, class _A2> 1586 inline _LIBCPP_INLINE_VISIBILITY 1587 typename std::__enable_if_t 1588 < 1589 std::is_arithmetic<_A1>::value && 1590 std::is_arithmetic<_A2>::value, 1591 std::__promote<_A1, _A2> 1592 >::type 1593 remainder(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT 1594 { 1595 typedef typename std::__promote<_A1, _A2>::type __result_type; 1596 static_assert((!(std::_IsSame<_A1, __result_type>::value && 1597 std::_IsSame<_A2, __result_type>::value)), ""); 1598 return ::remainder((__result_type)__lcpp_x, (__result_type)__lcpp_y); 1599 } 1600 1601 // remquo 1602 1603 inline _LIBCPP_INLINE_VISIBILITY float remquo(float __lcpp_x, float __lcpp_y, int* __lcpp_z) _NOEXCEPT {return ::remquof(__lcpp_x, __lcpp_y, __lcpp_z);} 1604 inline _LIBCPP_INLINE_VISIBILITY long double remquo(long double __lcpp_x, long double __lcpp_y, int* __lcpp_z) _NOEXCEPT {return ::remquol(__lcpp_x, __lcpp_y, __lcpp_z);} 1605 1606 template <class _A1, class _A2> 1607 inline _LIBCPP_INLINE_VISIBILITY 1608 typename std::__enable_if_t 1609 < 1610 std::is_arithmetic<_A1>::value && 1611 std::is_arithmetic<_A2>::value, 1612 std::__promote<_A1, _A2> 1613 >::type 1614 remquo(_A1 __lcpp_x, _A2 __lcpp_y, int* __lcpp_z) _NOEXCEPT 1615 { 1616 typedef typename std::__promote<_A1, _A2>::type __result_type; 1617 static_assert((!(std::_IsSame<_A1, __result_type>::value && 1618 std::_IsSame<_A2, __result_type>::value)), ""); 1619 return ::remquo((__result_type)__lcpp_x, (__result_type)__lcpp_y, __lcpp_z); 1620 } 1621 1622 // rint 1623 1624 inline _LIBCPP_INLINE_VISIBILITY float rint(float __lcpp_x) _NOEXCEPT 1625 { 1626 #if __has_builtin(__builtin_rintf) 1627 return __builtin_rintf(__lcpp_x); 1628 #else 1629 return ::rintf(__lcpp_x); 1630 #endif 1631 } 1632 inline _LIBCPP_INLINE_VISIBILITY long double rint(long double __lcpp_x) _NOEXCEPT 1633 { 1634 #if __has_builtin(__builtin_rintl) 1635 return __builtin_rintl(__lcpp_x); 1636 #else 1637 return ::rintl(__lcpp_x); 1638 #endif 1639 } 1640 1641 template <class _A1> 1642 inline _LIBCPP_INLINE_VISIBILITY 1643 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1644 rint(_A1 __lcpp_x) _NOEXCEPT 1645 { 1646 #if __has_builtin(__builtin_rint) 1647 return __builtin_rint((double)__lcpp_x); 1648 #else 1649 return ::rint((double)__lcpp_x); 1650 #endif 1651 } 1652 1653 // round 1654 1655 inline _LIBCPP_INLINE_VISIBILITY float round(float __lcpp_x) _NOEXCEPT 1656 { 1657 #if __has_builtin(__builtin_round) 1658 return __builtin_round(__lcpp_x); 1659 #else 1660 return ::round(__lcpp_x); 1661 #endif 1662 } 1663 inline _LIBCPP_INLINE_VISIBILITY long double round(long double __lcpp_x) _NOEXCEPT 1664 { 1665 #if __has_builtin(__builtin_roundl) 1666 return __builtin_roundl(__lcpp_x); 1667 #else 1668 return ::roundl(__lcpp_x); 1669 #endif 1670 } 1671 1672 template <class _A1> 1673 inline _LIBCPP_INLINE_VISIBILITY 1674 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1675 round(_A1 __lcpp_x) _NOEXCEPT 1676 { 1677 #if __has_builtin(__builtin_round) 1678 return __builtin_round((double)__lcpp_x); 1679 #else 1680 return ::round((double)__lcpp_x); 1681 #endif 1682 } 1683 1684 // scalbln 1685 1686 inline _LIBCPP_INLINE_VISIBILITY float scalbln(float __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalblnf(__lcpp_x, __lcpp_y);} 1687 inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalblnl(__lcpp_x, __lcpp_y);} 1688 1689 template <class _A1> 1690 inline _LIBCPP_INLINE_VISIBILITY 1691 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1692 scalbln(_A1 __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalbln((double)__lcpp_x, __lcpp_y);} 1693 1694 // scalbn 1695 1696 inline _LIBCPP_INLINE_VISIBILITY float scalbn(float __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbnf(__lcpp_x, __lcpp_y);} 1697 inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbnl(__lcpp_x, __lcpp_y);} 1698 1699 template <class _A1> 1700 inline _LIBCPP_INLINE_VISIBILITY 1701 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1702 scalbn(_A1 __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbn((double)__lcpp_x, __lcpp_y);} 1703 1704 // tgamma 1705 1706 inline _LIBCPP_INLINE_VISIBILITY float tgamma(float __lcpp_x) _NOEXCEPT {return ::tgammaf(__lcpp_x);} 1707 inline _LIBCPP_INLINE_VISIBILITY long double tgamma(long double __lcpp_x) _NOEXCEPT {return ::tgammal(__lcpp_x);} 1708 1709 template <class _A1> 1710 inline _LIBCPP_INLINE_VISIBILITY 1711 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1712 tgamma(_A1 __lcpp_x) _NOEXCEPT {return ::tgamma((double)__lcpp_x);} 1713 1714 // trunc 1715 1716 inline _LIBCPP_INLINE_VISIBILITY float trunc(float __lcpp_x) _NOEXCEPT 1717 { 1718 #if __has_builtin(__builtin_trunc) 1719 return __builtin_trunc(__lcpp_x); 1720 #else 1721 return ::trunc(__lcpp_x); 1722 #endif 1723 } 1724 inline _LIBCPP_INLINE_VISIBILITY long double trunc(long double __lcpp_x) _NOEXCEPT 1725 { 1726 #if __has_builtin(__builtin_truncl) 1727 return __builtin_truncl(__lcpp_x); 1728 #else 1729 return ::truncl(__lcpp_x); 1730 #endif 1731 } 1732 1733 template <class _A1> 1734 inline _LIBCPP_INLINE_VISIBILITY 1735 typename std::enable_if<std::is_integral<_A1>::value, double>::type 1736 trunc(_A1 __lcpp_x) _NOEXCEPT 1737 { 1738 #if __has_builtin(__builtin_trunc) 1739 return __builtin_trunc((double)__lcpp_x); 1740 #else 1741 return ::trunc((double)__lcpp_x); 1742 #endif 1743 } 1744 1745 } // extern "C++" 1746 1747 #endif // __cplusplus 1748 1749 #else // _LIBCPP_MATH_H 1750 1751 // This include lives outside the header guard in order to support an MSVC 1752 // extension which allows users to do: 1753 // 1754 // #define _USE_MATH_DEFINES 1755 // #include <math.h> 1756 // 1757 // and receive the definitions of mathematical constants, even if <math.h> 1758 // has previously been included. 1759 #if defined(_LIBCPP_MSVCRT) && defined(_USE_MATH_DEFINES) 1760 #include_next <math.h> 1761 #endif 1762 1763 #endif // _LIBCPP_MATH_H 1764