1 | /* Declarations for math functions. |
2 | Copyright (C) 1991-2017 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 | #define |
27 | #include <bits/libc-header-start.h> |
28 | |
29 | __BEGIN_DECLS |
30 | |
31 | /* Get definitions of __intmax_t and __uintmax_t. */ |
32 | #include <bits/types.h> |
33 | |
34 | /* Get machine-dependent vector math functions declarations. */ |
35 | #include <bits/math-vector.h> |
36 | |
37 | /* Get machine-dependent HUGE_VAL value (returned on overflow). |
38 | On all IEEE754 machines, this is +Infinity. */ |
39 | #include <bits/huge_val.h> |
40 | #ifdef __USE_ISOC99 |
41 | # include <bits/huge_valf.h> |
42 | # include <bits/huge_vall.h> |
43 | |
44 | /* Get machine-dependent INFINITY value. */ |
45 | # include <bits/inf.h> |
46 | |
47 | /* Get machine-dependent NAN value (returned for some domain errors). */ |
48 | # include <bits/nan.h> |
49 | #endif /* __USE_ISOC99 */ |
50 | |
51 | #if __GLIBC_USE (IEC_60559_BFP_EXT) |
52 | /* Signaling NaN macros, if supported. */ |
53 | # if __GNUC_PREREQ (3, 3) |
54 | # define SNANF (__builtin_nansf ("")) |
55 | # define SNAN (__builtin_nans ("")) |
56 | # define SNANL (__builtin_nansl ("")) |
57 | # endif |
58 | #endif |
59 | |
60 | /* Get __GLIBC_FLT_EVAL_METHOD. */ |
61 | #include <bits/flt-eval-method.h> |
62 | |
63 | #ifdef __USE_ISOC99 |
64 | /* Define the following typedefs. |
65 | |
66 | float_t floating-point type at least as wide as `float' used |
67 | to evaluate `float' expressions |
68 | double_t floating-point type at least as wide as `double' used |
69 | to evaluate `double' expressions |
70 | */ |
71 | # if __GLIBC_FLT_EVAL_METHOD == 0 || __GLIBC_FLT_EVAL_METHOD == 16 |
72 | typedef float float_t; |
73 | typedef double double_t; |
74 | # elif __GLIBC_FLT_EVAL_METHOD == 1 |
75 | typedef double float_t; |
76 | typedef double double_t; |
77 | # elif __GLIBC_FLT_EVAL_METHOD == 2 |
78 | typedef long double float_t; |
79 | typedef long double double_t; |
80 | # elif __GLIBC_FLT_EVAL_METHOD == 32 |
81 | typedef _Float32 float_t; |
82 | typedef double double_t; |
83 | # elif __GLIBC_FLT_EVAL_METHOD == 33 |
84 | typedef _Float32x float_t; |
85 | typedef _Float32x double_t; |
86 | # elif __GLIBC_FLT_EVAL_METHOD == 64 |
87 | typedef _Float64 float_t; |
88 | typedef _Float64 double_t; |
89 | # elif __GLIBC_FLT_EVAL_METHOD == 65 |
90 | typedef _Float64x float_t; |
91 | typedef _Float64x double_t; |
92 | # elif __GLIBC_FLT_EVAL_METHOD == 128 |
93 | typedef _Float128 float_t; |
94 | typedef _Float128 double_t; |
95 | # elif __GLIBC_FLT_EVAL_METHOD == 129 |
96 | typedef _Float128x float_t; |
97 | typedef _Float128x double_t; |
98 | # else |
99 | # error "Unknown __GLIBC_FLT_EVAL_METHOD" |
100 | # endif |
101 | #endif |
102 | |
103 | /* Define macros for the return values of ilogb and llogb, based on |
104 | __FP_LOGB0_IS_MIN and __FP_LOGBNAN_IS_MIN. |
105 | |
106 | FP_ILOGB0 Expands to a value returned by `ilogb (0.0)'. |
107 | FP_ILOGBNAN Expands to a value returned by `ilogb (NAN)'. |
108 | FP_LLOGB0 Expands to a value returned by `llogb (0.0)'. |
109 | FP_LLOGBNAN Expands to a value returned by `llogb (NAN)'. |
110 | |
111 | */ |
112 | |
113 | #include <bits/fp-logb.h> |
114 | #ifdef __USE_ISOC99 |
115 | # if __FP_LOGB0_IS_MIN |
116 | # define FP_ILOGB0 (-2147483647 - 1) |
117 | # else |
118 | # define FP_ILOGB0 (-2147483647) |
119 | # endif |
120 | # if __FP_LOGBNAN_IS_MIN |
121 | # define FP_ILOGBNAN (-2147483647 - 1) |
122 | # else |
123 | # define FP_ILOGBNAN 2147483647 |
124 | # endif |
125 | #endif |
126 | #if __GLIBC_USE (IEC_60559_BFP_EXT) |
127 | # if __WORDSIZE == 32 |
128 | # define __FP_LONG_MAX 0x7fffffffL |
129 | # else |
130 | # define __FP_LONG_MAX 0x7fffffffffffffffL |
131 | # endif |
132 | # if __FP_LOGB0_IS_MIN |
133 | # define FP_LLOGB0 (-__FP_LONG_MAX - 1) |
134 | # else |
135 | # define FP_LLOGB0 (-__FP_LONG_MAX) |
136 | # endif |
137 | # if __FP_LOGBNAN_IS_MIN |
138 | # define FP_LLOGBNAN (-__FP_LONG_MAX - 1) |
139 | # else |
140 | # define FP_LLOGBNAN __FP_LONG_MAX |
141 | # endif |
142 | #endif |
143 | |
144 | /* Get the architecture specific values describing the floating-point |
145 | evaluation. The following symbols will get defined: |
146 | |
147 | FP_FAST_FMA |
148 | FP_FAST_FMAF |
149 | FP_FAST_FMAL |
150 | If defined it indicates that the `fma' function |
151 | generally executes about as fast as a multiply and an add. |
152 | This macro is defined only iff the `fma' function is |
153 | implemented directly with a hardware multiply-add instructions. |
154 | */ |
155 | |
156 | #include <bits/fp-fast.h> |
157 | |
158 | #if __GLIBC_USE (IEC_60559_BFP_EXT) |
159 | /* Rounding direction macros for fromfp functions. */ |
160 | enum |
161 | { |
162 | FP_INT_UPWARD = |
163 | # define FP_INT_UPWARD 0 |
164 | FP_INT_UPWARD, |
165 | FP_INT_DOWNWARD = |
166 | # define FP_INT_DOWNWARD 1 |
167 | FP_INT_DOWNWARD, |
168 | FP_INT_TOWARDZERO = |
169 | # define FP_INT_TOWARDZERO 2 |
170 | FP_INT_TOWARDZERO, |
171 | FP_INT_TONEARESTFROMZERO = |
172 | # define FP_INT_TONEARESTFROMZERO 3 |
173 | FP_INT_TONEARESTFROMZERO, |
174 | FP_INT_TONEAREST = |
175 | # define FP_INT_TONEAREST 4 |
176 | FP_INT_TONEAREST, |
177 | }; |
178 | #endif |
179 | |
180 | /* The file <bits/mathcalls.h> contains the prototypes for all the |
181 | actual math functions. These macros are used for those prototypes, |
182 | so we can easily declare each function as both `name' and `__name', |
183 | and can declare the float versions `namef' and `__namef'. */ |
184 | |
185 | #define __SIMD_DECL(function) __CONCAT (__DECL_SIMD_, function) |
186 | |
187 | #define __MATHCALL_VEC(function, suffix, args) \ |
188 | __SIMD_DECL (__MATH_PRECNAME (function, suffix)) \ |
189 | __MATHCALL (function, suffix, args) |
190 | |
191 | #define __MATHDECL_VEC(type, function,suffix, args) \ |
192 | __SIMD_DECL (__MATH_PRECNAME (function, suffix)) \ |
193 | __MATHDECL(type, function,suffix, args) |
194 | |
195 | #define __MATHCALL(function,suffix, args) \ |
196 | __MATHDECL (_Mdouble_,function,suffix, args) |
197 | #define __MATHDECL(type, function,suffix, args) \ |
198 | __MATHDECL_1(type, function,suffix, args); \ |
199 | __MATHDECL_1(type, __CONCAT(__,function),suffix, args) |
200 | #define __MATHCALLX(function,suffix, args, attrib) \ |
201 | __MATHDECLX (_Mdouble_,function,suffix, args, attrib) |
202 | #define __MATHDECLX(type, function,suffix, args, attrib) \ |
203 | __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); \ |
204 | __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib) |
205 | #define __MATHDECL_1(type, function,suffix, args) \ |
206 | extern type __MATH_PRECNAME(function,suffix) args __THROW |
207 | |
208 | #define _Mdouble_ double |
209 | #define __MATH_PRECNAME(name,r) __CONCAT(name,r) |
210 | #define __MATH_DECLARING_DOUBLE 1 |
211 | #define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_STD |
212 | #define _Mdouble_END_NAMESPACE __END_NAMESPACE_STD |
213 | #include <bits/mathcalls.h> |
214 | #undef _Mdouble_ |
215 | #undef _Mdouble_BEGIN_NAMESPACE |
216 | #undef _Mdouble_END_NAMESPACE |
217 | #undef __MATH_PRECNAME |
218 | #undef __MATH_DECLARING_DOUBLE |
219 | |
220 | #ifdef __USE_ISOC99 |
221 | |
222 | |
223 | /* Include the file of declarations again, this time using `float' |
224 | instead of `double' and appending f to each function name. */ |
225 | |
226 | # ifndef _Mfloat_ |
227 | # define _Mfloat_ float |
228 | # endif |
229 | # define _Mdouble_ _Mfloat_ |
230 | # define __MATH_PRECNAME(name,r) name##f##r |
231 | # define __MATH_DECLARING_DOUBLE 0 |
232 | # define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99 |
233 | # define _Mdouble_END_NAMESPACE __END_NAMESPACE_C99 |
234 | # include <bits/mathcalls.h> |
235 | # undef _Mdouble_ |
236 | # undef _Mdouble_BEGIN_NAMESPACE |
237 | # undef _Mdouble_END_NAMESPACE |
238 | # undef __MATH_PRECNAME |
239 | # undef __MATH_DECLARING_DOUBLE |
240 | |
241 | # if !(defined __NO_LONG_DOUBLE_MATH && defined _LIBC) \ |
242 | || defined __LDBL_COMPAT \ |
243 | || defined _LIBC_TEST |
244 | # ifdef __LDBL_COMPAT |
245 | |
246 | # ifdef __USE_ISOC99 |
247 | extern float __nldbl_nexttowardf (float __x, long double __y) |
248 | __THROW __attribute__ ((__const__)); |
249 | # ifdef __REDIRECT_NTH |
250 | extern float __REDIRECT_NTH (nexttowardf, (float __x, long double __y), |
251 | __nldbl_nexttowardf) |
252 | __attribute__ ((__const__)); |
253 | extern double __REDIRECT_NTH (nexttoward, (double __x, long double __y), |
254 | nextafter) __attribute__ ((__const__)); |
255 | extern long double __REDIRECT_NTH (nexttowardl, |
256 | (long double __x, long double __y), |
257 | nextafter) __attribute__ ((__const__)); |
258 | # endif |
259 | # endif |
260 | |
261 | # undef __MATHDECL_1 |
262 | # define __MATHDECL_2(type, function,suffix, args, alias) \ |
263 | extern type __REDIRECT_NTH(__MATH_PRECNAME(function,suffix), \ |
264 | args, alias) |
265 | # define __MATHDECL_1(type, function,suffix, args) \ |
266 | __MATHDECL_2(type, function,suffix, args, __CONCAT(function,suffix)) |
267 | # endif |
268 | |
269 | /* Include the file of declarations again, this time using `long double' |
270 | instead of `double' and appending l to each function name. */ |
271 | |
272 | # ifndef _Mlong_double_ |
273 | # define _Mlong_double_ long double |
274 | # endif |
275 | # define _Mdouble_ _Mlong_double_ |
276 | # define __MATH_PRECNAME(name,r) name##l##r |
277 | # define __MATH_DECLARING_DOUBLE 0 |
278 | # define _Mdouble_BEGIN_NAMESPACE __BEGIN_NAMESPACE_C99 |
279 | # define _Mdouble_END_NAMESPACE __END_NAMESPACE_C99 |
280 | # define __MATH_DECLARE_LDOUBLE 1 |
281 | # include <bits/mathcalls.h> |
282 | # undef _Mdouble_ |
283 | # undef _Mdouble_BEGIN_NAMESPACE |
284 | # undef _Mdouble_END_NAMESPACE |
285 | # undef __MATH_PRECNAME |
286 | # undef __MATH_DECLARING_DOUBLE |
287 | |
288 | # endif /* !(__NO_LONG_DOUBLE_MATH && _LIBC) || __LDBL_COMPAT */ |
289 | |
290 | #endif /* Use ISO C99. */ |
291 | #undef __MATHDECL_1 |
292 | #undef __MATHDECL |
293 | #undef __MATHCALL |
294 | |
295 | |
296 | #if defined __USE_MISC || defined __USE_XOPEN |
297 | /* This variable is used by `gamma' and `lgamma'. */ |
298 | extern int signgam; |
299 | #endif |
300 | |
301 | |
302 | /* Depending on the type of TG_ARG, call an appropriately suffixed |
303 | version of FUNC with arguments (including parentheses) ARGS. |
304 | Suffixed functions may not exist for long double if it has the same |
305 | format as double, or for other types with the same format as float, |
306 | double or long double. The behavior is undefined if the argument |
307 | does not have a real floating type. The definition may use a |
308 | conditional expression, so all suffixed versions of FUNC must |
309 | return the same type (FUNC may include a cast if necessary rather |
310 | than being a single identifier). */ |
311 | #ifdef __NO_LONG_DOUBLE_MATH |
312 | # define __MATH_TG(TG_ARG, FUNC, ARGS) \ |
313 | (sizeof (TG_ARG) == sizeof (float) ? FUNC ## f ARGS : FUNC ARGS) |
314 | #else |
315 | # define __MATH_TG(TG_ARG, FUNC, ARGS) \ |
316 | (sizeof (TG_ARG) == sizeof (float) \ |
317 | ? FUNC ## f ARGS \ |
318 | : sizeof (TG_ARG) == sizeof (double) \ |
319 | ? FUNC ARGS \ |
320 | : FUNC ## l ARGS) |
321 | #endif |
322 | |
323 | /* ISO C99 defines some generic macros which work on any data type. */ |
324 | #ifdef __USE_ISOC99 |
325 | |
326 | /* All floating-point numbers can be put in one of these categories. */ |
327 | enum |
328 | { |
329 | FP_NAN = |
330 | # define FP_NAN 0 |
331 | FP_NAN, |
332 | FP_INFINITE = |
333 | # define FP_INFINITE 1 |
334 | FP_INFINITE, |
335 | FP_ZERO = |
336 | # define FP_ZERO 2 |
337 | FP_ZERO, |
338 | FP_SUBNORMAL = |
339 | # define FP_SUBNORMAL 3 |
340 | FP_SUBNORMAL, |
341 | FP_NORMAL = |
342 | # define FP_NORMAL 4 |
343 | FP_NORMAL |
344 | }; |
345 | |
346 | /* GCC bug 66462 means we cannot use the math builtins with -fsignaling-nan, |
347 | so disable builtins if this is enabled. When fixed in a newer GCC, |
348 | the __SUPPORT_SNAN__ check may be skipped for those versions. */ |
349 | |
350 | /* Return number of classification appropriate for X. */ |
351 | # if __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__ \ |
352 | && !defined __OPTIMIZE_SIZE__ |
353 | # define fpclassify(x) __builtin_fpclassify (FP_NAN, FP_INFINITE, \ |
354 | FP_NORMAL, FP_SUBNORMAL, FP_ZERO, x) |
355 | # else |
356 | # define fpclassify(x) __MATH_TG ((x), __fpclassify, (x)) |
357 | # endif |
358 | |
359 | /* Return nonzero value if sign of X is negative. */ |
360 | # if __GNUC_PREREQ (4,0) |
361 | # define signbit(x) __MATH_TG ((x), __builtin_signbit, (x)) |
362 | # else |
363 | # define signbit(x) __MATH_TG ((x), __signbit, (x)) |
364 | # endif |
365 | |
366 | /* Return nonzero value if X is not +-Inf or NaN. */ |
367 | # if __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__ |
368 | # define isfinite(x) __builtin_isfinite (x) |
369 | # else |
370 | # define isfinite(x) __MATH_TG ((x), __finite, (x)) |
371 | # endif |
372 | |
373 | /* Return nonzero value if X is neither zero, subnormal, Inf, nor NaN. */ |
374 | # if __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__ |
375 | # define isnormal(x) __builtin_isnormal (x) |
376 | # else |
377 | # define isnormal(x) (fpclassify (x) == FP_NORMAL) |
378 | # endif |
379 | |
380 | /* Return nonzero value if X is a NaN. We could use `fpclassify' but |
381 | we already have this functions `__isnan' and it is faster. */ |
382 | # if __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__ |
383 | # define isnan(x) __builtin_isnan (x) |
384 | # else |
385 | # define isnan(x) __MATH_TG ((x), __isnan, (x)) |
386 | # endif |
387 | |
388 | /* Return nonzero value if X is positive or negative infinity. */ |
389 | # if __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__ |
390 | # define isinf(x) __builtin_isinf_sign (x) |
391 | # else |
392 | # define isinf(x) __MATH_TG ((x), __isinf, (x)) |
393 | # endif |
394 | |
395 | /* Bitmasks for the math_errhandling macro. */ |
396 | # define MATH_ERRNO 1 /* errno set by math functions. */ |
397 | # define MATH_ERREXCEPT 2 /* Exceptions raised by math functions. */ |
398 | |
399 | /* By default all functions support both errno and exception handling. |
400 | In gcc's fast math mode and if inline functions are defined this |
401 | might not be true. */ |
402 | # ifndef __FAST_MATH__ |
403 | # define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT) |
404 | # endif |
405 | |
406 | #endif /* Use ISO C99. */ |
407 | |
408 | #if __GLIBC_USE (IEC_60559_BFP_EXT) |
409 | # include <bits/iscanonical.h> |
410 | |
411 | /* Return nonzero value if X is a signaling NaN. */ |
412 | # define issignaling(x) __MATH_TG ((x), __issignaling, (x)) |
413 | |
414 | /* Return nonzero value if X is subnormal. */ |
415 | # define issubnormal(x) (fpclassify (x) == FP_SUBNORMAL) |
416 | |
417 | /* Return nonzero value if X is zero. */ |
418 | # ifndef __cplusplus |
419 | # ifdef __SUPPORT_SNAN__ |
420 | # define iszero(x) (fpclassify (x) == FP_ZERO) |
421 | # else |
422 | # define iszero(x) (((__typeof (x)) (x)) == 0) |
423 | # endif |
424 | # else /* __cplusplus */ |
425 | extern "C++" { |
426 | template <class __T> inline bool |
427 | iszero (__T __val) |
428 | { |
429 | # ifdef __SUPPORT_SNAN__ |
430 | return fpclassify (__val) == FP_ZERO; |
431 | # else |
432 | return __val == 0; |
433 | # endif |
434 | } |
435 | } /* extern C++ */ |
436 | # endif /* __cplusplus */ |
437 | #endif /* Use IEC_60559_BFP_EXT. */ |
438 | |
439 | #ifdef __USE_MISC |
440 | /* Support for various different standard error handling behaviors. */ |
441 | typedef enum |
442 | { |
443 | _IEEE_ = -1, /* According to IEEE 754/IEEE 854. */ |
444 | _SVID_, /* According to System V, release 4. */ |
445 | _XOPEN_, /* Nowadays also Unix98. */ |
446 | _POSIX_, |
447 | _ISOC_ /* Actually this is ISO C99. */ |
448 | } _LIB_VERSION_TYPE; |
449 | |
450 | /* This variable can be changed at run-time to any of the values above to |
451 | affect floating point error handling behavior (it may also be necessary |
452 | to change the hardware FPU exception settings). */ |
453 | extern _LIB_VERSION_TYPE _LIB_VERSION; |
454 | #endif |
455 | |
456 | |
457 | #ifdef __USE_MISC |
458 | /* In SVID error handling, `matherr' is called with this description |
459 | of the exceptional condition. |
460 | |
461 | We have a problem when using C++ since `exception' is a reserved |
462 | name in C++. */ |
463 | # ifdef __cplusplus |
464 | struct __exception |
465 | # else |
466 | struct exception |
467 | # endif |
468 | { |
469 | int type; |
470 | char *name; |
471 | double arg1; |
472 | double arg2; |
473 | double retval; |
474 | }; |
475 | |
476 | # ifdef __cplusplus |
477 | extern int matherr (struct __exception *__exc) throw (); |
478 | # else |
479 | extern int matherr (struct exception *__exc); |
480 | # endif |
481 | |
482 | # define X_TLOSS 1.41484755040568800000e+16 |
483 | |
484 | /* Types of exceptions in the `type' field. */ |
485 | # define DOMAIN 1 |
486 | # define SING 2 |
487 | # define OVERFLOW 3 |
488 | # define UNDERFLOW 4 |
489 | # define TLOSS 5 |
490 | # define PLOSS 6 |
491 | |
492 | /* SVID mode specifies returning this large value instead of infinity. */ |
493 | # define HUGE 3.40282347e+38F |
494 | |
495 | #else /* !Misc. */ |
496 | |
497 | # ifdef __USE_XOPEN |
498 | /* X/Open wants another strange constant. */ |
499 | # define MAXFLOAT 3.40282347e+38F |
500 | # endif |
501 | |
502 | #endif /* Misc. */ |
503 | |
504 | |
505 | /* Some useful constants. */ |
506 | #if defined __USE_MISC || defined __USE_XOPEN |
507 | # define M_E 2.7182818284590452354 /* e */ |
508 | # define M_LOG2E 1.4426950408889634074 /* log_2 e */ |
509 | # define M_LOG10E 0.43429448190325182765 /* log_10 e */ |
510 | # define M_LN2 0.69314718055994530942 /* log_e 2 */ |
511 | # define M_LN10 2.30258509299404568402 /* log_e 10 */ |
512 | # define M_PI 3.14159265358979323846 /* pi */ |
513 | # define M_PI_2 1.57079632679489661923 /* pi/2 */ |
514 | # define M_PI_4 0.78539816339744830962 /* pi/4 */ |
515 | # define M_1_PI 0.31830988618379067154 /* 1/pi */ |
516 | # define M_2_PI 0.63661977236758134308 /* 2/pi */ |
517 | # define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */ |
518 | # define M_SQRT2 1.41421356237309504880 /* sqrt(2) */ |
519 | # define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */ |
520 | #endif |
521 | |
522 | /* The above constants are not adequate for computation using `long double's. |
523 | Therefore we provide as an extension constants with similar names as a |
524 | GNU extension. Provide enough digits for the 128-bit IEEE quad. */ |
525 | #ifdef __USE_GNU |
526 | # define M_El 2.718281828459045235360287471352662498L /* e */ |
527 | # define M_LOG2El 1.442695040888963407359924681001892137L /* log_2 e */ |
528 | # define M_LOG10El 0.434294481903251827651128918916605082L /* log_10 e */ |
529 | # define M_LN2l 0.693147180559945309417232121458176568L /* log_e 2 */ |
530 | # define M_LN10l 2.302585092994045684017991454684364208L /* log_e 10 */ |
531 | # define M_PIl 3.141592653589793238462643383279502884L /* pi */ |
532 | # define M_PI_2l 1.570796326794896619231321691639751442L /* pi/2 */ |
533 | # define M_PI_4l 0.785398163397448309615660845819875721L /* pi/4 */ |
534 | # define M_1_PIl 0.318309886183790671537767526745028724L /* 1/pi */ |
535 | # define M_2_PIl 0.636619772367581343075535053490057448L /* 2/pi */ |
536 | # define M_2_SQRTPIl 1.128379167095512573896158903121545172L /* 2/sqrt(pi) */ |
537 | # define M_SQRT2l 1.414213562373095048801688724209698079L /* sqrt(2) */ |
538 | # define M_SQRT1_2l 0.707106781186547524400844362104849039L /* 1/sqrt(2) */ |
539 | #endif |
540 | |
541 | |
542 | /* When compiling in strict ISO C compatible mode we must not use the |
543 | inline functions since they, among other things, do not set the |
544 | `errno' variable correctly. */ |
545 | #if defined __STRICT_ANSI__ && !defined __NO_MATH_INLINES |
546 | # define __NO_MATH_INLINES 1 |
547 | #endif |
548 | |
549 | #if defined __USE_ISOC99 && __GNUC_PREREQ(2,97) |
550 | /* ISO C99 defines some macros to compare number while taking care for |
551 | unordered numbers. Many FPUs provide special instructions to support |
552 | these operations. Generic support in GCC for these as builtins went |
553 | in before 3.0.0, but not all cpus added their patterns. We define |
554 | versions that use the builtins here, and <bits/mathinline.h> will |
555 | undef/redefine as appropriate for the specific GCC version in use. */ |
556 | # define isgreater(x, y) __builtin_isgreater(x, y) |
557 | # define isgreaterequal(x, y) __builtin_isgreaterequal(x, y) |
558 | # define isless(x, y) __builtin_isless(x, y) |
559 | # define islessequal(x, y) __builtin_islessequal(x, y) |
560 | # define islessgreater(x, y) __builtin_islessgreater(x, y) |
561 | # define isunordered(u, v) __builtin_isunordered(u, v) |
562 | #endif |
563 | |
564 | /* Get machine-dependent inline versions (if there are any). */ |
565 | #ifdef __USE_EXTERN_INLINES |
566 | # include <bits/mathinline.h> |
567 | #endif |
568 | |
569 | /* Define special entry points to use when the compiler got told to |
570 | only expect finite results. */ |
571 | #if defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ > 0 |
572 | # include <bits/math-finite.h> |
573 | #endif |
574 | |
575 | #ifdef __USE_ISOC99 |
576 | /* If we've still got undefined comparison macros, provide defaults. */ |
577 | |
578 | /* Return nonzero value if X is greater than Y. */ |
579 | # ifndef isgreater |
580 | # define isgreater(x, y) \ |
581 | (__extension__ \ |
582 | ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \ |
583 | !isunordered (__x, __y) && __x > __y; })) |
584 | # endif |
585 | |
586 | /* Return nonzero value if X is greater than or equal to Y. */ |
587 | # ifndef isgreaterequal |
588 | # define isgreaterequal(x, y) \ |
589 | (__extension__ \ |
590 | ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \ |
591 | !isunordered (__x, __y) && __x >= __y; })) |
592 | # endif |
593 | |
594 | /* Return nonzero value if X is less than Y. */ |
595 | # ifndef isless |
596 | # define isless(x, y) \ |
597 | (__extension__ \ |
598 | ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \ |
599 | !isunordered (__x, __y) && __x < __y; })) |
600 | # endif |
601 | |
602 | /* Return nonzero value if X is less than or equal to Y. */ |
603 | # ifndef islessequal |
604 | # define islessequal(x, y) \ |
605 | (__extension__ \ |
606 | ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \ |
607 | !isunordered (__x, __y) && __x <= __y; })) |
608 | # endif |
609 | |
610 | /* Return nonzero value if either X is less than Y or Y is less than X. */ |
611 | # ifndef islessgreater |
612 | # define islessgreater(x, y) \ |
613 | (__extension__ \ |
614 | ({ __typeof__(x) __x = (x); __typeof__(y) __y = (y); \ |
615 | !isunordered (__x, __y) && (__x < __y || __y < __x); })) |
616 | # endif |
617 | |
618 | /* Return nonzero value if arguments are unordered. */ |
619 | # ifndef isunordered |
620 | # define isunordered(u, v) \ |
621 | (__extension__ \ |
622 | ({ __typeof__(u) __u = (u); __typeof__(v) __v = (v); \ |
623 | fpclassify (__u) == FP_NAN || fpclassify (__v) == FP_NAN; })) |
624 | # endif |
625 | |
626 | #endif |
627 | |
628 | #if __GLIBC_USE (IEC_60559_BFP_EXT) |
629 | /* An expression whose type has the widest of the evaluation formats |
630 | of X and Y (which are of floating-point types). */ |
631 | # if __FLT_EVAL_METHOD__ == 2 || __FLT_EVAL_METHOD__ > 64 |
632 | # define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0L) |
633 | # elif __FLT_EVAL_METHOD__ == 1 || __FLT_EVAL_METHOD__ > 32 |
634 | # define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0) |
635 | # else |
636 | # define __MATH_EVAL_FMT2(x, y) ((x) + (y)) |
637 | # endif |
638 | |
639 | /* Return X == Y but raising "invalid" and setting errno if X or Y is |
640 | a NaN. */ |
641 | # define iseqsig(x, y) \ |
642 | __MATH_TG (__MATH_EVAL_FMT2 (x, y), __iseqsig, ((x), (y))) |
643 | #endif |
644 | |
645 | __END_DECLS |
646 | |
647 | |
648 | #endif /* math.h */ |
649 | |