include/cmath

   1 // -*- C++ -*-
   2 //===---------------------------- cmath -----------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef _LIBCPP_CMATH
  11 #define _LIBCPP_CMATH
  12
  13 /*
  14     cmath synopsis
  15
  16 Macros:
  17
  18     HUGE_VAL
  19     HUGE_VALF               // C99
  20     HUGE_VALL               // C99
  21     INFINITY                // C99
  22     NAN                     // C99
  23     FP_INFINITE             // C99
  24     FP_NAN                  // C99
  25     FP_NORMAL               // C99
  26     FP_SUBNORMAL            // C99
  27     FP_ZERO                 // C99
  28     FP_FAST_FMA             // C99
  29     FP_FAST_FMAF            // C99
  30     FP_FAST_FMAL            // C99
  31     FP_ILOGB0               // C99
  32     FP_ILOGBNAN             // C99
  33     MATH_ERRNO              // C99
  34     MATH_ERREXCEPT          // C99
  35     math_errhandling        // C99
  36
  37 namespace std
  38 {
  39
  40 Types:
  41
  42     float_t                 // C99
  43     double_t                // C99
  44
  45 // C90
  46
  47 floating_point abs(floating_point x);
  48
  49 floating_point acos (arithmetic x);
  50 float          acosf(float x);
  51 long double    acosl(long double x);
  52
  53 floating_point asin (arithmetic x);
  54 float          asinf(float x);
  55 long double    asinl(long double x);
  56
  57 floating_point atan (arithmetic x);
  58 float          atanf(float x);
  59 long double    atanl(long double x);
  60
  61 floating_point atan2 (arithmetic y, arithmetic x);
  62 float          atan2f(float y, float x);
  63 long double    atan2l(long double y, long double x);
  64
  65 floating_point ceil (arithmetic x);
  66 float          ceilf(float x);
  67 long double    ceill(long double x);
  68
  69 floating_point cos (arithmetic x);
  70 float          cosf(float x);
  71 long double    cosl(long double x);
  72
  73 floating_point cosh (arithmetic x);
  74 float          coshf(float x);
  75 long double    coshl(long double x);
  76
  77 floating_point exp (arithmetic x);
  78 float          expf(float x);
  79 long double    expl(long double x);
  80
  81 floating_point fabs (arithmetic x);
  82 float          fabsf(float x);
  83 long double    fabsl(long double x);
  84
  85 floating_point floor (arithmetic x);
  86 float          floorf(float x);
  87 long double    floorl(long double x);
  88
  89 floating_point fmod (arithmetic x, arithmetic y);
  90 float          fmodf(float x, float y);
  91 long double    fmodl(long double x, long double y);
  92
  93 floating_point frexp (arithmetic value, int* exp);
  94 float          frexpf(float value, int* exp);
  95 long double    frexpl(long double value, int* exp);
  96
  97 floating_point ldexp (arithmetic value, int exp);
  98 float          ldexpf(float value, int exp);
  99 long double    ldexpl(long double value, int exp);
 100
 101 floating_point log (arithmetic x);
 102 float          logf(float x);
 103 long double    logl(long double x);
 104
 105 floating_point log10 (arithmetic x);
 106 float          log10f(float x);
 107 long double    log10l(long double x);
 108
 109 floating_point modf (floating_point value, floating_point* iptr);
 110 float          modff(float value, float* iptr);
 111 long double    modfl(long double value, long double* iptr);
 112
 113 floating_point pow (arithmetic x, arithmetic y);
 114 float          powf(float x, float y);
 115 long double    powl(long double x, long double y);
 116
 117 floating_point sin (arithmetic x);
 118 float          sinf(float x);
 119 long double    sinl(long double x);
 120
 121 floating_point sinh (arithmetic x);
 122 float          sinhf(float x);
 123 long double    sinhl(long double x);
 124
 125 floating_point sqrt (arithmetic x);
 126 float          sqrtf(float x);
 127 long double    sqrtl(long double x);
 128
 129 floating_point tan (arithmetic x);
 130 float          tanf(float x);
 131 long double    tanl(long double x);
 132
 133 floating_point tanh (arithmetic x);
 134 float          tanhf(float x);
 135 long double    tanhl(long double x);
 136
 137 //  C99
 138
 139 bool signbit(arithmetic x);
 140
 141 int fpclassify(arithmetic x);
 142
 143 bool isfinite(arithmetic x);
 144 bool isinf(arithmetic x);
 145 bool isnan(arithmetic x);
 146 bool isnormal(arithmetic x);
 147
 148 bool isgreater(arithmetic x, arithmetic y);
 149 bool isgreaterequal(arithmetic x, arithmetic y);
 150 bool isless(arithmetic x, arithmetic y);
 151 bool islessequal(arithmetic x, arithmetic y);
 152 bool islessgreater(arithmetic x, arithmetic y);
 153 bool isunordered(arithmetic x, arithmetic y);
 154
 155 floating_point acosh (arithmetic x);
 156 float          acoshf(float x);
 157 long double    acoshl(long double x);
 158
 159 floating_point asinh (arithmetic x);
 160 float          asinhf(float x);
 161 long double    asinhl(long double x);
 162
 163 floating_point atanh (arithmetic x);
 164 float          atanhf(float x);
 165 long double    atanhl(long double x);
 166
 167 floating_point cbrt (arithmetic x);
 168 float          cbrtf(float x);
 169 long double    cbrtl(long double x);
 170
 171 floating_point copysign (arithmetic x, arithmetic y);
 172 float          copysignf(float x, float y);
 173 long double    copysignl(long double x, long double y);
 174
 175 floating_point erf (arithmetic x);
 176 float          erff(float x);
 177 long double    erfl(long double x);
 178
 179 floating_point erfc (arithmetic x);
 180 float          erfcf(float x);
 181 long double    erfcl(long double x);
 182
 183 floating_point exp2 (arithmetic x);
 184 float          exp2f(float x);
 185 long double    exp2l(long double x);
 186
 187 floating_point expm1 (arithmetic x);
 188 float          expm1f(float x);
 189 long double    expm1l(long double x);
 190
 191 floating_point fdim (arithmetic x, arithmetic y);
 192 float          fdimf(float x, float y);
 193 long double    fdiml(long double x, long double y);
 194
 195 floating_point fma (arithmetic x, arithmetic y, arithmetic z);
 196 float          fmaf(float x, float y, float z);
 197 long double    fmal(long double x, long double y, long double z);
 198
 199 floating_point fmax (arithmetic x, arithmetic y);
 200 float          fmaxf(float x, float y);
 201 long double    fmaxl(long double x, long double y);
 202
 203 floating_point fmin (arithmetic x, arithmetic y);
 204 float          fminf(float x, float y);
 205 long double    fminl(long double x, long double y);
 206
 207 floating_point hypot (arithmetic x, arithmetic y);
 208 float          hypotf(float x, float y);
 209 long double    hypotl(long double x, long double y);
 210
 211 double       hypot(double x, double y, double z);                // C++17
 212 float        hypot(float x, float y, float z);                   // C++17
 213 long double  hypot(long double x, long double y, long double z); // C++17
 214
 215 int ilogb (arithmetic x);
 216 int ilogbf(float x);
 217 int ilogbl(long double x);
 218
 219 floating_point lgamma (arithmetic x);
 220 float          lgammaf(float x);
 221 long double    lgammal(long double x);
 222
 223 long long llrint (arithmetic x);
 224 long long llrintf(float x);
 225 long long llrintl(long double x);
 226
 227 long long llround (arithmetic x);
 228 long long llroundf(float x);
 229 long long llroundl(long double x);
 230
 231 floating_point log1p (arithmetic x);
 232 float          log1pf(float x);
 233 long double    log1pl(long double x);
 234
 235 floating_point log2 (arithmetic x);
 236 float          log2f(float x);
 237 long double    log2l(long double x);
 238
 239 floating_point logb (arithmetic x);
 240 float          logbf(float x);
 241 long double    logbl(long double x);
 242
 243 long lrint (arithmetic x);
 244 long lrintf(float x);
 245 long lrintl(long double x);
 246
 247 long lround (arithmetic x);
 248 long lroundf(float x);
 249 long lroundl(long double x);
 250
 251 double      nan (const char* str);
 252 float       nanf(const char* str);
 253 long double nanl(const char* str);
 254
 255 floating_point nearbyint (arithmetic x);
 256 float          nearbyintf(float x);
 257 long double    nearbyintl(long double x);
 258
 259 floating_point nextafter (arithmetic x, arithmetic y);
 260 float          nextafterf(float x, float y);
 261 long double    nextafterl(long double x, long double y);
 262
 263 floating_point nexttoward (arithmetic x, long double y);
 264 float          nexttowardf(float x, long double y);
 265 long double    nexttowardl(long double x, long double y);
 266
 267 floating_point remainder (arithmetic x, arithmetic y);
 268 float          remainderf(float x, float y);
 269 long double    remainderl(long double x, long double y);
 270
 271 floating_point remquo (arithmetic x, arithmetic y, int* pquo);
 272 float          remquof(float x, float y, int* pquo);
 273 long double    remquol(long double x, long double y, int* pquo);
 274
 275 floating_point rint (arithmetic x);
 276 float          rintf(float x);
 277 long double    rintl(long double x);
 278
 279 floating_point round (arithmetic x);
 280 float          roundf(float x);
 281 long double    roundl(long double x);
 282
 283 floating_point scalbln (arithmetic x, long ex);
 284 float          scalblnf(float x, long ex);
 285 long double    scalblnl(long double x, long ex);
 286
 287 floating_point scalbn (arithmetic x, int ex);
 288 float          scalbnf(float x, int ex);
 289 long double    scalbnl(long double x, int ex);
 290
 291 floating_point tgamma (arithmetic x);
 292 float          tgammaf(float x);
 293 long double    tgammal(long double x);
 294
 295 floating_point trunc (arithmetic x);
 296 float          truncf(float x);
 297 long double    truncl(long double x);
 298
 299 }  // std
 300
 301 */
 302
 303 #include <__config>
 304 #include <math.h>
 305 #include <version>
 306 #include <type_traits>
 307
 308 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 309 #pragma GCC system_header
 310 #endif
 311
 312 _LIBCPP_PUSH_MACROS
 313 #include <__undef_macros>
 314
 315 _LIBCPP_BEGIN_NAMESPACE_STD
 316
 317 using ::signbit;
 318 using ::fpclassify;
 319 using ::isfinite;
 320 using ::isinf;
 321 using ::isnan;
 322 using ::isnormal;
 323 using ::isgreater;
 324 using ::isgreaterequal;
 325 using ::isless;
 326 using ::islessequal;
 327 using ::islessgreater;
 328 using ::isunordered;
 329 using ::isunordered;
 330
 331 using ::float_t;
 332 using ::double_t;
 333
 334 #ifndef _AIX
 335 using ::abs;
 336 #endif
 337
 338 using ::acos;
 339 using ::acosf;
 340 using ::asin;
 341 using ::asinf;
 342 using ::atan;
 343 using ::atanf;
 344 using ::atan2;
 345 using ::atan2f;
 346 using ::ceil;
 347 using ::ceilf;
 348 using ::cos;
 349 using ::cosf;
 350 using ::cosh;
 351 using ::coshf;
 352
 353 using ::exp;
 354 using ::expf;
 355
 356 using ::fabs;
 357 using ::fabsf;
 358 using ::floor;
 359 using ::floorf;
 360
 361 using ::fmod;
 362 using ::fmodf;
 363
 364 using ::frexp;
 365 using ::frexpf;
 366 using ::ldexp;
 367 using ::ldexpf;
 368
 369 using ::log;
 370 using ::logf;
 371
 372 using ::log10;
 373 using ::log10f;
 374 using ::modf;
 375 using ::modff;
 376
 377 using ::pow;
 378 using ::powf;
 379
 380 using ::sin;
 381 using ::sinf;
 382 using ::sinh;
 383 using ::sinhf;
 384
 385 using ::sqrt;
 386 using ::sqrtf;
 387 using ::tan;
 388 using ::tanf;
 389
 390 using ::tanh;
 391 using ::tanhf;
 392
 393 using ::acosh;
 394 using ::acoshf;
 395 using ::asinh;
 396 using ::asinhf;
 397 using ::atanh;
 398 using ::atanhf;
 399 using ::cbrt;
 400 using ::cbrtf;
 401
 402 using ::copysign;
 403 using ::copysignf;
 404
 405 using ::erf;
 406 using ::erff;
 407 using ::erfc;
 408 using ::erfcf;
 409 using ::exp2;
 410 using ::exp2f;
 411 using ::expm1;
 412 using ::expm1f;
 413 using ::fdim;
 414 using ::fdimf;
 415 using ::fmaf;
 416 using ::fma;
 417 using ::fmax;
 418 using ::fmaxf;
 419 using ::fmin;
 420 using ::fminf;
 421 using ::hypot;
 422 using ::hypotf;
 423 using ::ilogb;
 424 using ::ilogbf;
 425 using ::lgamma;
 426 using ::lgammaf;
 427 using ::llrint;
 428 using ::llrintf;
 429 using ::llround;
 430 using ::llroundf;
 431 using ::log1p;
 432 using ::log1pf;
 433 using ::log2;
 434 using ::log2f;
 435 using ::logb;
 436 using ::logbf;
 437 using ::lrint;
 438 using ::lrintf;
 439 using ::lround;
 440 using ::lroundf;
 441
 442 using ::nan;
 443 using ::nanf;
 444
 445 using ::nearbyint;
 446 using ::nearbyintf;
 447 using ::nextafter;
 448 using ::nextafterf;
 449 using ::nexttoward;
 450 using ::nexttowardf;
 451 using ::remainder;
 452 using ::remainderf;
 453 using ::remquo;
 454 using ::remquof;
 455 using ::rint;
 456 using ::rintf;
 457 using ::round;
 458 using ::roundf;
 459 using ::scalbln;
 460 using ::scalblnf;
 461 using ::scalbn;
 462 using ::scalbnf;
 463 using ::tgamma;
 464 using ::tgammaf;
 465 using ::trunc;
 466 using ::truncf;
 467
 468 using ::acosl;
 469 using ::asinl;
 470 using ::atanl;
 471 using ::atan2l;
 472 using ::ceill;
 473 using ::cosl;
 474 using ::coshl;
 475 using ::expl;
 476 using ::fabsl;
 477 using ::floorl;
 478 using ::fmodl;
 479 using ::frexpl;
 480 using ::ldexpl;
 481 using ::logl;
 482 using ::log10l;
 483 using ::modfl;
 484 using ::powl;
 485 using ::sinl;
 486 using ::sinhl;
 487 using ::sqrtl;
 488 using ::tanl;
 489
 490 using ::tanhl;
 491 using ::acoshl;
 492 using ::asinhl;
 493 using ::atanhl;
 494 using ::cbrtl;
 495
 496 using ::copysignl;
 497
 498 using ::erfl;
 499 using ::erfcl;
 500 using ::exp2l;
 501 using ::expm1l;
 502 using ::fdiml;
 503 using ::fmal;
 504 using ::fmaxl;
 505 using ::fminl;
 506 using ::hypotl;
 507 using ::ilogbl;
 508 using ::lgammal;
 509 using ::llrintl;
 510 using ::llroundl;
 511 using ::log1pl;
 512 using ::log2l;
 513 using ::logbl;
 514 using ::lrintl;
 515 using ::lroundl;
 516 using ::nanl;
 517 using ::nearbyintl;
 518 using ::nextafterl;
 519 using ::nexttowardl;
 520 using ::remainderl;
 521 using ::remquol;
 522 using ::rintl;
 523 using ::roundl;
 524 using ::scalblnl;
 525 using ::scalbnl;
 526 using ::tgammal;
 527 using ::truncl;
 528
 529 #if _LIBCPP_STD_VER > 14
 530 inline _LIBCPP_INLINE_VISIBILITY float       hypot(       float x,       float y,       float z ) { return sqrt(x*x + y*y + z*z); }
 531 inline _LIBCPP_INLINE_VISIBILITY double      hypot(      double x,      double y,      double z ) { return sqrt(x*x + y*y + z*z); }
 532 inline _LIBCPP_INLINE_VISIBILITY long double hypot( long double x, long double y, long double z ) { return sqrt(x*x + y*y + z*z); }
 533
 534 template <class _A1, class _A2, class _A3>
 535 inline _LIBCPP_INLINE_VISIBILITY
 536 typename _EnableIf
 537 <
 538     is_arithmetic<_A1>::value &&
 539     is_arithmetic<_A2>::value &&
 540     is_arithmetic<_A3>::value,
 541     __promote<_A1, _A2, _A3>
 542 >::type
 543 hypot(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT
 544 {
 545     typedef typename __promote<_A1, _A2, _A3>::type __result_type;
 546     static_assert((!(is_same<_A1, __result_type>::value &&
 547                      is_same<_A2, __result_type>::value &&
 548                      is_same<_A3, __result_type>::value)), "");
 549     return hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
 550 }
 551 #endif
 552
 553 template <class _A1>
 554 _LIBCPP_INLINE_VISIBILITY
 555 _LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
 556 __libcpp_isnan_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 557 {
 558 #if __has_builtin(__builtin_isnan)
 559     return __builtin_isnan(__lcpp_x);
 560 #else
 561     return isnan(__lcpp_x);
 562 #endif
 563 }
 564
 565 template <class _A1>
 566 _LIBCPP_INLINE_VISIBILITY
 567 _LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
 568 __libcpp_isnan_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 569 {
 570     return isnan(__lcpp_x);
 571 }
 572
 573 template <class _A1>
 574 _LIBCPP_INLINE_VISIBILITY
 575 _LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
 576 __libcpp_isinf_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 577 {
 578 #if __has_builtin(__builtin_isinf)
 579     return __builtin_isinf(__lcpp_x);
 580 #else
 581     return isinf(__lcpp_x);
 582 #endif
 583 }
 584
 585 template <class _A1>
 586 _LIBCPP_INLINE_VISIBILITY
 587 _LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
 588 __libcpp_isinf_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 589 {
 590     return isinf(__lcpp_x);
 591 }
 592
 593 template <class _A1>
 594 _LIBCPP_INLINE_VISIBILITY
 595 _LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
 596 __libcpp_isfinite_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 597 {
 598 #if __has_builtin(__builtin_isfinite)
 599     return __builtin_isfinite(__lcpp_x);
 600 #else
 601     return isfinite(__lcpp_x);
 602 #endif
 603 }
 604
 605 template <class _A1>
 606 _LIBCPP_INLINE_VISIBILITY
 607 _LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
 608 __libcpp_isfinite_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 609 {
 610     return isfinite(__lcpp_x);
 611 }
 612
 613 #if _LIBCPP_STD_VER > 17
 614 template <typename _Fp>
 615 constexpr
 616 _Fp __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept {
 617     if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
 618         return __t * __b + (1 - __t) * __a;
 619
 620     if (__t == 1) return __b;
 621     const _Fp __x = __a + __t * (__b - __a);
 622     if (__t > 1 == __b > __a)
 623         return __b < __x ? __x : __b;
 624     else
 625         return __x < __b ? __x : __b;
 626 }
 627
 628 constexpr float
 629 lerp(float __a, float __b, float __t)                   _NOEXCEPT { return __lerp(__a, __b, __t); }
 630
 631 constexpr double
 632 lerp(double __a, double __b, double __t)                _NOEXCEPT { return __lerp(__a, __b, __t); }
 633
 634 constexpr long double
 635 lerp(long double __a, long double __b, long double __t) _NOEXCEPT { return __lerp(__a, __b, __t); }
 636
 637 #endif // _LIBCPP_STD_VER > 17
 638
 639 template <class _IntT, class _FloatT,
 640     bool _FloatBigger = (numeric_limits<_FloatT>::digits > numeric_limits<_IntT>::digits),
 641     int _Bits = (numeric_limits<_IntT>::digits - numeric_limits<_FloatT>::digits)>
 642 _LIBCPP_INLINE_VISIBILITY
 643 _LIBCPP_CONSTEXPR _IntT __max_representable_int_for_float() _NOEXCEPT {
 644   static_assert(is_floating_point<_FloatT>::value, "must be a floating point type");
 645   static_assert(is_integral<_IntT>::value, "must be an integral type");
 646   static_assert(numeric_limits<_FloatT>::radix == 2, "FloatT has incorrect radix");
 647   static_assert((_IsSame<_FloatT, float>::value || _IsSame<_FloatT, double>::value
 648                  || _IsSame<_FloatT,long double>::value), "unsupported floating point type");
 649   return _FloatBigger ? numeric_limits<_IntT>::max() :  (numeric_limits<_IntT>::max() >> _Bits << _Bits);
 650 }
 651
 652 // Convert a floating point number to the specified integral type after
 653 // clamping to the integral types representable range.
 654 //
 655 // The behavior is undefined if `__r` is NaN.
 656 template <class _IntT, class _RealT>
 657 _LIBCPP_INLINE_VISIBILITY
 658 _IntT __clamp_to_integral(_RealT __r) _NOEXCEPT {
 659   using _Lim = std::numeric_limits<_IntT>;
 660   const _IntT _MaxVal = std::__max_representable_int_for_float<_IntT, _RealT>();
 661   if (__r >= ::nextafter(static_cast<_RealT>(_MaxVal), INFINITY)) {
 662     return _Lim::max();
 663   } else if (__r <= _Lim::lowest()) {
 664     return _Lim::min();
 665   }
 666   return static_cast<_IntT>(__r);
 667 }
 668
 669 _LIBCPP_END_NAMESPACE_STD
 670
 671 _LIBCPP_POP_MACROS
 672
 673 #endif  // _LIBCPP_CMATH