1 #ifndef _MATH_H_ 2 3 #define _MATH_H_ 4 5 #include <sys/cdefs.h> 6 #include <ieeefp.h> 7 #include "_ansi.h" 8 9 _BEGIN_STD_C 10 11 /* Natural log of 2 */ 12 #define _M_LN2 0.693147180559945309417 13 14 #if __GNUC_PREREQ (3, 3) 15 /* gcc >= 3.3 implicitly defines builtins for HUGE_VALx values. */ 16 17 # ifndef HUGE_VAL 18 # define HUGE_VAL (__builtin_huge_val()) 19 # endif 20 21 # ifndef HUGE_VALF 22 # define HUGE_VALF (__builtin_huge_valf()) 23 # endif 24 25 # ifndef HUGE_VALL 26 # define HUGE_VALL (__builtin_huge_vall()) 27 # endif 28 29 # ifndef INFINITY 30 # define INFINITY (__builtin_inff()) 31 # endif 32 33 # ifndef NAN 34 # define NAN (__builtin_nanf("")) 35 # endif 36 37 #else /* !gcc >= 3.3 */ 38 39 /* No builtins. Use fixed defines instead. (All 3 HUGE plus the INFINITY 40 * and NAN macros are required to be constant expressions. Using a variable-- 41 * even a static const--does not meet this requirement, as it cannot be 42 * evaluated at translation time.) 43 * The infinities are done using numbers that are far in excess of 44 * something that would be expected to be encountered in a floating-point 45 * implementation. (A more certain way uses values from float.h, but that is 46 * avoided because system includes are not supposed to include each other.) 47 * This method might produce warnings from some compilers. (It does in 48 * newer GCCs, but not for ones that would hit this #else.) If this happens, 49 * please report details to the Newlib mailing list. */ 50 51 #ifndef HUGE_VAL 52 #define HUGE_VAL (1.0e999999999) 53 #endif 54 55 #ifndef HUGE_VALF 56 #define HUGE_VALF (1.0e999999999F) 57 #endif 58 59 #if !defined(HUGE_VALL) && defined(_HAVE_LONG_DOUBLE) 60 #define HUGE_VALL (1.0e999999999L) 61 #endif 62 63 #if !defined(INFINITY) 64 #define INFINITY (HUGE_VALF) 65 #endif 66 67 #if !defined(NAN) 68 #if defined(__GNUC__) && defined(__cplusplus) 69 /* Exception: older g++ versions warn about the divide by 0 used in the 70 * normal case (even though older gccs do not). This trick suppresses the 71 * warning, but causes errors for plain gcc, so is only used in the one 72 * special case. */ 73 static const union { __ULong __i[1]; float __d; } __Nanf = {0x7FC00000}; 74 #define NAN (__Nanf.__d) 75 #else 76 #define NAN (0.0F/0.0F) 77 #endif 78 #endif 79 80 #endif /* !gcc >= 3.3 */ 81 82 /* Reentrant ANSI C functions. */ 83 84 #ifndef __math_68881 85 extern double atan (double); 86 extern double cos (double); 87 extern double sin (double); 88 extern double tan (double); 89 extern double tanh (double); 90 extern double frexp (double, int *); 91 extern double modf (double, double *); 92 extern double ceil (double); 93 extern double fabs (double); 94 extern double floor (double); 95 #endif /* ! defined (__math_68881) */ 96 97 /* Non reentrant ANSI C functions. */ 98 99 #ifndef _REENT_ONLY 100 #ifndef __math_68881 101 extern double acos (double); 102 extern double asin (double); 103 extern double atan2 (double, double); 104 extern double cosh (double); 105 extern double sinh (double); 106 extern double exp (double); 107 extern double ldexp (double, int); 108 extern double log (double); 109 extern double log10 (double); 110 extern double pow (double, double); 111 extern double sqrt (double); 112 extern double fmod (double, double); 113 #endif /* ! defined (__math_68881) */ 114 #endif /* ! defined (_REENT_ONLY) */ 115 116 #if __MISC_VISIBLE 117 extern int finite (double); 118 extern int finitef (float); 119 extern int finitel (long double); 120 extern int isinff (float); 121 extern int isnanf (float); 122 #ifdef __CYGWIN__ /* not implemented in newlib yet */ 123 extern int isinfl (long double); 124 extern int isnanl (long double); 125 #endif 126 #if !defined(__cplusplus) || __cplusplus < 201103L 127 extern int isinf (double); 128 #endif 129 #endif /* __MISC_VISIBLE */ 130 #if (__MISC_VISIBLE || (__XSI_VISIBLE && __XSI_VISIBLE < 600)) \ 131 && (!defined(__cplusplus) || __cplusplus < 201103L) 132 extern int isnan (double); 133 #endif 134 135 #if __ISO_C_VISIBLE >= 1999 136 /* ISO C99 types and macros. */ 137 138 /* FIXME: FLT_EVAL_METHOD should somehow be gotten from float.h (which is hard, 139 * considering that the standard says the includes it defines should not 140 * include other includes that it defines) and that value used. (This can be 141 * solved, but autoconf has a bug which makes the solution more difficult, so 142 * it has been skipped for now.) */ 143 #if !defined(FLT_EVAL_METHOD) && defined(__FLT_EVAL_METHOD__) 144 #define FLT_EVAL_METHOD __FLT_EVAL_METHOD__ 145 #define __TMP_FLT_EVAL_METHOD 146 #endif /* FLT_EVAL_METHOD */ 147 #if defined FLT_EVAL_METHOD 148 #if FLT_EVAL_METHOD == 0 149 typedef float float_t; 150 typedef double double_t; 151 #elif FLT_EVAL_METHOD == 1 152 typedef double float_t; 153 typedef double double_t; 154 #elif FLT_EVAL_METHOD == 2 155 typedef long double float_t; 156 typedef long double double_t; 157 #else 158 /* Implementation-defined. Assume float_t and double_t have been 159 * defined previously for this configuration (e.g. config.h). */ 160 #endif 161 #else 162 /* Assume basic definitions. */ 163 typedef float float_t; 164 typedef double double_t; 165 #endif 166 #if defined(__TMP_FLT_EVAL_METHOD) 167 #undef FLT_EVAL_METHOD 168 #endif 169 170 #define FP_NAN 0 171 #define FP_INFINITE 1 172 #define FP_ZERO 2 173 #define FP_SUBNORMAL 3 174 #define FP_NORMAL 4 175 176 #ifndef FP_ILOGB0 177 # define FP_ILOGB0 (-__INT_MAX__) 178 #endif 179 #ifndef FP_ILOGBNAN 180 # define FP_ILOGBNAN __INT_MAX__ 181 #endif 182 183 #ifndef MATH_ERRNO 184 # define MATH_ERRNO 1 185 #endif 186 #ifndef MATH_ERREXCEPT 187 # define MATH_ERREXCEPT 2 188 #endif 189 #ifndef math_errhandling 190 # define math_errhandling MATH_ERRNO 191 #endif 192 193 extern int __isinff (float x); 194 extern int __isinfd (double x); 195 extern int __isnanf (float x); 196 extern int __isnand (double x); 197 extern int __fpclassifyf (float x); 198 extern int __fpclassifyd (double x); 199 extern int __signbitf (float x); 200 extern int __signbitd (double x); 201 202 /* Note: isinf and isnan were once functions in newlib that took double 203 * arguments. C99 specifies that these names are reserved for macros 204 * supporting multiple floating point types. Thus, they are 205 * now defined as macros. Implementations of the old functions 206 * taking double arguments still exist for compatibility purposes 207 * (prototypes for them are earlier in this header). */ 208 209 #if __GNUC_PREREQ (4, 4) 210 #define fpclassify(__x) (__builtin_fpclassify (FP_NAN, FP_INFINITE, \ 211 FP_NORMAL, FP_SUBNORMAL, \ 212 FP_ZERO, __x)) 213 #ifndef isfinite 214 #define isfinite(__x) (__builtin_isfinite (__x)) 215 #endif 216 #ifndef isinf 217 #define isinf(__x) (__builtin_isinf_sign (__x)) 218 #endif 219 #ifndef isnan 220 #define isnan(__x) (__builtin_isnan (__x)) 221 #endif 222 #define isnormal(__x) (__builtin_isnormal (__x)) 223 #else 224 #define fpclassify(__x) \ 225 ((sizeof(__x) == sizeof(float)) ? __fpclassifyf(__x) : \ 226 __fpclassifyd(__x)) 227 #ifndef isfinite 228 #define isfinite(__y) \ 229 (__extension__ ({int __cy = fpclassify(__y); \ 230 __cy != FP_INFINITE && __cy != FP_NAN;})) 231 #endif 232 #ifndef isinf 233 #define isinf(__x) (fpclassify(__x) == FP_INFINITE) 234 #endif 235 #ifndef isnan 236 #define isnan(__x) (fpclassify(__x) == FP_NAN) 237 #endif 238 #define isnormal(__x) (fpclassify(__x) == FP_NORMAL) 239 #endif 240 241 #if __GNUC_PREREQ (4, 0) 242 #if defined(_HAVE_LONG_DOUBLE) 243 #define signbit(__x) \ 244 ((sizeof(__x) == sizeof(float)) ? __builtin_signbitf(__x) : \ 245 (sizeof(__x) == sizeof(double)) ? __builtin_signbit (__x) : \ 246 __builtin_signbitl(__x)) 247 #else 248 #define signbit(__x) \ 249 ((sizeof(__x) == sizeof(float)) ? __builtin_signbitf(__x) : \ 250 __builtin_signbit (__x)) 251 #endif 252 #else 253 #define signbit(__x) \ 254 ((sizeof(__x) == sizeof(float)) ? __signbitf(__x) : \ 255 __signbitd(__x)) 256 #endif 257 258 #if __GNUC_PREREQ (2, 97) 259 #define isgreater(__x,__y) (__builtin_isgreater (__x, __y)) 260 #define isgreaterequal(__x,__y) (__builtin_isgreaterequal (__x, __y)) 261 #define isless(__x,__y) (__builtin_isless (__x, __y)) 262 #define islessequal(__x,__y) (__builtin_islessequal (__x, __y)) 263 #define islessgreater(__x,__y) (__builtin_islessgreater (__x, __y)) 264 #define isunordered(__x,__y) (__builtin_isunordered (__x, __y)) 265 #else 266 #define isgreater(x,y) \ 267 (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \ 268 !isunordered(__x,__y) && (__x > __y);})) 269 #define isgreaterequal(x,y) \ 270 (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \ 271 !isunordered(__x,__y) && (__x >= __y);})) 272 #define isless(x,y) \ 273 (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \ 274 !isunordered(__x,__y) && (__x < __y);})) 275 #define islessequal(x,y) \ 276 (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \ 277 !isunordered(__x,__y) && (__x <= __y);})) 278 #define islessgreater(x,y) \ 279 (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); \ 280 !isunordered(__x,__y) && (__x < __y || __x > __y);})) 281 282 #define isunordered(a,b) \ 283 (__extension__ ({__typeof__(a) __a = (a); __typeof__(b) __b = (b); \ 284 fpclassify(__a) == FP_NAN || fpclassify(__b) == FP_NAN;})) 285 #endif 286 287 /* Non ANSI double precision functions. */ 288 289 extern double infinity (void); 290 extern double nan (const char *); 291 extern double copysign (double, double); 292 extern double logb (double); 293 extern int ilogb (double); 294 295 extern double asinh (double); 296 extern double cbrt (double); 297 extern double nextafter (double, double); 298 extern double rint (double); 299 extern double scalbn (double, int); 300 301 extern double exp2 (double); 302 extern double scalbln (double, long int); 303 extern double tgamma (double); 304 extern double nearbyint (double); 305 extern long int lrint (double); 306 extern long long int llrint (double); 307 extern double round (double); 308 extern long int lround (double); 309 extern long long int llround (double); 310 extern double trunc (double); 311 extern double remquo (double, double, int *); 312 extern double fdim (double, double); 313 extern double fmax (double, double); 314 extern double fmin (double, double); 315 extern double fma (double, double, double); 316 317 #ifndef __math_68881 318 extern double log1p (double); 319 extern double expm1 (double); 320 #endif /* ! defined (__math_68881) */ 321 322 #ifndef _REENT_ONLY 323 extern double acosh (double); 324 extern double atanh (double); 325 extern double remainder (double, double); 326 extern double gamma (double); 327 extern double lgamma (double); 328 extern double erf (double); 329 extern double erfc (double); 330 extern double log2 (double); 331 #if !defined(__cplusplus) 332 #define log2(x) (log (x) / _M_LN2) 333 #endif 334 335 #ifndef __math_68881 336 extern double hypot (double, double); 337 #endif 338 339 #endif /* ! defined (_REENT_ONLY) */ 340 341 /* Single precision versions of ANSI functions. */ 342 343 extern float atanf (float); 344 extern float cosf (float); 345 extern float sinf (float); 346 extern float tanf (float); 347 extern float tanhf (float); 348 extern float frexpf (float, int *); 349 extern float modff (float, float *); 350 extern float ceilf (float); 351 extern float fabsf (float); 352 extern float floorf (float); 353 354 #ifndef _REENT_ONLY 355 extern float acosf (float); 356 extern float asinf (float); 357 extern float atan2f (float, float); 358 extern float coshf (float); 359 extern float sinhf (float); 360 extern float expf (float); 361 extern float ldexpf (float, int); 362 extern float logf (float); 363 extern float log10f (float); 364 extern float powf (float, float); 365 extern float sqrtf (float); 366 extern float fmodf (float, float); 367 #endif /* ! defined (_REENT_ONLY) */ 368 369 /* Other single precision functions. */ 370 371 extern float exp2f (float); 372 extern float scalblnf (float, long int); 373 extern float tgammaf (float); 374 extern float nearbyintf (float); 375 extern long int lrintf (float); 376 extern long long int llrintf (float); 377 extern float roundf (float); 378 extern long int lroundf (float); 379 extern long long int llroundf (float); 380 extern float truncf (float); 381 extern float remquof (float, float, int *); 382 extern float fdimf (float, float); 383 extern float fmaxf (float, float); 384 extern float fminf (float, float); 385 extern float fmaf (float, float, float); 386 387 extern float infinityf (void); 388 extern float nanf (const char *); 389 extern float copysignf (float, float); 390 extern float logbf (float); 391 extern int ilogbf (float); 392 393 extern float asinhf (float); 394 extern float cbrtf (float); 395 extern float nextafterf (float, float); 396 extern float rintf (float); 397 extern float scalbnf (float, int); 398 extern float log1pf (float); 399 extern float expm1f (float); 400 401 #ifndef _REENT_ONLY 402 extern float acoshf (float); 403 extern float atanhf (float); 404 extern float remainderf (float, float); 405 extern float gammaf (float); 406 extern float lgammaf (float); 407 extern float erff (float); 408 extern float erfcf (float); 409 extern float log2f (float); 410 extern float hypotf (float, float); 411 #endif /* ! defined (_REENT_ONLY) */ 412 413 /* Newlib doesn't fully support long double math functions so far. 414 On platforms where long double equals double the long double functions 415 simply call the double functions. On Cygwin the long double functions 416 are implemented independently from newlib to be able to use optimized 417 assembler functions despite using the Microsoft x86_64 ABI. */ 418 #if defined (_LDBL_EQ_DBL) || defined (__CYGWIN__) 419 /* Reentrant ANSI C functions. */ 420 #ifndef __math_68881 421 extern long double atanl (long double); 422 extern long double cosl (long double); 423 extern long double sinl (long double); 424 extern long double tanl (long double); 425 extern long double tanhl (long double); 426 extern long double frexpl (long double, int *); 427 extern long double modfl (long double, long double *); 428 extern long double ceill (long double); 429 extern long double fabsl (long double); 430 extern long double floorl (long double); 431 extern long double log1pl (long double); 432 extern long double expm1l (long double); 433 #endif /* ! defined (__math_68881) */ 434 /* Non reentrant ANSI C functions. */ 435 #ifndef _REENT_ONLY 436 #ifndef __math_68881 437 extern long double acosl (long double); 438 extern long double asinl (long double); 439 extern long double atan2l (long double, long double); 440 extern long double coshl (long double); 441 extern long double sinhl (long double); 442 extern long double expl (long double); 443 extern long double ldexpl (long double, int); 444 extern long double logl (long double); 445 extern long double log10l (long double); 446 extern long double powl (long double, long double); 447 extern long double sqrtl (long double); 448 extern long double fmodl (long double, long double); 449 extern long double hypotl (long double, long double); 450 #endif /* ! defined (__math_68881) */ 451 #endif /* ! defined (_REENT_ONLY) */ 452 extern long double copysignl (long double, long double); 453 extern long double nanl (const char *); 454 extern int ilogbl (long double); 455 extern long double asinhl (long double); 456 extern long double cbrtl (long double); 457 extern long double nextafterl (long double, long double); 458 extern float nexttowardf (float, long double); 459 extern double nexttoward (double, long double); 460 extern long double nexttowardl (long double, long double); 461 extern long double logbl (long double); 462 extern long double log2l (long double); 463 extern long double rintl (long double); 464 extern long double scalbnl (long double, int); 465 extern long double exp2l (long double); 466 extern long double scalblnl (long double, long); 467 extern long double tgammal (long double); 468 extern long double nearbyintl (long double); 469 extern long int lrintl (long double); 470 extern long long int llrintl (long double); 471 extern long double roundl (long double); 472 extern long lroundl (long double); 473 extern long long int llroundl (long double); 474 extern long double truncl (long double); 475 extern long double remquol (long double, long double, int *); 476 extern long double fdiml (long double, long double); 477 extern long double fmaxl (long double, long double); 478 extern long double fminl (long double, long double); 479 extern long double fmal (long double, long double, long double); 480 #ifndef _REENT_ONLY 481 extern long double acoshl (long double); 482 extern long double atanhl (long double); 483 extern long double remainderl (long double, long double); 484 extern long double lgammal (long double); 485 extern long double erfl (long double); 486 extern long double erfcl (long double); 487 #endif /* ! defined (_REENT_ONLY) */ 488 #else /* !_LDBL_EQ_DBL && !__CYGWIN__ */ 489 extern long double hypotl (long double, long double); 490 extern long double sqrtl (long double); 491 #ifdef __i386__ 492 /* Other long double precision functions. */ 493 extern _LONG_DOUBLE rintl (_LONG_DOUBLE); 494 extern long int lrintl (_LONG_DOUBLE); 495 extern long long int llrintl (_LONG_DOUBLE); 496 #endif /* __i386__ */ 497 #endif /* !_LDBL_EQ_DBL && !__CYGWIN__ */ 498 499 #endif /* __ISO_C_VISIBLE >= 1999 */ 500 501 #if __MISC_VISIBLE 502 extern double drem (double, double); 503 extern float dremf (float, float); 504 #ifdef __CYGWIN__ 505 extern float dreml (long double, long double); 506 #endif /* __CYGWIN__ */ 507 extern double gamma_r (double, int *); 508 extern double lgamma_r (double, int *); 509 extern float gammaf_r (float, int *); 510 extern float lgammaf_r (float, int *); 511 #endif 512 513 #if __MISC_VISIBLE || __XSI_VISIBLE 514 extern double y0 (double); 515 extern double y1 (double); 516 extern double yn (int, double); 517 extern double j0 (double); 518 extern double j1 (double); 519 extern double jn (int, double); 520 #endif 521 522 #if __MISC_VISIBLE || __XSI_VISIBLE >= 600 523 extern float y0f (float); 524 extern float y1f (float); 525 extern float ynf (int, float); 526 extern float j0f (float); 527 extern float j1f (float); 528 extern float jnf (int, float); 529 #endif 530 531 /* GNU extensions */ 532 #if __GNU_VISIBLE 533 extern void sincos (double, double *, double *); 534 extern void sincosf (float, float *, float *); 535 #ifdef __CYGWIN__ 536 extern void sincosl (long double, long double *, long double *); 537 #endif /* __CYGWIN__ */ 538 # ifndef exp10 539 extern double exp10 (double); 540 # endif 541 # ifndef pow10 542 extern double pow10 (double); 543 # endif 544 # ifndef exp10f 545 extern float exp10f (float); 546 # endif 547 # ifndef pow10f 548 extern float pow10f (float); 549 # endif 550 #ifdef __CYGWIN__ 551 # ifndef exp10l 552 extern float exp10l (float); 553 # endif 554 # ifndef pow10l 555 extern float pow10l (float); 556 # endif 557 #endif /* __CYGWIN__ */ 558 #endif /* __GNU_VISIBLE */ 559 560 #if __MISC_VISIBLE || __XSI_VISIBLE 561 extern NEWLIB_THREAD_LOCAL int signgam; 562 #endif /* __MISC_VISIBLE || __XSI_VISIBLE */ 563 564 /* Useful constants. */ 565 566 #if __BSD_VISIBLE || __XSI_VISIBLE 567 568 #define MAXFLOAT 3.40282347e+38F 569 570 #define M_E 2.7182818284590452354 571 #define M_LOG2E 1.4426950408889634074 572 #define M_LOG10E 0.43429448190325182765 573 #define M_LN2 _M_LN2 574 #define M_LN10 2.30258509299404568402 575 #define M_PI 3.14159265358979323846 576 #define M_PI_2 1.57079632679489661923 577 #define M_PI_4 0.78539816339744830962 578 #define M_1_PI 0.31830988618379067154 579 #define M_2_PI 0.63661977236758134308 580 #define M_2_SQRTPI 1.12837916709551257390 581 #define M_SQRT2 1.41421356237309504880 582 #define M_SQRT1_2 0.70710678118654752440 583 584 #endif 585 586 #if __BSD_VISIBLE 587 588 #define M_TWOPI (M_PI * 2.0) 589 #define M_3PI_4 2.3561944901923448370E0 590 #define M_SQRTPI 1.77245385090551602792981 591 #define M_LN2LO 1.9082149292705877000E-10 592 #define M_LN2HI 6.9314718036912381649E-1 593 #define M_SQRT3 1.73205080756887719000 594 #define M_IVLN10 0.43429448190325182765 /* 1 / log(10) */ 595 #define M_LOG2_E _M_LN2 596 #define M_INVLN2 1.4426950408889633870E0 /* 1 / log(2) */ 597 598 /* Global control over fdlibm error handling. */ 599 600 enum __fdlibm_version 601 { 602 __fdlibm_ieee = -1, 603 __fdlibm_posix 604 }; 605 606 #define _LIB_VERSION_TYPE enum __fdlibm_version 607 #define _LIB_VERSION __fdlib_version 608 609 extern __IMPORT _LIB_VERSION_TYPE _LIB_VERSION; 610 611 #define _IEEE_ __fdlibm_ieee 612 #define _POSIX_ __fdlibm_posix 613 614 #endif /* __BSD_VISIBLE */ 615 616 _END_STD_C 617 618 #ifdef __FAST_MATH__ 619 #include <machine/fastmath.h> 620 #endif 621 622 #endif /* _MATH_H_ */ 623