contrib/libc++/include/cmath

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