2 * ====================================================
3 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
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
9 * ====================================================
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 $
16 * @(#)fdlibm.h 5.1 93/09/24
22 #include <sys/cdefs.h>
24 #if __GNUC_PREREQ__(3, 3) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 800)
25 #define __MATH_BUILTIN_CONSTANTS
28 #if __GNUC_PREREQ__(3, 0) && !defined(__INTEL_COMPILER)
29 #define __MATH_BUILTIN_RELOPS
33 unsigned char __dummy[sizeof(float)];
38 unsigned char __dummy[sizeof(double)];
42 union __long_double_u {
43 unsigned char __dummy[sizeof(long double)];
47 #include <machine/math.h>
49 #ifdef __HAVE_LONG_DOUBLE
50 #define __fpmacro_unary_floating(__name, __arg0) \
52 ((sizeof (__arg0) == sizeof (float)) \
53 ? __ ## __name ## f (__arg0) \
54 : (sizeof (__arg0) == sizeof (double)) \
55 ? __ ## __name ## d (__arg0) \
56 : __ ## __name ## l (__arg0))
58 #define __fpmacro_unary_floating(__name, __arg0) \
60 ((sizeof (__arg0) == sizeof (float)) \
61 ? __ ## __name ## f (__arg0) \
62 : __ ## __name ## d (__arg0))
63 #endif /* __HAVE_LONG_DOUBLE */
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()
73 #define HUGE_VAL __infinity.__val
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()
85 #define HUGE_VALF __infinityf.__val
88 extern const union __long_double_u __infinityl;
89 #ifdef __MATH_BUILTIN_CONSTANTS
90 #define HUGE_VALL __builtin_huge_vall()
92 #define HUGE_VALL __infinityl.__val
96 #ifdef __MATH_BUILTIN_CONSTANTS
97 #define INFINITY __builtin_inf()
98 #elif defined(__INFINITY)
99 #define INFINITY __INFINITY /* float constant which overflows */
101 #define INFINITY HUGE_VALF /* positive infinity */
102 #endif /* __INFINITY */
104 /* 7.12#5 NAN: a quiet NaN, if supported */
105 #ifdef __MATH_BUILTIN_CONSTANTS
106 #define NAN __builtin_nan("")
107 #elif defined(__HAVE_NANF)
108 extern const union __float_u __nanf;
109 #define NAN __nanf.__val
110 #endif /* __HAVE_NANF */
112 /* 7.12#6 number classification macros */
113 #define FP_INFINITE 0x00
115 #define FP_NORMAL 0x02
116 #define FP_SUBNORMAL 0x03
118 /* NetBSD extensions */
119 #define _FP_LOMD 0x80 /* range for machine-specific classes */
120 #define _FP_HIMD 0xff
127 #if __XSI_VISIBLE > 0
128 #define M_E 2.7182818284590452354 /* e */
129 #define M_LOG2E 1.4426950408889634074 /* log 2e */
130 #define M_LOG10E 0.43429448190325182765 /* log 10e */
131 #define M_LN2 0.69314718055994530942 /* log e2 */
132 #define M_LN10 2.30258509299404568402 /* log e10 */
133 #define M_PI 3.14159265358979323846 /* pi */
134 #define M_PI_2 1.57079632679489661923 /* pi/2 */
135 #define M_PI_4 0.78539816339744830962 /* pi/4 */
136 #define M_1_PI 0.31830988618379067154 /* 1/pi */
137 #define M_2_PI 0.63661977236758134308 /* 2/pi */
138 #define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
139 #define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
140 #define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
142 #define MAXFLOAT ((float)3.40282346638528860e+38)
144 #endif /* _XSI_VISIBLE */
147 #define HUGE MAXFLOAT
150 * set X_TLOSS = pi*2**52, which is possibly defined in <values.h>
151 * (one may replace the following line by "#include <values.h>")
154 #define X_TLOSS 1.41484755040568800000e+16
163 #endif /* __DF_VISIBLE */
172 double atan2(double, double);
183 double frexp(double, int *);
184 double ldexp(double, int);
187 double log10(double);
188 double modf(double, double *);
190 double pow(double, double);
195 double floor(double);
196 double fmod(double, double);
198 #if __XSI_VISIBLE > 0
201 double gamma(double);
202 double hypot(double, double);
206 double jn(int, double);
207 double lgamma(double);
208 double tgamma(double);
211 double yn(int, double);
212 #endif /* __XSI_VISIBLE */
214 #if __XSI_VISIBLE >= 500
215 double acosh(double);
216 double asinh(double);
217 double atanh(double);
219 double expm1(double);
221 double log1p(double);
223 double nextafter(double, double);
224 double remainder(double, double);
226 double scalb(double, double);
227 #endif /* __XSI_VISIBLE >= 500 */
232 #if __ISO_C_VISIBLE >= 1999
233 /* 7.12.3.1 int fpclassify(real-floating x) */
234 #define fpclassify(__x) __fpmacro_unary_floating(fpclassify, __x)
236 /* 7.12.3.2 int isfinite(real-floating x) */
237 #define isfinite(__x) __fpmacro_unary_floating(isfinite, __x)
239 /* 7.12.3.5 int isnormal(real-floating x) */
240 #define isnormal(__x) (fpclassify(__x) == FP_NORMAL)
242 /* 7.12.3.6 int signbit(real-floating x) */
243 #define signbit(__x) __fpmacro_unary_floating(signbit, __x)
245 /* 7.12.4 trigonometric */
250 float atan2f(float, float);
255 /* 7.12.5 hyperbolic */
264 /* 7.12.6 exp / log */
269 float frexpf(float, int *);
271 float ldexpf(float, int);
277 float modff(float, float *);
278 float scalblnf(float, long);
279 float scalbnf(float, int);
281 /* 7.12.7 power / absolute */
285 float hypotf(float, float);
286 float powf(float, float);
289 /* 7.12.8 error / gamma */
293 float lgammaf(float);
294 float tgammaf(float);
296 /* 7.12.9 nearest integer */
300 float nearbyintf(float);
301 double nearbyint(double);
303 double round(double);
305 double trunc(double);
307 long int lrint(double);
308 long int lrintf(float);
310 long long int llrint(double);
312 long long int llrintf(float);
313 long int lround(double);
314 long int lroundf(float);
316 long long int llround(double);
318 long long int llroundf(float);
320 /* 7.12.10 remainder */
322 float fmodf(float, float);
323 float remainderf(float, float);
325 /* 7.12.10.3 The remquo functions */
326 double remquo(double, double, int *);
327 float remquof(float, float, int *);
329 /* 7.12.11 manipulation */
331 float copysignf(float, float);
332 double nan(const char *);
333 float nanf(const char *);
334 float nextafterf(float, float);
336 /* 7.12.12 maximum, minimum, positive difference */
337 double fdim(double, double);
338 float fdimf(float, float);
340 double fmax(double, double);
341 float fmaxf(float, float);
343 double fmin(double, double);
344 float fminf(float, float);
348 double fma (double, double, double);
349 float fmaf (float, float, float);
354 #endif /* __ISO_C_VISIBLE >= 1999 */
356 #if __ISO_C_VISIBLE >= 1999
357 /* 7.12.3.3 int isinf(real-floating x) */
359 #define isinf(__x) __isinf(__x)
361 #define isinf(__x) __fpmacro_unary_floating(isinf, __x)
364 /* 7.12.3.4 int isnan(real-floating x) */
366 #define isnan(__x) __isnan(__x)
368 #define isnan(__x) __fpmacro_unary_floating(isnan, __x)
371 /* 7.12.14 Comparision macros */
372 #ifdef __MATH_BUILTIN_RELOPS
373 #define isgreater(x, y) __builtin_isgreater((x), (y))
374 #define isgreaterequal(x, y) __builtin_isgreaterequal((x), (y))
375 #define isless(x, y) __builtin_isless((x), (y))
376 #define islessequal(x, y) __builtin_islessequal((x), (y))
377 #define islessgreater(x, y) __builtin_islessgreater((x), (y))
378 #define isunordered(x, y) __builtin_isunordered((x), (y))
380 #define isgreater(x, y) (!isunordered((x), (y)) && (x) > (y))
381 #define isgreaterequal(x, y) (!isunordered((x), (y)) && (x) >= (y))
382 #define isless(x, y) (!isunordered((x), (y)) && (x) < (y))
383 #define islessequal(x, y) (!isunordered((x), (y)) && (x) <= (y))
384 #define islessgreater(x, y) (!isunordered((x), (y)) && \
385 ((x) > (y) || (y) > (x)))
386 #define isunordered(x, y) (isnan(x) || isnan(y))
387 #endif /* __MATH_BUILTIN_RELOPS */
389 #endif /* __ISO_C_VISIBLE >= 1999 */
395 double significand(double);
398 * Functions callable from C, intended to support IEEE arithmetic.
400 double copysign(double, double);
401 double scalbln(double, long);
402 double scalbn(double, int);
405 * BSD math library entry points
407 double drem(double, double);
410 * Reentrant version of gamma & lgamma; passes signgam back by reference
411 * as the second argument; user must allocate space for signgam.
413 double gamma_r(double, int *);
414 double lgamma_r(double, int *);
415 #endif /* __DF_VISIBLE */
420 /* float versions of ANSI/POSIX functions */
426 float jnf(int, float);
429 float ynf(int, float);
431 float scalbf(float, float);
434 * float version of IEEE Test Vector
436 float significandf(float);
439 * float versions of BSD math library entry points
441 float dremf(float, float);
444 * Float versions of reentrant version of gamma & lgamma; passes
445 * signgam back by reference as the second argument; user must
446 * allocate space for signgam.
448 float gammaf_r(float, int *);
449 float lgammaf_r(float, int *);
450 #endif /* __DF_VISIBLE */
453 * Library implementation
455 int __fpclassifyf(float);
456 int __fpclassifyd(double);
457 int __isfinitef(float);
458 int __isfinited(double);
460 int __isinfd(double);
462 int __isnand(double);
463 int __signbitf(float);
464 int __signbitd(double);
466 #ifdef __HAVE_LONG_DOUBLE
467 int __fpclassifyl (long double);
468 int __isfinitel (long double);
469 int __isinfl (long double);
470 int __isnanl (long double);
471 int __signbitl (long double);
473 long double acosl (long double);
474 long double asinl (long double);
475 long double atan2l (long double, long double);
476 long double atanl (long double);
477 long double ceill (long double);
478 long double cosl (long double);
479 long double cbrtl (long double);
480 long double copysignl (long double, long double);
481 long double fdiml (long double, long double);
482 long double exp2l (long double);
483 long double fabsl (long double);
484 long double floorl (long double);
485 long double fmal (long double, long double, long double);
486 long double frexpl (long double, int *);
487 long double fmaxl (long double, long double);
488 long double fminl (long double, long double);
489 long double fmodl (long double, long double);
490 long double hypotl (long double, long double);
491 int ilogbl (long double);
492 long double ldexpl (long double, int);
493 long long llroundl (long double);
494 long double logbl (long double);
495 long lrintl (long double);
496 long lroundl (long double);
497 long double modfl (long double, long double *);
498 long double nanl (const char *);
499 long double nextafterl (long double, long double);
500 double nexttoward (double, long double);
501 float nexttowardf (float, long double);
502 long double remainderl (long double, long double);
503 long double remquol (long double, long double, int *);
504 long double rintl (long double);
505 long double roundl (long double);
506 long double scalblnl (long double, long);
507 long double scalbnl (long double, int);
508 long double sinl (long double);
509 long double sqrtl (long double);
510 long double tanl (long double);
511 long double truncl (long double);
515 #endif /* _MATH_H_ */