cmath revision 232924
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(floating_point x); 141 142int fpclassify(floating_point x); 143 144bool isfinite(floating_point x); 145bool isinf(floating_point x); 146bool isnan(floating_point x); 147bool isnormal(floating_point x); 148 149bool isgreater(floating_point x, floating_point y); 150bool isgreaterequal(floating_point x, floating_point y); 151bool isless(floating_point x, floating_point y); 152bool islessequal(floating_point x, floating_point y); 153bool islessgreater(floating_point x, floating_point y); 154bool isunordered(floating_point x, floating_point 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 _MSC_VER 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 __x) 320{ 321 return signbit(__x); 322} 323 324#undef signbit 325 326template <class _A1> 327inline _LIBCPP_INLINE_VISIBILITY 328typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type 329signbit(_A1 __x) 330{ 331 return __libcpp_signbit(__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 __x) 344{ 345 return fpclassify(__x); 346} 347 348#undef fpclassify 349 350template <class _A1> 351inline _LIBCPP_INLINE_VISIBILITY 352typename std::enable_if<std::is_floating_point<_A1>::value, int>::type 353fpclassify(_A1 __x) 354{ 355 return __libcpp_fpclassify(__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 __x) 368{ 369 return isfinite(__x); 370} 371 372#undef isfinite 373 374template <class _A1> 375inline _LIBCPP_INLINE_VISIBILITY 376typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type 377isfinite(_A1 __x) 378{ 379 return __libcpp_isfinite(__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 __x) 392{ 393 return isinf(__x); 394} 395 396#undef isinf 397 398template <class _A1> 399inline _LIBCPP_INLINE_VISIBILITY 400typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type 401isinf(_A1 __x) 402{ 403 return __libcpp_isinf(__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 __x) 416{ 417 return isnan(__x); 418} 419 420#undef isnan 421 422template <class _A1> 423inline _LIBCPP_INLINE_VISIBILITY 424typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type 425isnan(_A1 __x) 426{ 427 return __libcpp_isnan(__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 __x) 440{ 441 return isnormal(__x); 442} 443 444#undef isnormal 445 446template <class _A1> 447inline _LIBCPP_INLINE_VISIBILITY 448typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type 449isnormal(_A1 __x) 450{ 451 return __libcpp_isnormal(__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 __x, _A2 __y) 464{ 465 return isgreater(__x, __y); 466} 467 468#undef isgreater 469 470template <class _A1, class _A2> 471inline _LIBCPP_INLINE_VISIBILITY 472typename std::enable_if 473< 474 std::is_floating_point<_A1>::value && 475 std::is_floating_point<_A2>::value, 476 bool 477>::type 478isgreater(_A1 __x, _A2 __y) 479{ 480 return __libcpp_isgreater(__x, __y); 481} 482 483#endif // isgreater 484 485// isgreaterequal 486 487#ifdef isgreaterequal 488 489template <class _A1, class _A2> 490_LIBCPP_ALWAYS_INLINE 491bool 492__libcpp_isgreaterequal(_A1 __x, _A2 __y) 493{ 494 return isgreaterequal(__x, __y); 495} 496 497#undef isgreaterequal 498 499template <class _A1, class _A2> 500inline _LIBCPP_INLINE_VISIBILITY 501typename std::enable_if 502< 503 std::is_floating_point<_A1>::value && 504 std::is_floating_point<_A2>::value, 505 bool 506>::type 507isgreaterequal(_A1 __x, _A2 __y) 508{ 509 return __libcpp_isgreaterequal(__x, __y); 510} 511 512#endif // isgreaterequal 513 514// isless 515 516#ifdef isless 517 518template <class _A1, class _A2> 519_LIBCPP_ALWAYS_INLINE 520bool 521__libcpp_isless(_A1 __x, _A2 __y) 522{ 523 return isless(__x, __y); 524} 525 526#undef isless 527 528template <class _A1, class _A2> 529inline _LIBCPP_INLINE_VISIBILITY 530typename std::enable_if 531< 532 std::is_floating_point<_A1>::value && 533 std::is_floating_point<_A2>::value, 534 bool 535>::type 536isless(_A1 __x, _A2 __y) 537{ 538 return __libcpp_isless(__x, __y); 539} 540 541#endif // isless 542 543// islessequal 544 545#ifdef islessequal 546 547template <class _A1, class _A2> 548_LIBCPP_ALWAYS_INLINE 549bool 550__libcpp_islessequal(_A1 __x, _A2 __y) 551{ 552 return islessequal(__x, __y); 553} 554 555#undef islessequal 556 557template <class _A1, class _A2> 558inline _LIBCPP_INLINE_VISIBILITY 559typename std::enable_if 560< 561 std::is_floating_point<_A1>::value && 562 std::is_floating_point<_A2>::value, 563 bool 564>::type 565islessequal(_A1 __x, _A2 __y) 566{ 567 return __libcpp_islessequal(__x, __y); 568} 569 570#endif // islessequal 571 572// islessgreater 573 574#ifdef islessgreater 575 576template <class _A1, class _A2> 577_LIBCPP_ALWAYS_INLINE 578bool 579__libcpp_islessgreater(_A1 __x, _A2 __y) 580{ 581 return islessgreater(__x, __y); 582} 583 584#undef islessgreater 585 586template <class _A1, class _A2> 587inline _LIBCPP_INLINE_VISIBILITY 588typename std::enable_if 589< 590 std::is_floating_point<_A1>::value && 591 std::is_floating_point<_A2>::value, 592 bool 593>::type 594islessgreater(_A1 __x, _A2 __y) 595{ 596 return __libcpp_islessgreater(__x, __y); 597} 598 599#endif // islessgreater 600 601// isunordered 602 603#ifdef isunordered 604 605template <class _A1, class _A2> 606_LIBCPP_ALWAYS_INLINE 607bool 608__libcpp_isunordered(_A1 __x, _A2 __y) 609{ 610 return isunordered(__x, __y); 611} 612 613#undef isunordered 614 615template <class _A1, class _A2> 616inline _LIBCPP_INLINE_VISIBILITY 617typename std::enable_if 618< 619 std::is_floating_point<_A1>::value && 620 std::is_floating_point<_A2>::value, 621 bool 622>::type 623isunordered(_A1 __x, _A2 __y) 624{ 625 return __libcpp_isunordered(__x, __y); 626} 627 628#endif // isunordered 629 630_LIBCPP_BEGIN_NAMESPACE_STD 631 632using ::signbit; 633using ::fpclassify; 634using ::isfinite; 635using ::isinf; 636using ::isnan; 637using ::isnormal; 638using ::isgreater; 639using ::isgreaterequal; 640using ::isless; 641using ::islessequal; 642using ::islessgreater; 643using ::isunordered; 644using ::isunordered; 645 646using ::float_t; 647using ::double_t; 648 649// abs 650 651template <class _A1> 652inline _LIBCPP_INLINE_VISIBILITY 653typename enable_if<is_floating_point<_A1>::value, _A1>::type 654abs(_A1 __x) {return fabs(__x);} 655 656#ifndef __sun__ 657 658// acos 659 660using ::acos; 661using ::acosf; 662 663#ifndef _MSC_VER 664inline _LIBCPP_INLINE_VISIBILITY float acos(float __x) {return acosf(__x);} 665inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __x) {return acosl(__x);} 666#endif 667 668template <class _A1> 669inline _LIBCPP_INLINE_VISIBILITY 670typename enable_if<is_integral<_A1>::value, double>::type 671acos(_A1 __x) {return acos((double)__x);} 672 673// asin 674 675using ::asin; 676using ::asinf; 677 678#ifndef _MSC_VER 679inline _LIBCPP_INLINE_VISIBILITY float asin(float __x) {return asinf(__x);} 680inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __x) {return asinl(__x);} 681#endif 682 683template <class _A1> 684inline _LIBCPP_INLINE_VISIBILITY 685typename enable_if<is_integral<_A1>::value, double>::type 686asin(_A1 __x) {return asin((double)__x);} 687 688// atan 689 690using ::atan; 691using ::atanf; 692 693#ifndef _MSC_VER 694inline _LIBCPP_INLINE_VISIBILITY float atan(float __x) {return atanf(__x);} 695inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __x) {return atanl(__x);} 696#endif 697 698template <class _A1> 699inline _LIBCPP_INLINE_VISIBILITY 700typename enable_if<is_integral<_A1>::value, double>::type 701atan(_A1 __x) {return atan((double)__x);} 702 703// atan2 704 705using ::atan2; 706using ::atan2f; 707 708#ifndef _MSC_VER 709inline _LIBCPP_INLINE_VISIBILITY float atan2(float __y, float __x) {return atan2f(__y, __x);} 710inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __y, long double __x) {return atan2l(__y, __x);} 711#endif 712 713template <class _A1, class _A2> 714inline _LIBCPP_INLINE_VISIBILITY 715typename enable_if 716< 717 is_arithmetic<_A1>::value && 718 is_arithmetic<_A2>::value, 719 typename __promote<_A1, _A2>::type 720>::type 721atan2(_A1 __y, _A2 __x) 722{ 723 typedef typename __promote<_A1, _A2>::type __result_type; 724 static_assert((!(is_same<_A1, __result_type>::value && 725 is_same<_A2, __result_type>::value)), ""); 726 return atan2((__result_type)__y, (__result_type)__x); 727} 728 729// ceil 730 731using ::ceil; 732using ::ceilf; 733 734#ifndef _MSC_VER 735inline _LIBCPP_INLINE_VISIBILITY float ceil(float __x) {return ceilf(__x);} 736inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __x) {return ceill(__x);} 737#endif 738 739template <class _A1> 740inline _LIBCPP_INLINE_VISIBILITY 741typename enable_if<is_integral<_A1>::value, double>::type 742ceil(_A1 __x) {return ceil((double)__x);} 743 744// cos 745 746using ::cos; 747using ::cosf; 748 749#ifndef _MSC_VER 750inline _LIBCPP_INLINE_VISIBILITY float cos(float __x) {return cosf(__x);} 751inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __x) {return cosl(__x);} 752#endif 753 754template <class _A1> 755inline _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY 756typename enable_if<is_integral<_A1>::value, double>::type 757cos(_A1 __x) {return cos((double)__x);} 758 759// cosh 760 761using ::cosh; 762using ::coshf; 763 764#ifndef _MSC_VER 765inline _LIBCPP_INLINE_VISIBILITY float cosh(float __x) {return coshf(__x);} 766inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __x) {return coshl(__x);} 767#endif 768 769template <class _A1> 770inline _LIBCPP_INLINE_VISIBILITY 771typename enable_if<is_integral<_A1>::value, double>::type 772cosh(_A1 __x) {return cosh((double)__x);} 773 774#endif // __sun__ 775// exp 776 777using ::exp; 778using ::expf; 779 780#ifndef __sun__ 781 782#ifndef _MSC_VER 783inline _LIBCPP_INLINE_VISIBILITY float exp(float __x) {return expf(__x);} 784inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __x) {return expl(__x);} 785#endif 786 787 788template <class _A1> 789inline _LIBCPP_INLINE_VISIBILITY 790typename enable_if<is_integral<_A1>::value, double>::type 791exp(_A1 __x) {return exp((double)__x);} 792 793// fabs 794 795using ::fabs; 796using ::fabsf; 797 798#ifndef _MSC_VER 799inline _LIBCPP_INLINE_VISIBILITY float fabs(float __x) {return fabsf(__x);} 800inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __x) {return fabsl(__x);} 801#endif 802 803template <class _A1> 804inline _LIBCPP_INLINE_VISIBILITY 805typename enable_if<is_integral<_A1>::value, double>::type 806fabs(_A1 __x) {return fabs((double)__x);} 807 808// floor 809 810using ::floor; 811using ::floorf; 812 813#ifndef _MSC_VER 814inline _LIBCPP_INLINE_VISIBILITY float floor(float __x) {return floorf(__x);} 815inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __x) {return floorl(__x);} 816#endif 817 818template <class _A1> 819inline _LIBCPP_INLINE_VISIBILITY 820typename enable_if<is_integral<_A1>::value, double>::type 821floor(_A1 __x) {return floor((double)__x);} 822 823// fmod 824 825#endif //__sun__ 826using ::fmod; 827using ::fmodf; 828#ifndef __sun__ 829 830#ifndef _MSC_VER 831inline _LIBCPP_INLINE_VISIBILITY float fmod(float __x, float __y) {return fmodf(__x, __y);} 832inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __x, long double __y) {return fmodl(__x, __y);} 833#endif 834 835template <class _A1, class _A2> 836inline _LIBCPP_INLINE_VISIBILITY 837typename enable_if 838< 839 is_arithmetic<_A1>::value && 840 is_arithmetic<_A2>::value, 841 typename __promote<_A1, _A2>::type 842>::type 843fmod(_A1 __x, _A2 __y) 844{ 845 typedef typename __promote<_A1, _A2>::type __result_type; 846 static_assert((!(is_same<_A1, __result_type>::value && 847 is_same<_A2, __result_type>::value)), ""); 848 return fmod((__result_type)__x, (__result_type)__y); 849} 850 851 852// frexp 853 854using ::frexp; 855using ::frexpf; 856 857#ifndef _MSC_VER 858inline _LIBCPP_INLINE_VISIBILITY float frexp(float __x, int* __e) {return frexpf(__x, __e);} 859inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __x, int* __e) {return frexpl(__x, __e);} 860#endif 861 862template <class _A1> 863inline _LIBCPP_INLINE_VISIBILITY 864typename enable_if<is_integral<_A1>::value, double>::type 865frexp(_A1 __x, int* __e) {return frexp((double)__x, __e);} 866 867// ldexp 868 869using ::ldexp; 870using ::ldexpf; 871 872#ifndef _MSC_VER 873inline _LIBCPP_INLINE_VISIBILITY float ldexp(float __x, int __e) {return ldexpf(__x, __e);} 874inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __x, int __e) {return ldexpl(__x, __e);} 875#endif 876 877template <class _A1> 878inline _LIBCPP_INLINE_VISIBILITY 879typename enable_if<is_integral<_A1>::value, double>::type 880ldexp(_A1 __x, int __e) {return ldexp((double)__x, __e);} 881 882// log 883 884#endif // __sun__ 885using ::log; 886using ::logf; 887#ifndef __sun__ 888 889#ifndef _MSC_VER 890inline _LIBCPP_INLINE_VISIBILITY float log(float __x) {return logf(__x);} 891inline _LIBCPP_INLINE_VISIBILITY long double log(long double __x) {return logl(__x);} 892#endif 893 894template <class _A1> 895inline _LIBCPP_INLINE_VISIBILITY 896typename enable_if<is_integral<_A1>::value, double>::type 897log(_A1 __x) {return log((double)__x);} 898 899 900// log10 901 902using ::log10; 903using ::log10f; 904 905#ifndef _MSC_VER 906inline _LIBCPP_INLINE_VISIBILITY float log10(float __x) {return log10f(__x);} 907inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __x) {return log10l(__x);} 908#endif 909 910template <class _A1> 911inline _LIBCPP_INLINE_VISIBILITY 912typename enable_if<is_integral<_A1>::value, double>::type 913log10(_A1 __x) {return log10((double)__x);} 914 915// modf 916 917using ::modf; 918using ::modff; 919 920#ifndef _MSC_VER 921inline _LIBCPP_INLINE_VISIBILITY float modf(float __x, float* __y) {return modff(__x, __y);} 922inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __x, long double* __y) {return modfl(__x, __y);} 923#endif 924 925// pow 926 927#endif // __sun__ 928using ::pow; 929using ::powf; 930 931#ifndef __sun__ 932 933#ifndef _MSC_VER 934inline _LIBCPP_INLINE_VISIBILITY float pow(float __x, float __y) {return powf(__x, __y);} 935inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __x, long double __y) {return powl(__x, __y);} 936#endif 937 938template <class _A1, class _A2> 939inline _LIBCPP_INLINE_VISIBILITY 940typename enable_if 941< 942 is_arithmetic<_A1>::value && 943 is_arithmetic<_A2>::value, 944 typename __promote<_A1, _A2>::type 945>::type 946pow(_A1 __x, _A2 __y) 947{ 948 typedef typename __promote<_A1, _A2>::type __result_type; 949 static_assert((!(is_same<_A1, __result_type>::value && 950 is_same<_A2, __result_type>::value)), ""); 951 return pow((__result_type)__x, (__result_type)__y); 952} 953 954 955// sin 956 957using ::sin; 958using ::sinf; 959 960#ifndef _MSC_VER 961inline _LIBCPP_INLINE_VISIBILITY float sin(float __x) {return sinf(__x);} 962inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __x) {return sinl(__x);} 963#endif 964 965template <class _A1> 966inline _LIBCPP_INLINE_VISIBILITY 967typename enable_if<is_integral<_A1>::value, double>::type 968sin(_A1 __x) {return sin((double)__x);} 969 970// sinh 971 972using ::sinh; 973using ::sinhf; 974 975#ifndef _MSC_VER 976inline _LIBCPP_INLINE_VISIBILITY float sinh(float __x) {return sinhf(__x);} 977inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __x) {return sinhl(__x);} 978#endif 979 980template <class _A1> 981inline _LIBCPP_INLINE_VISIBILITY 982typename enable_if<is_integral<_A1>::value, double>::type 983sinh(_A1 __x) {return sinh((double)__x);} 984 985// sqrt 986 987#endif // __sun__ 988using ::sqrt; 989using ::sqrtf; 990 991 992#if !(defined(_MSC_VER) || defined(__sun__)) 993inline _LIBCPP_INLINE_VISIBILITY float sqrt(float __x) {return sqrtf(__x);} 994inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __x) {return sqrtl(__x);} 995#endif 996 997template <class _A1> 998inline _LIBCPP_INLINE_VISIBILITY 999typename enable_if<is_integral<_A1>::value, double>::type 1000sqrt(_A1 __x) {return sqrt((double)__x);} 1001 1002// tan 1003 1004using ::tan; 1005using ::tanf; 1006#ifndef __sun__ 1007 1008#ifndef _MSC_VER 1009inline _LIBCPP_INLINE_VISIBILITY float tan(float __x) {return tanf(__x);} 1010inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __x) {return tanl(__x);} 1011#endif 1012 1013template <class _A1> 1014inline _LIBCPP_INLINE_VISIBILITY 1015typename enable_if<is_integral<_A1>::value, double>::type 1016tan(_A1 __x) {return tan((double)__x);} 1017 1018// tanh 1019 1020using ::tanh; 1021using ::tanhf; 1022 1023#ifndef _MSC_VER 1024inline _LIBCPP_INLINE_VISIBILITY float tanh(float __x) {return tanhf(__x);} 1025inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __x) {return tanhl(__x);} 1026#endif 1027 1028template <class _A1> 1029inline _LIBCPP_INLINE_VISIBILITY 1030typename enable_if<is_integral<_A1>::value, double>::type 1031tanh(_A1 __x) {return tanh((double)__x);} 1032 1033// acosh 1034 1035#ifndef _MSC_VER 1036using ::acosh; 1037using ::acoshf; 1038 1039inline _LIBCPP_INLINE_VISIBILITY float acosh(float __x) {return acoshf(__x);} 1040inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __x) {return acoshl(__x);} 1041 1042template <class _A1> 1043inline _LIBCPP_INLINE_VISIBILITY 1044typename enable_if<is_integral<_A1>::value, double>::type 1045acosh(_A1 __x) {return acosh((double)__x);} 1046#endif 1047 1048// asinh 1049 1050#ifndef _MSC_VER 1051using ::asinh; 1052using ::asinhf; 1053 1054inline _LIBCPP_INLINE_VISIBILITY float asinh(float __x) {return asinhf(__x);} 1055inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __x) {return asinhl(__x);} 1056 1057template <class _A1> 1058inline _LIBCPP_INLINE_VISIBILITY 1059typename enable_if<is_integral<_A1>::value, double>::type 1060asinh(_A1 __x) {return asinh((double)__x);} 1061#endif 1062 1063// atanh 1064 1065#ifndef _MSC_VER 1066using ::atanh; 1067using ::atanhf; 1068 1069inline _LIBCPP_INLINE_VISIBILITY float atanh(float __x) {return atanhf(__x);} 1070inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __x) {return atanhl(__x);} 1071 1072template <class _A1> 1073inline _LIBCPP_INLINE_VISIBILITY 1074typename enable_if<is_integral<_A1>::value, double>::type 1075atanh(_A1 __x) {return atanh((double)__x);} 1076#endif 1077 1078// cbrt 1079 1080#ifndef _MSC_VER 1081using ::cbrt; 1082using ::cbrtf; 1083 1084inline _LIBCPP_INLINE_VISIBILITY float cbrt(float __x) {return cbrtf(__x);} 1085inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __x) {return cbrtl(__x);} 1086 1087template <class _A1> 1088inline _LIBCPP_INLINE_VISIBILITY 1089typename enable_if<is_integral<_A1>::value, double>::type 1090cbrt(_A1 __x) {return cbrt((double)__x);} 1091#endif 1092 1093// copysign 1094 1095using ::copysign; 1096using ::copysignf; 1097 1098inline _LIBCPP_INLINE_VISIBILITY float copysign(float __x, float __y) {return copysignf(__x, __y);} 1099inline _LIBCPP_INLINE_VISIBILITY long double copysign(long double __x, long double __y) {return copysignl(__x, __y);} 1100 1101template <class _A1, class _A2> 1102inline _LIBCPP_INLINE_VISIBILITY 1103typename enable_if 1104< 1105 is_arithmetic<_A1>::value && 1106 is_arithmetic<_A2>::value, 1107 typename __promote<_A1, _A2>::type 1108>::type 1109copysign(_A1 __x, _A2 __y) 1110{ 1111 typedef typename __promote<_A1, _A2>::type __result_type; 1112 static_assert((!(is_same<_A1, __result_type>::value && 1113 is_same<_A2, __result_type>::value)), ""); 1114 return copysign((__result_type)__x, (__result_type)__y); 1115} 1116 1117#ifndef _MSC_VER 1118 1119// erf 1120 1121using ::erf; 1122using ::erff; 1123 1124inline _LIBCPP_INLINE_VISIBILITY float erf(float __x) {return erff(__x);} 1125inline _LIBCPP_INLINE_VISIBILITY long double erf(long double __x) {return erfl(__x);} 1126 1127template <class _A1> 1128inline _LIBCPP_INLINE_VISIBILITY 1129typename enable_if<is_integral<_A1>::value, double>::type 1130erf(_A1 __x) {return erf((double)__x);} 1131 1132// erfc 1133 1134using ::erfc; 1135using ::erfcf; 1136 1137inline _LIBCPP_INLINE_VISIBILITY float erfc(float __x) {return erfcf(__x);} 1138inline _LIBCPP_INLINE_VISIBILITY long double erfc(long double __x) {return erfcl(__x);} 1139 1140template <class _A1> 1141inline _LIBCPP_INLINE_VISIBILITY 1142typename enable_if<is_integral<_A1>::value, double>::type 1143erfc(_A1 __x) {return erfc((double)__x);} 1144 1145// exp2 1146 1147using ::exp2; 1148using ::exp2f; 1149 1150inline _LIBCPP_INLINE_VISIBILITY float exp2(float __x) {return exp2f(__x);} 1151inline _LIBCPP_INLINE_VISIBILITY long double exp2(long double __x) {return exp2l(__x);} 1152 1153template <class _A1> 1154inline _LIBCPP_INLINE_VISIBILITY 1155typename enable_if<is_integral<_A1>::value, double>::type 1156exp2(_A1 __x) {return exp2((double)__x);} 1157 1158// expm1 1159 1160using ::expm1; 1161using ::expm1f; 1162 1163inline _LIBCPP_INLINE_VISIBILITY float expm1(float __x) {return expm1f(__x);} 1164inline _LIBCPP_INLINE_VISIBILITY long double expm1(long double __x) {return expm1l(__x);} 1165 1166template <class _A1> 1167inline _LIBCPP_INLINE_VISIBILITY 1168typename enable_if<is_integral<_A1>::value, double>::type 1169expm1(_A1 __x) {return expm1((double)__x);} 1170 1171// fdim 1172 1173using ::fdim; 1174using ::fdimf; 1175 1176inline _LIBCPP_INLINE_VISIBILITY float fdim(float __x, float __y) {return fdimf(__x, __y);} 1177inline _LIBCPP_INLINE_VISIBILITY long double fdim(long double __x, long double __y) {return fdiml(__x, __y);} 1178 1179template <class _A1, class _A2> 1180inline _LIBCPP_INLINE_VISIBILITY 1181typename enable_if 1182< 1183 is_arithmetic<_A1>::value && 1184 is_arithmetic<_A2>::value, 1185 typename __promote<_A1, _A2>::type 1186>::type 1187fdim(_A1 __x, _A2 __y) 1188{ 1189 typedef typename __promote<_A1, _A2>::type __result_type; 1190 static_assert((!(is_same<_A1, __result_type>::value && 1191 is_same<_A2, __result_type>::value)), ""); 1192 return fdim((__result_type)__x, (__result_type)__y); 1193} 1194 1195// fma 1196 1197inline _LIBCPP_INLINE_VISIBILITY float fmaf(float __x, float __y, float __z) {return (float)((double)__x*__y + __z);} 1198#define FP_FAST_FMAF 1199 1200using ::fma; 1201 1202inline _LIBCPP_INLINE_VISIBILITY float fma(float __x, float __y, float __z) {return fmaf(__x, __y, __z);} 1203inline _LIBCPP_INLINE_VISIBILITY long double fma(long double __x, long double __y, long double __z) {return fmal(__x, __y, __z);} 1204 1205template <class _A1, class _A2, class _A3> 1206inline _LIBCPP_INLINE_VISIBILITY 1207typename enable_if 1208< 1209 is_arithmetic<_A1>::value && 1210 is_arithmetic<_A2>::value && 1211 is_arithmetic<_A3>::value, 1212 typename __promote<_A1, _A2, _A3>::type 1213>::type 1214fma(_A1 __x, _A2 __y, _A3 __z) 1215{ 1216 typedef typename __promote<_A1, _A2, _A3>::type __result_type; 1217 static_assert((!(is_same<_A1, __result_type>::value && 1218 is_same<_A2, __result_type>::value && 1219 is_same<_A3, __result_type>::value)), ""); 1220 return fma((__result_type)__x, (__result_type)__y, (__result_type)__z); 1221} 1222 1223// fmax 1224 1225using ::fmax; 1226using ::fmaxf; 1227 1228inline _LIBCPP_INLINE_VISIBILITY float fmax(float __x, float __y) {return fmaxf(__x, __y);} 1229inline _LIBCPP_INLINE_VISIBILITY long double fmax(long double __x, long double __y) {return fmaxl(__x, __y);} 1230 1231template <class _A1, class _A2> 1232inline _LIBCPP_INLINE_VISIBILITY 1233typename enable_if 1234< 1235 is_arithmetic<_A1>::value && 1236 is_arithmetic<_A2>::value, 1237 typename __promote<_A1, _A2>::type 1238>::type 1239fmax(_A1 __x, _A2 __y) 1240{ 1241 typedef typename __promote<_A1, _A2>::type __result_type; 1242 static_assert((!(is_same<_A1, __result_type>::value && 1243 is_same<_A2, __result_type>::value)), ""); 1244 return fmax((__result_type)__x, (__result_type)__y); 1245} 1246 1247// fmin 1248 1249using ::fmin; 1250using ::fminf; 1251 1252inline _LIBCPP_INLINE_VISIBILITY float fmin(float __x, float __y) {return fminf(__x, __y);} 1253inline _LIBCPP_INLINE_VISIBILITY long double fmin(long double __x, long double __y) {return fminl(__x, __y);} 1254 1255template <class _A1, class _A2> 1256inline _LIBCPP_INLINE_VISIBILITY 1257typename enable_if 1258< 1259 is_arithmetic<_A1>::value && 1260 is_arithmetic<_A2>::value, 1261 typename __promote<_A1, _A2>::type 1262>::type 1263fmin(_A1 __x, _A2 __y) 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 fmin((__result_type)__x, (__result_type)__y); 1269} 1270 1271// hypot 1272 1273using ::hypot; 1274using ::hypotf; 1275 1276inline _LIBCPP_INLINE_VISIBILITY float hypot(float __x, float __y) {return hypotf(__x, __y);} 1277inline _LIBCPP_INLINE_VISIBILITY long double hypot(long double __x, long double __y) {return hypotl(__x, __y);} 1278 1279template <class _A1, class _A2> 1280inline _LIBCPP_INLINE_VISIBILITY 1281typename enable_if 1282< 1283 is_arithmetic<_A1>::value && 1284 is_arithmetic<_A2>::value, 1285 typename __promote<_A1, _A2>::type 1286>::type 1287hypot(_A1 __x, _A2 __y) 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 hypot((__result_type)__x, (__result_type)__y); 1293} 1294 1295// ilogb 1296 1297using ::ilogb; 1298using ::ilogbf; 1299 1300inline _LIBCPP_INLINE_VISIBILITY int ilogb(float __x) {return ilogbf(__x);} 1301inline _LIBCPP_INLINE_VISIBILITY int ilogb(long double __x) {return ilogbl(__x);} 1302 1303template <class _A1> 1304inline _LIBCPP_INLINE_VISIBILITY 1305typename enable_if<is_integral<_A1>::value, int>::type 1306ilogb(_A1 __x) {return ilogb((double)__x);} 1307 1308// lgamma 1309 1310using ::lgamma; 1311using ::lgammaf; 1312 1313inline _LIBCPP_INLINE_VISIBILITY float lgamma(float __x) {return lgammaf(__x);} 1314inline _LIBCPP_INLINE_VISIBILITY long double lgamma(long double __x) {return lgammal(__x);} 1315 1316 1317template <class _A1> 1318inline _LIBCPP_INLINE_VISIBILITY 1319typename enable_if<is_integral<_A1>::value, double>::type 1320lgamma(_A1 __x) {return lgamma((double)__x);} 1321 1322 1323// llrint 1324 1325using ::llrint; 1326using ::llrintf; 1327 1328inline _LIBCPP_INLINE_VISIBILITY long long llrint(float __x) {return llrintf(__x);} 1329inline _LIBCPP_INLINE_VISIBILITY long long llrint(long double __x) {return llrintl(__x);} 1330 1331template <class _A1> 1332inline _LIBCPP_INLINE_VISIBILITY 1333typename enable_if<is_integral<_A1>::value, long long>::type 1334llrint(_A1 __x) {return llrint((double)__x);} 1335 1336// llround 1337 1338using ::llround; 1339using ::llroundf; 1340 1341inline _LIBCPP_INLINE_VISIBILITY long long llround(float __x) {return llroundf(__x);} 1342inline _LIBCPP_INLINE_VISIBILITY long long llround(long double __x) {return llroundl(__x);} 1343 1344template <class _A1> 1345inline _LIBCPP_INLINE_VISIBILITY 1346typename enable_if<is_integral<_A1>::value, long long>::type 1347llround(_A1 __x) {return llround((double)__x);} 1348 1349// log1p 1350 1351using ::log1p; 1352using ::log1pf; 1353 1354inline _LIBCPP_INLINE_VISIBILITY float log1p(float __x) {return log1pf(__x);} 1355inline _LIBCPP_INLINE_VISIBILITY long double log1p(long double __x) {return log1pl(__x);} 1356 1357template <class _A1> 1358inline _LIBCPP_INLINE_VISIBILITY 1359typename enable_if<is_integral<_A1>::value, double>::type 1360log1p(_A1 __x) {return log1p((double)__x);} 1361 1362// log2 1363 1364using ::log2; 1365using ::log2f; 1366 1367inline _LIBCPP_INLINE_VISIBILITY float log2(float __x) {return log2f(__x);} 1368inline _LIBCPP_INLINE_VISIBILITY long double log2(long double __x) {return log2l(__x);} 1369 1370template <class _A1> 1371inline _LIBCPP_INLINE_VISIBILITY 1372typename enable_if<is_integral<_A1>::value, double>::type 1373log2(_A1 __x) {return log2((double)__x);} 1374 1375// logb 1376 1377using ::logb; 1378using ::logbf; 1379 1380inline _LIBCPP_INLINE_VISIBILITY float logb(float __x) {return logbf(__x);} 1381inline _LIBCPP_INLINE_VISIBILITY long double logb(long double __x) {return logbl(__x);} 1382 1383template <class _A1> 1384inline _LIBCPP_INLINE_VISIBILITY 1385typename enable_if<is_integral<_A1>::value, double>::type 1386logb(_A1 __x) {return logb((double)__x);} 1387 1388// lrint 1389 1390using ::lrint; 1391using ::lrintf; 1392 1393inline _LIBCPP_INLINE_VISIBILITY long lrint(float __x) {return lrintf(__x);} 1394inline _LIBCPP_INLINE_VISIBILITY long lrint(long double __x) {return lrintl(__x);} 1395 1396template <class _A1> 1397inline _LIBCPP_INLINE_VISIBILITY 1398typename enable_if<is_integral<_A1>::value, long>::type 1399lrint(_A1 __x) {return lrint((double)__x);} 1400 1401// lround 1402 1403using ::lround; 1404using ::lroundf; 1405 1406inline _LIBCPP_INLINE_VISIBILITY long lround(float __x) {return lroundf(__x);} 1407inline _LIBCPP_INLINE_VISIBILITY long lround(long double __x) {return lroundl(__x);} 1408 1409template <class _A1> 1410inline _LIBCPP_INLINE_VISIBILITY 1411typename enable_if<is_integral<_A1>::value, long>::type 1412lround(_A1 __x) {return lround((double)__x);} 1413 1414// nan 1415#endif // _MSC_VER 1416#endif // __sun__ 1417using ::nan; 1418using ::nanf; 1419#ifndef __sun__ 1420#ifndef _MSC_VER 1421 1422// nearbyint 1423 1424using ::nearbyint; 1425using ::nearbyintf; 1426 1427inline _LIBCPP_INLINE_VISIBILITY float nearbyint(float __x) {return nearbyintf(__x);} 1428inline _LIBCPP_INLINE_VISIBILITY long double nearbyint(long double __x) {return nearbyintl(__x);} 1429 1430template <class _A1> 1431inline _LIBCPP_INLINE_VISIBILITY 1432typename enable_if<is_integral<_A1>::value, double>::type 1433nearbyint(_A1 __x) {return nearbyint((double)__x);} 1434 1435// nextafter 1436 1437using ::nextafter; 1438using ::nextafterf; 1439 1440inline _LIBCPP_INLINE_VISIBILITY float nextafter(float __x, float __y) {return nextafterf(__x, __y);} 1441inline _LIBCPP_INLINE_VISIBILITY long double nextafter(long double __x, long double __y) {return nextafterl(__x, __y);} 1442 1443template <class _A1, class _A2> 1444inline _LIBCPP_INLINE_VISIBILITY 1445typename enable_if 1446< 1447 is_arithmetic<_A1>::value && 1448 is_arithmetic<_A2>::value, 1449 typename __promote<_A1, _A2>::type 1450>::type 1451nextafter(_A1 __x, _A2 __y) 1452{ 1453 typedef typename __promote<_A1, _A2>::type __result_type; 1454 static_assert((!(is_same<_A1, __result_type>::value && 1455 is_same<_A2, __result_type>::value)), ""); 1456 return nextafter((__result_type)__x, (__result_type)__y); 1457} 1458 1459// nexttoward 1460 1461using ::nexttoward; 1462using ::nexttowardf; 1463 1464inline _LIBCPP_INLINE_VISIBILITY float nexttoward(float __x, long double __y) {return nexttowardf(__x, __y);} 1465inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __x, long double __y) {return nexttowardl(__x, __y);} 1466 1467template <class _A1> 1468inline _LIBCPP_INLINE_VISIBILITY 1469typename enable_if<is_integral<_A1>::value, double>::type 1470nexttoward(_A1 __x, long double __y) {return nexttoward((double)__x, __y);} 1471 1472// remainder 1473 1474using ::remainder; 1475using ::remainderf; 1476 1477inline _LIBCPP_INLINE_VISIBILITY float remainder(float __x, float __y) {return remainderf(__x, __y);} 1478inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __x, long double __y) {return remainderl(__x, __y);} 1479 1480template <class _A1, class _A2> 1481inline _LIBCPP_INLINE_VISIBILITY 1482typename enable_if 1483< 1484 is_arithmetic<_A1>::value && 1485 is_arithmetic<_A2>::value, 1486 typename __promote<_A1, _A2>::type 1487>::type 1488remainder(_A1 __x, _A2 __y) 1489{ 1490 typedef typename __promote<_A1, _A2>::type __result_type; 1491 static_assert((!(is_same<_A1, __result_type>::value && 1492 is_same<_A2, __result_type>::value)), ""); 1493 return remainder((__result_type)__x, (__result_type)__y); 1494} 1495 1496// remquo 1497 1498using ::remquo; 1499using ::remquof; 1500 1501inline _LIBCPP_INLINE_VISIBILITY float remquo(float __x, float __y, int* __z) {return remquof(__x, __y, __z);} 1502inline _LIBCPP_INLINE_VISIBILITY long double remquo(long double __x, long double __y, int* __z) {return remquol(__x, __y, __z);} 1503 1504template <class _A1, class _A2> 1505inline _LIBCPP_INLINE_VISIBILITY 1506typename enable_if 1507< 1508 is_arithmetic<_A1>::value && 1509 is_arithmetic<_A2>::value, 1510 typename __promote<_A1, _A2>::type 1511>::type 1512remquo(_A1 __x, _A2 __y, int* __z) 1513{ 1514 typedef typename __promote<_A1, _A2>::type __result_type; 1515 static_assert((!(is_same<_A1, __result_type>::value && 1516 is_same<_A2, __result_type>::value)), ""); 1517 return remquo((__result_type)__x, (__result_type)__y, __z); 1518} 1519 1520// rint 1521 1522using ::rint; 1523using ::rintf; 1524 1525inline _LIBCPP_INLINE_VISIBILITY float rint(float __x) {return rintf(__x);} 1526inline _LIBCPP_INLINE_VISIBILITY long double rint(long double __x) {return rintl(__x);} 1527 1528template <class _A1> 1529inline _LIBCPP_INLINE_VISIBILITY 1530typename enable_if<is_integral<_A1>::value, double>::type 1531rint(_A1 __x) {return rint((double)__x);} 1532 1533// round 1534 1535using ::round; 1536using ::roundf; 1537 1538inline _LIBCPP_INLINE_VISIBILITY float round(float __x) {return roundf(__x);} 1539inline _LIBCPP_INLINE_VISIBILITY long double round(long double __x) {return roundl(__x);} 1540 1541template <class _A1> 1542inline _LIBCPP_INLINE_VISIBILITY 1543typename enable_if<is_integral<_A1>::value, double>::type 1544round(_A1 __x) {return round((double)__x);} 1545 1546// scalbln 1547 1548using ::scalbln; 1549using ::scalblnf; 1550 1551inline _LIBCPP_INLINE_VISIBILITY float scalbln(float __x, long __y) {return scalblnf(__x, __y);} 1552inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __x, long __y) {return scalblnl(__x, __y);} 1553 1554template <class _A1> 1555inline _LIBCPP_INLINE_VISIBILITY 1556typename enable_if<is_integral<_A1>::value, double>::type 1557scalbln(_A1 __x, long __y) {return scalbln((double)__x, __y);} 1558 1559// scalbn 1560 1561using ::scalbn; 1562using ::scalbnf; 1563 1564inline _LIBCPP_INLINE_VISIBILITY float scalbn(float __x, int __y) {return scalbnf(__x, __y);} 1565inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __x, int __y) {return scalbnl(__x, __y);} 1566 1567template <class _A1> 1568inline _LIBCPP_INLINE_VISIBILITY 1569typename enable_if<is_integral<_A1>::value, double>::type 1570scalbn(_A1 __x, int __y) {return scalbn((double)__x, __y);} 1571 1572// tgamma 1573 1574using ::tgamma; 1575using ::tgammaf; 1576 1577inline _LIBCPP_INLINE_VISIBILITY float tgamma(float __x) {return tgammaf(__x);} 1578inline _LIBCPP_INLINE_VISIBILITY long double tgamma(long double __x) {return tgammal(__x);} 1579 1580template <class _A1> 1581inline _LIBCPP_INLINE_VISIBILITY 1582typename enable_if<is_integral<_A1>::value, double>::type 1583tgamma(_A1 __x) {return tgamma((double)__x);} 1584 1585// trunc 1586 1587using ::trunc; 1588using ::truncf; 1589 1590inline _LIBCPP_INLINE_VISIBILITY float trunc(float __x) {return truncf(__x);} 1591inline _LIBCPP_INLINE_VISIBILITY long double trunc(long double __x) {return truncl(__x);} 1592 1593template <class _A1> 1594inline _LIBCPP_INLINE_VISIBILITY 1595typename enable_if<is_integral<_A1>::value, double>::type 1596trunc(_A1 __x) {return trunc((double)__x);} 1597 1598#endif // !_MSC_VER 1599 1600using ::acosl; 1601using ::asinl; 1602using ::atanl; 1603using ::atan2l; 1604using ::ceill; 1605using ::cosl; 1606using ::coshl; 1607using ::expl; 1608using ::fabsl; 1609using ::floorl; 1610using ::fmodl; 1611using ::frexpl; 1612using ::ldexpl; 1613using ::logl; 1614using ::log10l; 1615using ::modfl; 1616using ::powl; 1617using ::sinl; 1618using ::sinhl; 1619using ::sqrtl; 1620using ::tanl; 1621#ifndef _MSC_VER 1622using ::tanhl; 1623using ::acoshl; 1624using ::asinhl; 1625using ::atanhl; 1626using ::cbrtl; 1627#endif // !_MSC_VER 1628using ::copysignl; 1629#ifndef _MSC_VER 1630using ::erfl; 1631using ::erfcl; 1632using ::exp2l; 1633using ::expm1l; 1634using ::fdiml; 1635using ::fmal; 1636using ::fmaxl; 1637using ::fminl; 1638using ::hypotl; 1639using ::ilogbl; 1640using ::lgammal; 1641using ::llrintl; 1642using ::llroundl; 1643using ::log1pl; 1644using ::log2l; 1645using ::logbl; 1646using ::lrintl; 1647using ::lroundl; 1648using ::nanl; 1649using ::nearbyintl; 1650using ::nextafterl; 1651using ::nexttowardl; 1652using ::remainderl; 1653using ::remquol; 1654using ::rintl; 1655using ::roundl; 1656using ::scalblnl; 1657using ::scalbnl; 1658using ::tgammal; 1659using ::truncl; 1660#endif // !_MSC_VER 1661 1662#else 1663using ::lgamma; 1664using ::lgammaf; 1665#endif // __sun__ 1666_LIBCPP_END_NAMESPACE_STD 1667 1668#endif // _LIBCPP_CMATH 1669