1/* Declarations for math functions.
2 Copyright (C) 1991-2014 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, see
17 <http://www.gnu.org/licenses/>. */
18
19/*
20 * ISO C99 Standard: 7.12 Mathematics <math.h>
21 */
22
23#ifndef _MATH_H
24#define _MATH_H 1
25
26#include <features.h>
27
28__BEGIN_DECLS
29
30/* Get machine-dependent HUGE_VAL value (returned on overflow).
31 On all IEEE754 machines, this is +Infinity. */
32#include <bits/huge_val.h>
33#ifdef __USE_ISOC99
34# include <bits/huge_valf.h>
35# include <bits/huge_vall.h>
36
37/* Get machine-dependent INFINITY value. */
38# include <bits/inf.h>
39
40/* Get machine-dependent NAN value (returned for some domain errors). */
41# include <bits/nan.h>
42#endif /* __USE_ISOC99 */
43
44/* Get general and ISO C99 specific information. */
45#include <bits/mathdef.h>
46
47/* The file <bits/mathcalls.h> contains the prototypes for all the
48 actual math functions. These macros are used for those prototypes,
49 so we can easily declare each function as both `name' and `__name',
50 and can declare the float versions `namef' and `__namef'. */
51
52#define __MATHCALL(function,suffix, args) \
53 __MATHDECL (_Mdouble_,function,suffix, args)
54#define __MATHDECL(type, function,suffix, args) \
55 __MATHDECL_1(type, function,suffix, args); \
56 __MATHDECL_1(type, __CONCAT(__,function),suffix, args)
57#define __MATHCALLX(function,suffix, args, attrib) \
58 __MATHDECLX (_Mdouble_,function,suffix, args, attrib)
59#define __MATHDECLX(type, function,suffix, args, attrib) \
60 __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); \
61 __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)
62#define __MATHDECL_1(type, function,suffix, args) \
63 extern type __MATH_PRECNAME(function,suffix) args __THROW
64
65#define _Mdouble_ double
66#define __MATH_PRECNAME(name,r) __CONCAT(name,r)
67#define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_STD
68#define _Mdouble_END_NAMESPACE __END_NAMESPACE_STD
69#include <bits/mathcalls.h>
70#undef _Mdouble_
71#undef _Mdouble_BEGIN_NAMESPACE
72#undef _Mdouble_END_NAMESPACE
73#undef __MATH_PRECNAME
74
75#if defined __USE_MISC || defined __USE_ISOC99
76
77
78/* Include the file of declarations again, this time using `float'
79 instead of `double' and appending f to each function name. */
80
81# ifndef _Mfloat_
82# define _Mfloat_ float
83# endif
84# define _Mdouble_ _Mfloat_
85# define __MATH_PRECNAME(name,r) name##f##r
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 !(defined __NO_LONG_DOUBLE_MATH && defined _LIBC) \
95 || defined __LDBL_COMPAT
96# ifdef __LDBL_COMPAT
97
98# ifdef __USE_ISOC99
99extern float __nldbl_nexttowardf (float __x, long double __y)
100 __THROW __attribute__ ((__const__));
101# ifdef __REDIRECT_NTH
102extern float __REDIRECT_NTH (nexttowardf, (float __x, long double __y),
103 __nldbl_nexttowardf)
104 __attribute__ ((__const__));
105extern double __REDIRECT_NTH (nexttoward, (double __x, long double __y),
106 nextafter) __attribute__ ((__const__));
107extern long double __REDIRECT_NTH (nexttowardl,
108 (long double __x, long double __y),
109 nextafter) __attribute__ ((__const__));
110# endif
111# endif
112
113# undef __MATHDECL_1
114# define __MATHDECL_2(type, function,suffix, args, alias) \
115 extern type __REDIRECT_NTH(__MATH_PRECNAME(function,suffix), \
116 args, alias)
117# define __MATHDECL_1(type, function,suffix, args) \
118 __MATHDECL_2(type, function,suffix, args, __CONCAT(function,suffix))
119# endif
120
121/* Include the file of declarations again, this time using `long double'
122 instead of `double' and appending l to each function name. */
123
124# ifndef _Mlong_double_
125# define _Mlong_double_ long double
126# endif
127# define _Mdouble_ _Mlong_double_
128# define __MATH_PRECNAME(name,r) name##l##r
129# define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99
130# define _Mdouble_END_NAMESPACE __END_NAMESPACE_C99
131# define __MATH_DECLARE_LDOUBLE 1
132# include <bits/mathcalls.h>
133# undef _Mdouble_
134# undef _Mdouble_BEGIN_NAMESPACE
135# undef _Mdouble_END_NAMESPACE
136# undef __MATH_PRECNAME
137
138# endif /* !(__NO_LONG_DOUBLE_MATH && _LIBC) || __LDBL_COMPAT */
139
140#endif /* Use misc or ISO C99. */
141#undef __MATHDECL_1
142#undef __MATHDECL
143#undef __MATHCALL
144
145
146#if defined __USE_MISC || defined __USE_XOPEN
147/* This variable is used by `gamma' and `lgamma'. */
148extern int signgam;
149#endif
150
151
152/* ISO C99 defines some generic macros which work on any data type. */
153#ifdef __USE_ISOC99
154
155/* Get the architecture specific values describing the floating-point
156 evaluation. The following symbols will get defined:
157
158 float_t floating-point type at least as wide as `float' used
159 to evaluate `float' expressions
160 double_t floating-point type at least as wide as `double' used
161 to evaluate `double' expressions
162
163 FLT_EVAL_METHOD
164 Defined to
165 0 if `float_t' is `float' and `double_t' is `double'
166 1 if `float_t' and `double_t' are `double'
167 2 if `float_t' and `double_t' are `long double'
168 else `float_t' and `double_t' are unspecified
169
170 INFINITY representation of the infinity value of type `float'
171
172 FP_FAST_FMA
173 FP_FAST_FMAF
174 FP_FAST_FMAL
175 If defined it indicates that the `fma' function
176 generally executes about as fast as a multiply and an add.
177 This macro is defined only iff the `fma' function is
178 implemented directly with a hardware multiply-add instructions.
179
180 FP_ILOGB0 Expands to a value returned by `ilogb (0.0)'.
181 FP_ILOGBNAN Expands to a value returned by `ilogb (NAN)'.
182
183 DECIMAL_DIG Number of decimal digits supported by conversion between
184 decimal and all internal floating-point formats.
185
186*/
187
188/* All floating-point numbers can be put in one of these categories. */
189enum
190 {
191 FP_NAN =
192# define FP_NAN 0
193 FP_NAN,
194 FP_INFINITE =
195# define FP_INFINITE 1
196 FP_INFINITE,
197 FP_ZERO =
198# define FP_ZERO 2
199 FP_ZERO,
200 FP_SUBNORMAL =
201# define FP_SUBNORMAL 3
202 FP_SUBNORMAL,
203 FP_NORMAL =
204# define FP_NORMAL 4
205 FP_NORMAL
206 };
207
208/* Return number of classification appropriate for X. */
209# ifdef __NO_LONG_DOUBLE_MATH
210# define fpclassify(x) \
211 (sizeof (x) == sizeof (float) ? __fpclassifyf (x) : __fpclassify (x))
212# else
213# define fpclassify(x) \
214 (sizeof (x) == sizeof (float) \
215 ? __fpclassifyf (x) \
216 : sizeof (x) == sizeof (double) \
217 ? __fpclassify (x) : __fpclassifyl (x))
218# endif
219
220/* Return nonzero value if sign of X is negative. */
221# ifdef __NO_LONG_DOUBLE_MATH
222# define signbit(x) \
223 (sizeof (x) == sizeof (float) ? __signbitf (x) : __signbit (x))
224# else
225# define signbit(x) \
226 (sizeof (x) == sizeof (float) \
227 ? __signbitf (x) \
228 : sizeof (x) == sizeof (double) \
229 ? __signbit (x) : __signbitl (x))
230# endif
231
232/* Return nonzero value if X is not +-Inf or NaN. */
233# ifdef __NO_LONG_DOUBLE_MATH
234# define isfinite(x) \
235 (sizeof (x) == sizeof (float) ? __finitef (x) : __finite (x))
236# else
237# define isfinite(x) \
238 (sizeof (x) == sizeof (float) \
239 ? __finitef (x) \
240 : sizeof (x) == sizeof (double) \
241 ? __finite (x) : __finitel (x))
242# endif
243
244/* Return nonzero value if X is neither zero, subnormal, Inf, nor NaN. */
245# define isnormal(x) (fpclassify (x) == FP_NORMAL)
246
247/* Return nonzero value if X is a NaN. We could use `fpclassify' but
248 we already have this functions `__isnan' and it is faster. */
249# ifdef __NO_LONG_DOUBLE_MATH
250# define isnan(x) \
251 (sizeof (x) == sizeof (float) ? __isnanf (x) : __isnan (x))
252# else
253# define isnan(x) \
254 (sizeof (x) == sizeof (float) \
255 ? __isnanf (x) \
256 : sizeof (x) == sizeof (double) \
257 ? __isnan (x) : __isnanl (x))
258# endif
259
260/* Return nonzero value if X is positive or negative infinity. */
261# ifdef __NO_LONG_DOUBLE_MATH
262# define isinf(x) \
263 (sizeof (x) == sizeof (float) ? __isinff (x) : __isinf (x))
264# else
265# define isinf(x) \
266 (sizeof (x) == sizeof (float) \
267 ? __isinff (x) \
268 : sizeof (x) == sizeof (double) \
269 ? __isinf (x) : __isinfl (x))
270# endif
271
272/* Bitmasks for the math_errhandling macro. */
273# define MATH_ERRNO 1 /* errno set by math functions. */
274# define MATH_ERREXCEPT 2 /* Exceptions raised by math functions. */
275
276/* By default all functions support both errno and exception handling.
277 In gcc's fast math mode and if inline functions are defined this
278 might not be true. */
279# ifndef __FAST_MATH__
280# define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT)
281# endif
282
283#endif /* Use ISO C99. */
284
285#ifdef __USE_GNU
286/* Return nonzero value if X is a signaling NaN. */
287# ifdef __NO_LONG_DOUBLE_MATH
288# define issignaling(x) \
289 (sizeof (x) == sizeof (float) ? __issignalingf (x) : __issignaling (x))
290# else
291# define issignaling(x) \
292 (sizeof (x) == sizeof (float) \
293 ? __issignalingf (x) \
294 : sizeof (x) == sizeof (double) \
295 ? __issignaling (x) : __issignalingl (x))
296# endif
297#endif /* Use GNU. */
298
299#ifdef __USE_MISC
300/* Support for various different standard error handling behaviors. */
301typedef enum
302{
303 _IEEE_ = -1, /* According to IEEE 754/IEEE 854. */
304 _SVID_, /* According to System V, release 4. */
305 _XOPEN_, /* Nowadays also Unix98. */
306 _POSIX_,
307 _ISOC_ /* Actually this is ISO C99. */
308} _LIB_VERSION_TYPE;
309
310/* This variable can be changed at run-time to any of the values above to
311 affect floating point error handling behavior (it may also be necessary
312 to change the hardware FPU exception settings). */
313extern _LIB_VERSION_TYPE _LIB_VERSION;
314#endif
315
316
317#ifdef __USE_SVID
318/* In SVID error handling, `matherr' is called with this description
319 of the exceptional condition.
320
321 We have a problem when using C++ since `exception' is a reserved
322 name in C++. */
323# ifdef __cplusplus
324struct __exception
325# else
326struct exception
327# endif
328 {
329 int type;
330 char *name;
331 double arg1;
332 double arg2;
333 double retval;
334 };
335
336# ifdef __cplusplus
337extern int matherr (struct __exception *__exc) throw ();
338# else
339extern int matherr (struct exception *__exc);
340# endif
341
342# define X_TLOSS 1.41484755040568800000e+16
343
344/* Types of exceptions in the `type' field. */
345# define DOMAIN 1
346# define SING 2
347# define OVERFLOW 3
348# define UNDERFLOW 4
349# define TLOSS 5
350# define PLOSS 6
351
352/* SVID mode specifies returning this large value instead of infinity. */
353# define HUGE 3.40282347e+38F
354
355#else /* !SVID */
356
357# ifdef __USE_XOPEN
358/* X/Open wants another strange constant. */
359# define MAXFLOAT 3.40282347e+38F
360# endif
361
362#endif /* SVID */
363
364
365/* Some useful constants. */
366#if defined __USE_BSD || defined __USE_XOPEN
367# define M_E 2.7182818284590452354 /* e */
368# define M_LOG2E 1.4426950408889634074 /* log_2 e */
369# define M_LOG10E 0.43429448190325182765 /* log_10 e */
370# define M_LN2 0.69314718055994530942 /* log_e 2 */
371# define M_LN10 2.30258509299404568402 /* log_e 10 */
372# define M_PI 3.14159265358979323846 /* pi */
373# define M_PI_2 1.57079632679489661923 /* pi/2 */
374# define M_PI_4 0.78539816339744830962 /* pi/4 */
375# define M_1_PI 0.31830988618379067154 /* 1/pi */
376# define M_2_PI 0.63661977236758134308 /* 2/pi */
377# define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
378# define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
379# define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
380#endif
381
382/* The above constants are not adequate for computation using `long double's.
383 Therefore we provide as an extension constants with similar names as a
384 GNU extension. Provide enough digits for the 128-bit IEEE quad. */
385#ifdef __USE_GNU
386# define M_El 2.718281828459045235360287471352662498L /* e */
387# define M_LOG2El 1.442695040888963407359924681001892137L /* log_2 e */
388# define M_LOG10El 0.434294481903251827651128918916605082L /* log_10 e */
389# define M_LN2l 0.693147180559945309417232121458176568L /* log_e 2 */
390# define M_LN10l 2.302585092994045684017991454684364208L /* log_e 10 */
391# define M_PIl 3.141592653589793238462643383279502884L /* pi */
392# define M_PI_2l 1.570796326794896619231321691639751442L /* pi/2 */
393# define M_PI_4l 0.785398163397448309615660845819875721L /* pi/4 */
394# define M_1_PIl 0.318309886183790671537767526745028724L /* 1/pi */
395# define M_2_PIl 0.636619772367581343075535053490057448L /* 2/pi */
396# define M_2_SQRTPIl 1.128379167095512573896158903121545172L /* 2/sqrt(pi) */
397# define M_SQRT2l 1.414213562373095048801688724209698079L /* sqrt(2) */
398# define M_SQRT1_2l 0.707106781186547524400844362104849039L /* 1/sqrt(2) */
399#endif
400
401
402/* When compiling in strict ISO C compatible mode we must not use the
403 inline functions since they, among other things, do not set the
404 `errno' variable correctly. */
405#if defined __STRICT_ANSI__ && !defined __NO_MATH_INLINES
406# define __NO_MATH_INLINES 1
407#endif
408
409#if defined __USE_ISOC99 && __GNUC_PREREQ(2,97)
410/* ISO C99 defines some macros to compare number while taking care for
411 unordered numbers. Many FPUs provide special instructions to support
412 these operations. Generic support in GCC for these as builtins went
413 in before 3.0.0, but not all cpus added their patterns. We define
414 versions that use the builtins here, and <bits/mathinline.h> will
415 undef/redefine as appropriate for the specific GCC version in use. */
416# define isgreater(x, y) __builtin_isgreater(x, y)
417# define isgreaterequal(x, y) __builtin_isgreaterequal(x, y)
418# define isless(x, y) __builtin_isless(x, y)
419# define islessequal(x, y) __builtin_islessequal(x, y)
420# define islessgreater(x, y) __builtin_islessgreater(x, y)
421# define isunordered(u, v) __builtin_isunordered(u, v)
422#endif
423
424/* Get machine-dependent inline versions (if there are any). */
425#ifdef __USE_EXTERN_INLINES
426# include <bits/mathinline.h>
427#endif
428
429/* Define special entry points to use when the compiler got told to
430 only expect finite results. */
431#if defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ > 0
432# include <bits/math-finite.h>
433#endif
434
435#ifdef __USE_ISOC99
436/* If we've still got undefined comparison macros, provide defaults. */
437
438/* Return nonzero value if X is greater than Y. */
439# ifndef isgreater
440# define isgreater(x, y) \
441 (__extension__ \
442 ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \
443 !isunordered (__x, __y) && __x > __y; }))
444# endif
445
446/* Return nonzero value if X is greater than or equal to Y. */
447# ifndef isgreaterequal
448# define isgreaterequal(x, y) \
449 (__extension__ \
450 ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \
451 !isunordered (__x, __y) && __x >= __y; }))
452# endif
453
454/* Return nonzero value if X is less than Y. */
455# ifndef isless
456# define isless(x, y) \
457 (__extension__ \
458 ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \
459 !isunordered (__x, __y) && __x < __y; }))
460# endif
461
462/* Return nonzero value if X is less than or equal to Y. */
463# ifndef islessequal
464# define islessequal(x, y) \
465 (__extension__ \
466 ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \
467 !isunordered (__x, __y) && __x <= __y; }))
468# endif
469
470/* Return nonzero value if either X is less than Y or Y is less than X. */
471# ifndef islessgreater
472# define islessgreater(x, y) \
473 (__extension__ \
474 ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \
475 !isunordered (__x, __y) && (__x < __y || __y < __x); }))
476# endif
477
478/* Return nonzero value if arguments are unordered. */
479# ifndef isunordered
480# define isunordered(u, v) \
481 (__extension__ \
482 ({ __typeof__(u) __u = (u); __typeof__(v) __v = (v); \
483 fpclassify (__u) == FP_NAN || fpclassify (__v) == FP_NAN; }))
484# endif
485
486#endif
487
488__END_DECLS
489
490
491#endif /* math.h */
492