contrib/libc++/include/math.h

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