include/math.h

   1 /*
   2  * math.h
   3  * This file has no copyright assigned and is placed in the Public Domain.
   4  * This file is a part of the mingw-runtime package.
   5  * No warranty is given; refer to the file DISCLAIMER within the package.
   6  *
   7  * Mathematical functions.
   8  *
   9  */
  10
  11
  12 #ifndef _MATH_H_
  13 #define _MATH_H_
  14
  15 #if __GNUC__ >= 3
  16 #pragma GCC system_header
  17 #endif
  18
  19 /* All the headers include this file. */
  20 #include <_mingw.h>
  21
  22 /*
  23  * Types for the _exception structure.
  24  */
  25
  26 #define _DOMAIN         1       /* domain error in argument */
  27 #define _SING           2       /* singularity */
  28 #define _OVERFLOW       3       /* range overflow */
  29 #define _UNDERFLOW      4       /* range underflow */
  30 #define _TLOSS          5       /* total loss of precision */
  31 #define _PLOSS          6       /* partial loss of precision */
  32
  33 /*
  34  * Exception types with non-ANSI names for compatibility.
  35  */
  36
  37 #ifndef __STRICT_ANSI__
  38 #ifndef _NO_OLDNAMES
  39
  40 #define DOMAIN          _DOMAIN
  41 #define SING            _SING
  42 #define OVERFLOW        _OVERFLOW
  43 #define UNDERFLOW       _UNDERFLOW
  44 #define TLOSS           _TLOSS
  45 #define PLOSS           _PLOSS
  46
  47 #endif  /* Not _NO_OLDNAMES */
  48 #endif  /* Not __STRICT_ANSI__ */
  49
  50
  51 /* Traditional/XOPEN math constants (double precison) */
  52 #ifndef __STRICT_ANSI__
  53 #define M_E             2.7182818284590452354
  54 #define M_LOG2E         1.4426950408889634074
  55 #define M_LOG10E        0.43429448190325182765
  56 #define M_LN2           0.69314718055994530942
  57 #define M_LN10          2.30258509299404568402
  58 #define M_PI            3.14159265358979323846
  59 #define M_PI_2          1.57079632679489661923
  60 #define M_PI_4          0.78539816339744830962
  61 #define M_1_PI          0.31830988618379067154
  62 #define M_2_PI          0.63661977236758134308
  63 #define M_2_SQRTPI      1.12837916709551257390
  64 #define M_SQRT2         1.41421356237309504880
  65 #define M_SQRT1_2       0.70710678118654752440
  66 #endif
  67
  68 /* These are also defined in Mingw float.h; needed here as well to work
  69    around GCC build issues.  */
  70 #ifndef __STRICT_ANSI__
  71 #ifndef __MINGW_FPCLASS_DEFINED
  72 #define __MINGW_FPCLASS_DEFINED 1
  73 /* IEEE 754 classication */
  74 #define _FPCLASS_SNAN   0x0001  /* Signaling "Not a Number" */
  75 #define _FPCLASS_QNAN   0x0002  /* Quiet "Not a Number" */
  76 #define _FPCLASS_NINF   0x0004  /* Negative Infinity */
  77 #define _FPCLASS_NN     0x0008  /* Negative Normal */
  78 #define _FPCLASS_ND     0x0010  /* Negative Denormal */
  79 #define _FPCLASS_NZ     0x0020  /* Negative Zero */
  80 #define _FPCLASS_PZ     0x0040  /* Positive Zero */
  81 #define _FPCLASS_PD     0x0080  /* Positive Denormal */
  82 #define _FPCLASS_PN     0x0100  /* Positive Normal */
  83 #define _FPCLASS_PINF   0x0200  /* Positive Infinity */
  84 #endif /* __MINGW_FPCLASS_DEFINED */
  85 #endif  /* Not __STRICT_ANSI__ */
  86
  87 #ifndef RC_INVOKED
  88
  89 #ifdef __cplusplus
  90 extern "C" {
  91 #endif
  92
  93 /*
  94  * HUGE_VAL is returned by strtod when the value would overflow the
  95  * representation of 'double'. There are other uses as well.
  96  *
  97  * __imp__HUGE is a pointer to the actual variable _HUGE in
  98  * MSVCRT.DLL. If we used _HUGE directly we would get a pointer
  99  * to a thunk function.
 100  *
 101  * NOTE: The CRTDLL version uses _HUGE_dll instead.
 102  */
 103
 104 #if __MINGW_GNUC_PREREQ(3, 3)
 105 #define HUGE_VAL __builtin_huge_val()
 106 #else
 107
 108 #ifndef __DECLSPEC_SUPPORTED
 109
 110 #ifdef __MSVCRT__
 111 extern double*  _imp___HUGE;
 112 #define HUGE_VAL        (*_imp___HUGE)
 113 #else
 114 /* CRTDLL */
 115 extern double*  _imp___HUGE_dll;
 116 #define HUGE_VAL        (*_imp___HUGE_dll)
 117 #endif
 118
 119 #else /* __DECLSPEC_SUPPORTED */
 120
 121 #ifdef __MSVCRT__
 122 __MINGW_IMPORT double   _HUGE;
 123 #define HUGE_VAL        _HUGE
 124 #else
 125 /* CRTDLL */
 126 __MINGW_IMPORT double   _HUGE_dll;
 127 #define HUGE_VAL        _HUGE_dll
 128 #endif
 129
 130 #endif /* __DECLSPEC_SUPPORTED */
 131 #endif /* __MINGW_GNUC_PREREQ(3, 3) */
 132
 133
 134 struct _exception
 135 {
 136         int     type;
 137         char    *name;
 138         double  arg1;
 139         double  arg2;
 140         double  retval;
 141 };
 142
 143 _CRTIMP double __cdecl sin (double);
 144 _CRTIMP double __cdecl cos (double);
 145 _CRTIMP double __cdecl tan (double);
 146 _CRTIMP double __cdecl sinh (double);
 147 _CRTIMP double __cdecl cosh (double);
 148 _CRTIMP double __cdecl tanh (double);
 149 _CRTIMP double __cdecl asin (double);
 150 _CRTIMP double __cdecl acos (double);
 151 _CRTIMP double __cdecl atan (double);
 152 _CRTIMP double __cdecl atan2 (double, double);
 153 _CRTIMP double __cdecl exp (double);
 154 _CRTIMP double __cdecl log (double);
 155 _CRTIMP double __cdecl log10 (double);
 156 _CRTIMP double __cdecl pow (double, double);
 157 _CRTIMP double __cdecl sqrt (double);
 158 _CRTIMP double __cdecl ceil (double);
 159 _CRTIMP double __cdecl floor (double);
 160 _CRTIMP double __cdecl fabs (double);
 161 _CRTIMP double __cdecl ldexp (double, int);
 162 _CRTIMP double __cdecl frexp (double, int*);
 163 _CRTIMP double __cdecl modf (double, double*);
 164 _CRTIMP double __cdecl fmod (double, double);
 165
 166 /* Excess precision when using a 64-bit mantissa for FPU math ops can
 167    cause unexpected results with some of the MSVCRT math functions.  For
 168    example, unless the function return value is stored (truncating to
 169    53-bit mantissa), calls to pow with both x and y as integral values
 170    sometimes produce a non-integral result.
 171    One workaround is to reset the FPU env to 53-bit mantissa
 172    by a call to fesetenv (FE_PC53_ENV).  Amother is to force storage
 173    of the return value of individual math functions using wrappers.
 174    NB, using these wrappers will disable builtin math functions and
 175    hence disable the folding of function results at compile time when
 176    arguments are constant.  */
 177
 178 #if 0
 179 #define __DEFINE_FLOAT_STORE_MATHFN_D1(fn1)     \
 180 static __inline__ double                        \
 181 __float_store_ ## fn1 (double x)                \
 182 {                                               \
 183    __volatile__ double res = (fn1) (x);         \
 184   return res;                                   \
 185 }
 186
 187 #define __DEFINE_FLOAT_STORE_MATHFN_D2(fn2)     \
 188 static __inline__ double                        \
 189 __float_store_ ## fn2 (double x, double y)      \
 190 {                                               \
 191   __volatile__ double res = (fn2) (x, y);       \
 192   return res;                                   \
 193 }
 194 #endif
 195
 196 /* For example, here is how to force the result of the pow function
 197    to be stored:   */
 198 #if 0
 199 #undef pow
 200 /* Define the ___float_store_pow function and use it instead of pow().  */
 201 __DEFINE_FLOAT_STORE_MATHFN_D2 (pow)
 202 #define pow __float_store_pow
 203 #endif
 204
 205 #ifndef __STRICT_ANSI__
 206
 207 /* Complex number (for _cabs). This is the MS version. The ISO
 208    C99 counterpart _Complex is an intrinsic type in GCC and
 209    'complex' is defined as a macro.  See complex.h  */
 210 struct _complex
 211 {
 212         double  x;      /* Real part */
 213         double  y;      /* Imaginary part */
 214 };
 215
 216 _CRTIMP double __cdecl _cabs (struct _complex);
 217
 218 _CRTIMP double __cdecl _hypot (double, double);
 219 _CRTIMP double __cdecl _j0 (double);
 220 _CRTIMP double __cdecl _j1 (double);
 221 _CRTIMP double __cdecl _jn (int, double);
 222 _CRTIMP double __cdecl _y0 (double);
 223 _CRTIMP double __cdecl _y1 (double);
 224 _CRTIMP double __cdecl _yn (int, double);
 225 _CRTIMP int __cdecl _matherr (struct _exception *);
 226
 227 /* These are also declared in Mingw float.h; needed here as well to work
 228    around GCC build issues.  */
 229 /* BEGIN FLOAT.H COPY */
 230 /*
 231  * IEEE recommended functions
 232  */
 233
 234 _CRTIMP double __cdecl _chgsign (double);
 235 _CRTIMP double __cdecl _copysign (double, double);
 236 _CRTIMP double __cdecl _logb (double);
 237 _CRTIMP double __cdecl _nextafter (double, double);
 238 _CRTIMP double __cdecl _scalb (double, long);
 239
 240 _CRTIMP int __cdecl _finite (double);
 241 _CRTIMP int __cdecl _fpclass (double);
 242 _CRTIMP int __cdecl _isnan (double);
 243
 244 /* END FLOAT.H COPY */
 245
 246
 247 /*
 248  * Non-underscored versions of non-ANSI functions.
 249  * These reside in liboldnames.a.
 250  */
 251
 252 #if !defined (_NO_OLDNAMES)
 253
 254 _CRTIMP double __cdecl j0 (double);
 255 _CRTIMP double __cdecl j1 (double);
 256 _CRTIMP double __cdecl jn (int, double);
 257 _CRTIMP double __cdecl y0 (double);
 258 _CRTIMP double __cdecl y1 (double);
 259 _CRTIMP double __cdecl yn (int, double);
 260
 261 _CRTIMP double __cdecl chgsign (double);
 262 /*
 263  * scalb() is a GCC built-in.
 264  * Exclude this _scalb() stub; the semantics are incompatible
 265  * with the built-in implementation.
 266  *
 267 _CRTIMP double __cdecl scalb (double, long);
 268  *
 269  */
 270 _CRTIMP int __cdecl finite (double);
 271 _CRTIMP int __cdecl fpclass (double);
 272
 273 #define FP_SNAN    _FPCLASS_SNAN
 274 #define FP_QNAN    _FPCLASS_QNAN
 275 #define FP_NINF    _FPCLASS_NINF
 276 #define FP_PINF    _FPCLASS_PINF
 277 #define FP_NDENORM _FPCLASS_ND
 278 #define FP_PDENORM _FPCLASS_PD
 279 #define FP_NZERO   _FPCLASS_NZ
 280 #define FP_PZERO   _FPCLASS_PZ
 281 #define FP_NNORM   _FPCLASS_NN
 282 #define FP_PNORM   _FPCLASS_PN
 283
 284 #endif /* Not _NO_OLDNAMES */
 285
 286 /* This require msvcr70.dll or higher. */
 287 #if __MSVCRT_VERSION__ >= 0x0700
 288 _CRTIMP int __cdecl _set_SSE2_enable (int);
 289 #endif /* __MSVCRT_VERSION__ >= 0x0700 */
 290
 291
 292 #endif /* __STRICT_ANSI__ */
 293
 294
 295 #ifndef __NO_ISOCEXT
 296 #if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) \
 297         || !defined __STRICT_ANSI__ || defined __cplusplus
 298
 299 #if __MINGW_GNUC_PREREQ(3, 3)
 300 #define HUGE_VALF       __builtin_huge_valf()
 301 #define HUGE_VALL       __builtin_huge_vall()
 302 #define INFINITY        __builtin_inf()
 303 #define NAN             __builtin_nan("")
 304 #else
 305 extern const float __INFF;
 306 #define HUGE_VALF __INFF
 307 extern const long double  __INFL;
 308 #define HUGE_VALL __INFL
 309 #define INFINITY HUGE_VALF
 310 extern const double __QNAN;
 311 #define NAN __QNAN
 312 #endif /* __MINGW_GNUC_PREREQ(3, 3) */
 313
 314 /* Use the compiler's builtin define for FLT_EVAL_METHOD to
 315    set float_t and double_t.  */
 316 #if defined(__FLT_EVAL_METHOD__)
 317 # if ( __FLT_EVAL_METHOD__== 0)
 318 typedef float float_t;
 319 typedef double double_t;
 320 # elif (__FLT_EVAL_METHOD__ == 1)
 321 typedef double float_t;
 322 typedef double double_t;
 323 # elif (__FLT_EVAL_METHOD__ == 2)
 324 typedef long double float_t;
 325 typedef long double double_t;
 326 #endif
 327 #else /* ix87 FPU default */
 328 typedef long double float_t;
 329 typedef long double double_t;
 330 #endif
 331
 332 /* 7.12.3.1 */
 333 /*
 334    Return values for fpclassify.
 335    These are based on Intel x87 fpu condition codes
 336    in the high byte of status word and differ from
 337    the return values for MS IEEE 754 extension _fpclass()
 338 */
 339 #define FP_NAN          0x0100
 340 #define FP_NORMAL       0x0400
 341 #define FP_INFINITE     (FP_NAN | FP_NORMAL)
 342 #define FP_ZERO         0x4000
 343 #define FP_SUBNORMAL    (FP_NORMAL | FP_ZERO)
 344 /* 0x0200 is signbit mask */
 345
 346
 347 /*
 348   We can't inline float or double, because we want to ensure truncation
 349   to semantic type before classification.
 350   (A normal long double value might become subnormal when
 351   converted to double, and zero when converted to float.)
 352 */
 353
 354 extern int __cdecl __fpclassifyf (float);
 355 extern int __cdecl __fpclassify (double);
 356 extern int __cdecl __fpclassifyl (long double);
 357
 358 #ifndef __NO_INLINE__
 359 __CRT_INLINE int __cdecl __fpclassifyl (long double x){
 360   unsigned short sw;
 361   __asm__ ("fxam; fstsw %%ax;" : "=a" (sw): "t" (x));
 362   return sw & (FP_NAN | FP_NORMAL | FP_ZERO );
 363 }
 364 #endif
 365
 366 #define fpclassify(x) (sizeof (x) == sizeof (float) ? __fpclassifyf (x)   \
 367                        : sizeof (x) == sizeof (double) ? __fpclassify (x) \
 368                        : __fpclassifyl (x))
 369
 370 /* 7.12.3.2 */
 371 #define isfinite(x) ((fpclassify(x) & FP_NAN) == 0)
 372
 373 /* 7.12.3.3 */
 374 #define isinf(x) (fpclassify(x) == FP_INFINITE)
 375
 376 /* 7.12.3.4 */
 377 /* We don't need to worry about truncation here:
 378    A NaN stays a NaN. */
 379 extern int __cdecl __isnan (double);
 380 extern int __cdecl __isnanf (float);
 381 extern int __cdecl __isnanl (long double);
 382 #ifndef __NO_INLINE__
 383 __CRT_INLINE int __cdecl __isnan (double _x)
 384 {
 385   unsigned short sw;
 386   __asm__ ("fxam;"
 387            "fstsw %%ax": "=a" (sw) : "t" (_x));
 388   return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
 389     == FP_NAN;
 390 }
 391
 392 __CRT_INLINE int __cdecl __isnanf (float _x)
 393 {
 394   unsigned short sw;
 395   __asm__ ("fxam;"
 396             "fstsw %%ax": "=a" (sw) : "t" (_x));
 397   return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
 398     == FP_NAN;
 399 }
 400
 401 __CRT_INLINE int __cdecl __isnanl (long double _x)
 402 {
 403   unsigned short sw;
 404   __asm__ ("fxam;"
 405             "fstsw %%ax": "=a" (sw) : "t" (_x));
 406   return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
 407     == FP_NAN;
 408 }
 409 #endif
 410
 411 #define isnan(x) (sizeof (x) == sizeof (float) ? __isnanf (x)   \
 412                   : sizeof (x) == sizeof (double) ? __isnan (x) \
 413                   : __isnanl (x))
 414
 415 /* 7.12.3.5 */
 416 #define isnormal(x) (fpclassify(x) == FP_NORMAL)
 417
 418 /* 7.12.3.6 The signbit macro */
 419 extern int __cdecl __signbit (double);
 420 extern int __cdecl __signbitf (float);
 421 extern int __cdecl __signbitl (long double);
 422 #ifndef __NO_INLINE__
 423 __CRT_INLINE int __cdecl __signbit (double x) {
 424   unsigned short stw;
 425   __asm__ ( "fxam; fstsw %%ax;": "=a" (stw) : "t" (x));
 426   return (stw & 0x0200) != 0;
 427 }
 428
 429 __CRT_INLINE int __cdecl __signbitf (float x) {
 430   unsigned short stw;
 431   __asm__ ("fxam; fstsw %%ax;": "=a" (stw) : "t" (x));
 432   return (stw & 0x0200) != 0;
 433 }
 434
 435 __CRT_INLINE int __cdecl __signbitl (long double x) {
 436   unsigned short stw;
 437   __asm__ ("fxam; fstsw %%ax;": "=a" (stw) : "t" (x));
 438   return (stw & 0x0200) != 0;
 439 }
 440 #endif
 441
 442 #define signbit(x) (sizeof (x) == sizeof (float) ? __signbitf (x)       \
 443                     : sizeof (x) == sizeof (double) ? __signbit (x)     \
 444                     : __signbitl (x))
 445
 446 /* 7.12.4 Trigonometric functions: Double in C89 */
 447 extern float __cdecl sinf (float);
 448 extern long double __cdecl sinl (long double);
 449
 450 extern float __cdecl cosf (float);
 451 extern long double __cdecl cosl (long double);
 452
 453 extern float __cdecl tanf (float);
 454 extern long double __cdecl tanl (long double);
 455
 456 extern float __cdecl asinf (float);
 457 extern long double __cdecl asinl (long double);
 458
 459 extern float __cdecl acosf (float);
 460 extern long double __cdecl acosl (long double);
 461
 462 extern float __cdecl atanf (float);
 463 extern long double __cdecl atanl (long double);
 464
 465 extern float __cdecl atan2f (float, float);
 466 extern long double __cdecl atan2l (long double, long double);
 467
 468 /* 7.12.5 Hyperbolic functions: Double in C89  */
 469 extern float __cdecl sinhf (float);
 470 #ifndef __NO_INLINE__
 471 __CRT_INLINE float __cdecl sinhf (float x)
 472   {return (float) sinh (x);}
 473 #endif
 474 extern long double __cdecl sinhl (long double);
 475
 476 extern float __cdecl coshf (float);
 477 #ifndef __NO_INLINE__
 478 __CRT_INLINE float __cdecl coshf (float x)
 479   {return (float) cosh (x);}
 480 #endif
 481 extern long double __cdecl coshl (long double);
 482
 483 extern float __cdecl tanhf (float);
 484 #ifndef __NO_INLINE__
 485 __CRT_INLINE float __cdecl tanhf (float x)
 486   {return (float) tanh (x);}
 487 #endif
 488 extern long double __cdecl tanhl (long double);
 489
 490 /* Inverse hyperbolic trig functions  */
 491 /* 7.12.5.1 */
 492 extern double __cdecl acosh (double);
 493 extern float __cdecl acoshf (float);
 494 extern long double __cdecl acoshl (long double);
 495
 496 /* 7.12.5.2 */
 497 extern double __cdecl asinh (double);
 498 extern float __cdecl asinhf (float);
 499 extern long double __cdecl asinhl (long double);
 500
 501 /* 7.12.5.3 */
 502 extern double __cdecl atanh (double);
 503 extern float __cdecl atanhf  (float);
 504 extern long double __cdecl atanhl (long double);
 505
 506 /* Exponentials and logarithms  */
 507 /* 7.12.6.1 Double in C89 */
 508 extern float __cdecl expf (float);
 509 #ifndef __NO_INLINE__
 510 __CRT_INLINE float __cdecl expf (float x)
 511   {return (float) exp (x);}
 512 #endif
 513 extern long double __cdecl expl (long double);
 514
 515 /* 7.12.6.2 */
 516 extern double __cdecl exp2(double);
 517 extern float __cdecl exp2f(float);
 518 extern long double __cdecl exp2l(long double);
 519
 520 /* 7.12.6.3 The expm1 functions */
 521 /* TODO: These could be inlined */
 522 extern double __cdecl expm1(double);
 523 extern float __cdecl expm1f(float);
 524 extern long double __cdecl expm1l(long double);
 525
 526 /* 7.12.6.4 Double in C89 */
 527 extern float __cdecl frexpf (float, int*);
 528 #ifndef __NO_INLINE__
 529 __CRT_INLINE float __cdecl frexpf (float x, int* expn)
 530   {return (float) frexp (x, expn);}
 531 #endif
 532 extern long double __cdecl frexpl (long double, int*);
 533
 534 /* 7.12.6.5 */
 535 #define FP_ILOGB0 ((int)0x80000000)
 536 #define FP_ILOGBNAN ((int)0x80000000)
 537 extern int __cdecl ilogb (double);
 538 extern int __cdecl ilogbf (float);
 539 extern int __cdecl ilogbl (long double);
 540
 541 /* 7.12.6.6  Double in C89 */
 542 extern float __cdecl ldexpf (float, int);
 543 #ifndef __NO_INLINE__
 544 __CRT_INLINE float __cdecl ldexpf (float x, int expn)
 545   {return (float) ldexp (x, expn);}
 546 #endif
 547 extern long double __cdecl ldexpl (long double, int);
 548
 549 /* 7.12.6.7 Double in C89 */
 550 extern float __cdecl logf (float);
 551 extern long double __cdecl logl (long double);
 552
 553 /* 7.12.6.8 Double in C89 */
 554 extern float __cdecl log10f (float);
 555 extern long double __cdecl log10l (long double);
 556
 557 /* 7.12.6.9 */
 558 extern double __cdecl log1p(double);
 559 extern float __cdecl log1pf(float);
 560 extern long double __cdecl log1pl(long double);
 561
 562 /* 7.12.6.10 */
 563 extern double __cdecl log2 (double);
 564 extern float __cdecl log2f (float);
 565 extern long double __cdecl log2l (long double);
 566
 567 /* 7.12.6.11 */
 568 extern double __cdecl logb (double);
 569 extern float __cdecl logbf (float);
 570 extern long double __cdecl logbl (long double);
 571
 572 /* Inline versions.  GCC-4.0+ can do a better fast-math optimization
 573    with __builtins. */
 574 #ifndef __NO_INLINE__
 575 #if !(__MINGW_GNUC_PREREQ (4, 0) && defined __FAST_MATH__ )
 576 __CRT_INLINE double __cdecl logb (double x)
 577 {
 578   double res;
 579   __asm__ ("fxtract\n\t"
 580        "fstp    %%st" : "=t" (res) : "0" (x));
 581   return res;
 582 }
 583
 584 __CRT_INLINE float __cdecl logbf (float x)
 585 {
 586   float res;
 587   __asm__ ("fxtract\n\t"
 588        "fstp    %%st" : "=t" (res) : "0" (x));
 589   return res;
 590 }
 591
 592 __CRT_INLINE long double __cdecl logbl (long double x)
 593 {
 594   long double res;
 595   __asm__ ("fxtract\n\t"
 596        "fstp    %%st" : "=t" (res) : "0" (x));
 597   return res;
 598 }
 599 #endif /* !defined __FAST_MATH__ || !__MINGW_GNUC_PREREQ (4, 0) */
 600 #endif /* !defined __NO_INLINE__ */
 601
 602 /* 7.12.6.12  Double in C89 */
 603 extern float __cdecl modff (float, float*);
 604 extern long double __cdecl modfl (long double, long double*);
 605
 606 /* 7.12.6.13 */
 607 extern double __cdecl scalbn (double, int);
 608 extern float __cdecl scalbnf (float, int);
 609 extern long double __cdecl scalbnl (long double, int);
 610
 611 extern double __cdecl scalbln (double, long);
 612 extern float __cdecl scalblnf (float, long);
 613 extern long double __cdecl scalblnl (long double, long);
 614
 615 /* 7.12.7.1 */
 616 /* Implementations adapted from Cephes versions */
 617 extern double __cdecl cbrt (double);
 618 extern float __cdecl cbrtf (float);
 619 extern long double __cdecl cbrtl (long double);
 620
 621 /* 7.12.7.2 The fabs functions: Double in C89 */
 622 extern  float __cdecl fabsf (float x);
 623 extern long double __cdecl fabsl (long double x);
 624
 625 /* 7.12.7.3  */
 626 extern double __cdecl hypot (double, double); /* in libmoldname.a */
 627 extern float __cdecl hypotf (float, float);
 628 #ifndef __NO_INLINE__
 629 __CRT_INLINE float __cdecl hypotf (float x, float y)
 630   { return (float) hypot (x, y);}
 631 #endif
 632 extern long double __cdecl hypotl (long double, long double);
 633
 634 /* 7.12.7.4 The pow functions. Double in C89 */
 635 extern float __cdecl powf (float, float);
 636 #ifndef __NO_INLINE__
 637 __CRT_INLINE float __cdecl powf (float x, float y)
 638   {return (float) pow (x, y);}
 639 #endif
 640 extern long double __cdecl powl (long double, long double);
 641
 642 /* 7.12.7.5 The sqrt functions. Double in C89. */
 643 extern float __cdecl sqrtf (float);
 644 extern long double __cdecl sqrtl (long double);
 645
 646 /* 7.12.8.1 The erf functions  */
 647 extern double __cdecl erf (double);
 648 extern float __cdecl erff (float);
 649 extern long double __cdecl erfl (long double);
 650
 651 /* 7.12.8.2 The erfc functions  */
 652 extern double __cdecl erfc (double);
 653 extern float __cdecl erfcf (float);
 654 extern long double __cdecl erfcl (long double);
 655
 656 /* 7.12.8.3 The lgamma functions */
 657 extern double __cdecl lgamma (double);
 658 extern float __cdecl lgammaf (float);
 659 extern long double __cdecl lgammal (long double);
 660
 661 /* 7.12.8.4 The tgamma functions */
 662 extern double __cdecl tgamma (double);
 663 extern float __cdecl tgammaf (float);
 664 extern long double __cdecl tgammal (long double);
 665
 666 /* 7.12.9.1 Double in C89 */
 667 extern float __cdecl ceilf (float);
 668 extern long double __cdecl ceill (long double);
 669
 670 /* 7.12.9.2 Double in C89 */
 671 extern float __cdecl floorf (float);
 672 extern long double __cdecl floorl (long double);
 673
 674 /* 7.12.9.3 */
 675 extern double __cdecl nearbyint ( double);
 676 extern float __cdecl nearbyintf (float);
 677 extern long double __cdecl nearbyintl (long double);
 678
 679 /* 7.12.9.4 */
 680 /* round, using fpu control word settings */
 681 extern double __cdecl rint (double);
 682 extern float __cdecl rintf (float);
 683 extern long double __cdecl rintl (long double);
 684
 685 /* 7.12.9.5 */
 686 extern long __cdecl lrint (double);
 687 extern long __cdecl lrintf (float);
 688 extern long __cdecl lrintl (long double);
 689
 690 extern long long __cdecl llrint (double);
 691 extern long long __cdecl llrintf (float);
 692 extern long long __cdecl llrintl (long double);
 693
 694 /* Inline versions of above.
 695    GCC 4.0+ can do a better fast-math job with __builtins. */
 696 #ifndef __NO_INLINE__
 697 #if !(__MINGW_GNUC_PREREQ (4, 0) && defined __FAST_MATH__ )
 698 __CRT_INLINE double __cdecl rint (double x)
 699 {
 700   double retval;
 701   __asm__ ("frndint;": "=t" (retval) : "0" (x));
 702   return retval;
 703 }
 704
 705 __CRT_INLINE float __cdecl rintf (float x)
 706 {
 707   float retval;
 708   __asm__ ("frndint;" : "=t" (retval) : "0" (x) );
 709   return retval;
 710 }
 711
 712 __CRT_INLINE long double __cdecl rintl (long double x)
 713 {
 714   long double retval;
 715   __asm__ ("frndint;" : "=t" (retval) : "0" (x) );
 716   return retval;
 717 }
 718
 719 __CRT_INLINE long __cdecl lrint (double x)
 720 {
 721   long retval;
 722   __asm__ __volatile__
 723     ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");
 724   return retval;
 725 }
 726
 727 __CRT_INLINE long __cdecl lrintf (float x)
 728 {
 729   long retval;
 730   __asm__ __volatile__
 731     ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");
 732   return retval;
 733 }
 734
 735 __CRT_INLINE long __cdecl lrintl (long double x)
 736 {
 737   long retval;
 738   __asm__ __volatile__
 739     ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");
 740   return retval;
 741 }
 742
 743 __CRT_INLINE long long __cdecl llrint (double x)
 744 {
 745   long long retval;
 746   __asm__ __volatile__
 747     ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");
 748   return retval;
 749 }
 750
 751 __CRT_INLINE long long __cdecl llrintf (float x)
 752 {
 753   long long retval;
 754   __asm__ __volatile__
 755     ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");
 756   return retval;
 757 }
 758
 759 __CRT_INLINE long long __cdecl llrintl (long double x)
 760 {
 761   long long retval;
 762   __asm__ __volatile__
 763     ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");
 764   return retval;
 765 }
 766 #endif /* !__FAST_MATH__ || !__MINGW_GNUC_PREREQ (4,0)  */
 767 #endif /* !defined __NO_INLINE */
 768
 769 /* 7.12.9.6 */
 770 /* round away from zero, regardless of fpu control word settings */
 771 extern double __cdecl round (double);
 772 extern float __cdecl roundf (float);
 773 extern long double __cdecl roundl (long double);
 774
 775 /* 7.12.9.7  */
 776 extern long __cdecl lround (double);
 777 extern long __cdecl lroundf (float);
 778 extern long __cdecl lroundl (long double);
 779
 780 extern long long __cdecl llround (double);
 781 extern long long __cdecl llroundf (float);
 782 extern long long __cdecl llroundl (long double);
 783
 784 /* 7.12.9.8 */
 785 /* round towards zero, regardless of fpu control word settings */
 786 extern double __cdecl trunc (double);
 787 extern float __cdecl truncf (float);
 788 extern long double __cdecl truncl (long double);
 789
 790 /* 7.12.10.1 Double in C89 */
 791 extern float __cdecl fmodf (float, float);
 792 extern long double __cdecl fmodl (long double, long double);
 793
 794 /* 7.12.10.2 */
 795 extern double __cdecl remainder (double, double);
 796 extern float __cdecl remainderf (float, float);
 797 extern long double __cdecl remainderl (long double, long double);
 798
 799 /* 7.12.10.3 */
 800 extern double __cdecl remquo(double, double, int *);
 801 extern float __cdecl remquof(float, float, int *);
 802 extern long double __cdecl remquol(long double, long double, int *);
 803
 804 /* 7.12.11.1 */
 805 extern double __cdecl copysign (double, double); /* in libmoldname.a */
 806 extern float __cdecl copysignf (float, float);
 807 extern long double __cdecl copysignl (long double, long double);
 808
 809 /* 7.12.11.2 Return a NaN */
 810 extern double __cdecl nan(const char *tagp);
 811 extern float __cdecl nanf(const char *tagp);
 812 extern long double __cdecl nanl(const char *tagp);
 813
 814 #ifndef __STRICT_ANSI__
 815 #define _nan() nan("")
 816 #define _nanf() nanf("")
 817 #define _nanl() nanl("")
 818 #endif
 819
 820 /* 7.12.11.3 */
 821 extern double __cdecl nextafter (double, double); /* in libmoldname.a */
 822 extern float __cdecl nextafterf (float, float);
 823 extern long double __cdecl nextafterl (long double, long double);
 824
 825 /* 7.12.11.4 The nexttoward functions */
 826 extern double __cdecl nexttoward (double,  long double);
 827 extern float __cdecl nexttowardf (float,  long double);
 828 extern long double __cdecl nexttowardl (long double, long double);
 829
 830 /* 7.12.12.1 */
 831 /*  x > y ? (x - y) : 0.0  */
 832 extern double __cdecl fdim (double x, double y);
 833 extern float __cdecl fdimf (float x, float y);
 834 extern long double __cdecl fdiml (long double x, long double y);
 835
 836 /* fmax and fmin.
 837    NaN arguments are treated as missing data: if one argument is a NaN
 838    and the other numeric, then these functions choose the numeric
 839    value. */
 840
 841 /* 7.12.12.2 */
 842 extern double __cdecl fmax  (double, double);
 843 extern float __cdecl fmaxf (float, float);
 844 extern long double __cdecl fmaxl (long double, long double);
 845
 846 /* 7.12.12.3 */
 847 extern double __cdecl fmin (double, double);
 848 extern float __cdecl fminf (float, float);
 849 extern long double __cdecl fminl (long double, long double);
 850
 851 /* 7.12.13.1 */
 852 /* return x * y + z as a ternary op */
 853 extern double __cdecl fma (double, double, double);
 854 extern float __cdecl fmaf (float, float, float);
 855 extern long double __cdecl fmal (long double, long double, long double);
 856
 857
 858 /* 7.12.14 */
 859 /*
 860  *  With these functions, comparisons involving quiet NaNs set the FP
 861  *  condition code to "unordered".  The IEEE floating-point spec
 862  *  dictates that the result of floating-point comparisons should be
 863  *  false whenever a NaN is involved, with the exception of the != op,
 864  *  which always returns true: yes, (NaN != NaN) is true).
 865  */
 866
 867 #if __GNUC__ >= 3
 868
 869 #define isgreater(x, y) __builtin_isgreater(x, y)
 870 #define isgreaterequal(x, y) __builtin_isgreaterequal(x, y)
 871 #define isless(x, y) __builtin_isless(x, y)
 872 #define islessequal(x, y) __builtin_islessequal(x, y)
 873 #define islessgreater(x, y) __builtin_islessgreater(x, y)
 874 #define isunordered(x, y) __builtin_isunordered(x, y)
 875
 876 #else
 877 /*  helper  */
 878 extern int  __cdecl __fp_unordered_compare (long double, long double);
 879 #ifndef __NO_INLINE__
 880 __CRT_INLINE int  __cdecl
 881 __fp_unordered_compare (long double x, long double y){
 882   unsigned short retval;
 883   __asm__ ("fucom %%st(1);"
 884            "fnstsw;": "=a" (retval) : "t" (x), "u" (y));
 885   return retval;
 886 }
 887 #endif
 888
 889 #define isgreater(x, y) ((__fp_unordered_compare(x, y) \
 890                            & 0x4500) == 0)
 891 #define isless(x, y) ((__fp_unordered_compare (y, x) \
 892                        & 0x4500) == 0)
 893 #define isgreaterequal(x, y) ((__fp_unordered_compare (x, y) \
 894                                & FP_INFINITE) == 0)
 895 #define islessequal(x, y) ((__fp_unordered_compare(y, x) \
 896                             & FP_INFINITE) == 0)
 897 #define islessgreater(x, y) ((__fp_unordered_compare(x, y) \
 898                               & FP_SUBNORMAL) == 0)
 899 #define isunordered(x, y) ((__fp_unordered_compare(x, y) \
 900                             & 0x4500) == 0x4500)
 901
 902 #endif
 903
 904
 905 #endif /* __STDC_VERSION__ >= 199901L */
 906 #endif /* __NO_ISOCEXT */
 907
 908
 909 #ifdef __cplusplus
 910 }
 911 #endif
 912 #endif  /* Not RC_INVOKED */
 913
 914
 915 #endif  /* Not _MATH_H_ */