xref: /haiku/src/system/libroot/posix/glibc/math/math.h (revision f19586ee86fa01c76044879ac905c196c63444e4)
1 /* Declarations for math functions.
2    Copyright (C) 1991-1993,1995-1999,2001,2002 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4 
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9 
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Lesser General Public License for more details.
14 
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19 
20 /*
21  *	ISO C99 Standard: 7.12 Mathematics	<math.h>
22  */
23 
24 #ifndef	_MATH_H
25 #define	_MATH_H	1
26 
27 #include <features.h>
28 
29 __BEGIN_DECLS
30 
31 /* Get machine-dependent HUGE_VAL value (returned on overflow).
32    On all IEEE754 machines, this is +Infinity.  */
33 #include <bits/huge_val.h>
34 
35 /* Get machine-dependent NAN value (returned for some domain errors).  */
36 #ifdef	 __USE_ISOC99
37 # include <bits/nan.h>
38 #endif
39 /* Get general and ISO C99 specific information.  */
40 #include <bits/mathdef.h>
41 
42 
43 /* The file <bits/mathcalls.h> contains the prototypes for all the
44    actual math functions.  These macros are used for those prototypes,
45    so we can easily declare each function as both `name' and `__name',
46    and can declare the float versions `namef' and `__namef'.  */
47 
48 #define __MATHCALL(function,suffix, args)	\
49   __MATHDECL (_Mdouble_,function,suffix, args)
50 #define __MATHDECL(type, function,suffix, args) \
51   __MATHDECL_1(type, function,suffix, args); \
52   __MATHDECL_1(type, __CONCAT(__,function),suffix, args)
53 #define __MATHCALLX(function,suffix, args, attrib)	\
54   __MATHDECLX (_Mdouble_,function,suffix, args, attrib)
55 #define __MATHDECLX(type, function,suffix, args, attrib) \
56   __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); \
57   __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)
58 #define __MATHDECL_1(type, function,suffix, args) \
59   extern type __MATH_PRECNAME(function,suffix) args __THROW
60 
61 #define _Mdouble_ 		double
62 #define __MATH_PRECNAME(name,r)	__CONCAT(name,r)
63 # define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_STD
64 # define _Mdouble_END_NAMESPACE   __END_NAMESPACE_STD
65 #include <bits/mathcalls.h>
66 #undef	_Mdouble_
67 #undef _Mdouble_BEGIN_NAMESPACE
68 #undef _Mdouble_END_NAMESPACE
69 #undef	__MATH_PRECNAME
70 
71 #if defined __USE_MISC || defined __USE_ISOC99
72 
73 
74 /* Include the file of declarations again, this time using `float'
75    instead of `double' and appending f to each function name.  */
76 
77 # ifndef _Mfloat_
78 #  define _Mfloat_		float
79 # endif
80 # define _Mdouble_ 		_Mfloat_
81 # ifdef __STDC__
82 #  define __MATH_PRECNAME(name,r) name##f##r
83 # else
84 #  define __MATH_PRECNAME(name,r) name/**/f/**/r
85 # endif
86 # define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
87 # define _Mdouble_END_NAMESPACE   __END_NAMESPACE_C99
88 # include <bits/mathcalls.h>
89 # undef	_Mdouble_
90 # undef _Mdouble_BEGIN_NAMESPACE
91 # undef _Mdouble_END_NAMESPACE
92 # undef	__MATH_PRECNAME
93 
94 # if (__STDC__ - 0 || __GNUC__ - 0) && !defined __NO_LONG_DOUBLE_MATH
95 /* Include the file of declarations again, this time using `long double'
96    instead of `double' and appending l to each function name.  */
97 
98 #  ifndef _Mlong_double_
99 #   define _Mlong_double_	long double
100 #  endif
101 #  define _Mdouble_ 		_Mlong_double_
102 #  ifdef __STDC__
103 #   define __MATH_PRECNAME(name,r) name##l##r
104 #  else
105 #   define __MATH_PRECNAME(name,r) name/**/l/**/r
106 #  endif
107 #  define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
108 #  define _Mdouble_END_NAMESPACE   __END_NAMESPACE_C99
109 #  include <bits/mathcalls.h>
110 #  undef _Mdouble_
111 # undef _Mdouble_BEGIN_NAMESPACE
112 # undef _Mdouble_END_NAMESPACE
113 #  undef __MATH_PRECNAME
114 
115 # endif /* __STDC__ || __GNUC__ */
116 
117 #endif	/* Use misc or ISO C99.  */
118 #undef	__MATHDECL_1
119 #undef	__MATHDECL
120 #undef	__MATHCALL
121 
122 
123 #if defined __USE_MISC || defined __USE_XOPEN
124 /* This variable is used by `gamma' and `lgamma'.  */
125 extern int signgam;
126 #endif
127 
128 
129 /* Depending on the type of TG_ARG, call an appropriately suffixed
130    version of FUNC with arguments (including parentheses) ARGS.
131    Suffixed functions may not exist for long double if it has the same
132    format as double, or for other types with the same format as float,
133    double or long double.  The behavior is undefined if the argument
134    does not have a real floating type.  The definition may use a
135    conditional expression, so all suffixed versions of FUNC must
136    return the same type (FUNC may include a cast if necessary rather
137    than being a single identifier).  */
138 #ifdef __NO_LONG_DOUBLE_MATH
139 # if __HAVE_DISTINCT_FLOAT128
140 #  error "Distinct _Float128 without distinct long double not supported."
141 # endif
142 # define __MATH_TG(TG_ARG, FUNC, ARGS)					\
143   (sizeof (TG_ARG) == sizeof (float) ? FUNC ## f ARGS : FUNC ARGS)
144 #elif __HAVE_DISTINCT_FLOAT128
145 # if __HAVE_GENERIC_SELECTION
146 #  if __HAVE_FLOATN_NOT_TYPEDEF && __HAVE_FLOAT32
147 #   define __MATH_TG_F32(FUNC, ARGS) _Float32: FUNC ## f ARGS,
148 #  else
149 #   define __MATH_TG_F32(FUNC, ARGS)
150 #  endif
151 #  if __HAVE_FLOATN_NOT_TYPEDEF && __HAVE_FLOAT64X
152 #   if __HAVE_FLOAT64X_LONG_DOUBLE
153 #    define __MATH_TG_F64X(FUNC, ARGS) _Float64x: FUNC ## l ARGS,
154 #   else
155 #    define __MATH_TG_F64X(FUNC, ARGS) _Float64x: FUNC ## f128 ARGS,
156 #   endif
157 #  else
158 #   define __MATH_TG_F64X(FUNC, ARGS)
159 #  endif
160 #  define __MATH_TG(TG_ARG, FUNC, ARGS)	\
161      _Generic ((TG_ARG),			\
162 	       float: FUNC ## f ARGS,		\
163 	       __MATH_TG_F32 (FUNC, ARGS)	\
164 	       default: FUNC ARGS,		\
165 	       long double: FUNC ## l ARGS,	\
166 	       __MATH_TG_F64X (FUNC, ARGS)	\
167 	       _Float128: FUNC ## f128 ARGS)
168 # else
169 #  if __HAVE_FLOATN_NOT_TYPEDEF
170 #   error "Non-typedef _FloatN but no _Generic."
171 #  endif
172 #  define __MATH_TG(TG_ARG, FUNC, ARGS)					\
173      __builtin_choose_expr						\
174      (__builtin_types_compatible_p (__typeof (TG_ARG), float),		\
175       FUNC ## f ARGS,							\
176       __builtin_choose_expr						\
177       (__builtin_types_compatible_p (__typeof (TG_ARG), double),	\
178        FUNC ARGS,							\
179        __builtin_choose_expr						\
180        (__builtin_types_compatible_p (__typeof (TG_ARG), long double),	\
181 	FUNC ## l ARGS,							\
182 	FUNC ## f128 ARGS)))
183 # endif
184 #else
185 # define __MATH_TG(TG_ARG, FUNC, ARGS)		\
186   (sizeof (TG_ARG) == sizeof (float)		\
187    ? FUNC ## f ARGS				\
188    : sizeof (TG_ARG) == sizeof (double)		\
189    ? FUNC ARGS					\
190    : FUNC ## l ARGS)
191 #endif
192 
193 
194 /* ISO C99 defines some generic macros which work on any data type.  */
195 #if __USE_ISOC99
196 
197 /* Get the architecture specific values describing the floating-point
198    evaluation.  The following symbols will get defined:
199 
200     float_t	floating-point type at least as wide as `float' used
201 		to evaluate `float' expressions
202     double_t	floating-point type at least as wide as `double' used
203 		to evaluate `double' expressions
204 
205     FLT_EVAL_METHOD
206 		Defined to
207 		  0	if `float_t' is `float' and `double_t' is `double'
208 		  1	if `float_t' and `double_t' are `double'
209 		  2	if `float_t' and `double_t' are `long double'
210 		  else	`float_t' and `double_t' are unspecified
211 
212     INFINITY	representation of the infinity value of type `float'
213 
214     FP_FAST_FMA
215     FP_FAST_FMAF
216     FP_FAST_FMAL
217 		If defined it indicates that the `fma' function
218 		generally executes about as fast as a multiply and an add.
219 		This macro is defined only iff the `fma' function is
220 		implemented directly with a hardware multiply-add instructions.
221 
222     FP_ILOGB0	Expands to a value returned by `ilogb (0.0)'.
223     FP_ILOGBNAN	Expands to a value returned by `ilogb (NAN)'.
224 
225     DECIMAL_DIG	Number of decimal digits supported by conversion between
226 		decimal and all internal floating-point formats.
227 
228 */
229 
230 /* All floating-point numbers can be put in one of these categories.  */
231 enum
232   {
233     FP_NAN,
234 # define FP_NAN FP_NAN
235     FP_INFINITE,
236 # define FP_INFINITE FP_INFINITE
237     FP_ZERO,
238 # define FP_ZERO FP_ZERO
239     FP_SUBNORMAL,
240 # define FP_SUBNORMAL FP_SUBNORMAL
241     FP_NORMAL
242 # define FP_NORMAL FP_NORMAL
243   };
244 
245 /* Return number of classification appropriate for X.  */
246 # ifdef __NO_LONG_DOUBLE_MATH
247 #  define fpclassify(x) \
248      (sizeof (x) == sizeof (float) ? __fpclassifyf (x) : __fpclassify (x))
249 # else
250 #  define fpclassify(x) \
251      (sizeof (x) == sizeof (float)					      \
252       ? __fpclassifyf (x)						      \
253       : sizeof (x) == sizeof (double)					      \
254       ? __fpclassify (x) : __fpclassifyl (x))
255 # endif
256 
257 /* Return nonzero value if sign of X is negative.  */
258 # ifdef __NO_LONG_DOUBLE_MATH
259 #  define signbit(x) \
260      (sizeof (x) == sizeof (float) ? __signbitf (x) : __signbit (x))
261 # else
262 #  define signbit(x) \
263      (sizeof (x) == sizeof (float)					      \
264       ? __signbitf (x)							      \
265       : sizeof (x) == sizeof (double)					      \
266       ? __signbit (x) : __signbitl (x))
267 # endif
268 
269 /* Return nonzero value if X is not +-Inf or NaN.  */
270 # ifdef __NO_LONG_DOUBLE_MATH
271 #  define isfinite(x) \
272      (sizeof (x) == sizeof (float) ? __finitef (x) : __finite (x))
273 # else
274 #  define isfinite(x) \
275      (sizeof (x) == sizeof (float)					      \
276       ? __finitef (x)							      \
277       : sizeof (x) == sizeof (double)					      \
278       ? __finite (x) : __finitel (x))
279 # endif
280 
281 /* Return nonzero value if X is neither zero, subnormal, Inf, nor NaN.  */
282 # define isnormal(x) (fpclassify (x) == FP_NORMAL)
283 
284 /* Return nonzero value if X is a NaN.  We could use `fpclassify' but
285    we already have this functions `__isnan' and it is faster.  */
286 # ifdef __NO_LONG_DOUBLE_MATH
287 #  define isnan(x) \
288      (sizeof (x) == sizeof (float) ? __isnanf (x) : __isnan (x))
289 # else
290 #  define isnan(x) \
291      (sizeof (x) == sizeof (float)					      \
292       ? __isnanf (x)							      \
293       : sizeof (x) == sizeof (double)					      \
294       ? __isnan (x) : __isnanl (x))
295 # endif
296 
297 /* Return nonzero value is X is positive or negative infinity.  */
298 # ifdef __NO_LONG_DOUBLE_MATH
299 #  define isinf(x) \
300      (sizeof (x) == sizeof (float) ? __isinff (x) : __isinf (x))
301 # else
302 #  define isinf(x) \
303      (sizeof (x) == sizeof (float)					      \
304       ? __isinff (x)							      \
305       : sizeof (x) == sizeof (double)					      \
306       ? __isinf (x) : __isinfl (x))
307 # endif
308 
309 /* Bitmasks for the math_errhandling macro.  */
310 # define MATH_ERRNO	1	/* errno set by math functions.  */
311 # define MATH_ERREXCEPT	2	/* Exceptions raised by math functions.  */
312 
313 #endif /* Use ISO C99.  */
314 
315 /* Return nonzero value if X is a signaling NaN.  */
316 # ifndef __cplusplus
317 #  define issignaling(x) __MATH_TG ((x), __issignaling, (x))
318 # else
319    /* In C++ mode, __MATH_TG cannot be used, because it relies on
320       __builtin_types_compatible_p, which is a C-only builtin. */
321 # ifdef __NO_LONG_DOUBLE_MATH
322 #  define issignaling(x) \
323      (sizeof (x) == sizeof (float) ? __issignalingf (x) : __issignaling (x))
324 # else
325 #  define issignaling(x) \
326      (sizeof (x) == sizeof (float)					      \
327       ? __issignalingf (x)						      \
328       : sizeof (x) == sizeof (double)					      \
329       ? __issignaling (x) : __issignalingl (x))
330 # endif
331 # endif
332 
333 
334 #ifdef	__USE_MISC
335 /* Support for various different standard error handling behaviors.  */
336 typedef enum
337 {
338   _IEEE_ = -1,	/* According to IEEE 754/IEEE 854.  */
339   _SVID_,	/* According to System V, release 4.  */
340   _XOPEN_,	/* Nowadays also Unix98.  */
341   _POSIX_,
342   _ISOC_	/* Actually this is ISO C99.  */
343 } _LIB_VERSION_TYPE;
344 
345 /* This variable can be changed at run-time to any of the values above to
346    affect floating point error handling behavior (it may also be necessary
347    to change the hardware FPU exception settings).  */
348 extern _LIB_VERSION_TYPE _LIB_VERSION;
349 #endif
350 
351 
352 #ifdef __USE_SVID
353 /* In SVID error handling, `matherr' is called with this description
354    of the exceptional condition.
355 
356    We have a problem when using C++ since `exception' is a reserved
357    name in C++.  */
358 # ifdef __cplusplus
359 struct __exception
360 # else
361 struct exception
362 # endif
363   {
364     int type;
365     char *name;
366     double arg1;
367     double arg2;
368     double retval;
369   };
370 
371 # ifdef __cplusplus
372 extern int matherr (struct __exception *__exc) throw ();
373 # else
374 extern int matherr (struct exception *__exc);
375 # endif
376 
377 # define X_TLOSS	1.41484755040568800000e+16
378 
379 /* Types of exceptions in the `type' field.  */
380 # define DOMAIN		1
381 # define SING		2
382 # define OVERFLOW	3
383 # define UNDERFLOW	4
384 # define TLOSS		5
385 # define PLOSS		6
386 
387 /* SVID mode specifies returning this large value instead of infinity.  */
388 # define HUGE		3.40282347e+38F
389 
390 #else	/* !SVID */
391 
392 # ifdef __USE_XOPEN
393 /* X/Open wants another strange constant.  */
394 #  define MAXFLOAT	3.40282347e+38F
395 # endif
396 
397 #endif	/* SVID */
398 
399 
400 /* Some useful constants.  */
401 #if defined __USE_BSD || defined __USE_XOPEN
402 # define M_E		2.7182818284590452354	/* e */
403 # define M_LOG2E	1.4426950408889634074	/* log_2 e */
404 # define M_LOG10E	0.43429448190325182765	/* log_10 e */
405 # define M_LN2		0.69314718055994530942	/* log_e 2 */
406 # define M_LN10		2.30258509299404568402	/* log_e 10 */
407 # define M_PI		3.14159265358979323846	/* pi */
408 # define M_PI_2		1.57079632679489661923	/* pi/2 */
409 # define M_PI_4		0.78539816339744830962	/* pi/4 */
410 # define M_1_PI		0.31830988618379067154	/* 1/pi */
411 # define M_2_PI		0.63661977236758134308	/* 2/pi */
412 # define M_2_SQRTPI	1.12837916709551257390	/* 2/sqrt(pi) */
413 # define M_SQRT2	1.41421356237309504880	/* sqrt(2) */
414 # define M_SQRT1_2	0.70710678118654752440	/* 1/sqrt(2) */
415 #endif
416 
417 /* The above constants are not adequate for computation using `long double's.
418    Therefore we provide as an extension constants with similar names as a
419    GNU extension.  Provide enough digits for the 128-bit IEEE quad.  */
420 #ifdef __USE_GNU
421 # define M_El		2.7182818284590452353602874713526625L  /* e */
422 # define M_LOG2El	1.4426950408889634073599246810018921L  /* log_2 e */
423 # define M_LOG10El	0.4342944819032518276511289189166051L  /* log_10 e */
424 # define M_LN2l		0.6931471805599453094172321214581766L  /* log_e 2 */
425 # define M_LN10l	2.3025850929940456840179914546843642L  /* log_e 10 */
426 # define M_PIl		3.1415926535897932384626433832795029L  /* pi */
427 # define M_PI_2l	1.5707963267948966192313216916397514L  /* pi/2 */
428 # define M_PI_4l	0.7853981633974483096156608458198757L  /* pi/4 */
429 # define M_1_PIl	0.3183098861837906715377675267450287L  /* 1/pi */
430 # define M_2_PIl	0.6366197723675813430755350534900574L  /* 2/pi */
431 # define M_2_SQRTPIl	1.1283791670955125738961589031215452L  /* 2/sqrt(pi) */
432 # define M_SQRT2l	1.4142135623730950488016887242096981L  /* sqrt(2) */
433 # define M_SQRT1_2l	0.7071067811865475244008443621048490L  /* 1/sqrt(2) */
434 #endif
435 
436 
437 /* When compiling in strict ISO C compatible mode we must not use the
438    inline functions since they, among other things, do not set the
439    `errno' variable correctly.  */
440 #if defined __STRICT_ANSI__ && !defined __NO_MATH_INLINES
441 # define __NO_MATH_INLINES	1
442 #endif
443 
444 #if __USE_ISOC99
445 /* ISO C99 defines some macros to compare number while taking care
446    for unordered numbers.  Since many FPUs provide special
447    instructions to support these operations and these tests are
448    defined in <bits/mathinline.h>, we define the generic macros at
449    this late point and only if they are not defined yet.  */
450 
451 /* Return nonzero value if X is greater than Y.  */
452 # ifndef isgreater
453 #  define isgreater(x, y) \
454   (__extension__							      \
455    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);			      \
456       !isunordered (__x, __y) && __x > __y; }))
457 # endif
458 
459 /* Return nonzero value if X is greater than or equal to Y.  */
460 # ifndef isgreaterequal
461 #  define isgreaterequal(x, y) \
462   (__extension__							      \
463    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);			      \
464       !isunordered (__x, __y) && __x >= __y; }))
465 # endif
466 
467 /* Return nonzero value if X is less than Y.  */
468 # ifndef isless
469 #  define isless(x, y) \
470   (__extension__							      \
471    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);			      \
472       !isunordered (__x, __y) && __x < __y; }))
473 # endif
474 
475 /* Return nonzero value if X is less than or equal to Y.  */
476 # ifndef islessequal
477 #  define islessequal(x, y) \
478   (__extension__							      \
479    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);			      \
480       !isunordered (__x, __y) && __x <= __y; }))
481 # endif
482 
483 /* Return nonzero value if either X is less than Y or Y is less than X.  */
484 # ifndef islessgreater
485 #  define islessgreater(x, y) \
486   (__extension__							      \
487    ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y);			      \
488       !isunordered (__x, __y) && (__x < __y || __y < __x); }))
489 # endif
490 
491 /* Return nonzero value if arguments are unordered.  */
492 # ifndef isunordered
493 #  define isunordered(u, v) \
494   (__extension__							      \
495    ({ __typeof__(u) __u = (u); __typeof__(v) __v = (v);			      \
496       fpclassify (__u) == FP_NAN || fpclassify (__v) == FP_NAN; }))
497 # endif
498 
499 #endif
500 
501 __END_DECLS
502 
503 
504 #endif /* math.h  */
505