87513344cd10cd1debccf039e014e3843e12e51b
[dragonfly.git] / include / math.h
1 /*
2  * ====================================================
3  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
4  *
5  * Developed at SunPro, a Sun Microsystems, Inc. business.
6  * Permission to use, copy, modify, and distribute this
7  * software is freely granted, provided that this notice
8  * is preserved.
9  * ====================================================
10  *
11  * $NetBSD: math.h,v 1.46 2007/02/22 22:08:19 drochner Exp $
12  * $DragonFly: src/include/math.h,v 1.12 2007/06/17 18:00:08 pavalos Exp $
13  */
14
15 /*
16  * @(#)fdlibm.h 5.1 93/09/24
17  */
18
19 #ifndef _MATH_H_
20 #define _MATH_H_
21
22 #include <sys/cdefs.h>
23
24 #if __GNUC_PREREQ__(3, 3) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 800)
25 #define __MATH_BUILTIN_CONSTANTS
26 #endif
27
28 #if __GNUC_PREREQ__(3, 0) && !defined(__INTEL_COMPILER)
29 #define __MATH_BUILTIN_RELOPS
30 #endif
31
32 union __float_u {
33         unsigned char __dummy[sizeof(float)];
34         float __val;
35 };
36
37 union __double_u {
38         unsigned char __dummy[sizeof(double)];
39         double __val;
40 };
41
42 union __long_double_u {
43         unsigned char __dummy[sizeof(long double)];
44         long double __val;
45 };
46
47 #include <machine/math.h>
48
49 #ifdef __HAVE_LONG_DOUBLE
50 #define __fpmacro_unary_floating(__name, __arg0)                        \
51         /* LINTED */                                                    \
52         ((sizeof (__arg0) == sizeof (float))                            \
53         ?       __ ## __name ## f (__arg0)                              \
54         : (sizeof (__arg0) == sizeof (double))                          \
55         ?       __ ## __name ## d (__arg0)                              \
56         :       __ ## __name ## l (__arg0))
57 #else
58 #define __fpmacro_unary_floating(__name, __arg0)                        \
59         /* LINTED */                                                    \
60         ((sizeof (__arg0) == sizeof (float))                            \
61         ?       __ ## __name ## f (__arg0)                              \
62         :       __ ## __name ## d (__arg0))
63 #endif /* __HAVE_LONG_DOUBLE */
64
65 /*
66  * ANSI/POSIX
67  */
68 /* 7.12#3 HUGE_VAL, HUGELF, HUGE_VALL */
69 extern const union __double_u __infinity;
70 #ifdef __MATH_BUILTIN_CONSTANTS
71 #define HUGE_VAL        __builtin_huge_val()
72 #else
73 #define HUGE_VAL        __infinity.__val
74 #endif
75
76 /*
77  * ISO C99
78  */
79 #if __ISO_C_VISIBLE >= 1999
80 /* 7.12#3 HUGE_VAL, HUGELF, HUGE_VALL */
81 extern const union __float_u __infinityf;
82 #ifdef __MATH_BUILTIN_CONSTANTS
83 #define HUGE_VALF       __builtin_huge_valf()
84 #else
85 #define HUGE_VALF       __infinityf.__val
86 #endif
87
88 extern const union __long_double_u __infinityl;
89 #define HUGE_VALL       __infinityl.__val
90
91 /* 7.12#4 INFINITY */
92 #ifdef __MATH_BUILTIN_CONSTANTS
93 #define INFINITY        __builtin_inf()
94 #elif defined(__INFINITY)
95 #define INFINITY        __INFINITY      /* float constant which overflows */
96 #else
97 #define INFINITY        HUGE_VALF       /* positive infinity */
98 #endif /* __INFINITY */
99
100 /* 7.12#5 NAN: a quiet NaN, if supported */
101 #ifdef __MATH_BUILTIN_CONSTANTS
102 #define NAN             __builtin_nan("")
103 #elif defined(__HAVE_NANF)
104 extern const union __float_u __nanf;
105 #define NAN             __nanf.__val
106 #endif /* __HAVE_NANF */
107
108 /* 7.12#6 number classification macros */
109 #define FP_INFINITE     0x00
110 #define FP_NAN          0x01
111 #define FP_NORMAL       0x02
112 #define FP_SUBNORMAL    0x03
113 #define FP_ZERO         0x04
114 /* NetBSD extensions */
115 #define _FP_LOMD        0x80            /* range for machine-specific classes */
116 #define _FP_HIMD        0xff
117
118 #endif /* ISO C99 */
119
120 /*
121  * XOPEN/SVID
122  */
123 #if __XSI_VISIBLE > 0
124 #define M_E             2.7182818284590452354   /* e */
125 #define M_LOG2E         1.4426950408889634074   /* log 2e */
126 #define M_LOG10E        0.43429448190325182765  /* log 10e */
127 #define M_LN2           0.69314718055994530942  /* log e2 */
128 #define M_LN10          2.30258509299404568402  /* log e10 */
129 #define M_PI            3.14159265358979323846  /* pi */
130 #define M_PI_2          1.57079632679489661923  /* pi/2 */
131 #define M_PI_4          0.78539816339744830962  /* pi/4 */
132 #define M_1_PI          0.31830988618379067154  /* 1/pi */
133 #define M_2_PI          0.63661977236758134308  /* 2/pi */
134 #define M_2_SQRTPI      1.12837916709551257390  /* 2/sqrt(pi) */
135 #define M_SQRT2         1.41421356237309504880  /* sqrt(2) */
136 #define M_SQRT1_2       0.70710678118654752440  /* 1/sqrt(2) */
137
138 #define MAXFLOAT        ((float)3.40282346638528860e+38)
139 extern int signgam;
140 #endif /* _XSI_VISIBLE */
141
142 #if __DF_VISIBLE
143 #define HUGE            MAXFLOAT
144
145 /*
146  * set X_TLOSS = pi*2**52, which is possibly defined in <values.h>
147  * (one may replace the following line by "#include <values.h>")
148  */
149
150 #define X_TLOSS         1.41484755040568800000e+16
151
152 #define DOMAIN          1
153 #define SING            2
154 #define OVERFLOW        3
155 #define UNDERFLOW       4
156 #define TLOSS           5
157 #define PLOSS           6
158
159 #endif /* __DF_VISIBLE */
160
161 __BEGIN_DECLS
162 /*
163  * ANSI/POSIX
164  */
165 double  acos(double);
166 double  asin(double);
167 double  atan(double);
168 double  atan2(double, double);
169 double  cos(double);
170 double  sin(double);
171 double  tan(double);
172
173 double  cosh(double);
174 double  sinh(double);
175 double  tanh(double);
176
177 double  exp(double);
178 double  frexp(double, int *);
179 double  ldexp(double, int);
180 double  log(double);
181 double  log2(double);
182 double  log10(double);
183 double  modf(double, double *);
184
185 double  pow(double, double);
186 double  sqrt(double);
187
188 double  ceil(double);
189 double  fabs(double);
190 double  floor(double);
191 double  fmod(double, double);
192
193 #if __XSI_VISIBLE > 0
194 double  erf(double);
195 double  erfc(double);
196 double  gamma(double);
197 double  hypot(double, double);
198 int     finite(double);
199 double  j0(double);
200 double  j1(double);
201 double  jn(int, double);
202 double  lgamma(double);
203 double  y0(double);
204 double  y1(double);
205 double  yn(int, double);
206 #endif /* __XSI_VISIBLE */
207
208 #if __XSI_VISIBLE >= 500
209 double  acosh(double);
210 double  asinh(double);
211 double  atanh(double);
212 double  cbrt(double);
213 double  expm1(double);
214 int     ilogb(double);
215 double  log1p(double);
216 double  logb(double);
217 double  nextafter(double, double);
218 double  remainder(double, double);
219 double  rint(double);
220 double  scalb(double, double);
221 #endif /* __XSI_VISIBLE >= 500 */
222
223 /*
224  * ISO C99
225  */
226 #if __ISO_C_VISIBLE >= 1999
227 /* 7.12.3.1 int fpclassify(real-floating x) */
228 #define fpclassify(__x) __fpmacro_unary_floating(fpclassify, __x)
229
230 /* 7.12.3.2 int isfinite(real-floating x) */
231 #define isfinite(__x)   __fpmacro_unary_floating(isfinite, __x)
232
233 /* 7.12.3.5 int isnormal(real-floating x) */
234 #define isnormal(__x)   (fpclassify(__x) == FP_NORMAL)
235
236 /* 7.12.3.6 int signbit(real-floating x) */
237 #define signbit(__x)    __fpmacro_unary_floating(signbit, __x)
238
239 /* 7.12.4 trigonometric */
240
241 float   acosf(float);
242 float   asinf(float);
243 float   atanf(float);
244 float   atan2f(float, float);
245 float   cosf(float);
246 float   sinf(float);
247 float   tanf(float);
248
249 /* 7.12.5 hyperbolic */
250
251 float   acoshf(float);
252 float   asinhf(float);
253 float   atanhf(float);
254 float   coshf(float);
255 float   sinhf(float);
256 float   tanhf(float);
257
258 /* 7.12.6 exp / log */
259
260 float   expf(float);
261 float   expm1f(float);
262 float   frexpf(float, int *);
263 long double     frexpl(long double, int *);
264 int     ilogbf(float);
265 float   ldexpf(float, int);
266 float   logf(float);
267 float   log2f(float);
268 float   log10f(float);
269 float   log1pf(float);
270 float   logbf(float);
271 float   modff(float, float *);
272 float   scalbnf(float, int);
273
274 /* 7.12.7 power / absolute */
275
276 float   cbrtf(float);
277 float   fabsf(float);
278 float   hypotf(float, float);
279 float   powf(float, float);
280 float   sqrtf(float);
281
282 /* 7.12.8 error / gamma */
283
284 float   erff(float);
285 float   erfcf(float);
286 float   lgammaf(float);
287
288 /* 7.12.9 nearest integer */
289
290 float   ceilf(float);
291 float   floorf(float);
292 float   rintf(float);
293 double  round(double);
294 float   roundf(float);
295 double  trunc(double);
296 float   truncf(float);
297 long int        lrint(double);
298 long int        lrintf(float);
299 /* LONGLONG */
300 long long int   llrint(double);
301 /* LONGLONG */
302 long long int   llrintf(float);
303 long int        lround(double);
304 long int        lroundf(float);
305 /* LONGLONG */
306 long long int   llround(double);
307 /* LONGLONG */
308 long long int   llroundf(float);
309
310 /* 7.12.10 remainder */
311
312 float   fmodf(float, float);
313 float   remainderf(float, float);
314
315 /* 7.12.11 manipulation */
316
317 float   copysignf(float, float);
318 double  nan(const char *);
319 float   nanf(const char *);
320 long double     nanl(const char *);
321 float   nextafterf(float, float);
322
323 /* 7.12.12 maximum, minimum, positive difference */
324 double  fmax(double, double);
325 float   fmaxf(float, float);
326 long double     fmaxl(long double, long double);
327
328 double  fmin(double, double);
329 float   fminf(float, float);
330 long double     fminl(long double, long double);
331
332 #endif /* __ISO_C_VISIBLE >= 1999 */
333
334 #if __ISO_C_VISIBLE >= 1999
335 /* 7.12.3.3 int isinf(real-floating x) */
336 #ifdef __isinf
337 #define isinf(__x)      __isinf(__x)
338 #else
339 #define isinf(__x)      __fpmacro_unary_floating(isinf, __x)
340 #endif
341
342 /* 7.12.3.4 int isnan(real-floating x) */
343 #ifdef __isnan
344 #define isnan(__x)      __isnan(__x)
345 #else
346 #define isnan(__x)      __fpmacro_unary_floating(isnan, __x)
347 #endif
348
349 /* 7.12.14 Comparision macros */
350 #ifdef __MATH_BUILTIN_RELOPS
351 #define isgreater(x, y)         __builtin_isgreater((x), (y))
352 #define isgreaterequal(x, y)    __builtin_isgreaterequal((x), (y))
353 #define isless(x, y)            __builtin_isless((x), (y))
354 #define islessequal(x, y)       __builtin_islessequal((x), (y))
355 #define islessgreater(x, y)     __builtin_islessgreater((x), (y))
356 #define isunordered(x, y)       __builtin_isunordered((x), (y))
357 #else
358 #define isgreater(x, y)         (!isunordered((x), (y)) && (x) > (y))
359 #define isgreaterequal(x, y)    (!isunordered((x), (y)) && (x) >= (y))
360 #define isless(x, y)            (!isunordered((x), (y)) && (x) < (y))
361 #define islessequal(x, y)       (!isunordered((x), (y)) && (x) <= (y))
362 #define islessgreater(x, y)     (!isunordered((x), (y)) && \
363                                         ((x) > (y) || (y) > (x)))
364 #define isunordered(x, y)       (isnan(x) || isnan(y))
365 #endif /* __MATH_BUILTIN_RELOPS */
366
367 #endif /* __ISO_C_VISIBLE >= 1999 */
368
369 #if __DF_VISIBLE
370 /*
371  * IEEE Test Vector
372  */
373 double  significand(double);
374
375 /*
376  * Functions callable from C, intended to support IEEE arithmetic.
377  */
378 double  copysign(double, double);
379 double  scalbn(double, int);
380
381 /*
382  * BSD math library entry points
383  */
384 double  drem(double, double);
385
386 /*
387  * Reentrant version of gamma & lgamma; passes signgam back by reference
388  * as the second argument; user must allocate space for signgam.
389  */
390 double  gamma_r(double, int *);
391 double  lgamma_r(double, int *);
392 #endif /* __DF_VISIBLE */
393
394
395 #if __DF_VISIBLE
396
397 /* float versions of ANSI/POSIX functions */
398
399 float   gammaf(float);
400 int     finitef(float);
401 float   j0f(float);
402 float   j1f(float);
403 float   jnf(int, float);
404 float   y0f(float);
405 float   y1f(float);
406 float   ynf(int, float);
407
408 float   scalbf(float, float);
409
410 /*
411  * float version of IEEE Test Vector
412  */
413 float   significandf(float);
414
415 /*
416  * float versions of BSD math library entry points
417  */
418 float   dremf(float, float);
419
420 /*
421  * Float versions of reentrant version of gamma & lgamma; passes
422  * signgam back by reference as the second argument; user must
423  * allocate space for signgam.
424  */
425 float   gammaf_r(float, int *);
426 float   lgammaf_r(float, int *);
427 #endif /* __DF_VISIBLE */
428
429 /*
430  * Library implementation
431  */
432 int     __fpclassifyf(float);
433 int     __fpclassifyd(double);
434 int     __isfinitef(float);
435 int     __isfinited(double);
436 int     __isinff(float);
437 int     __isinfd(double);
438 int     __isnanf(float);
439 int     __isnand(double);
440 int     __signbitf(float);
441 int     __signbitd(double);
442
443 #ifdef __HAVE_LONG_DOUBLE
444 int     __fpclassifyl(long double);
445 int     __isfinitel(long double);
446 int     __isinfl(long double);
447 int     __isnanl(long double);
448 int     __signbitl(long double);
449 #endif
450 __END_DECLS
451
452 #endif /* _MATH_H_ */