Annotation of src/include/math.h, Revision 1.27
1.27 ! martynas 1: /* $OpenBSD: math.h,v 1.26 2009/07/25 11:38:09 martynas Exp $ */
1.1 deraadt 2: /*
3: * ====================================================
4: * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
5: *
6: * Developed at SunPro, a Sun Microsystems, Inc. business.
7: * Permission to use, copy, modify, and distribute this
8: * software is freely granted, provided that this notice
9: * is preserved.
10: * ====================================================
11: */
12:
13: /*
1.3 millert 14: * from: @(#)fdlibm.h 5.1 93/09/24
1.1 deraadt 15: */
16:
17: #ifndef _MATH_H_
18: #define _MATH_H_
19:
1.17 martynas 20: #include <sys/_types.h>
1.11 millert 21: #include <sys/cdefs.h>
1.18 martynas 22: #include <sys/limits.h>
1.11 millert 23:
1.1 deraadt 24: /*
25: * ANSI/POSIX
26: */
27: extern char __infinity[];
1.27 ! martynas 28: #if __GNUC_PREREQ__(3, 3)
! 29: #define HUGE_VAL __builtin_huge_val()
! 30: #else /* __GNUC_PREREQ__(3, 3) */
1.12 otto 31: #define HUGE_VAL (*(double *)(void *)__infinity)
1.27 ! martynas 32: #endif /* __GNUC_PREREQ__(3, 3) */
1.9 espie 33:
1.18 martynas 34: /*
1.9 espie 35: * C99
36: */
1.18 martynas 37: #if __ISO_C_VISIBLE >= 1999
38: typedef __double_t double_t;
39: typedef __float_t float_t;
40:
1.27 ! martynas 41: #if __GNUC_PREREQ__(3, 3)
! 42: #define HUGE_VALF __builtin_huge_valf()
! 43: #define HUGE_VALL __builtin_huge_vall()
! 44: #define INFINITY __builtin_inff()
! 45: #define NAN __builtin_nanf("")
! 46: #else /* __GNUC_PREREQ__(3, 3) */
1.23 martynas 47: #ifdef __vax__
1.24 martynas 48: extern char __infinityf[];
1.23 martynas 49: #define HUGE_VALF (*(float *)(void *)__infinityf)
50: #else /* __vax__ */
1.18 martynas 51: #define HUGE_VALF ((float)HUGE_VAL)
1.23 martynas 52: #endif /* __vax__ */
1.18 martynas 53: #define HUGE_VALL ((long double)HUGE_VAL)
54: #define INFINITY HUGE_VALF
1.19 martynas 55: #ifndef __vax__
56: extern char __nan[];
57: #define NAN (*(float *)(void *)__nan)
58: #endif /* !__vax__ */
1.27 ! martynas 59: #endif /* __GNUC_PREREQ__(3, 3) */
1.18 martynas 60:
61: #define FP_INFINITE 0x01
62: #define FP_NAN 0x02
63: #define FP_NORMAL 0x04
64: #define FP_SUBNORMAL 0x08
65: #define FP_ZERO 0x10
66:
67: #define FP_ILOGB0 (-INT_MAX)
68: #define FP_ILOGBNAN INT_MAX
69:
70: #define fpclassify(x) \
71: ((sizeof (x) == sizeof (float)) ? \
72: __fpclassifyf(x) \
73: : (sizeof (x) == sizeof (double)) ? \
74: __fpclassify(x) \
75: : __fpclassifyl(x))
76: #define isfinite(x) \
77: ((sizeof (x) == sizeof (float)) ? \
78: __isfinitef(x) \
79: : (sizeof (x) == sizeof (double)) ? \
80: __isfinite(x) \
81: : __isfinitel(x))
82: #define isnormal(x) \
83: ((sizeof (x) == sizeof (float)) ? \
84: __isnormalf(x) \
85: : (sizeof (x) == sizeof (double)) ? \
86: __isnormal(x) \
87: : __isnormall(x))
88: #define signbit(x) \
89: ((sizeof (x) == sizeof (float)) ? \
90: __signbitf(x) \
91: : (sizeof (x) == sizeof (double)) ? \
92: __signbit(x) \
93: : __signbitl(x))
94:
95: #define isgreater(x, y) (!isunordered((x), (y)) && (x) > (y))
96: #define isgreaterequal(x, y) (!isunordered((x), (y)) && (x) >= (y))
97: #define isless(x, y) (!isunordered((x), (y)) && (x) < (y))
98: #define islessequal(x, y) (!isunordered((x), (y)) && (x) <= (y))
99: #define islessgreater(x, y) (!isunordered((x), (y)) && \
100: ((x) > (y) || (y) > (x)))
101: #define isunordered(x, y) (isnan(x) || isnan(y))
102: #endif /* __ISO_C_VISIBLE >= 1999 */
1.1 deraadt 103:
1.21 martynas 104: #define isinf(x) \
105: ((sizeof (x) == sizeof (float)) ? \
1.23 martynas 106: __isinff(x) \
1.21 martynas 107: : (sizeof (x) == sizeof (double)) ? \
108: __isinf(x) \
109: : __isinfl(x))
110: #define isnan(x) \
111: ((sizeof (x) == sizeof (float)) ? \
1.23 martynas 112: __isnanf(x) \
1.21 martynas 113: : (sizeof (x) == sizeof (double)) ? \
114: __isnan(x) \
115: : __isnanl(x))
116:
1.1 deraadt 117: /*
118: * XOPEN/SVID
119: */
1.11 millert 120: #if __BSD_VISIBLE || __XPG_VISIBLE
1.1 deraadt 121: #define M_E 2.7182818284590452354 /* e */
122: #define M_LOG2E 1.4426950408889634074 /* log 2e */
123: #define M_LOG10E 0.43429448190325182765 /* log 10e */
124: #define M_LN2 0.69314718055994530942 /* log e2 */
125: #define M_LN10 2.30258509299404568402 /* log e10 */
126: #define M_PI 3.14159265358979323846 /* pi */
127: #define M_PI_2 1.57079632679489661923 /* pi/2 */
128: #define M_PI_4 0.78539816339744830962 /* pi/4 */
129: #define M_1_PI 0.31830988618379067154 /* 1/pi */
130: #define M_2_PI 0.63661977236758134308 /* 2/pi */
131: #define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
132: #define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
133: #define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
134:
1.7 jason 135: #ifdef __vax__
1.18 martynas 136: #define MAXFLOAT ((float)1.70141173319264430e+38)
1.7 jason 137: #else
1.1 deraadt 138: #define MAXFLOAT ((float)3.40282346638528860e+38)
1.18 martynas 139: #endif /* __vax__ */
1.7 jason 140:
1.1 deraadt 141: extern int signgam;
1.11 millert 142: #endif /* __BSD_VISIBLE || __XPG_VISIBLE */
1.1 deraadt 143:
1.11 millert 144: #if __BSD_VISIBLE
1.1 deraadt 145: #define HUGE MAXFLOAT
1.11 millert 146: #endif /* __BSD_VISIBLE */
1.1 deraadt 147:
148: __BEGIN_DECLS
149: /*
150: * ANSI/POSIX
151: */
1.25 martynas 152: double acos(double);
153: double asin(double);
154: double atan(double);
155: double atan2(double, double);
156: double cos(double);
157: double sin(double);
158: double tan(double);
159:
160: double cosh(double);
161: double sinh(double);
162: double tanh(double);
163:
164: double exp(double);
165: double frexp(double, int *);
166: double ldexp(double, int);
167: double log(double);
168: double log10(double);
169: double modf(double, double *);
170:
171: double pow(double, double);
172: double sqrt(double);
173:
174: double ceil(double);
175: double fabs(double);
176: double floor(double);
177: double fmod(double, double);
1.1 deraadt 178:
1.18 martynas 179: /*
180: * C99
181: */
182: #if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XPG_VISIBLE
1.25 martynas 183: double acosh(double);
184: double asinh(double);
185: double atanh(double);
1.18 martynas 186:
1.25 martynas 187: double exp2(double);
188: double expm1(double);
189: int ilogb(double);
190: double log1p(double);
191: double log2(double);
192: double logb(double);
193: double scalbn(double, int);
194: double scalbln(double, long int);
1.18 martynas 195:
1.25 martynas 196: double cbrt(double);
197: double hypot(double, double);
1.18 martynas 198:
1.25 martynas 199: double erf(double);
200: double erfc(double);
201: double lgamma(double);
202: double tgamma(double);
1.18 martynas 203:
204: #if 0
1.25 martynas 205: double nearbyint(double);
1.18 martynas 206: #endif
1.25 martynas 207: double rint(double);
208: long int lrint(double);
209: long long int llrint(double);
210: double round(double);
211: long int lround(double);
212: long long int llround(double);
213: double trunc(double);
1.13 brad 214:
1.25 martynas 215: double remainder(double, double);
216: double remquo(double, double, int *);
1.18 martynas 217:
1.25 martynas 218: double copysign(double, double);
219: double nan(const char *);
220: double nextafter(double, double);
1.18 martynas 221: #if 0
1.25 martynas 222: double nexttoward(double, long double);
1.18 martynas 223: #endif
224:
1.25 martynas 225: double fdim(double, double);
226: double fmax(double, double);
227: double fmin(double, double);
1.18 martynas 228:
229: #if 0
1.25 martynas 230: double fma(double, double, double);
1.18 martynas 231: #endif
232: #endif /* __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XPG_VISIBLE */
233:
1.11 millert 234: #if __BSD_VISIBLE || __XPG_VISIBLE
1.25 martynas 235: double j0(double);
236: double j1(double);
237: double jn(int, double);
238: double scalb(double, double);
239: double y0(double);
240: double y1(double);
241: double yn(int, double);
1.18 martynas 242: #endif /* __BSD_VISIBLE || __XPG_VISIBLE */
1.1 deraadt 243:
1.18 martynas 244: #if __BSD_VISIBLE || __XPG_VISIBLE <= 500
1.25 martynas 245: double gamma(double);
1.18 martynas 246: #endif /* __BSD_VISIBLE || __XPG_VISIBLE <= 500 */
1.1 deraadt 247:
248: /*
249: * BSD math library entry points
250: */
1.18 martynas 251: #if __BSD_VISIBLE
1.25 martynas 252: double drem(double, double);
253: int finite(double);
1.1 deraadt 254:
255: /*
256: * Reentrant version of gamma & lgamma; passes signgam back by reference
257: * as the second argument; user must allocate space for signgam.
258: */
1.25 martynas 259: double gamma_r(double, int *);
260: double lgamma_r(double, int *);
1.1 deraadt 261:
1.18 martynas 262: /*
263: * IEEE Test Vector
264: */
1.25 martynas 265: double significand(double);
1.18 martynas 266: #endif /* __BSD_VISIBLE */
1.1 deraadt 267:
1.18 martynas 268: /*
269: * Float versions of C99 functions
270: */
271: #if __ISO_C_VISIBLE >= 1999
1.25 martynas 272: float acosf(float);
273: float asinf(float);
274: float atanf(float);
275: float atan2f(float, float);
276: float cosf(float);
277: float sinf(float);
278: float tanf(float);
279:
280: float acoshf(float);
281: float asinhf(float);
282: float atanhf(float);
283: float coshf(float);
284: float sinhf(float);
285: float tanhf(float);
286:
287: float expf(float);
288: float exp2f(float);
289: float expm1f(float);
290: float frexpf(float, int *);
291: int ilogbf(float);
292: float ldexpf(float, int);
293: float logf(float);
294: float log10f(float);
295: float log1pf(float);
296: float log2f(float);
297: float logbf(float);
298: float modff(float, float *);
299: float scalbnf(float, int);
300: float scalblnf(float, long int);
301:
302: float cbrtf(float);
303: float fabsf(float);
304: float hypotf(float, float);
305: float powf(float, float);
306: float sqrtf(float);
307:
308: float erff(float);
309: float erfcf(float);
310: float lgammaf(float);
311: float tgammaf(float);
312:
313: float ceilf(float);
314: float floorf(float);
315: #if 0
316: float nearbyintf(float);
317: #endif
318: float rintf(float);
319: long int lrintf(float);
320: long long int llrintf(float);
321: float roundf(float);
322: long int lroundf(float);
323: long long int llroundf(float);
324: float truncf(float);
325:
326: float fmodf(float, float);
327: float remainderf(float, float);
328: float remquof(float, float, int *);
329:
330: float copysignf(float, float);
331: float nanf(const char *);
332: float nextafterf(float, float);
333: #if 0
334: float nexttowardf(float, long double);
335: #endif
336:
337: float fdimf(float, float);
338: float fmaxf(float, float);
339: float fminf(float, float);
1.18 martynas 340:
341: #if 0
1.25 martynas 342: float fmaf(float, float, float);
1.18 martynas 343: #endif
344: #endif /* __ISO_C_VISIBLE >= 1999 */
1.6 millert 345:
1.18 martynas 346: #if __BSD_VISIBLE || __XPG_VISIBLE
1.25 martynas 347: float j0f(float);
348: float j1f(float);
349: float jnf(int, float);
350: float scalbf(float, float);
351: float y0f(float);
352: float y1f(float);
353: float ynf(int, float);
1.18 martynas 354: #endif /* __BSD_VISIBLE || __XPG_VISIBLE */
1.6 millert 355:
1.18 martynas 356: #if __BSD_VISIBLE || __XPG_VISIBLE <= 500
1.25 martynas 357: float gammaf(float);
1.18 martynas 358: #endif /* __BSD_VISIBLE || __XPG_VISIBLE <= 500 */
1.1 deraadt 359:
360: /*
1.18 martynas 361: * Float versions of BSD math library entry points
1.1 deraadt 362: */
1.18 martynas 363: #if __BSD_VISIBLE
1.25 martynas 364: float dremf(float, float);
365: int finitef(float);
366: int isinff(float);
367: int isnanf(float);
1.1 deraadt 368:
369: /*
1.18 martynas 370: * Float versions of reentrant version of gamma & lgamma; passes
371: * signgam back by reference as the second argument; user must
372: * allocate space for signgam.
1.1 deraadt 373: */
1.25 martynas 374: float gammaf_r(float, int *);
375: float lgammaf_r(float, int *);
1.1 deraadt 376:
377: /*
1.18 martynas 378: * Float version of IEEE Test Vector
1.1 deraadt 379: */
1.25 martynas 380: float significandf(float);
1.18 martynas 381: #endif /* __BSD_VISIBLE */
1.1 deraadt 382:
383: /*
1.18 martynas 384: * Long double versions of C99 functions
1.1 deraadt 385: */
1.18 martynas 386: #if __ISO_C_VISIBLE >= 1999
1.25 martynas 387: long double acosl(long double);
388: long double asinl(long double);
389: long double atanl(long double);
390: long double atan2l(long double, long double);
391: long double cosl(long double);
392: long double sinl(long double);
393: long double tanl(long double);
1.18 martynas 394:
1.23 martynas 395: #if 0
1.25 martynas 396: long double acoshl(long double);
397: long double asinhl(long double);
398: long double atanhl(long double);
399: long double coshl(long double);
400: long double sinhl(long double);
401: long double tanhl(long double);
1.23 martynas 402: #endif
1.18 martynas 403:
1.23 martynas 404: #if 0
1.25 martynas 405: long double expl(long double);
1.23 martynas 406: #endif
1.25 martynas 407: long double exp2l(long double);
1.23 martynas 408: #if 0
1.25 martynas 409: long double expm1l(long double);
1.23 martynas 410: #endif
1.25 martynas 411: long double frexpl(long double, int *);
412: int ilogbl(long double);
413: long double ldexpl(long double, int);
1.23 martynas 414: #if 0
1.25 martynas 415: long double logl(long double);
416: long double log10l(long double);
417: long double log1pl(long double);
418: long double log2l(long double);
1.23 martynas 419: #endif
1.25 martynas 420: long double logbl(long double);
1.23 martynas 421: #if 0
1.25 martynas 422: long double modfl(long double, long double *);
1.23 martynas 423: #endif
1.25 martynas 424: long double scalbnl(long double, int);
425: long double scalblnl(long double, long int);
1.18 martynas 426:
1.23 martynas 427: #if 0
1.25 martynas 428: long double cbrtl(long double);
1.23 martynas 429: #endif
1.25 martynas 430: long double fabsl(long double);
1.23 martynas 431: #if 0
1.25 martynas 432: long double hypotl(long double, long double);
433: long double powl(long double, long double);
1.23 martynas 434: #endif
1.25 martynas 435: long double sqrtl(long double);
1.18 martynas 436:
1.23 martynas 437: #if 0
1.25 martynas 438: long double erfl(long double);
439: long double erfcl(long double);
440: long double lgammal(long double);
441: long double tgammal(long double);
1.23 martynas 442: #endif
1.18 martynas 443:
1.23 martynas 444: #if 0
1.25 martynas 445: long double ceill(long double);
446: long double floorl(long double);
447: long double nearbyintl(long double);
1.23 martynas 448: #endif
1.25 martynas 449: long double rintl(long double);
1.23 martynas 450: #if 0
1.25 martynas 451: long int lrintl(long double);
452: long long int llrintl(long double);
453: long double roundl(long double);
454: long int lroundl(long double);
455: long long int llroundl(long double);
456: long double truncl(long double);
1.23 martynas 457: #endif
1.18 martynas 458:
1.23 martynas 459: #if 0
1.25 martynas 460: long double fmodl(long double, long double);
461: long double remainderl(long double, long double);
462: long double remquol(long double, long double, int *);
1.23 martynas 463: #endif
1.18 martynas 464:
1.25 martynas 465: long double copysignl(long double, long double);
466: long double nanl(const char *);
1.23 martynas 467: #if 0
1.25 martynas 468: long double nextafterl(long double, long double);
469: long double nexttowardl(long double, long double);
1.23 martynas 470: #endif
1.18 martynas 471:
1.25 martynas 472: long double fdiml(long double, long double);
473: long double fmaxl(long double, long double);
474: long double fminl(long double, long double);
1.18 martynas 475:
1.23 martynas 476: #if 0
1.25 martynas 477: long double fmal(long double, long double, long double);
1.18 martynas 478: #endif
479: #endif /* __ISO_C_VISIBLE >= 1999 */
1.1 deraadt 480:
1.18 martynas 481: /*
482: * Library implementation
483: */
1.25 martynas 484: int __fpclassify(double);
485: int __fpclassifyf(float);
486: int __fpclassifyl(long double);
487: int __isfinite(double);
488: int __isfinitef(float);
489: int __isfinitel(long double);
490: int __isinf(double);
491: int __isinff(float);
492: int __isinfl(long double);
493: int __isnan(double);
494: int __isnanf(float);
495: int __isnanl(long double);
496: int __isnormal(double);
497: int __isnormalf(float);
498: int __isnormall(long double);
499: int __signbit(double);
500: int __signbitf(float);
501: int __signbitl(long double);
1.16 martynas 502:
503: #if __BSD_VISIBLE && defined(__vax__)
1.25 martynas 504: double infnan(int);
1.16 martynas 505: #endif /* __BSD_VISIBLE && defined(__vax__) */
1.1 deraadt 506: __END_DECLS
507:
1.18 martynas 508: #endif /* !_MATH_H_ */
![[BACK]](/icons/back.gif){kind=icon}
Return to math.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / include