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