contrib/libc++/include/cmath

   1 // -*- C++ -*-
   2 //===---------------------------- cmath -----------------------------------===//
   3 //
   4 //                     The LLVM Compiler Infrastructure
   5 //
   6 // This file is dual licensed under the MIT and the University of Illinois Open
   7 // Source Licenses. See LICENSE.TXT for details.
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  11 #ifndef _LIBCPP_CMATH
  12 #define _LIBCPP_CMATH
  13
  14 /*
  15     cmath synopsis
  16
  17 Macros:
  18
  19     HUGE_VAL
  20     HUGE_VALF               // C99
  21     HUGE_VALL               // C99
  22     INFINITY                // C99
  23     NAN                     // C99
  24     FP_INFINITE             // C99
  25     FP_NAN                  // C99
  26     FP_NORMAL               // C99
  27     FP_SUBNORMAL            // C99
  28     FP_ZERO                 // C99
  29     FP_FAST_FMA             // C99
  30     FP_FAST_FMAF            // C99
  31     FP_FAST_FMAL            // C99
  32     FP_ILOGB0               // C99
  33     FP_ILOGBNAN             // C99
  34     MATH_ERRNO              // C99
  35     MATH_ERREXCEPT          // C99
  36     math_errhandling        // C99
  37
  38 namespace std
  39 {
  40
  41 Types:
  42
  43     float_t                 // C99
  44     double_t                // C99
  45
  46 // C90
  47
  48 floating_point abs(floating_point x);
  49
  50 floating_point acos (arithmetic x);
  51 float          acosf(float x);
  52 long double    acosl(long double x);
  53
  54 floating_point asin (arithmetic x);
  55 float          asinf(float x);
  56 long double    asinl(long double x);
  57
  58 floating_point atan (arithmetic x);
  59 float          atanf(float x);
  60 long double    atanl(long double x);
  61
  62 floating_point atan2 (arithmetic y, arithmetic x);
  63 float          atan2f(float y, float x);
  64 long double    atan2l(long double y, long double x);
  65
  66 floating_point ceil (arithmetic x);
  67 float          ceilf(float x);
  68 long double    ceill(long double x);
  69
  70 floating_point cos (arithmetic x);
  71 float          cosf(float x);
  72 long double    cosl(long double x);
  73
  74 floating_point cosh (arithmetic x);
  75 float          coshf(float x);
  76 long double    coshl(long double x);
  77
  78 floating_point exp (arithmetic x);
  79 float          expf(float x);
  80 long double    expl(long double x);
  81
  82 floating_point fabs (arithmetic x);
  83 float          fabsf(float x);
  84 long double    fabsl(long double x);
  85
  86 floating_point floor (arithmetic x);
  87 float          floorf(float x);
  88 long double    floorl(long double x);
  89
  90 floating_point fmod (arithmetic x, arithmetic y);
  91 float          fmodf(float x, float y);
  92 long double    fmodl(long double x, long double y);
  93
  94 floating_point frexp (arithmetic value, int* exp);
  95 float          frexpf(float value, int* exp);
  96 long double    frexpl(long double value, int* exp);
  97
  98 floating_point ldexp (arithmetic value, int exp);
  99 float          ldexpf(float value, int exp);
 100 long double    ldexpl(long double value, int exp);
 101
 102 floating_point log (arithmetic x);
 103 float          logf(float x);
 104 long double    logl(long double x);
 105
 106 floating_point log10 (arithmetic x);
 107 float          log10f(float x);
 108 long double    log10l(long double x);
 109
 110 floating_point modf (floating_point value, floating_point* iptr);
 111 float          modff(float value, float* iptr);
 112 long double    modfl(long double value, long double* iptr);
 113
 114 floating_point pow (arithmetic x, arithmetic y);
 115 float          powf(float x, float y);
 116 long double    powl(long double x, long double y);
 117
 118 floating_point sin (arithmetic x);
 119 float          sinf(float x);
 120 long double    sinl(long double x);
 121
 122 floating_point sinh (arithmetic x);
 123 float          sinhf(float x);
 124 long double    sinhl(long double x);
 125
 126 floating_point sqrt (arithmetic x);
 127 float          sqrtf(float x);
 128 long double    sqrtl(long double x);
 129
 130 floating_point tan (arithmetic x);
 131 float          tanf(float x);
 132 long double    tanl(long double x);
 133
 134 floating_point tanh (arithmetic x);
 135 float          tanhf(float x);
 136 long double    tanhl(long double x);
 137
 138 //  C99
 139
 140 bool signbit(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 double       hypot(double x, double y, double z);                // C++17
 213 float        hypot(float x, float y, float z);                   // C++17
 214 long double  hypot(long double x, long double y, long double z); // C++17
 215
 216 int ilogb (arithmetic x);
 217 int ilogbf(float x);
 218 int ilogbl(long double x);
 219
 220 floating_point lgamma (arithmetic x);
 221 float          lgammaf(float x);
 222 long double    lgammal(long double x);
 223
 224 long long llrint (arithmetic x);
 225 long long llrintf(float x);
 226 long long llrintl(long double x);
 227
 228 long long llround (arithmetic x);
 229 long long llroundf(float x);
 230 long long llroundl(long double x);
 231
 232 floating_point log1p (arithmetic x);
 233 float          log1pf(float x);
 234 long double    log1pl(long double x);
 235
 236 floating_point log2 (arithmetic x);
 237 float          log2f(float x);
 238 long double    log2l(long double x);
 239
 240 floating_point logb (arithmetic x);
 241 float          logbf(float x);
 242 long double    logbl(long double x);
 243
 244 long lrint (arithmetic x);
 245 long lrintf(float x);
 246 long lrintl(long double x);
 247
 248 long lround (arithmetic x);
 249 long lroundf(float x);
 250 long lroundl(long double x);
 251
 252 double      nan (const char* str);
 253 float       nanf(const char* str);
 254 long double nanl(const char* str);
 255
 256 floating_point nearbyint (arithmetic x);
 257 float          nearbyintf(float x);
 258 long double    nearbyintl(long double x);
 259
 260 floating_point nextafter (arithmetic x, arithmetic y);
 261 float          nextafterf(float x, float y);
 262 long double    nextafterl(long double x, long double y);
 263
 264 floating_point nexttoward (arithmetic x, long double y);
 265 float          nexttowardf(float x, long double y);
 266 long double    nexttowardl(long double x, long double y);
 267
 268 floating_point remainder (arithmetic x, arithmetic y);
 269 float          remainderf(float x, float y);
 270 long double    remainderl(long double x, long double y);
 271
 272 floating_point remquo (arithmetic x, arithmetic y, int* pquo);
 273 float          remquof(float x, float y, int* pquo);
 274 long double    remquol(long double x, long double y, int* pquo);
 275
 276 floating_point rint (arithmetic x);
 277 float          rintf(float x);
 278 long double    rintl(long double x);
 279
 280 floating_point round (arithmetic x);
 281 float          roundf(float x);
 282 long double    roundl(long double x);
 283
 284 floating_point scalbln (arithmetic x, long ex);
 285 float          scalblnf(float x, long ex);
 286 long double    scalblnl(long double x, long ex);
 287
 288 floating_point scalbn (arithmetic x, int ex);
 289 float          scalbnf(float x, int ex);
 290 long double    scalbnl(long double x, int ex);
 291
 292 floating_point tgamma (arithmetic x);
 293 float          tgammaf(float x);
 294 long double    tgammal(long double x);
 295
 296 floating_point trunc (arithmetic x);
 297 float          truncf(float x);
 298 long double    truncl(long double x);
 299
 300 }  // std
 301
 302 */
 303
 304 #include <__config>
 305 #include <math.h>
 306 #include <version>
 307
 308 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 309 #pragma GCC system_header
 310 #endif
 311
 312 _LIBCPP_BEGIN_NAMESPACE_STD
 313
 314 using ::signbit;
 315 using ::fpclassify;
 316 using ::isfinite;
 317 using ::isinf;
 318 using ::isnan;
 319 using ::isnormal;
 320 using ::isgreater;
 321 using ::isgreaterequal;
 322 using ::isless;
 323 using ::islessequal;
 324 using ::islessgreater;
 325 using ::isunordered;
 326 using ::isunordered;
 327
 328 using ::float_t;
 329 using ::double_t;
 330
 331 #ifndef _AIX
 332 using ::abs;
 333 #endif
 334
 335 using ::acos;
 336 using ::acosf;
 337 using ::asin;
 338 using ::asinf;
 339 using ::atan;
 340 using ::atanf;
 341 using ::atan2;
 342 using ::atan2f;
 343 using ::ceil;
 344 using ::ceilf;
 345 using ::cos;
 346 using ::cosf;
 347 using ::cosh;
 348 using ::coshf;
 349
 350 using ::exp;
 351 using ::expf;
 352
 353 using ::fabs;
 354 using ::fabsf;
 355 using ::floor;
 356 using ::floorf;
 357
 358 using ::fmod;
 359 using ::fmodf;
 360
 361 using ::frexp;
 362 using ::frexpf;
 363 using ::ldexp;
 364 using ::ldexpf;
 365
 366 using ::log;
 367 using ::logf;
 368
 369 using ::log10;
 370 using ::log10f;
 371 using ::modf;
 372 using ::modff;
 373
 374 using ::pow;
 375 using ::powf;
 376
 377 using ::sin;
 378 using ::sinf;
 379 using ::sinh;
 380 using ::sinhf;
 381
 382 using ::sqrt;
 383 using ::sqrtf;
 384 using ::tan;
 385 using ::tanf;
 386
 387 using ::tanh;
 388 using ::tanhf;
 389
 390 using ::acosh;
 391 using ::acoshf;
 392 using ::asinh;
 393 using ::asinhf;
 394 using ::atanh;
 395 using ::atanhf;
 396 using ::cbrt;
 397 using ::cbrtf;
 398
 399 using ::copysign;
 400 using ::copysignf;
 401
 402 using ::erf;
 403 using ::erff;
 404 using ::erfc;
 405 using ::erfcf;
 406 using ::exp2;
 407 using ::exp2f;
 408 using ::expm1;
 409 using ::expm1f;
 410 using ::fdim;
 411 using ::fdimf;
 412 using ::fmaf;
 413 using ::fma;
 414 using ::fmax;
 415 using ::fmaxf;
 416 using ::fmin;
 417 using ::fminf;
 418 using ::hypot;
 419 using ::hypotf;
 420 using ::ilogb;
 421 using ::ilogbf;
 422 using ::lgamma;
 423 using ::lgammaf;
 424 using ::llrint;
 425 using ::llrintf;
 426 using ::llround;
 427 using ::llroundf;
 428 using ::log1p;
 429 using ::log1pf;
 430 using ::log2;
 431 using ::log2f;
 432 using ::logb;
 433 using ::logbf;
 434 using ::lrint;
 435 using ::lrintf;
 436 using ::lround;
 437 using ::lroundf;
 438
 439 using ::nan;
 440 using ::nanf;
 441
 442 using ::nearbyint;
 443 using ::nearbyintf;
 444 using ::nextafter;
 445 using ::nextafterf;
 446 using ::nexttoward;
 447 using ::nexttowardf;
 448 using ::remainder;
 449 using ::remainderf;
 450 using ::remquo;
 451 using ::remquof;
 452 using ::rint;
 453 using ::rintf;
 454 using ::round;
 455 using ::roundf;
 456 using ::scalbln;
 457 using ::scalblnf;
 458 using ::scalbn;
 459 using ::scalbnf;
 460 using ::tgamma;
 461 using ::tgammaf;
 462 using ::trunc;
 463 using ::truncf;
 464
 465 using ::acosl;
 466 using ::asinl;
 467 using ::atanl;
 468 using ::atan2l;
 469 using ::ceill;
 470 using ::cosl;
 471 using ::coshl;
 472 using ::expl;
 473 using ::fabsl;
 474 using ::floorl;
 475 using ::fmodl;
 476 using ::frexpl;
 477 using ::ldexpl;
 478 using ::logl;
 479 using ::log10l;
 480 using ::modfl;
 481 using ::powl;
 482 using ::sinl;
 483 using ::sinhl;
 484 using ::sqrtl;
 485 using ::tanl;
 486
 487 using ::tanhl;
 488 using ::acoshl;
 489 using ::asinhl;
 490 using ::atanhl;
 491 using ::cbrtl;
 492
 493 using ::copysignl;
 494
 495 using ::erfl;
 496 using ::erfcl;
 497 using ::exp2l;
 498 using ::expm1l;
 499 using ::fdiml;
 500 using ::fmal;
 501 using ::fmaxl;
 502 using ::fminl;
 503 using ::hypotl;
 504 using ::ilogbl;
 505 using ::lgammal;
 506 using ::llrintl;
 507 using ::llroundl;
 508 using ::log1pl;
 509 using ::log2l;
 510 using ::logbl;
 511 using ::lrintl;
 512 using ::lroundl;
 513 using ::nanl;
 514 using ::nearbyintl;
 515 using ::nextafterl;
 516 using ::nexttowardl;
 517 using ::remainderl;
 518 using ::remquol;
 519 using ::rintl;
 520 using ::roundl;
 521 using ::scalblnl;
 522 using ::scalbnl;
 523 using ::tgammal;
 524 using ::truncl;
 525
 526 #if _LIBCPP_STD_VER > 14
 527 inline _LIBCPP_INLINE_VISIBILITY float       hypot(       float x,       float y,       float z ) { return sqrt(x*x + y*y + z*z); }
 528 inline _LIBCPP_INLINE_VISIBILITY double      hypot(      double x,      double y,      double z ) { return sqrt(x*x + y*y + z*z); }
 529 inline _LIBCPP_INLINE_VISIBILITY long double hypot( long double x, long double y, long double z ) { return sqrt(x*x + y*y + z*z); }
 530
 531 template <class _A1, class _A2, class _A3>
 532 inline _LIBCPP_INLINE_VISIBILITY
 533 typename __lazy_enable_if
 534 <
 535     is_arithmetic<_A1>::value &&
 536     is_arithmetic<_A2>::value &&
 537     is_arithmetic<_A3>::value,
 538     __promote<_A1, _A2, _A3>
 539 >::type
 540 hypot(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT
 541 {
 542     typedef typename __promote<_A1, _A2, _A3>::type __result_type;
 543     static_assert((!(is_same<_A1, __result_type>::value &&
 544                      is_same<_A2, __result_type>::value &&
 545                      is_same<_A3, __result_type>::value)), "");
 546     return hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
 547 }
 548 #endif
 549
 550 template <class _A1>
 551 _LIBCPP_INLINE_VISIBILITY
 552 _LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
 553 __libcpp_isnan_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 554 {
 555 #if __has_builtin(__builtin_isnan)
 556     return __builtin_isnan(__lcpp_x);
 557 #else
 558     return isnan(__lcpp_x);
 559 #endif
 560 }
 561
 562 template <class _A1>
 563 _LIBCPP_INLINE_VISIBILITY
 564 _LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
 565 __libcpp_isnan_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 566 {
 567     return isnan(__lcpp_x);
 568 }
 569
 570 template <class _A1>
 571 _LIBCPP_INLINE_VISIBILITY
 572 _LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
 573 __libcpp_isinf_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 574 {
 575 #if __has_builtin(__builtin_isinf)
 576     return __builtin_isinf(__lcpp_x);
 577 #else
 578     return isinf(__lcpp_x);
 579 #endif
 580 }
 581
 582 template <class _A1>
 583 _LIBCPP_INLINE_VISIBILITY
 584 _LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
 585 __libcpp_isinf_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 586 {
 587     return isinf(__lcpp_x);
 588 }
 589
 590 template <class _A1>
 591 _LIBCPP_INLINE_VISIBILITY
 592 _LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
 593 __libcpp_isfinite_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 594 {
 595 #if __has_builtin(__builtin_isfinite)
 596     return __builtin_isfinite(__lcpp_x);
 597 #else
 598     return isfinite(__lcpp_x);
 599 #endif
 600 }
 601
 602 template <class _A1>
 603 _LIBCPP_INLINE_VISIBILITY
 604 _LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
 605 __libcpp_isfinite_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 606 {
 607     return isfinite(__lcpp_x);
 608 }
 609
 610 _LIBCPP_END_NAMESPACE_STD
 611
 612 #endif  // _LIBCPP_CMATH