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
12/*
13 */
14
15#ifndef _MATH_H_
16#define _MATH_H_
17
18#include <sys/cdefs.h>
19#include <sys/_types.h>
20#include <machine/_limits.h>
21
22/*
23 * ANSI/POSIX
24 */
25extern const union __infinity_un {
26 unsigned char __uc[8];
27 double __ud;
28} __infinity;
29
30extern const union __nan_un {
31 unsigned char __uc[sizeof(float)];
32 float __uf;
33} __nan;
34
35#define __MATH_BUILTIN_CONSTANTS
36#define __MATH_BUILTIN_RELOPS
37
38#ifdef __MATH_BUILTIN_CONSTANTS
39#define HUGE_VAL __builtin_huge_val()
40#else
41#define HUGE_VAL (__infinity.__ud)
42#endif
43
44#if __ISO_C_VISIBLE >= 1999
45#define FP_ILOGB0 (-__INT_MAX)
46#define FP_ILOGBNAN __INT_MAX
47
48#ifdef __MATH_BUILTIN_CONSTANTS
49#define HUGE_VALF __builtin_huge_valf()
50#define HUGE_VALL __builtin_huge_vall()
51#define INFINITY __builtin_inff()
52#define NAN __builtin_nanf("")
53#else
54#define HUGE_VALF (float)HUGE_VAL
55#define HUGE_VALL (long double)HUGE_VAL
56#define INFINITY HUGE_VALF
57#define NAN (__nan.__uf)
58#endif /* __MATH_BUILTIN_CONSTANTS */
59
60#define MATH_ERRNO 1
61#define MATH_ERREXCEPT 2
62#define math_errhandling MATH_ERREXCEPT
63
64#define FP_FAST_FMAF 1
65
66/* Symbolic constants to classify floating point numbers. */
67#define FP_INFINITE 0x01
68#define FP_NAN 0x02
69#define FP_NORMAL 0x04
70#define FP_SUBNORMAL 0x08
71#define FP_ZERO 0x10
72
73#if __STDC_VERSION__ >= 201112L || __has_extension(c_generic_selections)
74#define __fp_type_select(x, f, d, ld) __extension__ _Generic((x), \
75 float: f, \
76 double: d, \
77 long double: ld)(x)
78#elif !defined(__cplusplus)
79#define __fp_type_select(x, f, d, ld) __builtin_choose_expr( \
80 __builtin_types_compatible_p(__typeof(x), long double), ld(x), \
81 __builtin_choose_expr( \
82 __builtin_types_compatible_p(__typeof(x), double), d(x), \
83 __builtin_choose_expr( \
84 __builtin_types_compatible_p(__typeof(x), float), f(x), (void)0)))
85#else
86#define __fp_type_select(x, f, d, ld) \
87 ((sizeof(x) == sizeof(float)) ? f(x) \
88 : (sizeof(x) == sizeof(double)) ? d(x) \
89 : ld(x))
90#endif
91
92#define fpclassify(x) \
93 __fp_type_select(x, __fpclassifyf, __fpclassifyd, __fpclassifyl)
94#define isfinite(x) __fp_type_select(x, __isfinitef, __isfinite, __isfinitel)
95#define isinf(x) __fp_type_select(x, __isinff, __isinf, __isinfl)
96#define isnan(x) \
97 __fp_type_select(x, __inline_isnanf, __inline_isnan, __inline_isnanl)
98#define isnormal(x) __fp_type_select(x, __isnormalf, __isnormal, __isnormall)
99
100#ifdef __MATH_BUILTIN_RELOPS
101#define isgreater(x, y) __builtin_isgreater((x), (y))
102#define isgreaterequal(x, y) __builtin_isgreaterequal((x), (y))
103#define isless(x, y) __builtin_isless((x), (y))
104#define islessequal(x, y) __builtin_islessequal((x), (y))
105#define islessgreater(x, y) __builtin_islessgreater((x), (y))
106#define isunordered(x, y) __builtin_isunordered((x), (y))
107#else
108#define isgreater(x, y) (!isunordered((x), (y)) && (x) > (y))
109#define isgreaterequal(x, y) (!isunordered((x), (y)) && (x) >= (y))
110#define isless(x, y) (!isunordered((x), (y)) && (x) < (y))
111#define islessequal(x, y) (!isunordered((x), (y)) && (x) <= (y))
112#define islessgreater(x, y) (!isunordered((x), (y)) && \
113 ((x) > (y) || (y) > (x)))
114#define isunordered(x, y) (isnan(x) || isnan(y))
115#endif /* __MATH_BUILTIN_RELOPS */
116
117#define signbit(x) __fp_type_select(x, __signbitf, __signbit, __signbitl)
118
119typedef __double_t double_t;
120typedef __float_t float_t;
121#endif /* __ISO_C_VISIBLE >= 1999 */
122
123/*
124 * XOPEN/SVID
125 */
126#if __BSD_VISIBLE || __XSI_VISIBLE
127#define M_E 2.7182818284590452354 /* e */
128#define M_LOG2E 1.4426950408889634074 /* log 2e */
129#define M_LOG10E 0.43429448190325182765 /* log 10e */
130#define M_LN2 0.69314718055994530942 /* log e2 */
131#define M_LN10 2.30258509299404568402 /* log e10 */
132#define M_PI 3.14159265358979323846 /* pi */
133#define M_PI_2 1.57079632679489661923 /* pi/2 */
134#define M_PI_4 0.78539816339744830962 /* pi/4 */
135#define M_1_PI 0.31830988618379067154 /* 1/pi */
136#define M_2_PI 0.63661977236758134308 /* 2/pi */
137#define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
138#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
139#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
140
141#if __BSD_VISIBLE || __XSI_VISIBLE >= 800
142#define M_El 2.718281828459045235360287471352662498L /* e */
143#define M_LOG2El 1.442695040888963407359924681001892137L /* log_2 e */
144#define M_LOG10El 0.434294481903251827651128918916605082L /* log_10 e */
145#define M_LN2l 0.693147180559945309417232121458176568L /* log_e 2 */
146#define M_LN10l 2.302585092994045684017991454684364208L /* log_e 10 */
147#define M_PIl 3.141592653589793238462643383279502884L /* pi */
148#define M_PI_2l 1.570796326794896619231321691639751442L /* pi/2 */
149#define M_PI_4l 0.785398163397448309615660845819875721L /* pi/4 */
150#define M_1_PIl 0.318309886183790671537767526745028724L /* 1/pi */
151#define M_2_PIl 0.636619772367581343075535053490057448L /* 2/pi */
152#define M_2_SQRTPIl 1.128379167095512573896158903121545172L /* 2/sqrt(pi) */
153#define M_SQRT2l 1.414213562373095048801688724209698079L /* sqrt(2) */
154#define M_SQRT1_2l 0.707106781186547524400844362104849039L /* 1/sqrt(2) */
155#endif /* __BSD_VISIBLE || __XSI_VISIBLE >= 800 */
156
157#define MAXFLOAT ((float)3.40282346638528860e+38)
158extern int signgam;
159#endif /* __BSD_VISIBLE || __XSI_VISIBLE */
160
161#if __BSD_VISIBLE
162#if 0
163/* Old value from 4.4BSD-Lite math.h; this is probably better. */
164#define HUGE HUGE_VAL
165#else
166#define HUGE MAXFLOAT
167#endif
168#endif /* __BSD_VISIBLE */
169
170/*
171 * Most of these functions depend on the rounding mode and have the side
172 * effect of raising floating-point exceptions, so they are not declared
173 * as __pure2. In C99, FENV_ACCESS affects the purity of these functions.
174 */
175__BEGIN_DECLS
176/*
177 * ANSI/POSIX
178 */
179int __fpclassifyd(double) __pure2;
180int __fpclassifyf(float) __pure2;
181int __fpclassifyl(long double) __pure2;
182int __isfinitef(float) __pure2;
183int __isfinite(double) __pure2;
184int __isfinitel(long double) __pure2;
185int __isinff(float) __pure2;
186int __isinf(double) __pure2;
187int __isinfl(long double) __pure2;
188int __isnormalf(float) __pure2;
189int __isnormal(double) __pure2;
190int __isnormall(long double) __pure2;
191int __signbit(double) __pure2;
192int __signbitf(float) __pure2;
193int __signbitl(long double) __pure2;
194
195static __inline int
196__inline_isnan(const double __x)
197{
198
199 return (__x != __x);
200}
201
202static __inline int
203__inline_isnanf(const float __x)
204{
205
206 return (__x != __x);
207}
208
209static __inline int
210__inline_isnanl(const long double __x)
211{
212
213 return (__x != __x);
214}
215
216/*
217 * Define the following aliases, for compatibility with glibc and CUDA.
218 */
219#define __isnan __inline_isnan
220#define __isnanf __inline_isnanf
221
222/*
223 * Version 2 of the Single UNIX Specification (UNIX98) defined isnan() and
224 * isinf() as functions taking double. C99, and the subsequent POSIX revisions
225 * (SUSv3, POSIX.1-2001, define it as a macro that accepts any real floating
226 * point type. If we are targeting SUSv2 and C99 or C11 (or C++11) then we
227 * expose the newer definition, assuming that the language spec takes
228 * precedence over the operating system interface spec.
229 */
230#if __XSI_VISIBLE > 0 && __XSI_VISIBLE < 600 && __ISO_C_VISIBLE < 1999
231#undef isinf
232#undef isnan
233int isinf(double);
234int isnan(double);
235#endif
236
237double acos(double);
238double asin(double);
239double atan(double);
240double atan2(double, double);
241double cos(double);
242double sin(double);
243double tan(double);
244
245double cosh(double);
246double sinh(double);
247double tanh(double);
248
249double exp(double);
250double frexp(double, int *); /* fundamentally !__pure2 */
251double ldexp(double, int);
252double log(double);
253double log10(double);
254double modf(double, double *); /* fundamentally !__pure2 */
255
256double pow(double, double);
257double sqrt(double);
258
259double ceil(double);
260double fabs(double) __pure2;
261double floor(double);
262double fmod(double, double);
263
264/*
265 * These functions are not in C90.
266 */
267#if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE
268double acosh(double);
269double asinh(double);
270double atanh(double);
271double cbrt(double);
272double erf(double);
273double erfc(double);
274double exp2(double);
275double expm1(double);
276double fma(double, double, double);
277double hypot(double, double);
278int ilogb(double) __pure2;
279double lgamma(double);
280long long llrint(double);
281long long llround(double);
282double log1p(double);
283double log2(double);
284double logb(double);
285long lrint(double);
286long lround(double);
287double nan(const char *) __pure2;
288double nextafter(double, double);
289double remainder(double, double);
290double remquo(double, double, int *);
291double rint(double);
292#endif /* __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE */
293
294#if __BSD_VISIBLE || __XSI_VISIBLE
295double j0(double);
296double j1(double);
297double jn(int, double);
298double y0(double);
299double y1(double);
300double yn(int, double);
301
302#if __XSI_VISIBLE <= 500 || __BSD_VISIBLE
303double gamma(double);
304#endif
305
306#if __XSI_VISIBLE <= 600 || __BSD_VISIBLE
307double scalb(double, double);
308#endif
309#endif /* __BSD_VISIBLE || __XSI_VISIBLE */
310
311#if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999
312double copysign(double, double) __pure2;
313double fdim(double, double);
314double fmax(double, double) __pure2;
315double fmin(double, double) __pure2;
316double nearbyint(double);
317double round(double);
318double scalbln(double, long);
319double scalbn(double, int);
320double tgamma(double);
321double trunc(double);
322#endif
323
324/*
325 * BSD math library entry points
326 */
327#if __BSD_VISIBLE
328double drem(double, double);
329int finite(double) __pure2;
330int isnanf(float) __pure2;
331
332/*
333 * Reentrant version of gamma & lgamma; passes signgam back by reference
334 * as the second argument; user must allocate space for signgam.
335 */
336double gamma_r(double, int *);
337double lgamma_r(double, int *);
338
339/*
340 * IEEE Test Vector
341 */
342double significand(double);
343#endif /* __BSD_VISIBLE */
344
345/* float versions of ANSI/POSIX functions */
346#if __ISO_C_VISIBLE >= 1999
347float acosf(float);
348float asinf(float);
349float atanf(float);
350float atan2f(float, float);
351float cosf(float);
352float sinf(float);
353float tanf(float);
354
355float coshf(float);
356float sinhf(float);
357float tanhf(float);
358
359float exp2f(float);
360float expf(float);
361float expm1f(float);
362float frexpf(float, int *); /* fundamentally !__pure2 */
363int ilogbf(float) __pure2;
364float ldexpf(float, int);
365float log10f(float);
366float log1pf(float);
367float log2f(float);
368float logf(float);
369float modff(float, float *); /* fundamentally !__pure2 */
370
371float powf(float, float);
372float sqrtf(float);
373
374float ceilf(float);
375float fabsf(float) __pure2;
376float floorf(float);
377float fmodf(float, float);
378float roundf(float);
379
380float erff(float);
381float erfcf(float);
382float hypotf(float, float);
383float lgammaf(float);
384float tgammaf(float);
385
386float acoshf(float);
387float asinhf(float);
388float atanhf(float);
389float cbrtf(float);
390float logbf(float);
391float copysignf(float, float) __pure2;
392long long llrintf(float);
393long long llroundf(float);
394long lrintf(float);
395long lroundf(float);
396float nanf(const char *) __pure2;
397float nearbyintf(float);
398float nextafterf(float, float);
399float remainderf(float, float);
400float remquof(float, float, int *);
401float rintf(float);
402float scalblnf(float, long);
403float scalbnf(float, int);
404float truncf(float);
405
406float fdimf(float, float);
407float fmaf(float, float, float);
408float fmaxf(float, float) __pure2;
409float fminf(float, float) __pure2;
410#endif
411
412/*
413 * float versions of BSD math library entry points
414 */
415#if __BSD_VISIBLE
416float dremf(float, float);
417int finitef(float) __pure2;
418float gammaf(float);
419float j0f(float);
420float j1f(float);
421float jnf(int, float);
422float scalbf(float, float);
423float y0f(float);
424float y1f(float);
425float ynf(int, float);
426
427/*
428 * Float versions of reentrant version of gamma & lgamma; passes
429 * signgam back by reference as the second argument; user must
430 * allocate space for signgam.
431 */
432float gammaf_r(float, int *);
433float lgammaf_r(float, int *);
434
435/*
436 * float version of IEEE Test Vector
437 */
438float significandf(float);
439#endif /* __BSD_VISIBLE */
440
441/*
442 * long double versions of ISO/POSIX math functions
443 */
444#if __ISO_C_VISIBLE >= 1999
445long double acoshl(long double);
446long double acosl(long double);
447long double asinhl(long double);
448long double asinl(long double);
449long double atan2l(long double, long double);
450long double atanhl(long double);
451long double atanl(long double);
452long double cbrtl(long double);
453long double ceill(long double);
454long double copysignl(long double, long double) __pure2;
455long double coshl(long double);
456long double cosl(long double);
457long double erfcl(long double);
458long double erfl(long double);
459long double exp2l(long double);
460long double expl(long double);
461long double expm1l(long double);
462long double fabsl(long double) __pure2;
463long double fdiml(long double, long double);
464long double floorl(long double);
465long double fmal(long double, long double, long double);
466long double fmaxl(long double, long double) __pure2;
467long double fminl(long double, long double) __pure2;
468long double fmodl(long double, long double);
469long double frexpl(long double, int *); /* fundamentally !__pure2 */
470long double hypotl(long double, long double);
471int ilogbl(long double) __pure2;
472long double ldexpl(long double, int);
473long double lgammal(long double);
474long long llrintl(long double);
475long long llroundl(long double);
476long double log10l(long double);
477long double log1pl(long double);
478long double log2l(long double);
479long double logbl(long double);
480long double logl(long double);
481long lrintl(long double);
482long lroundl(long double);
483long double modfl(long double, long double *); /* fundamentally !__pure2 */
484long double nanl(const char *) __pure2;
485long double nearbyintl(long double);
486long double nextafterl(long double, long double);
487double nexttoward(double, long double);
488float nexttowardf(float, long double);
489long double nexttowardl(long double, long double);
490long double powl(long double, long double);
491long double remainderl(long double, long double);
492long double remquol(long double, long double, int *);
493long double rintl(long double);
494long double roundl(long double);
495long double scalblnl(long double, long);
496long double scalbnl(long double, int);
497long double sinhl(long double);
498long double sinl(long double);
499long double sqrtl(long double);
500long double tanhl(long double);
501long double tanl(long double);
502long double tgammal(long double);
503long double truncl(long double);
504#endif /* __ISO_C_VISIBLE >= 1999 */
505
506#if __BSD_VISIBLE
507long double lgammal_r(long double, int *);
508void sincos(double, double *, double *);
509void sincosf(float, float *, float *);
510void sincosl(long double, long double *, long double *);
511double cospi(double);
512float cospif(float);
513long double cospil(long double);
514double sinpi(double);
515float sinpif(float);
516long double sinpil(long double);
517double tanpi(double);
518float tanpif(float);
519long double tanpil(long double);
520#endif
521
522__END_DECLS
523
524#endif /* !_MATH_H_ */