mingw/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
 357 __CRT_INLINE int __cdecl __fpclassifyl (long double x){
 358   unsigned short sw;
 359   __asm__ ("fxam; fstsw %%ax;" : "=a" (sw): "t" (x));
 360   return sw & (FP_NAN | FP_NORMAL | FP_ZERO );
 361 }
 362
 363 #define fpclassify(x) (sizeof (x) == sizeof (float) ? __fpclassifyf (x)   \
 364                        : sizeof (x) == sizeof (double) ? __fpclassify (x) \
 365                        : __fpclassifyl (x))
 366
 367 /* 7.12.3.2 */
 368 #define isfinite(x) ((fpclassify(x) & FP_NAN) == 0)
 369
 370 /* 7.12.3.3 */
 371 #define isinf(x) (fpclassify(x) == FP_INFINITE)
 372
 373 /* 7.12.3.4 */
 374 /* We don't need to worry about truncation here:
 375    A NaN stays a NaN. */
 376
 377 __CRT_INLINE int __cdecl __isnan (double _x)
 378 {
 379   unsigned short sw;
 380   __asm__ ("fxam;"
 381            "fstsw %%ax": "=a" (sw) : "t" (_x));
 382   return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
 383     == FP_NAN;
 384 }
 385
 386 __CRT_INLINE int __cdecl __isnanf (float _x)
 387 {
 388   unsigned short sw;
 389   __asm__ ("fxam;"
 390             "fstsw %%ax": "=a" (sw) : "t" (_x));
 391   return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
 392     == FP_NAN;
 393 }
 394
 395 __CRT_INLINE int __cdecl __isnanl (long double _x)
 396 {
 397   unsigned short sw;
 398   __asm__ ("fxam;"
 399             "fstsw %%ax": "=a" (sw) : "t" (_x));
 400   return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
 401     == FP_NAN;
 402 }
 403
 404
 405 #define isnan(x) (sizeof (x) == sizeof (float) ? __isnanf (x)   \
 406                   : sizeof (x) == sizeof (double) ? __isnan (x) \
 407                   : __isnanl (x))
 408
 409 /* 7.12.3.5 */
 410 #define isnormal(x) (fpclassify(x) == FP_NORMAL)
 411
 412 /* 7.12.3.6 The signbit macro */
 413 __CRT_INLINE int __cdecl __signbit (double x) {
 414   unsigned short stw;
 415   __asm__ ( "fxam; fstsw %%ax;": "=a" (stw) : "t" (x));
 416   return (stw & 0x0200) != 0;
 417 }
 418
 419 __CRT_INLINE int __cdecl __signbitf (float x) {
 420   unsigned short stw;
 421   __asm__ ("fxam; fstsw %%ax;": "=a" (stw) : "t" (x));
 422   return (stw & 0x0200) != 0;
 423 }
 424
 425 __CRT_INLINE int __cdecl __signbitl (long double x) {
 426   unsigned short stw;
 427   __asm__ ("fxam; fstsw %%ax;": "=a" (stw) : "t" (x));
 428   return (stw & 0x0200) != 0;
 429 }
 430
 431 #define signbit(x) (sizeof (x) == sizeof (float) ? __signbitf (x)       \
 432                     : sizeof (x) == sizeof (double) ? __signbit (x)     \
 433                     : __signbitl (x))
 434
 435 /* 7.12.4 Trigonometric functions: Double in C89 */
 436 extern float __cdecl sinf (float);
 437 extern long double __cdecl sinl (long double);
 438
 439 extern float __cdecl cosf (float);
 440 extern long double __cdecl cosl (long double);
 441
 442 extern float __cdecl tanf (float);
 443 extern long double __cdecl tanl (long double);
 444
 445 extern float __cdecl asinf (float);
 446 extern long double __cdecl asinl (long double);
 447
 448 extern float __cdecl acosf (float);
 449 extern long double __cdecl acosl (long double);
 450
 451 extern float __cdecl atanf (float);
 452 extern long double __cdecl atanl (long double);
 453
 454 extern float __cdecl atan2f (float, float);
 455 extern long double __cdecl atan2l (long double, long double);
 456
 457 /* 7.12.5 Hyperbolic functions: Double in C89  */
 458 __CRT_INLINE float __cdecl sinhf (float x)
 459   {return (float) sinh (x);}
 460 extern long double __cdecl sinhl (long double);
 461
 462 __CRT_INLINE float __cdecl coshf (float x)
 463   {return (float) cosh (x);}
 464 extern long double __cdecl coshl (long double);
 465
 466 __CRT_INLINE float __cdecl tanhf (float x)
 467   {return (float) tanh (x);}
 468 extern long double __cdecl tanhl (long double);
 469
 470 /* Inverse hyperbolic trig functions  */
 471 /* 7.12.5.1 */
 472 extern double __cdecl acosh (double);
 473 extern float __cdecl acoshf (float);
 474 extern long double __cdecl acoshl (long double);
 475
 476 /* 7.12.5.2 */
 477 extern double __cdecl asinh (double);
 478 extern float __cdecl asinhf (float);
 479 extern long double __cdecl asinhl (long double);
 480
 481 /* 7.12.5.3 */
 482 extern double __cdecl atanh (double);
 483 extern float __cdecl atanhf  (float);
 484 extern long double __cdecl atanhl (long double);
 485
 486 /* Exponentials and logarithms  */
 487 /* 7.12.6.1 Double in C89 */
 488 __CRT_INLINE float __cdecl expf (float x)
 489   {return (float) exp (x);}
 490 extern long double __cdecl expl (long double);
 491
 492 /* 7.12.6.2 */
 493 extern double __cdecl exp2(double);
 494 extern float __cdecl exp2f(float);
 495 extern long double __cdecl exp2l(long double);
 496
 497 /* 7.12.6.3 The expm1 functions */
 498 /* TODO: These could be inlined */
 499 extern double __cdecl expm1(double);
 500 extern float __cdecl expm1f(float);
 501 extern long double __cdecl expm1l(long double);
 502
 503 /* 7.12.6.4 Double in C89 */
 504 __CRT_INLINE float __cdecl frexpf (float x, int* expn)
 505   {return (float) frexp (x, expn);}
 506 extern long double __cdecl frexpl (long double, int*);
 507
 508 /* 7.12.6.5 */
 509 #define FP_ILOGB0 ((int)0x80000000)
 510 #define FP_ILOGBNAN ((int)0x80000000)
 511 extern int __cdecl ilogb (double);
 512 extern int __cdecl ilogbf (float);
 513 extern int __cdecl ilogbl (long double);
 514
 515 /* 7.12.6.6  Double in C89 */
 516 __CRT_INLINE float __cdecl ldexpf (float x, int expn)
 517   {return (float) ldexp (x, expn);}
 518 extern long double __cdecl ldexpl (long double, int);
 519
 520 /* 7.12.6.7 Double in C89 */
 521 extern float __cdecl logf (float);
 522 extern long double __cdecl logl (long double);
 523
 524 /* 7.12.6.8 Double in C89 */
 525 extern float __cdecl log10f (float);
 526 extern long double __cdecl log10l (long double);
 527
 528 /* 7.12.6.9 */
 529 extern double __cdecl log1p(double);
 530 extern float __cdecl log1pf(float);
 531 extern long double __cdecl log1pl(long double);
 532
 533 /* 7.12.6.10 */
 534 extern double __cdecl log2 (double);
 535 extern float __cdecl log2f (float);
 536 extern long double __cdecl log2l (long double);
 537
 538 /* 7.12.6.11 */
 539 extern double __cdecl logb (double);
 540 extern float __cdecl logbf (float);
 541 extern long double __cdecl logbl (long double);
 542
 543 /* Inline versions.  GCC-4.0+ can do a better fast-math optimization
 544    with __builtins. */
 545 #if !(__MINGW_GNUC_PREREQ (4, 0) && defined __FAST_MATH__ )
 546 __CRT_INLINE double __cdecl logb (double x)
 547 {
 548   double res;
 549   __asm__ ("fxtract\n\t"
 550        "fstp    %%st" : "=t" (res) : "0" (x));
 551   return res;
 552 }
 553
 554 __CRT_INLINE float __cdecl logbf (float x)
 555 {
 556   float res;
 557   __asm__ ("fxtract\n\t"
 558        "fstp    %%st" : "=t" (res) : "0" (x));
 559   return res;
 560 }
 561
 562 __CRT_INLINE long double __cdecl logbl (long double x)
 563 {
 564   long double res;
 565   __asm__ ("fxtract\n\t"
 566        "fstp    %%st" : "=t" (res) : "0" (x));
 567   return res;
 568 }
 569 #endif /* !defined __FAST_MATH__ || !__MINGW_GNUC_PREREQ (4, 0) */
 570
 571 /* 7.12.6.12  Double in C89 */
 572 extern float __cdecl modff (float, float*);
 573 extern long double __cdecl modfl (long double, long double*);
 574
 575 /* 7.12.6.13 */
 576 extern double __cdecl scalbn (double, int);
 577 extern float __cdecl scalbnf (float, int);
 578 extern long double __cdecl scalbnl (long double, int);
 579
 580 extern double __cdecl scalbln (double, long);
 581 extern float __cdecl scalblnf (float, long);
 582 extern long double __cdecl scalblnl (long double, long);
 583
 584 /* 7.12.7.1 */
 585 /* Implementations adapted from Cephes versions */
 586 extern double __cdecl cbrt (double);
 587 extern float __cdecl cbrtf (float);
 588 extern long double __cdecl cbrtl (long double);
 589
 590 /* 7.12.7.2 The fabs functions: Double in C89 */
 591 extern  float __cdecl fabsf (float x);
 592 extern long double __cdecl fabsl (long double x);
 593
 594 /* 7.12.7.3  */
 595 extern double __cdecl hypot (double, double); /* in libmoldname.a */
 596 __CRT_INLINE float __cdecl hypotf (float x, float y)
 597   { return (float) hypot (x, y);}
 598 extern long double __cdecl hypotl (long double, long double);
 599
 600 /* 7.12.7.4 The pow functions. Double in C89 */
 601 __CRT_INLINE float __cdecl powf (float x, float y)
 602   {return (float) pow (x, y);}
 603 extern long double __cdecl powl (long double, long double);
 604
 605 /* 7.12.7.5 The sqrt functions. Double in C89. */
 606 extern float __cdecl sqrtf (float);
 607 extern long double __cdecl sqrtl (long double);
 608
 609 /* 7.12.8.1 The erf functions  */
 610 extern double __cdecl erf (double);
 611 extern float __cdecl erff (float);
 612 extern long double __cdecl erfl (long double);
 613
 614 /* 7.12.8.2 The erfc functions  */
 615 extern double __cdecl erfc (double);
 616 extern float __cdecl erfcf (float);
 617 extern long double __cdecl erfcl (long double);
 618
 619 /* 7.12.8.3 The lgamma functions */
 620 extern double __cdecl lgamma (double);
 621 extern float __cdecl lgammaf (float);
 622 extern long double __cdecl lgammal (long double);
 623
 624 /* 7.12.8.4 The tgamma functions */
 625 extern double __cdecl tgamma (double);
 626 extern float __cdecl tgammaf (float);
 627 extern long double __cdecl tgammal (long double);
 628
 629 /* 7.12.9.1 Double in C89 */
 630 extern float __cdecl ceilf (float);
 631 extern long double __cdecl ceill (long double);
 632
 633 /* 7.12.9.2 Double in C89 */
 634 extern float __cdecl floorf (float);
 635 extern long double __cdecl floorl (long double);
 636
 637 /* 7.12.9.3 */
 638 extern double __cdecl nearbyint ( double);
 639 extern float __cdecl nearbyintf (float);
 640 extern long double __cdecl nearbyintl (long double);
 641
 642 /* 7.12.9.4 */
 643 /* round, using fpu control word settings */
 644 extern double __cdecl rint (double);
 645 extern float __cdecl rintf (float);
 646 extern long double __cdecl rintl (long double);
 647
 648 /* 7.12.9.5 */
 649 extern long __cdecl lrint (double);
 650 extern long __cdecl lrintf (float);
 651 extern long __cdecl lrintl (long double);
 652
 653 extern long long __cdecl llrint (double);
 654 extern long long __cdecl llrintf (float);
 655 extern long long __cdecl llrintl (long double);
 656
 657 /* Inline versions of above.
 658    GCC 4.0+ can do a better fast-math job with __builtins. */
 659 #if !(__MINGW_GNUC_PREREQ (4, 0) && defined __FAST_MATH__ )
 660 __CRT_INLINE double __cdecl rint (double x)
 661 {
 662   double retval;
 663   __asm__ ("frndint;": "=t" (retval) : "0" (x));
 664   return retval;
 665 }
 666
 667 __CRT_INLINE float __cdecl rintf (float x)
 668 {
 669   float retval;
 670   __asm__ ("frndint;" : "=t" (retval) : "0" (x) );
 671   return retval;
 672 }
 673
 674 __CRT_INLINE long double __cdecl rintl (long double x)
 675 {
 676   long double retval;
 677   __asm__ ("frndint;" : "=t" (retval) : "0" (x) );
 678   return retval;
 679 }
 680
 681 __CRT_INLINE long __cdecl lrint (double x)
 682 {
 683   long retval;
 684   __asm__ __volatile__
 685     ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");
 686   return retval;
 687 }
 688
 689 __CRT_INLINE long __cdecl lrintf (float x)
 690 {
 691   long retval;
 692   __asm__ __volatile__
 693     ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");
 694   return retval;
 695 }
 696
 697 __CRT_INLINE long __cdecl lrintl (long double x)
 698 {
 699   long retval;
 700   __asm__ __volatile__
 701     ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");
 702   return retval;
 703 }
 704
 705 __CRT_INLINE long long __cdecl llrint (double x)
 706 {
 707   long long retval;
 708   __asm__ __volatile__
 709     ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");
 710   return retval;
 711 }
 712
 713 __CRT_INLINE long long __cdecl llrintf (float x)
 714 {
 715   long long retval;
 716   __asm__ __volatile__
 717     ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");
 718   return retval;
 719 }
 720
 721 __CRT_INLINE long long __cdecl llrintl (long double x)
 722 {
 723   long long retval;
 724   __asm__ __volatile__
 725     ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");
 726   return retval;
 727 }
 728 #endif /* !__FAST_MATH__ || !__MINGW_GNUC_PREREQ (4,0)  */
 729
 730 /* 7.12.9.6 */
 731 /* round away from zero, regardless of fpu control word settings */
 732 extern double __cdecl round (double);
 733 extern float __cdecl roundf (float);
 734 extern long double __cdecl roundl (long double);
 735
 736 /* 7.12.9.7  */
 737 extern long __cdecl lround (double);
 738 extern long __cdecl lroundf (float);
 739 extern long __cdecl lroundl (long double);
 740
 741 extern long long __cdecl llround (double);
 742 extern long long __cdecl llroundf (float);
 743 extern long long __cdecl llroundl (long double);
 744
 745 /* 7.12.9.8 */
 746 /* round towards zero, regardless of fpu control word settings */
 747 extern double __cdecl trunc (double);
 748 extern float __cdecl truncf (float);
 749 extern long double __cdecl truncl (long double);
 750
 751 /* 7.12.10.1 Double in C89 */
 752 extern float __cdecl fmodf (float, float);
 753 extern long double __cdecl fmodl (long double, long double);
 754
 755 /* 7.12.10.2 */
 756 extern double __cdecl remainder (double, double);
 757 extern float __cdecl remainderf (float, float);
 758 extern long double __cdecl remainderl (long double, long double);
 759
 760 /* 7.12.10.3 */
 761 extern double __cdecl remquo(double, double, int *);
 762 extern float __cdecl remquof(float, float, int *);
 763 extern long double __cdecl remquol(long double, long double, int *);
 764
 765 /* 7.12.11.1 */
 766 extern double __cdecl copysign (double, double); /* in libmoldname.a */
 767 extern float __cdecl copysignf (float, float);
 768 extern long double __cdecl copysignl (long double, long double);
 769
 770 /* 7.12.11.2 Return a NaN */
 771 extern double __cdecl nan(const char *tagp);
 772 extern float __cdecl nanf(const char *tagp);
 773 extern long double __cdecl nanl(const char *tagp);
 774
 775 #ifndef __STRICT_ANSI__
 776 #define _nan() nan("")
 777 #define _nanf() nanf("")
 778 #define _nanl() nanl("")
 779 #endif
 780
 781 /* 7.12.11.3 */
 782 extern double __cdecl nextafter (double, double); /* in libmoldname.a */
 783 extern float __cdecl nextafterf (float, float);
 784 extern long double __cdecl nextafterl (long double, long double);
 785
 786 /* 7.12.11.4 The nexttoward functions */
 787 extern double __cdecl nexttoward (double,  long double);
 788 extern float __cdecl nexttowardf (float,  long double);
 789 extern long double __cdecl nexttowardl (long double, long double);
 790
 791 /* 7.12.12.1 */
 792 /*  x > y ? (x - y) : 0.0  */
 793 extern double __cdecl fdim (double x, double y);
 794 extern float __cdecl fdimf (float x, float y);
 795 extern long double __cdecl fdiml (long double x, long double y);
 796
 797 /* fmax and fmin.
 798    NaN arguments are treated as missing data: if one argument is a NaN
 799    and the other numeric, then these functions choose the numeric
 800    value. */
 801
 802 /* 7.12.12.2 */
 803 extern double __cdecl fmax  (double, double);
 804 extern float __cdecl fmaxf (float, float);
 805 extern long double __cdecl fmaxl (long double, long double);
 806
 807 /* 7.12.12.3 */
 808 extern double __cdecl fmin (double, double);
 809 extern float __cdecl fminf (float, float);
 810 extern long double __cdecl fminl (long double, long double);
 811
 812 /* 7.12.13.1 */
 813 /* return x * y + z as a ternary op */
 814 extern double __cdecl fma (double, double, double);
 815 extern float __cdecl fmaf (float, float, float);
 816 extern long double __cdecl fmal (long double, long double, long double);
 817
 818
 819 /* 7.12.14 */
 820 /*
 821  *  With these functions, comparisons involving quiet NaNs set the FP
 822  *  condition code to "unordered".  The IEEE floating-point spec
 823  *  dictates that the result of floating-point comparisons should be
 824  *  false whenever a NaN is involved, with the exception of the != op,
 825  *  which always returns true: yes, (NaN != NaN) is true).
 826  */
 827
 828 #if __GNUC__ >= 3
 829
 830 #define isgreater(x, y) __builtin_isgreater(x, y)
 831 #define isgreaterequal(x, y) __builtin_isgreaterequal(x, y)
 832 #define isless(x, y) __builtin_isless(x, y)
 833 #define islessequal(x, y) __builtin_islessequal(x, y)
 834 #define islessgreater(x, y) __builtin_islessgreater(x, y)
 835 #define isunordered(x, y) __builtin_isunordered(x, y)
 836
 837 #else
 838 /*  helper  */
 839 __CRT_INLINE int  __cdecl
 840 __fp_unordered_compare (long double x, long double y){
 841   unsigned short retval;
 842   __asm__ ("fucom %%st(1);"
 843            "fnstsw;": "=a" (retval) : "t" (x), "u" (y));
 844   return retval;
 845 }
 846
 847 #define isgreater(x, y) ((__fp_unordered_compare(x, y) \
 848                            & 0x4500) == 0)
 849 #define isless(x, y) ((__fp_unordered_compare (y, x) \
 850                        & 0x4500) == 0)
 851 #define isgreaterequal(x, y) ((__fp_unordered_compare (x, y) \
 852                                & FP_INFINITE) == 0)
 853 #define islessequal(x, y) ((__fp_unordered_compare(y, x) \
 854                             & FP_INFINITE) == 0)
 855 #define islessgreater(x, y) ((__fp_unordered_compare(x, y) \
 856                               & FP_SUBNORMAL) == 0)
 857 #define isunordered(x, y) ((__fp_unordered_compare(x, y) \
 858                             & 0x4500) == 0x4500)
 859
 860 #endif
 861
 862
 863 #endif /* __STDC_VERSION__ >= 199901L */
 864 #endif /* __NO_ISOCEXT */
 865
 866
 867 #ifdef __cplusplus
 868 }
 869 #endif
 870 #endif  /* Not RC_INVOKED */
 871
 872
 873 #endif  /* Not _MATH_H_ */