headers/libs/libc++/cmath

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