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