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