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