include/crt/math.h

   1 /**
   2  * This file has no copyright assigned and is placed in the Public Domain.
   3  * This file is part of the w64 mingw-runtime package.
   4  * No warranty is given; refer to the file DISCLAIMER within this package.
   5  */
   6 #ifndef _INC_MATH
   7 #define _INC_MATH
   8
   9 #include <crtdefs.h>
  10
  11 struct exception;
  12
  13 #pragma pack(push,_CRT_PACKING)
  14
  15 #ifdef __cplusplus
  16 extern "C" {
  17 #endif
  18
  19 #ifndef _EXCEPTION_DEFINED
  20 #define _EXCEPTION_DEFINED
  21   struct _exception {
  22     int type;
  23     char *name;
  24     double arg1;
  25     double arg2;
  26     double retval;
  27   };
  28 #endif
  29
  30 #ifndef _COMPLEX_DEFINED
  31 #define _COMPLEX_DEFINED
  32   struct _complex {
  33     double x,y;
  34   };
  35 #endif
  36
  37 #define _DOMAIN 1
  38 #define _SING 2
  39 #define _OVERFLOW 3
  40 #define _UNDERFLOW 4
  41 #define _TLOSS 5
  42 #define _PLOSS 6
  43
  44 #define EDOM 33
  45 #define ERANGE 34
  46
  47   _CRTIMP extern double _HUGE;
  48
  49 #define HUGE_VAL _HUGE
  50
  51 #ifndef _CRT_ABS_DEFINED
  52 #define _CRT_ABS_DEFINED
  53   int __cdecl abs(int _X);
  54   long __cdecl labs(long _X);
  55 #endif
  56   double __cdecl acos(double _X);
  57   double __cdecl asin(double _X);
  58   double __cdecl atan(double _X);
  59   double __cdecl atan2(double _Y,double _X);
  60 #ifndef _SIGN_DEFINED
  61 #define _SIGN_DEFINED
  62   _CRTIMP double __cdecl _copysign (double _Number,double _Sign);
  63   _CRTIMP double __cdecl _chgsign (double _X);
  64 #endif
  65   double __cdecl cos(double _X);
  66   double __cdecl cosh(double _X);
  67   double __cdecl exp(double _X);
  68   double expm1(double _X);
  69   double __cdecl fabs(double _X);
  70   double __cdecl fmod(double _X,double _Y);
  71   double __cdecl log(double _X);
  72   double __cdecl log10(double _X);
  73   double __cdecl pow(double _X,double _Y);
  74   double __cdecl sin(double _X);
  75   double __cdecl sinh(double _X);
  76   double __cdecl tan(double _X);
  77   double __cdecl tanh(double _X);
  78   double __cdecl sqrt(double _X);
  79 #ifndef _CRT_ATOF_DEFINED
  80 #define _CRT_ATOF_DEFINED
  81   double __cdecl atof(const char *_String);
  82   double __cdecl _atof_l(const char *_String,_locale_t _Locale);
  83 #endif
  84
  85   _CRTIMP double __cdecl _cabs(struct _complex _ComplexA);
  86   _CRTIMP double __cdecl ceil(double _X);
  87   _CRTIMP double __cdecl floor(double _X);
  88   _CRTIMP double __cdecl frexp(double _X,int *_Y);
  89   _CRTIMP double __cdecl _hypot(double _X,double _Y);
  90   _CRTIMP double __cdecl _j0(double _X);
  91   _CRTIMP double __cdecl _j1(double _X);
  92   _CRTIMP double __cdecl _jn(int _X,double _Y);
  93   _CRTIMP double __cdecl ldexp(double _X,int _Y);
  94 #ifndef _CRT_MATHERR_DEFINED
  95 #define _CRT_MATHERR_DEFINED
  96   int __cdecl _matherr(struct _exception *_Except);
  97 #endif
  98   _CRTIMP double __cdecl modf(double _X,double *_Y);
  99   _CRTIMP double __cdecl _y0(double _X);
 100   _CRTIMP double __cdecl _y1(double _X);
 101   _CRTIMP double __cdecl _yn(int _X,double _Y);
 102
 103 #if defined(__i386__) || defined(_M_IX86)
 104   _CRTIMP int __cdecl _set_SSE2_enable(int _Flag);
 105   /* from libmingwex */
 106   float __cdecl _hypotf(float _X,float _Y);
 107 #endif
 108
 109   float frexpf(float _X,int *_Y);
 110   float __cdecl ldexpf(float _X,int _Y);
 111   long double __cdecl ldexpl(long double _X,int _Y);
 112   float __cdecl acosf(float _X);
 113   float __cdecl asinf(float _X);
 114    float __cdecl atanf(float _X);
 115    float __cdecl atan2f(float _X,float _Y);
 116    float __cdecl cosf(float _X);
 117    float __cdecl sinf(float _X);
 118    float __cdecl tanf(float _X);
 119    float __cdecl coshf(float _X);
 120    float __cdecl sinhf(float _X);
 121    float __cdecl tanhf(float _X);
 122    float __cdecl expf(float _X);
 123    float expm1f(float _X);
 124    float __cdecl logf(float _X);
 125    float __cdecl log10f(float _X);
 126    float __cdecl modff(float _X,float *_Y);
 127    float __cdecl powf(float _X,float _Y);
 128    float __cdecl sqrtf(float _X);
 129    float __cdecl ceilf(float _X);
 130    float __cdecl floorf(float _X);
 131   float __cdecl fmodf(float _X,float _Y);
 132    float __cdecl _hypotf(float _X,float _Y);
 133   float __cdecl fabsf(float _X);
 134 #if !defined(__ia64__) && !defined(_M_IA64)
 135    /* from libmingwex */
 136    float __cdecl _copysignf (float _Number,float _Sign);
 137    float __cdecl _chgsignf (float _X);
 138    float __cdecl _logbf(float _X);
 139    float __cdecl _nextafterf(float _X,float _Y);
 140    int __cdecl _finitef(float _X);
 141    int __cdecl _isnanf(float _X);
 142    int __cdecl _fpclassf(float _X);
 143 #endif
 144
 145 #if defined(__GNUC__)
 146
 147 #define __fabs(x, res) \
 148   __asm__ ("fabs;" : "=t" (res) : "0" (x))
 149
 150 #elif defined(_MSC_VER)
 151
 152 #define __fabs(x, res) \
 153   __asm { fld [(x)] } \
 154   __asm { fabs } \
 155   __asm { fstp [(res)] }
 156
 157 #endif
 158
 159   __CRT_INLINE long double __cdecl fabsl (long double x)
 160   {
 161     long double res;
 162     __fabs(x, res);
 163     return res;
 164   }
 165
 166   __CRT_INLINE long double _chgsignl(long double _Number) { return _chgsign((double)(_Number)); }
 167   __CRT_INLINE long double _copysignl(long double _Number,long double _Sign) { return _copysign((double)(_Number),(double)(_Sign)); }
 168   __CRT_INLINE long double _hypotl(long double _X,long double _Y) { return _hypot((double)(_X),(double)(_Y)); }
 169   __CRT_INLINE float frexpf(float _X,int *_Y) { return ((float)frexp((double)_X,_Y)); }
 170
 171 #if !defined (__ia64__) && !defined (_M_IA64)
 172   __CRT_INLINE float __cdecl fabsf (float x)
 173   {
 174     float res;
 175     __fabs(x, res);
 176     return res;
 177   }
 178
 179   __CRT_INLINE float __cdecl ldexpf (float x, int expn) { return (float) ldexp (x, expn); }
 180 #endif
 181
 182 #define _matherrl _matherr
 183
 184   __CRT_INLINE long double modfl(long double _X,long double *_Y) {
 185     double _Di,_Df = modf((double)_X,&_Di);
 186     *_Y = (long double)_Di;
 187     return (_Df);
 188   }
 189
 190 #if !defined(__x86_64) && !defined(_M_AMD64)
 191   __CRT_INLINE float acosf(float _X) { return ((float)acos((double)_X)); }
 192   __CRT_INLINE float asinf(float _X) { return ((float)asin((double)_X)); }
 193   __CRT_INLINE float atanf(float _X) { return ((float)atan((double)_X)); }
 194   __CRT_INLINE float atan2f(float _X,float _Y) { return ((float)atan2((double)_X,(double)_Y)); }
 195   __CRT_INLINE float ceilf(float _X) { return ((float)ceil((double)_X)); }
 196   __CRT_INLINE float cosf(float _X) { return ((float)cos((double)_X)); }
 197   __CRT_INLINE float coshf(float _X) { return ((float)cosh((double)_X)); }
 198   __CRT_INLINE float expf(float _X) { return ((float)exp((double)_X)); }
 199   __CRT_INLINE float floorf(float _X) { return ((float)floor((double)_X)); }
 200   __CRT_INLINE float fmodf(float _X,float _Y) { return ((float)fmod((double)_X,(double)_Y)); }
 201   __CRT_INLINE float logf(float _X) { return ((float)log((double)_X)); }
 202   __CRT_INLINE float log10f(float _X) { return ((float)log10((double)_X)); }
 203   __CRT_INLINE float modff(float _X,float *_Y) {
 204     double _Di,_Df = modf((double)_X,&_Di);
 205     *_Y = (float)_Di;
 206     return ((float)_Df);
 207   }
 208   __CRT_INLINE float powf(float _X,float _Y) { return ((float)pow((double)_X,(double)_Y)); }
 209   __CRT_INLINE float sinf(float _X) { return ((float)sin((double)_X)); }
 210   __CRT_INLINE float sinhf(float _X) { return ((float)sinh((double)_X)); }
 211   __CRT_INLINE float sqrtf(float _X) { return ((float)sqrt((double)_X)); }
 212   __CRT_INLINE float tanf(float _X) { return ((float)tan((double)_X)); }
 213   __CRT_INLINE float tanhf(float _X) { return ((float)tanh((double)_X)); }
 214 #endif
 215
 216 #ifndef NO_OLDNAMES
 217 #define DOMAIN _DOMAIN
 218 #define SING _SING
 219 #define OVERFLOW _OVERFLOW
 220 #define UNDERFLOW _UNDERFLOW
 221 #define TLOSS _TLOSS
 222 #define PLOSS _PLOSS
 223 #define matherr _matherr
 224
 225 #define HUGE    _HUGE
 226   /*    double __cdecl cabs(struct _complex _X); */
 227   double __cdecl hypot(double _X,double _Y);
 228   __CRT_INLINE float __cdecl hypotf (float x, float y)
 229   { return (float) hypot (x, y);}
 230   _CRTIMP double __cdecl j0(double _X);
 231   _CRTIMP double __cdecl j1(double _X);
 232   _CRTIMP double __cdecl jn(int _X,double _Y);
 233   _CRTIMP double __cdecl y0(double _X);
 234   _CRTIMP double __cdecl y1(double _X);
 235   _CRTIMP double __cdecl yn(int _X,double _Y);
 236 #endif
 237
 238 #ifndef __NO_ISOCEXT
 239 #if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) \
 240   || !defined __STRICT_ANSI__ || defined __GLIBCPP__
 241
 242 #if !defined(_MSC_VER)
 243 #define NAN (0.0F/0.0F)
 244 #define HUGE_VALF (1.0F/0.0F)
 245 #define HUGE_VALL (1.0L/0.0L)
 246 #define INFINITY (1.0F/0.0F)
 247 #endif
 248
 249
 250 #define FP_NAN          0x0100
 251 #define FP_NORMAL       0x0400
 252 #define FP_INFINITE     (FP_NAN | FP_NORMAL)
 253 #define FP_ZERO         0x4000
 254 #define FP_SUBNORMAL    (FP_NORMAL | FP_ZERO)
 255   /* 0x0200 is signbit mask */
 256
 257 #if defined(__GNUC__)
 258
 259 #define __fxam(x, sw) \
 260         __asm__ ("fxam; fstsw %%ax;" : "=a" (sw): "t" (x))
 261
 262 #elif defined(_MSC_VER)
 263
 264 #define __fxam(x, sw) \
 265     __asm { fld [(x)] } \
 266     __asm { fxam } \
 267     __asm { wait } \
 268     __asm { fnstsw [(sw)] } \
 269     __asm { fstp st(0) }
 270
 271 #endif
 272
 273   /*
 274   We can't __CRT_INLINE float or double, because we want to ensure truncation
 275   to semantic type before classification.
 276   (A normal long double value might become subnormal when
 277   converted to double, and zero when converted to float.)
 278   */
 279
 280   extern int __cdecl __fpclassifyf (float);
 281   extern int __cdecl __fpclassify (double);
 282
 283   __CRT_INLINE int __cdecl __fpclassifyl (long double x){
 284     unsigned short sw;
 285     __fxam(x, sw);
 286     return sw & (FP_NAN | FP_NORMAL | FP_ZERO );
 287   }
 288
 289   __CRT_INLINE int __cdecl __fpclassify (double x){
 290     return __fpclassifyl((long double)x);
 291   }
 292
 293 #define fpclassify(x) (sizeof (x) == sizeof (float) ? __fpclassifyf (x)   \
 294   : sizeof (x) == sizeof (double) ? __fpclassify (x) \
 295   : __fpclassifyl (x))
 296
 297   /* 7.12.3.2 */
 298 #define isfinite(x) ((fpclassify(x) & FP_NAN) == 0)
 299
 300   /* 7.12.3.3 */
 301 /* #define isinf(x) (fpclassify(x) == FP_INFINITE) */
 302
 303   /* we don't have fpclassify */
 304 __CRT_INLINE int isinf (double d) {
 305   int expon = 0;
 306   double val = frexp (d, &expon);
 307   if (expon == 1025) {
 308     if (val == 0.5) {
 309         return 1;
 310     } else if (val == -0.5) {
 311         return -1;
 312     } else {
 313         return 0;
 314     }
 315   } else {
 316     return 0;
 317   }
 318 }
 319
 320   /* 7.12.3.4 */
 321   /* We don't need to worry about truncation here:
 322   A NaN stays a NaN. */
 323
 324   __CRT_INLINE int __cdecl __isnan (double _x)
 325   {
 326     unsigned short sw;
 327     __fxam(_x, sw);
 328     return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
 329       == FP_NAN;
 330   }
 331
 332   __CRT_INLINE int __cdecl __isnanf (float _x)
 333   {
 334     unsigned short sw;
 335     __fxam(_x, sw);
 336     return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
 337       == FP_NAN;
 338   }
 339
 340   __CRT_INLINE int __cdecl __isnanl (long double _x)
 341   {
 342     unsigned short sw;
 343     __fxam(_x, sw);
 344     return (sw & (FP_NAN | FP_NORMAL | FP_INFINITE | FP_ZERO | FP_SUBNORMAL))
 345       == FP_NAN;
 346   }
 347
 348
 349 #define isnan(x) (sizeof (x) == sizeof (float) ? __isnanf (x)   \
 350   : sizeof (x) == sizeof (double) ? __isnan (x) \
 351   : __isnanl (x))
 352
 353   /* 7.12.3.5 */
 354 #define isnormal(x) (fpclassify(x) == FP_NORMAL)
 355
 356   /* 7.12.3.6 The signbit macro */
 357   __CRT_INLINE int __cdecl __signbit (double x) {
 358     unsigned short stw;
 359     __fxam(x, stw);
 360     return stw & 0x0200;
 361   }
 362
 363   __CRT_INLINE int __cdecl __signbitf (float x) {
 364     unsigned short stw;
 365     __fxam(x, stw);
 366     return stw & 0x0200;
 367   }
 368
 369   __CRT_INLINE int __cdecl __signbitl (long double x) {
 370     unsigned short stw;
 371     __fxam(x, stw);
 372     return stw & 0x0200;
 373   }
 374
 375 #define signbit(x) (sizeof (x) == sizeof (float) ? __signbitf (x)       \
 376   : sizeof (x) == sizeof (double) ? __signbit (x)       \
 377   : __signbitl (x))
 378
 379   extern double __cdecl exp2(double);
 380   extern float __cdecl exp2f(float);
 381   extern long double __cdecl exp2l(long double);
 382
 383 #define FP_ILOGB0 ((int)0x80000000)
 384 #define FP_ILOGBNAN ((int)0x80000000)
 385   extern int __cdecl ilogb (double);
 386   extern int __cdecl ilogbf (float);
 387   extern int __cdecl ilogbl (long double);
 388
 389   extern double __cdecl log1p(double);
 390   extern float __cdecl log1pf(float);
 391   extern long double __cdecl log1pl(long double);
 392
 393   extern double __cdecl log2 (double);
 394   extern float __cdecl log2f (float);
 395   extern long double __cdecl log2l (long double);
 396
 397   extern double __cdecl logb (double);
 398   extern float __cdecl logbf (float);
 399   extern long double __cdecl logbl (long double);
 400
 401 #if defined(__GNUC__)
 402
 403 #define __fxtract(x, res) \
 404     __asm__ ("fxtract\n\t" \
 405       "fstp     %%st" : "=t" (res) : "0" (x))
 406
 407 #elif defined(_MSC_VER)
 408
 409 #define __fxtract(x, res) \
 410     __asm { fld [(x)] } \
 411     __asm { fxtract } \
 412     __asm { fstp st(0) } \
 413     __asm { fstp [(res)] }
 414
 415 #endif
 416
 417   __CRT_INLINE double __cdecl logb (double x)
 418   {
 419     double res;
 420     __fxtract(x, res);
 421     return res;
 422   }
 423
 424   __CRT_INLINE float __cdecl logbf (float x)
 425   {
 426     float res;
 427     __fxtract(x, res);
 428     return res;
 429   }
 430
 431   __CRT_INLINE long double __cdecl logbl (long double x)
 432   {
 433     long double res;
 434     __fxtract(x, res);
 435     return res;
 436   }
 437
 438   /* 7.12.6.13 */
 439   extern double __cdecl scalbn (double, int);
 440   extern float __cdecl scalbnf (float, int);
 441   extern long double __cdecl scalbnl (long double, int);
 442
 443   extern double __cdecl scalbln (double, long);
 444   extern float __cdecl scalblnf (float, long);
 445   extern long double __cdecl scalblnl (long double, long);
 446
 447   /* 7.12.7.1 */
 448   /* Implementations adapted from Cephes versions */
 449   extern double __cdecl cbrt (double);
 450   extern float __cdecl cbrtf (float);
 451   extern long double __cdecl cbrtl (long double);
 452
 453   extern long double __cdecl hypotl (long double, long double);
 454
 455   extern long double __cdecl powl (long double, long double);
 456   extern long double __cdecl expl(long double);
 457   extern long double expm1l(long double);
 458   extern long double __cdecl coshl(long double);
 459   extern long double __cdecl acosl(long double);
 460   extern long double __cdecl asinl(long double);
 461   extern long double __cdecl atanl(long double);
 462   extern long double __cdecl atan2l(long double,long double);
 463   extern long double __cdecl sinhl(long double);
 464   extern long double __cdecl tanhl(long double);
 465
 466   /* 7.12.8.1 The erf functions  */
 467   extern double __cdecl erf (double);
 468   extern float __cdecl erff (float);
 469   /* TODO
 470   extern long double __cdecl erfl (long double);
 471   */
 472
 473   /* 7.12.8.2 The erfc functions  */
 474   extern double __cdecl erfc (double);
 475   extern float __cdecl erfcf (float);
 476   /* TODO
 477   extern long double __cdecl erfcl (long double);
 478   */
 479
 480   /* 7.12.8.3 The lgamma functions */
 481   extern double __cdecl lgamma (double);
 482   extern float __cdecl lgammaf (float);
 483   extern long double __cdecl lgammal (long double);
 484
 485   /* 7.12.8.4 The tgamma functions */
 486   extern double __cdecl tgamma (double);
 487   extern float __cdecl tgammaf (float);
 488   extern long double __cdecl tgammal (long double);
 489
 490   extern long double __cdecl ceill (long double);
 491   extern long double __cdecl floorl (long double);
 492   extern long double __cdecl frexpl(long double,int *);
 493   extern long double __cdecl log10l(long double);
 494   extern long double __cdecl logl(long double);
 495   extern long double __cdecl cosl(long double);
 496   extern long double __cdecl sinl(long double);
 497   extern long double __cdecl tanl(long double);
 498   extern long double sqrtl(long double);
 499
 500   /* 7.12.9.3 */
 501   extern double __cdecl nearbyint ( double);
 502   extern float __cdecl nearbyintf (float);
 503   extern long double __cdecl nearbyintl (long double);
 504
 505   /* 7.12.9.4 */
 506   /* round, using fpu control word settings */
 507 #if defined(__GNUC__)
 508
 509 #define __frndint(x, res) \
 510   __asm__ ("fabs;" : "=t" (res) : "0" (x))
 511
 512 #elif defined(_MSC_VER)
 513
 514 #define __frndint(x, res) \
 515   __asm { fld [(x)] } \
 516   __asm { frndint } \
 517   __asm { fstp [(res)] }
 518
 519 #endif
 520
 521   __CRT_INLINE double __cdecl rint (double x)
 522   {
 523     double retval;
 524     __frndint(x, retval);
 525     return retval;
 526   }
 527
 528   __CRT_INLINE float __cdecl rintf (float x)
 529   {
 530     float retval;
 531     __frndint(x, retval);
 532     return retval;
 533   }
 534
 535   __CRT_INLINE long double __cdecl rintl (long double x)
 536   {
 537     long double retval;
 538     __frndint(x, retval);
 539     return retval;
 540   }
 541
 542   /* 7.12.9.5 */
 543 #if defined(__GNUC__)
 544
 545 #define __fistpl(x, res) \
 546   __asm__ __volatile__("fistpl %0"  : "=m" (res) : "t" (x) : "st")
 547
 548 #define __fistpll(x, res) \
 549   __asm__ __volatile__("fistpll %0"  : "=m" (res) : "t" (x) : "st")
 550
 551 #elif defined(_MSC_VER)
 552
 553 #define __fistpl(x, res) \
 554   __asm { fld [(x)] } \
 555   __asm { fistp [(res)] }
 556
 557 #define __fistpll(x, res) \
 558   __asm { fld [(x)] } \
 559   __asm { fistp [(res)] }
 560
 561 #endif
 562
 563   __CRT_INLINE long __cdecl lrint (double x)
 564   {
 565     long retval;
 566     __fistpl(x, retval);
 567     return retval;
 568   }
 569
 570   __CRT_INLINE long __cdecl lrintf (float x)
 571   {
 572     long retval;
 573     __fistpl(x, retval);
 574     return retval;
 575   }
 576
 577   __CRT_INLINE long __cdecl lrintl (long double x)
 578   {
 579     long retval;
 580     __fistpl(x, retval);
 581     return retval;
 582   }
 583
 584   __MINGW_EXTENSION __CRT_INLINE long long __cdecl llrint (double x)
 585   {
 586     __MINGW_EXTENSION long long retval;
 587     __fistpll(x, retval);
 588     return retval;
 589   }
 590
 591   __MINGW_EXTENSION __CRT_INLINE long long __cdecl llrintf (float x)
 592   {
 593     __MINGW_EXTENSION long long retval;
 594     __fistpll(x, retval);
 595     return retval;
 596   }
 597
 598   __MINGW_EXTENSION __CRT_INLINE long long __cdecl llrintl (long double x)
 599   {
 600     __MINGW_EXTENSION long long retval;
 601     __fistpll(x, retval);
 602     return retval;
 603   }
 604
 605   /* 7.12.9.6 */
 606   /* round away from zero, regardless of fpu control word settings */
 607   extern double __cdecl round (double);
 608   extern float __cdecl roundf (float);
 609   extern long double __cdecl roundl (long double);
 610
 611   /* 7.12.9.7  */
 612   extern long __cdecl lround (double);
 613   extern long __cdecl lroundf (float);
 614   extern long __cdecl lroundl (long double);
 615
 616   __MINGW_EXTENSION extern long long __cdecl llround (double);
 617   __MINGW_EXTENSION extern long long __cdecl llroundf (float);
 618   __MINGW_EXTENSION extern long long __cdecl llroundl (long double);
 619
 620   /* 7.12.9.8 */
 621   /* round towards zero, regardless of fpu control word settings */
 622   extern double __cdecl trunc (double);
 623   extern float __cdecl truncf (float);
 624   extern long double __cdecl truncl (long double);
 625
 626   extern long double __cdecl fmodl (long double, long double);
 627
 628   /* 7.12.10.2 */
 629   extern double __cdecl remainder (double, double);
 630   extern float __cdecl remainderf (float, float);
 631   extern long double __cdecl remainderl (long double, long double);
 632
 633   /* 7.12.10.3 */
 634   extern double __cdecl remquo(double, double, int *);
 635   extern float __cdecl remquof(float, float, int *);
 636   extern long double __cdecl remquol(long double, long double, int *);
 637
 638   /* 7.12.11.1 */
 639   extern double __cdecl copysign (double, double); /* in libmoldname.a */
 640   extern float __cdecl copysignf (float, float);
 641   extern long double __cdecl copysignl (long double, long double);
 642
 643   /* 7.12.11.2 Return a NaN */
 644   extern double __cdecl nan(const char *tagp);
 645   extern float __cdecl nanf(const char *tagp);
 646   extern long double __cdecl nanl(const char *tagp);
 647
 648 #ifndef __STRICT_ANSI__
 649 #define _nan() nan("")
 650 #define _nanf() nanf("")
 651 #define _nanl() nanl("")
 652 #endif
 653
 654   /* 7.12.11.3 */
 655   extern double __cdecl nextafter (double, double); /* in libmoldname.a */
 656   extern float __cdecl nextafterf (float, float);
 657   extern long double __cdecl nextafterl (long double, long double);
 658
 659   /* 7.12.11.4 The nexttoward functions: TODO */
 660
 661   /* 7.12.12.1 */
 662   /*  x > y ? (x - y) : 0.0  */
 663   extern double __cdecl fdim (double x, double y);
 664   extern float __cdecl fdimf (float x, float y);
 665   extern long double __cdecl fdiml (long double x, long double y);
 666
 667   /* fmax and fmin.
 668   NaN arguments are treated as missing data: if one argument is a NaN
 669   and the other numeric, then these functions choose the numeric
 670   value. */
 671
 672   /* 7.12.12.2 */
 673   extern double __cdecl fmax  (double, double);
 674   extern float __cdecl fmaxf (float, float);
 675   extern long double __cdecl fmaxl (long double, long double);
 676
 677   /* 7.12.12.3 */
 678   extern double __cdecl fmin (double, double);
 679   extern float __cdecl fminf (float, float);
 680   extern long double __cdecl fminl (long double, long double);
 681
 682   /* 7.12.13.1 */
 683   /* return x * y + z as a ternary op */
 684   extern double __cdecl fma (double, double, double);
 685   extern float __cdecl fmaf (float, float, float);
 686   extern long double __cdecl fmal (long double, long double, long double);
 687
 688
 689   /* 7.12.14 */
 690   /*
 691   *  With these functions, comparisons involving quiet NaNs set the FP
 692   *  condition code to "unordered".  The IEEE floating-point spec
 693   *  dictates that the result of floating-point comparisons should be
 694   *  false whenever a NaN is involved, with the exception of the != op,
 695   *  which always returns true: yes, (NaN != NaN) is true).
 696   */
 697
 698 #if defined(__GNUC__) && __GNUC__ >= 3
 699
 700 #define isgreater(x, y) __builtin_isgreater(x, y)
 701 #define isgreaterequal(x, y) __builtin_isgreaterequal(x, y)
 702 #define isless(x, y) __builtin_isless(x, y)
 703 #define islessequal(x, y) __builtin_islessequal(x, y)
 704 #define islessgreater(x, y) __builtin_islessgreater(x, y)
 705 #define isunordered(x, y) __builtin_isunordered(x, y)
 706
 707 #else
 708   /*  helper  */
 709   __CRT_INLINE int  __cdecl
 710     __fp_unordered_compare (long double x, long double y){
 711       unsigned short retval;
 712 #if defined(__GNUC__)
 713       __asm__ ("fucom %%st(1);"
 714         "fnstsw;": "=a" (retval) : "t" (x), "u" (y));
 715 #elif defined(_MSC_VER)
 716       __asm {
 717         fld [x]
 718         fld [y]
 719         fxch st(1)
 720         fucom st(1)
 721         fnstsw [retval]
 722         fstp st(0)
 723         fstp st(0)
 724       }
 725 #endif
 726       return retval;
 727   }
 728
 729 #define isgreater(x, y) ((__fp_unordered_compare(x, y) \
 730   & 0x4500) == 0)
 731 #define isless(x, y) ((__fp_unordered_compare (y, x) \
 732   & 0x4500) == 0)
 733 #define isgreaterequal(x, y) ((__fp_unordered_compare (x, y) \
 734   & FP_INFINITE) == 0)
 735 #define islessequal(x, y) ((__fp_unordered_compare(y, x) \
 736   & FP_INFINITE) == 0)
 737 #define islessgreater(x, y) ((__fp_unordered_compare(x, y) \
 738   & FP_SUBNORMAL) == 0)
 739 #define isunordered(x, y) ((__fp_unordered_compare(x, y) \
 740   & 0x4500) == 0x4500)
 741
 742 #endif
 743
 744
 745 #endif /* __STDC_VERSION__ >= 199901L */
 746 #endif /* __NO_ISOCEXT */
 747
 748 #ifdef __cplusplus
 749 }
 750 extern "C++" {
 751   template<class _Ty> inline _Ty _Pow_int(_Ty _X,int _Y) {
 752     unsigned int _N;
 753     if(_Y >= 0) _N = (unsigned int)_Y;
 754     else _N = (unsigned int)(-_Y);
 755     for(_Ty _Z = _Ty(1);;_X *= _X) {
 756       if((_N & 1)!=0) _Z *= _X;
 757       if((_N >>= 1)==0) return (_Y < 0 ? _Ty(1) / _Z : _Z);
 758     }
 759   }
 760 }
 761 #endif
 762
 763 #pragma pack(pop)
 764
 765 #if !defined(__STRICT_ANSI__) && !defined(_MATH_DEFINES_DEFINED)
 766 #define _MATH_DEFINES_DEFINED
 767
 768 #define M_E 2.71828182845904523536
 769 #define M_LOG2E 1.44269504088896340736
 770 #define M_LOG10E 0.434294481903251827651
 771 #define M_LN2 0.693147180559945309417
 772 #define M_LN10 2.30258509299404568402
 773 #define M_PI 3.14159265358979323846
 774 #define M_PI_2 1.57079632679489661923
 775 #define M_PI_4 0.785398163397448309616
 776 #define M_1_PI 0.318309886183790671538
 777 #define M_2_PI 0.636619772367581343076
 778 #define M_2_SQRTPI 1.12837916709551257390
 779 #define M_SQRT2 1.41421356237309504880
 780 #define M_SQRT1_2 0.707106781186547524401
 781 #endif
 782
 783 #ifndef __MINGW_FPCLASS_DEFINED
 784 #define __MINGW_FPCLASS_DEFINED 1
 785 #define _FPCLASS_SNAN   0x0001  /* Signaling "Not a Number" */
 786 #define _FPCLASS_QNAN   0x0002  /* Quiet "Not a Number" */
 787 #define _FPCLASS_NINF   0x0004  /* Negative Infinity */
 788 #define _FPCLASS_NN     0x0008  /* Negative Normal */
 789 #define _FPCLASS_ND     0x0010  /* Negative Denormal */
 790 #define _FPCLASS_NZ     0x0020  /* Negative Zero */
 791 #define _FPCLASS_PZ     0x0040  /* Positive Zero */
 792 #define _FPCLASS_PD     0x0080  /* Positive Denormal */
 793 #define _FPCLASS_PN     0x0100  /* Positive Normal */
 794 #define _FPCLASS_PINF   0x0200  /* Positive Infinity */
 795 #endif /* __MINGW_FPCLASS_DEFINED */
 796
 797 #endif /* !_INC_MATH */