1/* $NetBSD: math.h,v 1.72 2024/09/09 15:06:29 riastradh Exp $ */
2
3/*
4 * ====================================================
5 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
6 *
7 * Developed at SunPro, a Sun Microsystems, Inc. business.
8 * Permission to use, copy, modify, and distribute this
9 * software is freely granted, provided that this notice
10 * is preserved.
11 * ====================================================
12 */
13
14/*
15 * @(#)fdlibm.h 5.1 93/09/24
16 */
17
18#ifndef _MATH_H_
19#define _MATH_H_
20
21#include <sys/cdefs.h>
22#include <sys/featuretest.h>
23
24union __float_u {
25 unsigned char __dummy[sizeof(float)];
26 float __val;
27};
28
29union __double_u {
30 unsigned char __dummy[sizeof(double)];
31 double __val;
32};
33
34union __long_double_u {
35 unsigned char __dummy[sizeof(long double)];
36 long double __val;
37};
38
39#include <machine/math.h> /* may use __float_u, __double_u,
40 or __long_double_u */
41#include <limits.h> /* for INT_{MIN,MAX} */
42
43#if (!defined(_ANSI_SOURCE) && !defined(_POSIX_C_SOURCE) && \
44 !defined(_XOPEN_SOURCE)) || ((_POSIX_C_SOURCE - 0) >= 200809L || \
45 defined(_ISOC99_SOURCE) || (__STDC_VERSION__ - 0) >= 199901L || \
46 (__cplusplus - 0) >= 201103L || defined(_NETBSD_SOURCE))
47#define __MATH_C99_FEATURES
48#endif
49
50#ifdef __MATH_C99_FEATURES
51# if defined(__FLT_EVAL_METHOD__) && (__FLT_EVAL_METHOD__ - 0) == 0
52typedef double double_t;
53typedef float float_t;
54# elif (__FLT_EVAL_METHOD__ - 0) == 1
55typedef double double_t;
56typedef double float_t;
57# elif (__FLT_EVAL_METHOD__ - 0) == 2
58typedef long double double_t;
59typedef long double float_t;
60# endif
61#endif
62
63#ifdef __HAVE_LONG_DOUBLE
64#define __fpmacro_unary_floating(__name, __arg0) \
65 /* LINTED */ \
66 ((sizeof (__arg0) == sizeof (float)) \
67 ? __ ## __name ## f (__arg0) \
68 : (sizeof (__arg0) == sizeof (double)) \
69 ? __ ## __name ## d (__arg0) \
70 : __ ## __name ## l (__arg0))
71#else
72#define __fpmacro_unary_floating(__name, __arg0) \
73 /* LINTED */ \
74 ((sizeof (__arg0) == sizeof (float)) \
75 ? __ ## __name ## f (__arg0) \
76 : __ ## __name ## d (__arg0))
77#endif /* __HAVE_LONG_DOUBLE */
78
79/*
80 * ANSI/POSIX
81 */
82/* 7.12#3 HUGE_VAL, HUGELF, HUGE_VALL */
83#if __GNUC_PREREQ__(3, 3)
84#define HUGE_VAL __builtin_huge_val()
85#else
86extern const union __double_u __infinity;
87#define HUGE_VAL __infinity.__val
88#endif
89
90/*
91 * ISO C99
92 */
93#if defined(__MATH_C99_FEATURES) || \
94 (_POSIX_C_SOURCE - 0) >= 200112L || (_XOPEN_SOURCE - 0) >= 600
95/* 7.12#3 HUGE_VAL, HUGELF, HUGE_VALL */
96#if __GNUC_PREREQ__(3, 3)
97#define HUGE_VALF __builtin_huge_valf()
98#define HUGE_VALL __builtin_huge_vall()
99#else
100extern const union __float_u __infinityf;
101#define HUGE_VALF __infinityf.__val
102
103extern const union __long_double_u __infinityl;
104#define HUGE_VALL __infinityl.__val
105#endif
106
107/* 7.12#4 INFINITY */
108#if defined(__INFINITY)
109#define INFINITY __INFINITY /* float constant which overflows */
110#elif __GNUC_PREREQ__(3, 3)
111#define INFINITY __builtin_inff()
112#else
113#define INFINITY HUGE_VALF /* positive infinity */
114#endif /* __INFINITY */
115
116/* 7.12#5 NAN: a quiet NaN, if supported */
117#ifdef __HAVE_NANF
118#if __GNUC_PREREQ__(3,3)
119#define NAN __builtin_nanf("")
120#else
121extern const union __float_u __nanf;
122#define NAN __nanf.__val
123#endif
124#endif /* __HAVE_NANF */
125
126/* 7.12#6 number classification macros */
127#define FP_INFINITE 0x00
128#define FP_NAN 0x01
129#define FP_NORMAL 0x02
130#define FP_SUBNORMAL 0x03
131#define FP_ZERO 0x04
132/* NetBSD extensions */
133#define _FP_LOMD 0x80 /* range for machine-specific classes */
134#define _FP_HIMD 0xff
135
136/* 7.12#7 fast fma(3) feature test macros */
137#if __GNUC_PREREQ__(4, 4)
138# ifdef __FP_FAST_FMA
139# define FP_FAST_FMA 1
140# endif
141# ifdef __FP_FAST_FMAF
142# define FP_FAST_FMAF 1
143# endif
144# ifdef __FP_FAST_FMAL
145# define FP_FAST_FMAL 1
146# endif
147#endif
148
149/* 7.12#8 ilogb exceptional input result value macros */
150#define FP_ILOGB0 INT_MIN
151#define FP_ILOGBNAN INT_MAX
152
153/* 7.12#9 error handling (__math_errhandling from machine/math.h) */
154#define MATH_ERRNO 1
155#define MATH_ERREXCEPT 2
156#ifdef __vax__ /* XXX !__HAVE_FENV */
157#define math_errhandling MATH_ERRNO
158#else
159#define math_errhandling MATH_ERREXCEPT
160#endif
161
162#endif /* C99 || _XOPEN_SOURCE >= 600 */
163
164/*
165 * XOPEN/SVID
166 */
167#if defined(_XOPEN_SOURCE) || defined(_NETBSD_SOURCE)
168#define M_E 2.7182818284590452354 /* e */
169#define M_LOG2E 1.4426950408889634074 /* log 2e */
170#define M_LOG10E 0.43429448190325182765 /* log 10e */
171#define M_LN2 0.69314718055994530942 /* log e2 */
172#define M_LN10 2.30258509299404568402 /* log e10 */
173#define M_PI 3.14159265358979323846 /* pi */
174#define M_PI_2 1.57079632679489661923 /* pi/2 */
175#define M_PI_4 0.78539816339744830962 /* pi/4 */
176#define M_1_PI 0.31830988618379067154 /* 1/pi */
177#define M_2_PI 0.63661977236758134308 /* 2/pi */
178#define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
179#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
180#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
181
182#define MAXFLOAT ((float)3.40282346638528860e+38)
183extern int signgam;
184#endif /* _XOPEN_SOURCE || _NETBSD_SOURCE */
185
186#if defined(_NETBSD_SOURCE)
187enum fdversion {fdlibm_ieee = -1, fdlibm_svid, fdlibm_xopen, fdlibm_posix};
188
189#define _LIB_VERSION_TYPE enum fdversion
190#define _LIB_VERSION _fdlib_version
191
192/* if global variable _LIB_VERSION is not desirable, one may
193 * change the following to be a constant by:
194 * #define _LIB_VERSION_TYPE const enum version
195 * In that case, after one initializes the value _LIB_VERSION (see
196 * s_lib_version.c) during compile time, it cannot be modified
197 * in the middle of a program
198 */
199extern _LIB_VERSION_TYPE _LIB_VERSION;
200
201#define _IEEE_ fdlibm_ieee
202#define _SVID_ fdlibm_svid
203#define _XOPEN_ fdlibm_xopen
204#define _POSIX_ fdlibm_posix
205
206#ifndef __cplusplus
207struct exception {
208 int type;
209 const char *name;
210 double arg1;
211 double arg2;
212 double retval;
213};
214#endif
215
216#define HUGE MAXFLOAT
217
218/*
219 * set X_TLOSS = pi*2**52, which is possibly defined in <values.h>
220 * (one may replace the following line by "#include <values.h>")
221 */
222
223#define X_TLOSS 1.41484755040568800000e+16
224
225#define DOMAIN 1
226#define SING 2
227#define OVERFLOW 3
228#define UNDERFLOW 4
229#define TLOSS 5
230#define PLOSS 6
231
232#endif /* _NETBSD_SOURCE */
233
234__BEGIN_DECLS
235/*
236 * ANSI/POSIX
237 */
238double acos(double);
239double asin(double);
240double atan(double);
241double atan2(double, double);
242double cos(double);
243double sin(double);
244double tan(double);
245
246double cosh(double);
247double sinh(double);
248double tanh(double);
249
250double exp(double);
251double exp2(double);
252double frexp(double, int *);
253double ldexp(double, int);
254double log(double);
255double log2(double);
256double log10(double);
257double modf(double, double *);
258
259double pow(double, double);
260double sqrt(double);
261
262double ceil(double);
263double fabs(double);
264double floor(double);
265double fmod(double, double);
266
267#if defined(__MATH_C99_FEATURES) || defined(_XOPEN_SOURCE)
268double erf(double);
269double erfc(double);
270double hypot(double, double);
271#endif
272
273#if defined(_XOPEN_SOURCE) || defined(_NETBSD_SOURCE)
274int finite(double);
275double gamma(double);
276double j0(double);
277double j1(double);
278double jn(int, double);
279double y0(double);
280double y1(double);
281double yn(int, double);
282
283#if (_XOPEN_SOURCE - 0) >= 500 || defined(_NETBSD_SOURCE)
284double scalb(double, double);
285#endif /* (_XOPEN_SOURCE - 0) >= 500 || defined(_NETBSD_SOURCE)*/
286#endif /* _XOPEN_SOURCE || _NETBSD_SOURCE */
287
288/*
289 * ISO C99
290 */
291#if defined(__MATH_C99_FEATURES) || (_XOPEN_SOURCE - 0) >= 500
292double acosh(double);
293double asinh(double);
294double atanh(double);
295double cbrt(double);
296double expm1(double);
297int ilogb(double);
298double log1p(double);
299double logb(double);
300double nextafter(double, double);
301double remainder(double, double);
302double rint(double);
303#endif
304
305#if defined(__MATH_C99_FEATURES) || (_XOPEN_SOURCE - 0) >= 600 || \
306 (_POSIX_C_SOURCE - 0) >= 200112L
307/* 7.12.3.1 int fpclassify(real-floating x) */
308#define fpclassify(__x) __fpmacro_unary_floating(fpclassify, __x)
309
310/* 7.12.3.2 int isfinite(real-floating x) */
311#define isfinite(__x) __fpmacro_unary_floating(isfinite, __x)
312
313/* 7.12.3.5 int isnormal(real-floating x) */
314#define isnormal(__x) (fpclassify(__x) == FP_NORMAL)
315
316/* 7.12.3.6 int signbit(real-floating x) */
317#define signbit(__x) __fpmacro_unary_floating(signbit, __x)
318
319/* 7.12.4 trigonometric */
320
321float acosf(float);
322float asinf(float);
323float atanf(float);
324float atan2f(float, float);
325float cosf(float);
326float sinf(float);
327float tanf(float);
328
329long double acosl(long double);
330long double asinl(long double);
331long double atanl(long double);
332long double atan2l(long double, long double);
333long double cosl(long double);
334long double sinl(long double);
335long double tanl(long double);
336
337/* 7.12.5 hyperbolic */
338
339float acoshf(float);
340float asinhf(float);
341float atanhf(float);
342float coshf(float);
343float sinhf(float);
344float tanhf(float);
345long double acoshl(long double);
346long double asinhl(long double);
347long double atanhl(long double);
348long double coshl(long double);
349long double sinhl(long double);
350long double tanhl(long double);
351
352/* 7.12.6 exp / log */
353double scalbn(double, int);
354double scalbln(double, long);
355
356float expf(float);
357float exp2f(float);
358float expm1f(float);
359float frexpf(float, int *);
360int ilogbf(float);
361float ldexpf(float, int);
362float logf(float);
363float log2f(float);
364float log10f(float);
365float log1pf(float);
366float logbf(float);
367float modff(float, float *);
368float scalbnf(float, int);
369float scalblnf(float, long);
370
371long double expl(long double);
372long double exp2l(long double);
373long double expm1l(long double);
374long double frexpl(long double, int *);
375int ilogbl(long double);
376long double ldexpl(long double, int);
377long double logl(long double);
378long double log2l(long double);
379long double log10l(long double);
380long double log1pl(long double);
381long double logbl(long double);
382long double modfl(long double, long double *);
383long double scalbnl(long double, int);
384long double scalblnl(long double, long);
385
386
387/* 7.12.7 power / absolute */
388
389float cbrtf(float);
390float fabsf(float);
391float hypotf(float, float);
392float powf(float, float);
393float sqrtf(float);
394long double cbrtl(long double);
395long double fabsl(long double);
396long double hypotl(long double, long double);
397long double powl(long double, long double);
398long double sqrtl(long double);
399
400/* 7.12.8 error / gamma */
401
402double lgamma(double);
403double tgamma(double);
404float erff(float);
405float erfcf(float);
406float lgammaf(float);
407float tgammaf(float);
408long double erfl(long double);
409long double erfcl(long double);
410long double lgammal(long double);
411long double tgammal(long double);
412
413/* 7.12.9 nearest integer */
414
415/* LONGLONG */
416long long int llrint(double);
417long int lround(double);
418/* LONGLONG */
419long long int llround(double);
420long int lrint(double);
421double round(double);
422double trunc(double);
423
424float ceilf(float);
425float floorf(float);
426/* LONGLONG */
427long long int llrintf(float);
428long int lroundf(float);
429/* LONGLONG */
430long long int llroundf(float);
431long int lrintf(float);
432float rintf(float);
433float roundf(float);
434float truncf(float);
435long double ceill(long double);
436long double floorl(long double);
437/* LONGLONG */
438long long int llrintl(long double);
439long int lroundl(long double);
440/* LONGLONG */
441long long int llroundl(long double);
442long int lrintl(long double);
443long double rintl(long double);
444long double roundl(long double);
445long double truncl(long double);
446
447/* 7.12.10 remainder */
448
449float fmodf(float, float);
450float remainderf(float, float);
451long double fmodl(long double, long double);
452long double remainderl(long double, long double);
453
454/* 7.12.10.3 The remquo functions */
455double remquo(double, double, int *);
456float remquof(float, float, int *);
457long double remquol(long double, long double, int *);
458
459/* 7.12.11 manipulation */
460
461double copysign(double, double);
462double nan(const char *);
463double nearbyint(double);
464double nexttoward(double, long double);
465float copysignf(float, float);
466float nanf(const char *);
467float nearbyintf(float);
468float nextafterf(float, float);
469float nexttowardf(float, long double);
470long double copysignl(long double, long double);
471long double nanl(const char *);
472long double nearbyintl(long double);
473long double nextafterl(long double, long double);
474long double nexttowardl(long double, long double);
475
476/* 7.12.14 comparison */
477
478#define isunordered(x, y) (isnan(x) || isnan(y))
479#define isgreater(x, y) (!isunordered((x), (y)) && (x) > (y))
480#define isgreaterequal(x, y) (!isunordered((x), (y)) && (x) >= (y))
481#define isless(x, y) (!isunordered((x), (y)) && (x) < (y))
482#define islessequal(x, y) (!isunordered((x), (y)) && (x) <= (y))
483#define islessgreater(x, y) (!isunordered((x), (y)) && \
484 ((x) > (y) || (y) > (x)))
485double fdim(double, double);
486double fma(double, double, double);
487double fmax(double, double);
488double fmin(double, double);
489float fdimf(float, float);
490float fmaf(float, float, float);
491float fmaxf(float, float);
492float fminf(float, float);
493long double fdiml(long double, long double);
494long double fmal(long double, long double, long double);
495long double fmaxl(long double, long double);
496long double fminl(long double, long double);
497
498#endif /* !_ANSI_SOURCE && ... */
499
500#if defined(__MATH_C99_FEATURES) || (_POSIX_C_SOURCE - 0) >= 200112L
501/* 7.12.3.3 int isinf(real-floating x) */
502#if defined(__isinf) || defined(__HAVE_INLINE___ISINF)
503#define isinf(__x) __isinf(__x)
504#else
505#define isinf(__x) __fpmacro_unary_floating(isinf, __x)
506#endif
507
508/* 7.12.3.4 int isnan(real-floating x) */
509#if defined(__isnan) || defined(__HAVE_INLINE___ISNAN)
510#define isnan(__x) __isnan(__x)
511#else
512#define isnan(__x) __fpmacro_unary_floating(isnan, __x)
513#endif
514#endif /* !_ANSI_SOURCE && ... */
515
516#if defined(_NETBSD_SOURCE)
517
518#ifndef __cplusplus
519int matherr(struct exception *);
520#endif
521
522/*
523 * IEEE Test Vector
524 */
525double significand(double);
526
527/*
528 * BSD math library entry points
529 */
530double drem(double, double);
531
532void sincos(double, double *, double *);
533void sincosf(float, float *, float *);
534void sincosl(long double, long double *, long double *);
535
536double cospi(double);
537float cospif(float);
538long double cospil(long double);
539
540double sinpi(double);
541float sinpif(float);
542long double sinpil(long double);
543
544double tanpi(double);
545float tanpif(float);
546long double tanpil(long double);
547
548#endif /* _NETBSD_SOURCE */
549
550#if defined(_NETBSD_SOURCE) || defined(_REENTRANT)
551/*
552 * Reentrant version of gamma & lgamma; passes signgam back by reference
553 * as the second argument; user must allocate space for signgam.
554 */
555double gamma_r(double, int *);
556double lgamma_r(double, int *);
557long double lgammal_r(long double, int *);
558#endif /* _NETBSD_SOURCE || _REENTRANT */
559
560#if defined(_NETBSD_SOURCE)
561
562/* float versions of ANSI/POSIX functions */
563
564float gammaf(float);
565int isinff(float);
566int isnanf(float);
567int finitef(float);
568float j0f(float);
569float j1f(float);
570float jnf(int, float);
571float y0f(float);
572float y1f(float);
573float ynf(int, float);
574
575float scalbf(float, float);
576
577/*
578 * float version of IEEE Test Vector
579 */
580float significandf(float);
581
582/*
583 * float versions of BSD math library entry points
584 */
585float dremf(float, float);
586#endif /* _NETBSD_SOURCE */
587
588#if defined(_NETBSD_SOURCE) || defined(_REENTRANT)
589/*
590 * Float versions of reentrant version of gamma & lgamma; passes
591 * signgam back by reference as the second argument; user must
592 * allocate space for signgam.
593 */
594float gammaf_r(float, int *);
595float lgammaf_r(float, int *);
596#endif /* !... || _REENTRANT */
597
598/*
599 * Library implementation
600 */
601int __fpclassifyf(float);
602int __fpclassifyd(double);
603int __isfinitef(float);
604int __isfinited(double);
605int __isinff(float);
606int __isinfd(double);
607int __isnanf(float);
608int __isnand(double);
609int __signbitf(float);
610int __signbitd(double);
611
612#ifdef __HAVE_LONG_DOUBLE
613int __fpclassifyl(long double);
614int __isfinitel(long double);
615int __isinfl(long double);
616int __isnanl(long double);
617int __signbitl(long double);
618#endif
619
620__END_DECLS
621
622#endif /* _MATH_H_ */