home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 April / PCWorld_2008-04_cd.bin / temacd / devc++ / devcpp-4.9.9.2_setup.exe / math.h < prev    next >
C/C++ Source or Header  |  2005-01-29  |  23KB  |  812 lines
  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. #ifndef __DECLSPEC_SUPPORTED
  105.  
  106. #ifdef __MSVCRT__
  107. extern double*    _imp___HUGE;
  108. #define    HUGE_VAL    (*_imp___HUGE)
  109. #else
  110. /* CRTDLL */
  111. extern double*    _imp___HUGE_dll;
  112. #define    HUGE_VAL    (*_imp___HUGE_dll)
  113. #endif
  114.  
  115. #else /* __DECLSPEC_SUPPORTED */
  116.  
  117. #ifdef __MSVCRT__
  118. __MINGW_IMPORT double    _HUGE;
  119. #define    HUGE_VAL    _HUGE
  120. #else
  121. /* CRTDLL */
  122. __MINGW_IMPORT double    _HUGE_dll;
  123. #define    HUGE_VAL    _HUGE_dll
  124. #endif
  125.  
  126. #endif /* __DECLSPEC_SUPPORTED */
  127.  
  128. struct _exception
  129. {
  130.     int    type;
  131.     char    *name;
  132.     double    arg1;
  133.     double    arg2;
  134.     double    retval;
  135. };
  136.  
  137. _CRTIMP double __cdecl sin (double);
  138. _CRTIMP double __cdecl cos (double);
  139. _CRTIMP double __cdecl tan (double);
  140. _CRTIMP double __cdecl sinh (double);
  141. _CRTIMP double __cdecl cosh (double);
  142. _CRTIMP double __cdecl tanh (double);
  143. _CRTIMP double __cdecl asin (double);
  144. _CRTIMP double __cdecl acos (double);
  145. _CRTIMP double __cdecl atan (double);
  146. _CRTIMP double __cdecl atan2 (double, double);
  147. _CRTIMP double __cdecl exp (double);
  148. _CRTIMP double __cdecl log (double);
  149. _CRTIMP double __cdecl log10 (double);
  150. _CRTIMP    double __cdecl pow (double, double);
  151. _CRTIMP double __cdecl sqrt (double);
  152. _CRTIMP double __cdecl ceil (double);
  153. _CRTIMP double __cdecl floor (double);
  154. _CRTIMP double __cdecl fabs (double);
  155. _CRTIMP double __cdecl ldexp (double, int);
  156. _CRTIMP double __cdecl frexp (double, int*);
  157. _CRTIMP double __cdecl modf (double, double*);
  158. _CRTIMP double __cdecl fmod (double, double);
  159.  
  160. /* Excess precision when using a 64-bit mantissa for FPU math ops can
  161.    cause unexpected results with some of the MSVCRT math functions.  For
  162.    example, unless the function return value is stored (truncating to
  163.    53-bit mantissa), calls to pow with both x and y as integral values
  164.    sometimes produce a non-integral result.
  165.    One workaround is to reset the FPU env to 53-bit mantissa
  166.    by a call to fesetenv (FE_PC53_ENV).  Amother is to force storage
  167.    of the return value of individual math functions using wrappers.
  168.    NB, using these wrappers will disable builtin math functions and
  169.    hence disable the folding of function results at compile time when
  170.    arguments are constant.  */
  171.  
  172. #if 0
  173. #define __DEFINE_FLOAT_STORE_MATHFN_D1(fn1)    \
  174. static __inline__ double            \
  175. __float_store_ ## fn1 (double x)        \
  176. {                        \
  177.    __volatile__ double res = (fn1) (x);        \
  178.   return res;                    \
  179. }
  180.  
  181. #define __DEFINE_FLOAT_STORE_MATHFN_D2(fn2)    \
  182. static __inline__ double            \
  183. __float_store_ ## fn2 (double x, double y)    \
  184. {                        \
  185.   __volatile__ double res = (fn2) (x, y);    \
  186.   return res;                    \
  187. }
  188. #endif
  189.  
  190. /* For example, here is how to force the result of the pow function
  191.    to be stored:   */
  192. #if 0
  193. #undef pow
  194. /* Define the ___float_store_pow function and use it instead of pow().  */
  195. __DEFINE_FLOAT_STORE_MATHFN_D2 (pow)
  196. #define pow __float_store_pow
  197. #endif
  198.  
  199. #ifndef __STRICT_ANSI__
  200.  
  201. /* Complex number (for _cabs). This is the MS version. The ISO
  202.    C99 counterpart _Complex is an intrinsic type in GCC and
  203.    'complex' is defined as a macro.  See complex.h  */
  204. struct _complex
  205. {
  206.     double    x;    /* Real part */
  207.     double    y;    /* Imaginary part */
  208. };
  209.  
  210. _CRTIMP double __cdecl _cabs (struct _complex);
  211.  
  212. _CRTIMP double __cdecl _hypot (double, double);
  213. _CRTIMP double __cdecl _j0 (double);
  214. _CRTIMP double __cdecl _j1 (double);
  215. _CRTIMP double __cdecl _jn (int, double);
  216. _CRTIMP double __cdecl _y0 (double);
  217. _CRTIMP double __cdecl _y1 (double);
  218. _CRTIMP double __cdecl _yn (int, double);
  219. _CRTIMP int __cdecl _matherr (struct _exception *);
  220.  
  221. /* These are also declared in Mingw float.h; needed here as well to work 
  222.    around GCC build issues.  */
  223. /* BEGIN FLOAT.H COPY */
  224. /*
  225.  * IEEE recommended functions
  226.  */
  227.  
  228. _CRTIMP double __cdecl _chgsign (double);
  229. _CRTIMP double __cdecl _copysign (double, double);
  230. _CRTIMP double __cdecl _logb (double);
  231. _CRTIMP double __cdecl _nextafter (double, double);
  232. _CRTIMP double __cdecl _scalb (double, long);
  233.  
  234. _CRTIMP int __cdecl _finite (double);
  235. _CRTIMP int __cdecl _fpclass (double);
  236. _CRTIMP int __cdecl _isnan (double);
  237.  
  238. /* END FLOAT.H COPY */
  239.  
  240.  
  241. /*
  242.  * Non-underscored versions of non-ANSI functions.
  243.  * These reside in liboldnames.a.
  244.  */
  245.  
  246. #if !defined (_NO_OLDNAMES)
  247.  
  248. _CRTIMP double __cdecl j0 (double);
  249. _CRTIMP double __cdecl j1 (double);
  250. _CRTIMP double __cdecl jn (int, double);
  251. _CRTIMP double __cdecl y0 (double);
  252. _CRTIMP double __cdecl y1 (double);
  253. _CRTIMP double __cdecl yn (int, double);
  254.  
  255. _CRTIMP double __cdecl chgsign (double);
  256. _CRTIMP double __cdecl scalb (double, long);
  257. _CRTIMP int __cdecl finite (double);
  258. _CRTIMP int __cdecl fpclass (double);
  259.  
  260. #define FP_SNAN    _FPCLASS_SNAN
  261. #define FP_QNAN    _FPCLASS_QNAN
  262. #define FP_NINF    _FPCLASS_NINF
  263. #define FP_PINF    _FPCLASS_PINF
  264. #define FP_NDENORM _FPCLASS_ND
  265. #define FP_PDENORM _FPCLASS_PD
  266. #define FP_NZERO   _FPCLASS_NZ
  267. #define FP_PZERO   _FPCLASS_PZ
  268. #define FP_NNORM   _FPCLASS_NN
  269. #define FP_PNORM   _FPCLASS_PN
  270.  
  271. #endif /* Not _NO_OLDNAMES */
  272.  
  273. /* This require msvcr70.dll or higher. */ 
  274. #if __MSVCRT_VERSION__ >= 0x0700
  275. _CRTIMP int __cdecl _set_SSE2_enable (int);
  276. #endif /* __MSVCRT_VERSION__ >= 0x0700 */
  277.  
  278.  
  279. #endif /* __STRICT_ANSI__ */
  280.  
  281.  
  282. #ifndef __NO_ISOCEXT
  283. #if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) \
  284.     || !defined __STRICT_ANSI__ || defined __cplusplus
  285.  
  286. #define NAN (0.0F/0.0F)
  287. #define HUGE_VALF (1.0F/0.0F)
  288. #define HUGE_VALL (1.0L/0.0L)
  289. #define INFINITY (1.0F/0.0F)
  290.  
  291.  
  292. /* 7.12.3.1 */
  293. /*
  294.    Return values for fpclassify.
  295.    These are based on Intel x87 fpu condition codes
  296.    in the high byte of status word and differ from
  297.    the return values for MS IEEE 754 extension _fpclass()
  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 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. /* 7.12.4 Trigonometric functions: Double in C89 */
  396. extern float __cdecl sinf (float);
  397. extern long double __cdecl sinl (long double);
  398.  
  399. extern float __cdecl cosf (float);
  400. extern long double __cdecl cosl (long double);
  401.  
  402. extern float __cdecl tanf (float);
  403. extern long double __cdecl tanl (long double);
  404.  
  405. extern float __cdecl asinf (float);
  406. extern long double __cdecl asinl (long double);
  407.  
  408. extern float __cdecl acosf (float);
  409. extern long double __cdecl acosl (long double);
  410.  
  411. extern float __cdecl atanf (float);
  412. extern long double __cdecl atanl (long double);
  413.  
  414. extern float __cdecl atan2f (float, float);
  415. extern long double __cdecl atan2l (long double, long double);
  416.  
  417. /* 7.12.5 Hyperbolic functions: Double in C89  */
  418. __CRT_INLINE float __cdecl sinhf (float x)
  419.   {return (float) sinh (x);}
  420. extern long double __cdecl sinhl (long double);
  421.  
  422. __CRT_INLINE float __cdecl coshf (float x)
  423.   {return (float) cosh (x);}
  424. extern long double __cdecl coshl (long double);
  425.  
  426. __CRT_INLINE float __cdecl tanhf (float x)
  427.   {return (float) tanh (x);}
  428. extern long double __cdecl tanhl (long double);
  429.  
  430. /* Inverse hyperbolic trig functions  */ 
  431. /* 7.12.5.1 */
  432. extern double __cdecl acosh (double);
  433. extern float __cdecl acoshf (float);
  434. extern long double __cdecl acoshl (long double);
  435.  
  436. /* 7.12.5.2 */
  437. extern double __cdecl asinh (double);
  438. extern float __cdecl asinhf (float);
  439. extern long double __cdecl asinhl (long double);
  440.  
  441. /* 7.12.5.3 */
  442. extern double __cdecl atanh (double);
  443. extern float __cdecl atanf  (float);
  444. extern long double __cdecl atanhl (long double);
  445.  
  446. /* Exponentials and logarithms  */
  447. /* 7.12.6.1 Double in C89 */
  448. __CRT_INLINE float __cdecl expf (float x)
  449.   {return (float) exp (x);}
  450. extern long double __cdecl expl (long double);
  451.  
  452. /* 7.12.6.2 */
  453. extern double __cdecl exp2(double);
  454. extern float __cdecl exp2f(float);
  455. extern long double __cdecl exp2l(long double);
  456.  
  457. /* 7.12.6.3 The expm1 functions: TODO */
  458.  
  459. /* 7.12.6.4 Double in C89 */
  460. __CRT_INLINE float __cdecl frexpf (float x, int* expn)
  461.   {return (float) frexp (x, expn);}
  462. extern long double __cdecl frexpl (long double, int*);
  463.  
  464. /* 7.12.6.5 */
  465. #define FP_ILOGB0 ((int)0x80000000)
  466. #define FP_ILOGBNAN ((int)0x80000000)
  467. extern int __cdecl ilogb (double);
  468. extern int __cdecl ilogbf (float);
  469. extern int __cdecl ilogbl (long double);
  470.  
  471. /* 7.12.6.6  Double in C89 */
  472. __CRT_INLINE float __cdecl ldexpf (float x, int expn)
  473.   {return (float) ldexp (x, expn);}
  474. extern long double __cdecl ldexpl (long double, int);
  475.  
  476. /* 7.12.6.7 Double in C89 */
  477. extern float __cdecl logf (float);
  478. extern long double __cdecl logl (long double);
  479.  
  480. /* 7.12.6.8 Double in C89 */
  481. extern float __cdecl log10f (float);
  482. extern long double __cdecl log10l (long double);
  483.  
  484. /* 7.12.6.9 */
  485. extern double __cdecl log1p(double);
  486. extern float __cdecl log1pf(float);
  487. extern long double __cdecl log1pl(long double);
  488.  
  489. /* 7.12.6.10 */
  490. extern double __cdecl log2 (double);
  491. extern float __cdecl log2f (float);
  492. extern long double __cdecl log2l (long double);
  493.  
  494. /* 7.12.6.11 */
  495. extern double __cdecl logb (double);
  496. extern float __cdecl logbf (float);
  497. extern long double __cdecl logbl (long double);
  498.  
  499. __CRT_INLINE double __cdecl logb (double x)
  500. {
  501.   double res;
  502.   __asm__ ("fxtract\n\t"
  503.        "fstp    %%st" : "=t" (res) : "0" (x));
  504.   return res;
  505. }
  506.  
  507. __CRT_INLINE float __cdecl logbf (float x)
  508. {
  509.   float res;
  510.   __asm__ ("fxtract\n\t"
  511.        "fstp    %%st" : "=t" (res) : "0" (x));
  512.   return res;
  513. }
  514.  
  515. __CRT_INLINE long double __cdecl logbl (long double x)
  516. {
  517.   long double res;
  518.   __asm__ ("fxtract\n\t"
  519.        "fstp    %%st" : "=t" (res) : "0" (x));
  520.   return res;
  521. }
  522.  
  523. /* 7.12.6.12  Double in C89 */
  524. extern float __cdecl modff (float, float*);
  525. extern long double __cdecl modfl (long double, long double*);
  526.  
  527. /* 7.12.6.13 */
  528. extern double __cdecl scalbn (double, int);
  529. extern float __cdecl scalbnf (float, int);
  530. extern long double __cdecl scalbnl (long double, int);
  531.  
  532. extern double __cdecl scalbln (double, long);
  533. extern float __cdecl scalblnf (float, long);
  534. extern long double __cdecl scalblnl (long double, long);
  535.  
  536. /* 7.12.7.1 */
  537. /* Implementations adapted from Cephes versions */ 
  538. extern double __cdecl cbrt (double);
  539. extern float __cdecl cbrtf (float);
  540. extern long double __cdecl cbrtl (long double);
  541.  
  542. /* 7.12.7.2 The fabs functions: Double in C89 */
  543. extern  float __cdecl fabsf (float x);
  544. extern long double __cdecl fabsl (long double x);
  545.  
  546. /* 7.12.7.3  */
  547. extern double __cdecl hypot (double, double); /* in libmoldname.a */
  548. __CRT_INLINE float __cdecl hypotf (float x, float y)
  549.   { return (float) hypot (x, y);}
  550. extern long double __cdecl hypotl (long double, long double);
  551.  
  552. /* 7.12.7.4 The pow functions. Double in C89 */
  553. __CRT_INLINE float __cdecl powf (float x, float y)
  554.   {return (float) pow (x, y);}
  555. extern long double __cdecl powl (long double, long double);
  556.  
  557. /* 7.12.7.5 The sqrt functions. Double in C89. */
  558. extern float __cdecl sqrtf (float);
  559. extern long double __cdecl sqrtl (long double);
  560.  
  561. /* 7.12.8.1 The erf functions  */
  562. extern double __cdecl erf (double);
  563. extern float __cdecl erff (float);
  564. /* TODO
  565. extern long double __cdecl erfl (long double);
  566. */ 
  567.  
  568. /* 7.12.8.2 The erfc functions  */
  569. extern double __cdecl erfc (double);
  570. extern float __cdecl erfcf (float);
  571. /* TODO
  572. extern long double __cdecl erfcl (long double);
  573. */ 
  574.  
  575. /* 7.12.8.3 The lgamma functions */
  576. extern double __cdecl lgamma (double);
  577. extern float __cdecl lgammaf (float);
  578. extern long double __cdecl lgammal (long double);
  579.  
  580. /* 7.12.8.4 The tgamma functions */
  581. extern double __cdecl tgamma (double);
  582. extern float __cdecl tgammaf (float);
  583. extern long double __cdecl tgammal (long double);
  584.  
  585. /* 7.12.9.1 Double in C89 */
  586. extern float __cdecl ceilf (float);
  587. extern long double __cdecl ceill (long double);
  588.  
  589. /* 7.12.9.2 Double in C89 */
  590. extern float __cdecl floorf (float);
  591. extern long double __cdecl floorl (long double);
  592.  
  593. /* 7.12.9.3 */
  594. extern double __cdecl nearbyint ( double);
  595. extern float __cdecl nearbyintf (float);
  596. extern long double __cdecl nearbyintl (long double);
  597.  
  598. /* 7.12.9.4 */
  599. /* round, using fpu control word settings */
  600. __CRT_INLINE double __cdecl rint (double x)
  601. {
  602.   double retval;
  603.   __asm__ ("frndint;": "=t" (retval) : "0" (x));
  604.   return retval;
  605. }
  606.  
  607. __CRT_INLINE float __cdecl rintf (float x)
  608. {
  609.   float retval;
  610.   __asm__ ("frndint;" : "=t" (retval) : "0" (x) );
  611.   return retval;
  612. }
  613.  
  614. __CRT_INLINE long double __cdecl rintl (long double x)
  615. {
  616.   long double retval;
  617.   __asm__ ("frndint;" : "=t" (retval) : "0" (x) );
  618.   return retval;
  619. }
  620.  
  621. /* 7.12.9.5 */
  622. __CRT_INLINE long __cdecl lrint (double x) 
  623. {
  624.   long retval;  
  625.   __asm__ __volatile__                                  \
  626.     ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");                      \
  627.   return retval;
  628. }
  629.  
  630. __CRT_INLINE long __cdecl lrintf (float x) 
  631. {
  632.   long retval;
  633.   __asm__ __volatile__                                  \
  634.     ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");                      \
  635.   return retval;
  636. }
  637.  
  638. __CRT_INLINE long __cdecl lrintl (long double x) 
  639. {
  640.   long retval;
  641.   __asm__ __volatile__                                  \
  642.     ("fistpl %0"  : "=m" (retval) : "t" (x) : "st");                      \
  643.   return retval;
  644. }
  645.  
  646. __CRT_INLINE long long __cdecl llrint (double x) 
  647. {
  648.   long long retval;
  649.   __asm__ __volatile__                                  \
  650.     ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");                      \
  651.   return retval;
  652. }
  653.  
  654. __CRT_INLINE long long __cdecl llrintf (float x) 
  655. {
  656.   long long retval;
  657.   __asm__ __volatile__                                  \
  658.     ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");                      \
  659.   return retval;
  660. }
  661.  
  662. __CRT_INLINE long long __cdecl llrintl (long double x) 
  663. {
  664.   long long retval;
  665.   __asm__ __volatile__                                  \
  666.     ("fistpll %0"  : "=m" (retval) : "t" (x) : "st");                      \
  667.   return retval;
  668. }
  669.  
  670. /* 7.12.9.6 */
  671. /* round away from zero, regardless of fpu control word settings */
  672. extern double __cdecl round (double);
  673. extern float __cdecl roundf (float);
  674. extern long double __cdecl roundl (long double);
  675.  
  676. /* 7.12.9.7  */
  677. extern long __cdecl lround (double);
  678. extern long __cdecl lroundf (float);
  679. extern long __cdecl lroundl (long double);
  680.  
  681. extern long long __cdecl llround (double);
  682. extern long long __cdecl llroundf (float);
  683. extern long long __cdecl llroundl (long double);
  684.  
  685. /* 7.12.9.8 */
  686. /* round towards zero, regardless of fpu control word settings */
  687. extern double __cdecl trunc (double);
  688. extern float __cdecl truncf (float);
  689. extern long double __cdecl truncl (long double);
  690.  
  691. /* 7.12.10.1 Double in C89 */
  692. extern float __cdecl fmodf (float, float);
  693. extern long double __cdecl fmodl (long double, long double);
  694.  
  695. /* 7.12.10.2 */ 
  696. extern double __cdecl remainder (double, double);
  697. extern float __cdecl remainderf (float, float);
  698. extern long double __cdecl remainderl (long double, long double);
  699.  
  700. /* 7.12.10.3 */
  701. extern double __cdecl remquo(double, double, int *);
  702. extern float __cdecl remquof(float, float, int *);
  703. extern long double __cdecl remquol(long double, long double, int *);
  704.  
  705. /* 7.12.11.1 */
  706. extern double __cdecl copysign (double, double); /* in libmoldname.a */
  707. extern float __cdecl copysignf (float, float);
  708. extern long double __cdecl copysignl (long double, long double);
  709.  
  710. /* 7.12.11.2 Return a NaN */
  711. extern double __cdecl nan(const char *tagp);
  712. extern float __cdecl nanf(const char *tagp);
  713. extern long double __cdecl nanl(const char *tagp);
  714.  
  715. #ifndef __STRICT_ANSI__
  716. #define _nan() nan("")
  717. #define _nanf() nanf("")
  718. #define _nanl() nanl("")
  719. #endif
  720.  
  721. /* 7.12.11.3 */
  722. extern double __cdecl nextafter (double, double); /* in libmoldname.a */
  723. extern float __cdecl nextafterf (float, float);
  724. /* TODO: Not yet implemented */
  725. /* extern long double __cdecl nextafterl (long double, long double); */
  726.  
  727. /* 7.12.11.4 The nexttoward functions: TODO */
  728.  
  729. /* 7.12.12.1 */
  730. /*  x > y ? (x - y) : 0.0  */
  731. extern double __cdecl fdim (double x, double y);
  732. extern float __cdecl fdimf (float x, float y);
  733. extern long double __cdecl fdiml (long double x, long double y);
  734.  
  735. /* fmax and fmin.
  736.    NaN arguments are treated as missing data: if one argument is a NaN
  737.    and the other numeric, then these functions choose the numeric
  738.    value. */
  739.  
  740. /* 7.12.12.2 */
  741. extern double __cdecl fmax  (double, double);
  742. extern float __cdecl fmaxf (float, float);
  743. extern long double __cdecl fmaxl (long double, long double);
  744.  
  745. /* 7.12.12.3 */
  746. extern double __cdecl fmin (double, double);
  747. extern float __cdecl fminf (float, float);
  748. extern long double __cdecl fminl (long double, long double);
  749.  
  750. /* 7.12.13.1 */
  751. /* return x * y + z as a ternary op */ 
  752. extern double __cdecl fma (double, double, double);
  753. extern float __cdecl fmaf (float, float, float);
  754. extern long double __cdecl fmal (long double, long double, long double);
  755.  
  756.  
  757. /* 7.12.14 */
  758. /* 
  759.  *  With these functions, comparisons involving quiet NaNs set the FP
  760.  *  condition code to "unordered".  The IEEE floating-point spec
  761.  *  dictates that the result of floating-point comparisons should be
  762.  *  false whenever a NaN is involved, with the exception of the != op, 
  763.  *  which always returns true: yes, (NaN != NaN) is true).
  764.  */
  765.  
  766. #if __GNUC__ >= 3
  767.  
  768. #define isgreater(x, y) __builtin_isgreater(x, y)
  769. #define isgreaterequal(x, y) __builtin_isgreaterequal(x, y)
  770. #define isless(x, y) __builtin_isless(x, y)
  771. #define islessequal(x, y) __builtin_islessequal(x, y)
  772. #define islessgreater(x, y) __builtin_islessgreater(x, y)
  773. #define isunordered(x, y) __builtin_isunordered(x, y)
  774.  
  775. #else
  776. /*  helper  */
  777. __CRT_INLINE int  __cdecl
  778. __fp_unordered_compare (long double x, long double y){
  779.   unsigned short retval;
  780.   __asm__ ("fucom %%st(1);"
  781.        "fnstsw;": "=a" (retval) : "t" (x), "u" (y));
  782.   return retval;
  783. }
  784.  
  785. #define isgreater(x, y) ((__fp_unordered_compare(x, y) \
  786.                & 0x4500) == 0)
  787. #define isless(x, y) ((__fp_unordered_compare (y, x) \
  788.                        & 0x4500) == 0)
  789. #define isgreaterequal(x, y) ((__fp_unordered_compare (x, y) \
  790.                                & FP_INFINITE) == 0)
  791. #define islessequal(x, y) ((__fp_unordered_compare(y, x) \
  792.                 & FP_INFINITE) == 0)
  793. #define islessgreater(x, y) ((__fp_unordered_compare(x, y) \
  794.                   & FP_SUBNORMAL) == 0)
  795. #define isunordered(x, y) ((__fp_unordered_compare(x, y) \
  796.                 & 0x4500) == 0x4500)
  797.  
  798. #endif
  799.  
  800.  
  801. #endif /* __STDC_VERSION__ >= 199901L */
  802. #endif /* __NO_ISOCEXT */
  803.  
  804.  
  805. #ifdef __cplusplus
  806. }
  807. #endif
  808. #endif    /* Not RC_INVOKED */
  809.  
  810.  
  811. #endif    /* Not _MATH_H_ */
  812.