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