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