xref: /freebsd/lib/msun/src/math.h (revision 240dbabfa8e8f13bf761868a69f3045a8bc474ab)
13a8617a8SJordan K. Hubbard /*
23a8617a8SJordan K. Hubbard  * ====================================================
33a8617a8SJordan K. Hubbard  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
43a8617a8SJordan K. Hubbard  *
53a8617a8SJordan K. Hubbard  * Developed at SunPro, a Sun Microsystems, Inc. business.
63a8617a8SJordan K. Hubbard  * Permission to use, copy, modify, and distribute this
73a8617a8SJordan K. Hubbard  * software is freely granted, provided that this notice
83a8617a8SJordan K. Hubbard  * is preserved.
93a8617a8SJordan K. Hubbard  * ====================================================
103a8617a8SJordan K. Hubbard  */
113a8617a8SJordan K. Hubbard 
123a8617a8SJordan K. Hubbard /*
133a8617a8SJordan K. Hubbard  * from: @(#)fdlibm.h 5.1 93/09/24
147f3dea24SPeter Wemm  * $FreeBSD$
153a8617a8SJordan K. Hubbard  */
163a8617a8SJordan K. Hubbard 
173a8617a8SJordan K. Hubbard #ifndef _MATH_H_
183a8617a8SJordan K. Hubbard #define	_MATH_H_
193a8617a8SJordan K. Hubbard 
20207bc1d7SDavid Schultz #include <sys/cdefs.h>
218cf5ed51SMike Barcroft #include <sys/_types.h>
2283bc8931SStefan Farfeleder #include <machine/_limits.h>
238cf5ed51SMike Barcroft 
243a8617a8SJordan K. Hubbard /*
253a8617a8SJordan K. Hubbard  * ANSI/POSIX
263a8617a8SJordan K. Hubbard  */
2783999f5aSArchie Cobbs extern const union __infinity_un {
2883999f5aSArchie Cobbs 	unsigned char	__uc[8];
2983999f5aSArchie Cobbs 	double		__ud;
3083999f5aSArchie Cobbs } __infinity;
318cf5ed51SMike Barcroft 
328cf5ed51SMike Barcroft extern const union __nan_un {
338cf5ed51SMike Barcroft 	unsigned char	__uc[sizeof(float)];
348cf5ed51SMike Barcroft 	float		__uf;
358cf5ed51SMike Barcroft } __nan;
368cf5ed51SMike Barcroft 
37b2d5d0b3SDavid Schultz #if (defined(__GNUC__) && __GNUC__ >= 3) || defined(__INTEL_COMPILER)
38b2d5d0b3SDavid Schultz #define	__MATH_BUILTIN_CONSTANTS
39b2d5d0b3SDavid Schultz #endif
40b2d5d0b3SDavid Schultz 
41b2d5d0b3SDavid Schultz #if (defined(__GNUC__) && __GNUC__ >= 3)
42b2d5d0b3SDavid Schultz #define	__MATH_BUILTIN_RELOPS
43b2d5d0b3SDavid Schultz #endif
44b2d5d0b3SDavid Schultz 
45b2d5d0b3SDavid Schultz #ifdef __MATH_BUILTIN_CONSTANTS
46b2d5d0b3SDavid Schultz #define	HUGE_VAL	__builtin_huge_val()
47b2d5d0b3SDavid Schultz #else
488f3f7c66SDavid Schultz #define	HUGE_VAL	(__infinity.__ud)
49b2d5d0b3SDavid Schultz #endif
508f3f7c66SDavid Schultz 
518f3f7c66SDavid Schultz #if __ISO_C_VISIBLE >= 1999
5283bc8931SStefan Farfeleder #define	FP_ILOGB0	(-__INT_MAX)
5383bc8931SStefan Farfeleder #define	FP_ILOGBNAN	__INT_MAX
54b2d5d0b3SDavid Schultz 
55b2d5d0b3SDavid Schultz #ifdef __MATH_BUILTIN_CONSTANTS
56b2d5d0b3SDavid Schultz #define	HUGE_VALF	__builtin_huge_valf()
57b2d5d0b3SDavid Schultz #define	HUGE_VALL	__builtin_huge_vall()
58b2d5d0b3SDavid Schultz #define	INFINITY	__builtin_inf()
59b2d5d0b3SDavid Schultz #define	NAN		__builtin_nan("")
60b2d5d0b3SDavid Schultz #else
618cf5ed51SMike Barcroft #define	HUGE_VALF	(float)HUGE_VAL
628cf5ed51SMike Barcroft #define	HUGE_VALL	(long double)HUGE_VAL
638cf5ed51SMike Barcroft #define	INFINITY	HUGE_VALF
648cf5ed51SMike Barcroft #define	NAN		(__nan.__uf)
65b2d5d0b3SDavid Schultz #endif /* __MATH_BUILTIN_CONSTANTS */
668cf5ed51SMike Barcroft 
676eb2d83eSBruce Evans #define	MATH_ERRNO	1
686eb2d83eSBruce Evans #define	MATH_ERREXCEPT	2
696eb2d83eSBruce Evans #define	math_errhandling	0
706eb2d83eSBruce Evans 
718cf5ed51SMike Barcroft /* Symbolic constants to classify floating point numbers. */
725d62092fSMike Barcroft #define	FP_INFINITE	0x01
735d62092fSMike Barcroft #define	FP_NAN		0x02
745d62092fSMike Barcroft #define	FP_NORMAL	0x04
755d62092fSMike Barcroft #define	FP_SUBNORMAL	0x08
765d62092fSMike Barcroft #define	FP_ZERO		0x10
778cf5ed51SMike Barcroft #define	fpclassify(x) \
788cf5ed51SMike Barcroft     ((sizeof (x) == sizeof (float)) ? __fpclassifyf(x) \
798cf5ed51SMike Barcroft     : (sizeof (x) == sizeof (double)) ? __fpclassifyd(x) \
808cf5ed51SMike Barcroft     : __fpclassifyl(x))
815d62092fSMike Barcroft 
82240dbabfSDavid Schultz #define	isfinite(x)					\
83240dbabfSDavid Schultz     ((sizeof (x) == sizeof (float)) ? __isfinitef(x)	\
84240dbabfSDavid Schultz     : (sizeof (x) == sizeof (double)) ? __isfinite(x)	\
85240dbabfSDavid Schultz     : __isfinitel(x))
86240dbabfSDavid Schultz #define	isinf(x)					\
87240dbabfSDavid Schultz     ((sizeof (x) == sizeof (float)) ? __isinff(x)	\
88240dbabfSDavid Schultz     : (sizeof (x) == sizeof (double)) ? isinf(x)	\
89240dbabfSDavid Schultz     : __isinfl(x))
90240dbabfSDavid Schultz #define	isnan(x)					\
91240dbabfSDavid Schultz     ((sizeof (x) == sizeof (float)) ? isnanf(x)		\
92240dbabfSDavid Schultz     : (sizeof (x) == sizeof (double)) ? isnan(x)	\
93240dbabfSDavid Schultz     : __isnanl(x))
94240dbabfSDavid Schultz #define	isnormal(x)					\
95240dbabfSDavid Schultz     ((sizeof (x) == sizeof (float)) ? __isnormalf(x)	\
96240dbabfSDavid Schultz     : (sizeof (x) == sizeof (double)) ? __isnormal(x)	\
97240dbabfSDavid Schultz     : __isnormall(x))
985d62092fSMike Barcroft 
99b2d5d0b3SDavid Schultz #ifdef __MATH_BUILTIN_RELOPS
100b2d5d0b3SDavid Schultz #define	isgreater(x, y)		__builtin_isgreater((x), (y))
101b2d5d0b3SDavid Schultz #define	isgreaterequal(x, y)	__builtin_isgreaterequal((x), (y))
102b2d5d0b3SDavid Schultz #define	isless(x, y)		__builtin_isless((x), (y))
103b2d5d0b3SDavid Schultz #define	islessequal(x, y)	__builtin_islessequal((x), (y))
104b2d5d0b3SDavid Schultz #define	islessgreater(x, y)	__builtin_islessgreater((x), (y))
105b2d5d0b3SDavid Schultz #define	isunordered(x, y)	__builtin_isunordered((x), (y))
106b2d5d0b3SDavid Schultz #else
1075d62092fSMike Barcroft #define	isgreater(x, y)		(!isunordered((x), (y)) && (x) > (y))
1085d62092fSMike Barcroft #define	isgreaterequal(x, y)	(!isunordered((x), (y)) && (x) >= (y))
1095d62092fSMike Barcroft #define	isless(x, y)		(!isunordered((x), (y)) && (x) < (y))
1105d62092fSMike Barcroft #define	islessequal(x, y)	(!isunordered((x), (y)) && (x) <= (y))
1115d62092fSMike Barcroft #define	islessgreater(x, y)	(!isunordered((x), (y)) && \
1125d62092fSMike Barcroft 					((x) > (y) || (y) > (x)))
1135d62092fSMike Barcroft #define	isunordered(x, y)	(isnan(x) || isnan(y))
114b2d5d0b3SDavid Schultz #endif /* __MATH_BUILTIN_RELOPS */
1155d62092fSMike Barcroft 
1168e9b2831SMike Barcroft #define	signbit(x)	__signbit(x)
1178cf5ed51SMike Barcroft 
1188cf5ed51SMike Barcroft typedef	__double_t	double_t;
1198cf5ed51SMike Barcroft typedef	__float_t	float_t;
1208f3f7c66SDavid Schultz #endif /* __ISO_C_VISIBLE >= 1999 */
1213a8617a8SJordan K. Hubbard 
1223a8617a8SJordan K. Hubbard /*
1233a8617a8SJordan K. Hubbard  * XOPEN/SVID
1243a8617a8SJordan K. Hubbard  */
1258f3f7c66SDavid Schultz #if __BSD_VISIBLE || __XSI_VISIBLE
1263a8617a8SJordan K. Hubbard #define	M_E		2.7182818284590452354	/* e */
1273a8617a8SJordan K. Hubbard #define	M_LOG2E		1.4426950408889634074	/* log 2e */
1283a8617a8SJordan K. Hubbard #define	M_LOG10E	0.43429448190325182765	/* log 10e */
1293a8617a8SJordan K. Hubbard #define	M_LN2		0.69314718055994530942	/* log e2 */
1303a8617a8SJordan K. Hubbard #define	M_LN10		2.30258509299404568402	/* log e10 */
1313a8617a8SJordan K. Hubbard #define	M_PI		3.14159265358979323846	/* pi */
1323a8617a8SJordan K. Hubbard #define	M_PI_2		1.57079632679489661923	/* pi/2 */
1333a8617a8SJordan K. Hubbard #define	M_PI_4		0.78539816339744830962	/* pi/4 */
1343a8617a8SJordan K. Hubbard #define	M_1_PI		0.31830988618379067154	/* 1/pi */
1353a8617a8SJordan K. Hubbard #define	M_2_PI		0.63661977236758134308	/* 2/pi */
1363a8617a8SJordan K. Hubbard #define	M_2_SQRTPI	1.12837916709551257390	/* 2/sqrt(pi) */
1373a8617a8SJordan K. Hubbard #define	M_SQRT2		1.41421356237309504880	/* sqrt(2) */
1383a8617a8SJordan K. Hubbard #define	M_SQRT1_2	0.70710678118654752440	/* 1/sqrt(2) */
1393a8617a8SJordan K. Hubbard 
1403a8617a8SJordan K. Hubbard #define	MAXFLOAT	((float)3.40282346638528860e+38)
1413a8617a8SJordan K. Hubbard extern int signgam;
1428f3f7c66SDavid Schultz #endif /* __BSD_VISIBLE || __XSI_VISIBLE */
1433a8617a8SJordan K. Hubbard 
1448f3f7c66SDavid Schultz #if __BSD_VISIBLE
1453a8617a8SJordan K. Hubbard enum fdversion {fdlibm_ieee = -1, fdlibm_svid, fdlibm_xopen, fdlibm_posix};
1463a8617a8SJordan K. Hubbard 
1473a8617a8SJordan K. Hubbard #define _LIB_VERSION_TYPE enum fdversion
1483a8617a8SJordan K. Hubbard #define _LIB_VERSION _fdlib_version
1493a8617a8SJordan K. Hubbard 
1503a8617a8SJordan K. Hubbard /* if global variable _LIB_VERSION is not desirable, one may
1513a8617a8SJordan K. Hubbard  * change the following to be a constant by:
1523a8617a8SJordan K. Hubbard  *	#define _LIB_VERSION_TYPE const enum version
1533a8617a8SJordan K. Hubbard  * In that case, after one initializes the value _LIB_VERSION (see
1543a8617a8SJordan K. Hubbard  * s_lib_version.c) during compile time, it cannot be modified
1553a8617a8SJordan K. Hubbard  * in the middle of a program
1563a8617a8SJordan K. Hubbard  */
1573a8617a8SJordan K. Hubbard extern  _LIB_VERSION_TYPE  _LIB_VERSION;
1583a8617a8SJordan K. Hubbard 
1593a8617a8SJordan K. Hubbard #define _IEEE_  fdlibm_ieee
1603a8617a8SJordan K. Hubbard #define _SVID_  fdlibm_svid
1613a8617a8SJordan K. Hubbard #define _XOPEN_ fdlibm_xopen
1623a8617a8SJordan K. Hubbard #define _POSIX_ fdlibm_posix
1633a8617a8SJordan K. Hubbard 
164d6f56cfcSDavid E. O'Brien /* We have a problem when using C++ since `exception' is a reserved
165d6f56cfcSDavid E. O'Brien    name in C++.  */
1666a9280beSBruce Evans #ifndef __cplusplus
1673a8617a8SJordan K. Hubbard struct exception {
1683a8617a8SJordan K. Hubbard 	int type;
1693a8617a8SJordan K. Hubbard 	char *name;
1703a8617a8SJordan K. Hubbard 	double arg1;
1713a8617a8SJordan K. Hubbard 	double arg2;
1723a8617a8SJordan K. Hubbard 	double retval;
1733a8617a8SJordan K. Hubbard };
1746a9280beSBruce Evans #endif
1753a8617a8SJordan K. Hubbard 
176219cbe10SBruce Evans #if 0
17754e9b367SBruce Evans /* Old value from 4.4BSD-Lite math.h; this is probably better. */
178219cbe10SBruce Evans #define	HUGE		HUGE_VAL
179219cbe10SBruce Evans #else
1803a8617a8SJordan K. Hubbard #define	HUGE		MAXFLOAT
181219cbe10SBruce Evans #endif
1823a8617a8SJordan K. Hubbard 
183334c760eSDavid Schultz #define X_TLOSS		1.41484755040568800000e+16	/* pi*2**52 */
1843a8617a8SJordan K. Hubbard 
1853a8617a8SJordan K. Hubbard #define	DOMAIN		1
1863a8617a8SJordan K. Hubbard #define	SING		2
1873a8617a8SJordan K. Hubbard #define	OVERFLOW	3
1883a8617a8SJordan K. Hubbard #define	UNDERFLOW	4
1893a8617a8SJordan K. Hubbard #define	TLOSS		5
1903a8617a8SJordan K. Hubbard #define	PLOSS		6
1913a8617a8SJordan K. Hubbard 
1928f3f7c66SDavid Schultz #endif /* __BSD_VISIBLE */
1933a8617a8SJordan K. Hubbard 
194219cbe10SBruce Evans /*
195219cbe10SBruce Evans  * Most of these functions have the side effect of setting errno, so they
196219cbe10SBruce Evans  * are not declared as __pure2.  (XXX: this point needs to be revisited,
197219cbe10SBruce Evans  * since C99 doesn't require the mistake of setting errno, and we mostly
198219cbe10SBruce Evans  * don't set it anyway.  In C99, pragmas and functions for changing the
199219cbe10SBruce Evans  * rounding mode affect the purity of these functions.)
200219cbe10SBruce Evans  */
2016898f8c4SBruce Evans __BEGIN_DECLS
2023a8617a8SJordan K. Hubbard /*
2033a8617a8SJordan K. Hubbard  * ANSI/POSIX
2043a8617a8SJordan K. Hubbard  */
2055d62092fSMike Barcroft int	__fpclassifyd(double) __pure2;
2065d62092fSMike Barcroft int	__fpclassifyf(float) __pure2;
2075d62092fSMike Barcroft int	__fpclassifyl(long double) __pure2;
208240dbabfSDavid Schultz int	__isfinitef(float) __pure2;
209240dbabfSDavid Schultz int	__isfinite(double) __pure2;
210240dbabfSDavid Schultz int	__isfinitel(long double) __pure2;
211240dbabfSDavid Schultz int	__isinff(float) __pure2;
212240dbabfSDavid Schultz int	__isinfl(long double) __pure2;
213240dbabfSDavid Schultz int	__isnanl(long double) __pure2;
214240dbabfSDavid Schultz int	__isnormalf(float) __pure2;
215240dbabfSDavid Schultz int	__isnormal(double) __pure2;
216240dbabfSDavid Schultz int	__isnormall(long double) __pure2;
2175d62092fSMike Barcroft int	__signbit(double) __pure2;
2188cf5ed51SMike Barcroft 
21969160b1eSDavid E. O'Brien double	acos(double);
22069160b1eSDavid E. O'Brien double	asin(double);
22169160b1eSDavid E. O'Brien double	atan(double);
22269160b1eSDavid E. O'Brien double	atan2(double, double);
22369160b1eSDavid E. O'Brien double	cos(double);
22469160b1eSDavid E. O'Brien double	sin(double);
22569160b1eSDavid E. O'Brien double	tan(double);
2263a8617a8SJordan K. Hubbard 
22769160b1eSDavid E. O'Brien double	cosh(double);
22869160b1eSDavid E. O'Brien double	sinh(double);
22969160b1eSDavid E. O'Brien double	tanh(double);
2303a8617a8SJordan K. Hubbard 
23169160b1eSDavid E. O'Brien double	exp(double);
232219cbe10SBruce Evans double	frexp(double, int *);	/* fundamentally !__pure2 */
23369160b1eSDavid E. O'Brien double	ldexp(double, int);
23469160b1eSDavid E. O'Brien double	log(double);
23569160b1eSDavid E. O'Brien double	log10(double);
236219cbe10SBruce Evans double	modf(double, double *);	/* fundamentally !__pure2 */
2373a8617a8SJordan K. Hubbard 
23869160b1eSDavid E. O'Brien double	pow(double, double);
23969160b1eSDavid E. O'Brien double	sqrt(double);
2403a8617a8SJordan K. Hubbard 
24169160b1eSDavid E. O'Brien double	ceil(double);
24269160b1eSDavid E. O'Brien double	fabs(double);
24369160b1eSDavid E. O'Brien double	floor(double);
24469160b1eSDavid E. O'Brien double	fmod(double, double);
2453a8617a8SJordan K. Hubbard 
246219cbe10SBruce Evans /*
247219cbe10SBruce Evans  * These functions are not in C90 so they can be "right".  The ones that
248219cbe10SBruce Evans  * never set errno in lib/msun are declared as __pure2.
249219cbe10SBruce Evans  */
2508f3f7c66SDavid Schultz #if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE
25169160b1eSDavid E. O'Brien double	acosh(double);
25269160b1eSDavid E. O'Brien double	asinh(double);
25369160b1eSDavid E. O'Brien double	atanh(double);
254219cbe10SBruce Evans double	cbrt(double) __pure2;
2558f3f7c66SDavid Schultz double	erf(double);
2568f3f7c66SDavid Schultz double	erfc(double) __pure2;
2578f3f7c66SDavid Schultz double	expm1(double) __pure2;
2584f82cb46SDavid Schultz double	fdim(double, double);
2594f82cb46SDavid Schultz double	fmax(double, double) __pure2;
2604f82cb46SDavid Schultz double	fmin(double, double) __pure2;
2618f3f7c66SDavid Schultz double	hypot(double, double);
2628f3f7c66SDavid Schultz int	ilogb(double);
263240dbabfSDavid Schultz int	(isinf)(double) __pure2;
264240dbabfSDavid Schultz int	(isnan)(double) __pure2;
2658f3f7c66SDavid Schultz double	lgamma(double);
2668f3f7c66SDavid Schultz double	log1p(double) __pure2;
267219cbe10SBruce Evans double	logb(double) __pure2;
2689428e108SDavid Schultz double	nearbyint(double) __pure2;
26969160b1eSDavid E. O'Brien double	nextafter(double, double);
27069160b1eSDavid E. O'Brien double	remainder(double, double);
2718f3f7c66SDavid Schultz double	rint(double) __pure2;
272d0f13633SDavid Schultz double	round(double);
27362247e90SDavid Schultz double	trunc(double);
2748f3f7c66SDavid Schultz #endif /* __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999 || __XSI_VISIBLE */
2753a8617a8SJordan K. Hubbard 
2768f3f7c66SDavid Schultz #if __BSD_VISIBLE || __XSI_VISIBLE
2778f3f7c66SDavid Schultz double	j0(double);
2788f3f7c66SDavid Schultz double	j1(double);
2798f3f7c66SDavid Schultz double	jn(int, double);
2808f3f7c66SDavid Schultz double	scalb(double, double);
2818f3f7c66SDavid Schultz double	y0(double);
2828f3f7c66SDavid Schultz double	y1(double);
2838f3f7c66SDavid Schultz double	yn(int, double);
2848f3f7c66SDavid Schultz 
2858f3f7c66SDavid Schultz #if __XSI_VISIBLE <= 500 || __BSD_VISIBLE
2868f3f7c66SDavid Schultz double	gamma(double);
2876a9280beSBruce Evans #endif
2888f3f7c66SDavid Schultz #endif /* __BSD_VISIBLE || __XSI_VISIBLE */
2898f3f7c66SDavid Schultz 
2908f3f7c66SDavid Schultz #if __BSD_VISIBLE || __ISO_C_VISIBLE >= 1999
2918f3f7c66SDavid Schultz double	copysign(double, double) __pure2;
29262247e90SDavid Schultz double	scalbln(double, long);
2938f3f7c66SDavid Schultz double	scalbn(double, int);
2948f3f7c66SDavid Schultz double	tgamma(double);
2958f3f7c66SDavid Schultz #endif
2968f3f7c66SDavid Schultz 
2978f3f7c66SDavid Schultz /*
2988f3f7c66SDavid Schultz  * BSD math library entry points
2998f3f7c66SDavid Schultz  */
3008f3f7c66SDavid Schultz #if __BSD_VISIBLE
3018f3f7c66SDavid Schultz double	drem(double, double);
3028f3f7c66SDavid Schultz int	finite(double) __pure2;
303240dbabfSDavid Schultz int	isnanf(float) __pure2;
3048f3f7c66SDavid Schultz 
3058f3f7c66SDavid Schultz /*
3068f3f7c66SDavid Schultz  * Reentrant version of gamma & lgamma; passes signgam back by reference
3078f3f7c66SDavid Schultz  * as the second argument; user must allocate space for signgam.
3088f3f7c66SDavid Schultz  */
3098f3f7c66SDavid Schultz double	gamma_r(double, int *);
3108f3f7c66SDavid Schultz double	lgamma_r(double, int *);
3113a8617a8SJordan K. Hubbard 
3123a8617a8SJordan K. Hubbard /*
3133a8617a8SJordan K. Hubbard  * IEEE Test Vector
3143a8617a8SJordan K. Hubbard  */
31569160b1eSDavid E. O'Brien double	significand(double);
3163a8617a8SJordan K. Hubbard 
3178f3f7c66SDavid Schultz #ifndef __cplusplus
3188f3f7c66SDavid Schultz int	matherr(struct exception *);
3198f3f7c66SDavid Schultz #endif
320457f6cd2SWarner Losh #endif /* __BSD_VISIBLE */
3213a8617a8SJordan K. Hubbard 
3223a8617a8SJordan K. Hubbard /* float versions of ANSI/POSIX functions */
3238f3f7c66SDavid Schultz #if __ISO_C_VISIBLE >= 1999
32469160b1eSDavid E. O'Brien float	acosf(float);
32569160b1eSDavid E. O'Brien float	asinf(float);
32669160b1eSDavid E. O'Brien float	atanf(float);
32769160b1eSDavid E. O'Brien float	atan2f(float, float);
32869160b1eSDavid E. O'Brien float	cosf(float);
32969160b1eSDavid E. O'Brien float	sinf(float);
33069160b1eSDavid E. O'Brien float	tanf(float);
3313a8617a8SJordan K. Hubbard 
33269160b1eSDavid E. O'Brien float	coshf(float);
33369160b1eSDavid E. O'Brien float	sinhf(float);
33469160b1eSDavid E. O'Brien float	tanhf(float);
3353a8617a8SJordan K. Hubbard 
33669160b1eSDavid E. O'Brien float	expf(float);
3378f3f7c66SDavid Schultz float	expm1f(float) __pure2;
338219cbe10SBruce Evans float	frexpf(float, int *);	/* fundamentally !__pure2 */
3398f3f7c66SDavid Schultz int	ilogbf(float);
34069160b1eSDavid E. O'Brien float	ldexpf(float, int);
34169160b1eSDavid E. O'Brien float	log10f(float);
3428f3f7c66SDavid Schultz float	log1pf(float) __pure2;
3438f3f7c66SDavid Schultz float	logf(float);
344219cbe10SBruce Evans float	modff(float, float *);	/* fundamentally !__pure2 */
3453a8617a8SJordan K. Hubbard 
34669160b1eSDavid E. O'Brien float	powf(float, float);
34769160b1eSDavid E. O'Brien float	sqrtf(float);
3483a8617a8SJordan K. Hubbard 
34969160b1eSDavid E. O'Brien float	ceilf(float);
35069160b1eSDavid E. O'Brien float	fabsf(float);
35169160b1eSDavid E. O'Brien float	floorf(float);
35269160b1eSDavid E. O'Brien float	fmodf(float, float);
353d0f13633SDavid Schultz float	roundf(float);
3543a8617a8SJordan K. Hubbard 
35569160b1eSDavid E. O'Brien float	erff(float);
356219cbe10SBruce Evans float	erfcf(float) __pure2;
357219cbe10SBruce Evans float	hypotf(float, float) __pure2;
35869160b1eSDavid E. O'Brien float	lgammaf(float);
3593a8617a8SJordan K. Hubbard 
36069160b1eSDavid E. O'Brien float	acoshf(float);
36169160b1eSDavid E. O'Brien float	asinhf(float);
36269160b1eSDavid E. O'Brien float	atanhf(float);
363219cbe10SBruce Evans float	cbrtf(float) __pure2;
364219cbe10SBruce Evans float	logbf(float) __pure2;
3658f3f7c66SDavid Schultz float	copysignf(float, float) __pure2;
3669428e108SDavid Schultz float	nearbyintf(float) __pure2;
36769160b1eSDavid E. O'Brien float	nextafterf(float, float);
36869160b1eSDavid E. O'Brien float	remainderf(float, float);
36969160b1eSDavid E. O'Brien float	rintf(float);
37062247e90SDavid Schultz float	scalblnf(float, long);
37169160b1eSDavid E. O'Brien float	scalbnf(float, int);
37262247e90SDavid Schultz float	truncf(float);
3734f82cb46SDavid Schultz 
3744f82cb46SDavid Schultz float	fdimf(float, float);
3754f82cb46SDavid Schultz float	fmaxf(float, float) __pure2;
3764f82cb46SDavid Schultz float	fminf(float, float) __pure2;
3778f3f7c66SDavid Schultz #endif
3783a8617a8SJordan K. Hubbard 
3793a8617a8SJordan K. Hubbard /*
3803a8617a8SJordan K. Hubbard  * float versions of BSD math library entry points
3813a8617a8SJordan K. Hubbard  */
3828f3f7c66SDavid Schultz #if __BSD_VISIBLE
38369160b1eSDavid E. O'Brien float	dremf(float, float);
3848f3f7c66SDavid Schultz int	finitef(float) __pure2;
3858f3f7c66SDavid Schultz float	gammaf(float);
3868f3f7c66SDavid Schultz float	j0f(float);
3878f3f7c66SDavid Schultz float	j1f(float);
3888f3f7c66SDavid Schultz float	jnf(int, float);
3898f3f7c66SDavid Schultz float	scalbf(float, float);
3908f3f7c66SDavid Schultz float	y0f(float);
3918f3f7c66SDavid Schultz float	y1f(float);
3928f3f7c66SDavid Schultz float	ynf(int, float);
3933a8617a8SJordan K. Hubbard 
3943a8617a8SJordan K. Hubbard /*
3953a8617a8SJordan K. Hubbard  * Float versions of reentrant version of gamma & lgamma; passes
3963a8617a8SJordan K. Hubbard  * signgam back by reference as the second argument; user must
3973a8617a8SJordan K. Hubbard  * allocate space for signgam.
3983a8617a8SJordan K. Hubbard  */
39969160b1eSDavid E. O'Brien float	gammaf_r(float, int *);
40069160b1eSDavid E. O'Brien float	lgammaf_r(float, int *);
4018f3f7c66SDavid Schultz 
4028f3f7c66SDavid Schultz /*
4038f3f7c66SDavid Schultz  * float version of IEEE Test Vector
4048f3f7c66SDavid Schultz  */
4058f3f7c66SDavid Schultz float	significandf(float);
406457f6cd2SWarner Losh #endif	/* __BSD_VISIBLE */
4073a8617a8SJordan K. Hubbard 
40829bd23abSDag-Erling Smørgrav /*
40929bd23abSDag-Erling Smørgrav  * long double versions of ISO/POSIX math functions
41029bd23abSDag-Erling Smørgrav  */
4118f3f7c66SDavid Schultz #if __ISO_C_VISIBLE >= 1999
41229bd23abSDag-Erling Smørgrav #if 0
41329bd23abSDag-Erling Smørgrav long double	acoshl(long double);
41429bd23abSDag-Erling Smørgrav long double	acosl(long double);
41529bd23abSDag-Erling Smørgrav long double	asinhl(long double);
41629bd23abSDag-Erling Smørgrav long double	asinl(long double);
41729bd23abSDag-Erling Smørgrav long double	atan2l(long double, long double);
41829bd23abSDag-Erling Smørgrav long double	atanhl(long double);
41929bd23abSDag-Erling Smørgrav long double	atanl(long double);
42029bd23abSDag-Erling Smørgrav long double	cbrtl(long double);
42129bd23abSDag-Erling Smørgrav long double	ceill(long double);
422b60cb13fSStefan Farfeleder #endif
42329bd23abSDag-Erling Smørgrav long double	copysignl(long double, long double);
424b60cb13fSStefan Farfeleder #if 0
42529bd23abSDag-Erling Smørgrav long double	coshl(long double);
42629bd23abSDag-Erling Smørgrav long double	cosl(long double);
42729bd23abSDag-Erling Smørgrav long double	erfcl(long double);
42829bd23abSDag-Erling Smørgrav long double	erfl(long double);
42929bd23abSDag-Erling Smørgrav long double	exp2l(long double);
43029bd23abSDag-Erling Smørgrav long double	expl(long double);
43129bd23abSDag-Erling Smørgrav long double	expm1l(long double);
43229bd23abSDag-Erling Smørgrav #endif
43329bd23abSDag-Erling Smørgrav long double	fabsl(long double);
43429bd23abSDag-Erling Smørgrav long double	fdiml(long double, long double);
4354f82cb46SDavid Schultz #if 0
43629bd23abSDag-Erling Smørgrav long double	floorl(long double);
43729bd23abSDag-Erling Smørgrav long double	fmal(long double, long double, long double);
4384f82cb46SDavid Schultz #endif
4394f82cb46SDavid Schultz long double	fmaxl(long double, long double) __pure2;
4404f82cb46SDavid Schultz long double	fminl(long double, long double) __pure2;
4414f82cb46SDavid Schultz #if 0
44229bd23abSDag-Erling Smørgrav long double	fmodl(long double, long double);
44329bd23abSDag-Erling Smørgrav long double	frexpl(long double	value, int *);
44429bd23abSDag-Erling Smørgrav long double	hypotl(long double, long double);
44529bd23abSDag-Erling Smørgrav int		ilogbl(long double);
44629bd23abSDag-Erling Smørgrav long double	ldexpl(long double, int);
44729bd23abSDag-Erling Smørgrav long double	lgammal(long double);
44829bd23abSDag-Erling Smørgrav long long	llrintl(long double);
44929bd23abSDag-Erling Smørgrav long long	llroundl(long double);
45029bd23abSDag-Erling Smørgrav long double	log10l(long double);
45129bd23abSDag-Erling Smørgrav long double	log1pl(long double);
45229bd23abSDag-Erling Smørgrav long double	log2l(long double);
45329bd23abSDag-Erling Smørgrav long double	logbl(long double);
45429bd23abSDag-Erling Smørgrav long double	logl(long double);
45529bd23abSDag-Erling Smørgrav long		lrintl(long double);
45629bd23abSDag-Erling Smørgrav long		lroundl(long double);
45729bd23abSDag-Erling Smørgrav long double	modfl(long double, long double	*);
45829bd23abSDag-Erling Smørgrav long double	nanl(const char *);
45929bd23abSDag-Erling Smørgrav long double	nearbyintl(long double);
46029bd23abSDag-Erling Smørgrav long double	nextafterl(long double, long double);
46129bd23abSDag-Erling Smørgrav double		nexttoward(double, long double);
46229bd23abSDag-Erling Smørgrav float		nexttowardf(float, long double);
46329bd23abSDag-Erling Smørgrav long double	nexttowardl(long double, long double);
46429bd23abSDag-Erling Smørgrav long double	powl(long double, long double);
46529bd23abSDag-Erling Smørgrav long double	remainderl(long double, long double);
46629bd23abSDag-Erling Smørgrav long double	remquol(long double, long double, int *);
46729bd23abSDag-Erling Smørgrav long double	rintl(long double);
46829bd23abSDag-Erling Smørgrav long double	roundl(long double);
46929bd23abSDag-Erling Smørgrav long double	scalblnl(long double, long);
47029bd23abSDag-Erling Smørgrav long double	scalbnl(long double, int);
47129bd23abSDag-Erling Smørgrav long double	sinhl(long double);
47229bd23abSDag-Erling Smørgrav long double	sinl(long double);
47329bd23abSDag-Erling Smørgrav long double	sqrtl(long double);
47429bd23abSDag-Erling Smørgrav long double	tanhl(long double);
47529bd23abSDag-Erling Smørgrav long double	tanl(long double);
47629bd23abSDag-Erling Smørgrav long double	tgammal(long double);
47729bd23abSDag-Erling Smørgrav long double	truncl(long double);
47829bd23abSDag-Erling Smørgrav #endif
47929bd23abSDag-Erling Smørgrav 
4808f3f7c66SDavid Schultz #endif /* __ISO_C_VISIBLE >= 1999 */
4813a8617a8SJordan K. Hubbard __END_DECLS
4823a8617a8SJordan K. Hubbard 
483ef1ee63eSAlexey Zelkin #endif /* !_MATH_H_ */
484