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