?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
powerpc64le: bump binutils version requirement to >= 2.26
[glibc.git] / math / math.h
blobe48860e3915b0ec5c0ae0d594d84432c0568ddc6
1 /* Declarations for math functions.
2 Copyright (C) 1991-2020 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 <https://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 __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
27 #include <bits/libc-header-start.h>
28
29 #if defined log && defined __GNUC__
30 # warning A macro called log was already defined when <math.h> was included.
31 # warning This will cause compilation problems.
32 #endif
33
34 __BEGIN_DECLS
35
36 /* Get definitions of __intmax_t and __uintmax_t. */
37 #include <bits/types.h>
38
39 /* Get machine-dependent vector math functions declarations. */
40 #include <bits/math-vector.h>
41
42 /* Gather machine dependent type support. */
43 #include <bits/floatn.h>
44
45 /* Value returned on overflow. With IEEE 754 floating point, this is
46 +Infinity, otherwise the largest representable positive value. */
47 #if __GNUC_PREREQ (3, 3)
48 # define HUGE_VAL (__builtin_huge_val ())
49 #else
50 /* This may provoke compiler warnings, and may not be rounded to
51 +Infinity in all IEEE 754 rounding modes, but is the best that can
52 be done in ISO C while remaining a constant expression. 10,000 is
53 greater than the maximum (decimal) exponent for all supported
54 floating-point formats and widths. */
55 # define HUGE_VAL 1e10000
56 #endif
57 #ifdef __USE_ISOC99
58 # if __GNUC_PREREQ (3, 3)
59 # define HUGE_VALF (__builtin_huge_valf ())
60 # define HUGE_VALL (__builtin_huge_vall ())
61 # else
62 # define HUGE_VALF 1e10000f
63 # define HUGE_VALL 1e10000L
64 # endif
65 #endif
66 #if __HAVE_FLOAT16 && __GLIBC_USE (IEC_60559_TYPES_EXT)
67 # define HUGE_VAL_F16 (__builtin_huge_valf16 ())
68 #endif
69 #if __HAVE_FLOAT32 && __GLIBC_USE (IEC_60559_TYPES_EXT)
70 # define HUGE_VAL_F32 (__builtin_huge_valf32 ())
71 #endif
72 #if __HAVE_FLOAT64 && __GLIBC_USE (IEC_60559_TYPES_EXT)
73 # define HUGE_VAL_F64 (__builtin_huge_valf64 ())
74 #endif
75 #if __HAVE_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT)
76 # define HUGE_VAL_F128 (__builtin_huge_valf128 ())
77 #endif
78 #if __HAVE_FLOAT32X && __GLIBC_USE (IEC_60559_TYPES_EXT)
79 # define HUGE_VAL_F32X (__builtin_huge_valf32x ())
80 #endif
81 #if __HAVE_FLOAT64X && __GLIBC_USE (IEC_60559_TYPES_EXT)
82 # define HUGE_VAL_F64X (__builtin_huge_valf64x ())
83 #endif
84 #if __HAVE_FLOAT128X && __GLIBC_USE (IEC_60559_TYPES_EXT)
85 # define HUGE_VAL_F128X (__builtin_huge_valf128x ())
86 #endif
87
88 #ifdef __USE_ISOC99
89 /* IEEE positive infinity. */
90 # if __GNUC_PREREQ (3, 3)
91 # define INFINITY (__builtin_inff ())
92 # else
93 # define INFINITY HUGE_VALF
94 # endif
95
96 /* IEEE Not A Number. */
97 # if __GNUC_PREREQ (3, 3)
98 # define NAN (__builtin_nanf (""))
99 # else
100 /* This will raise an "invalid" exception outside static initializers,
101 but is the best that can be done in ISO C while remaining a
102 constant expression. */
103 # define NAN (0.0f / 0.0f)
104 # endif
105 #endif /* __USE_ISOC99 */
106
107 #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
108 /* Signaling NaN macros, if supported. */
109 # if __GNUC_PREREQ (3, 3)
110 # define SNANF (__builtin_nansf (""))
111 # define SNAN (__builtin_nans (""))
112 # define SNANL (__builtin_nansl (""))
113 # endif
114 #endif
115 #if __HAVE_FLOAT16 && __GLIBC_USE (IEC_60559_TYPES_EXT)
116 # define SNANF16 (__builtin_nansf16 (""))
117 #endif
118 #if __HAVE_FLOAT32 && __GLIBC_USE (IEC_60559_TYPES_EXT)
119 # define SNANF32 (__builtin_nansf32 (""))
120 #endif
121 #if __HAVE_FLOAT64 && __GLIBC_USE (IEC_60559_TYPES_EXT)
122 # define SNANF64 (__builtin_nansf64 (""))
123 #endif
124 #if __HAVE_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT)
125 # define SNANF128 (__builtin_nansf128 (""))
126 #endif
127 #if __HAVE_FLOAT32X && __GLIBC_USE (IEC_60559_TYPES_EXT)
128 # define SNANF32X (__builtin_nansf32x (""))
129 #endif
130 #if __HAVE_FLOAT64X && __GLIBC_USE (IEC_60559_TYPES_EXT)
131 # define SNANF64X (__builtin_nansf64x (""))
132 #endif
133 #if __HAVE_FLOAT128X && __GLIBC_USE (IEC_60559_TYPES_EXT)
134 # define SNANF128X (__builtin_nansf128x (""))
135 #endif
136
137 /* Get __GLIBC_FLT_EVAL_METHOD. */
138 #include <bits/flt-eval-method.h>
139
140 #ifdef __USE_ISOC99
141 /* Define the following typedefs.
142
143 float_t floating-point type at least as wide as `float' used
144 to evaluate `float' expressions
145 double_t floating-point type at least as wide as `double' used
146 to evaluate `double' expressions
147 */
148 # if __GLIBC_FLT_EVAL_METHOD == 0 || __GLIBC_FLT_EVAL_METHOD == 16
149 typedef float float_t;
150 typedef double double_t;
151 # elif __GLIBC_FLT_EVAL_METHOD == 1
152 typedef double float_t;
153 typedef double double_t;
154 # elif __GLIBC_FLT_EVAL_METHOD == 2
155 typedef long double float_t;
156 typedef long double double_t;
157 # elif __GLIBC_FLT_EVAL_METHOD == 32
158 typedef _Float32 float_t;
159 typedef double double_t;
160 # elif __GLIBC_FLT_EVAL_METHOD == 33
161 typedef _Float32x float_t;
162 typedef _Float32x double_t;
163 # elif __GLIBC_FLT_EVAL_METHOD == 64
164 typedef _Float64 float_t;
165 typedef _Float64 double_t;
166 # elif __GLIBC_FLT_EVAL_METHOD == 65
167 typedef _Float64x float_t;
168 typedef _Float64x double_t;
169 # elif __GLIBC_FLT_EVAL_METHOD == 128
170 typedef _Float128 float_t;
171 typedef _Float128 double_t;
172 # elif __GLIBC_FLT_EVAL_METHOD == 129
173 typedef _Float128x float_t;
174 typedef _Float128x double_t;
175 # else
176 # error "Unknown __GLIBC_FLT_EVAL_METHOD"
177 # endif
178 #endif
179
180 /* Define macros for the return values of ilogb and llogb, based on
181 __FP_LOGB0_IS_MIN and __FP_LOGBNAN_IS_MIN.
182
183 FP_ILOGB0 Expands to a value returned by `ilogb (0.0)'.
184 FP_ILOGBNAN Expands to a value returned by `ilogb (NAN)'.
185 FP_LLOGB0 Expands to a value returned by `llogb (0.0)'.
186 FP_LLOGBNAN Expands to a value returned by `llogb (NAN)'.
187
188 */
189
190 #include <bits/fp-logb.h>
191 #ifdef __USE_ISOC99
192 # if __FP_LOGB0_IS_MIN
193 # define FP_ILOGB0 (-2147483647 - 1)
194 # else
195 # define FP_ILOGB0 (-2147483647)
196 # endif
197 # if __FP_LOGBNAN_IS_MIN
198 # define FP_ILOGBNAN (-2147483647 - 1)
199 # else
200 # define FP_ILOGBNAN 2147483647
201 # endif
202 #endif
203 #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
204 # if __WORDSIZE == 32
205 # define __FP_LONG_MAX 0x7fffffffL
206 # else
207 # define __FP_LONG_MAX 0x7fffffffffffffffL
208 # endif
209 # if __FP_LOGB0_IS_MIN
210 # define FP_LLOGB0 (-__FP_LONG_MAX - 1)
211 # else
212 # define FP_LLOGB0 (-__FP_LONG_MAX)
213 # endif
214 # if __FP_LOGBNAN_IS_MIN
215 # define FP_LLOGBNAN (-__FP_LONG_MAX - 1)
216 # else
217 # define FP_LLOGBNAN __FP_LONG_MAX
218 # endif
219 #endif
220
221 /* Get the architecture specific values describing the floating-point
222 evaluation. The following symbols will get defined:
223
224 FP_FAST_FMA
225 FP_FAST_FMAF
226 FP_FAST_FMAL
227 If defined it indicates that the `fma' function
228 generally executes about as fast as a multiply and an add.
229 This macro is defined only iff the `fma' function is
230 implemented directly with a hardware multiply-add instructions.
231 */
232
233 #include <bits/fp-fast.h>
234
235 #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
236 /* Rounding direction macros for fromfp functions. */
237 enum
238 {
239 FP_INT_UPWARD =
240 # define FP_INT_UPWARD 0
241 FP_INT_UPWARD,
242 FP_INT_DOWNWARD =
243 # define FP_INT_DOWNWARD 1
244 FP_INT_DOWNWARD,
245 FP_INT_TOWARDZERO =
246 # define FP_INT_TOWARDZERO 2
247 FP_INT_TOWARDZERO,
248 FP_INT_TONEARESTFROMZERO =
249 # define FP_INT_TONEARESTFROMZERO 3
250 FP_INT_TONEARESTFROMZERO,
251 FP_INT_TONEAREST =
252 # define FP_INT_TONEAREST 4
253 FP_INT_TONEAREST,
254 };
255 #endif
256
257 /* The file <bits/mathcalls.h> contains the prototypes for all the
258 actual math functions. These macros are used for those prototypes,
259 so we can easily declare each function as both `name' and `__name',
260 and can declare the float versions `namef' and `__namef'. */
261
262 #define __SIMD_DECL(function) __CONCAT (__DECL_SIMD_, function)
263
264 #define __MATHCALL_VEC(function, suffix, args) \
265 __SIMD_DECL (__MATH_PRECNAME (function, suffix)) \
266 __MATHCALL (function, suffix, args)
267
268 #define __MATHDECL_VEC(type, function,suffix, args) \
269 __SIMD_DECL (__MATH_PRECNAME (function, suffix)) \
270 __MATHDECL(type, function,suffix, args)
271
272 #define __MATHCALL(function,suffix, args) \
273 __MATHDECL (_Mdouble_,function,suffix, args)
274 #define __MATHDECL(type, function,suffix, args) \
275 __MATHDECL_1(type, function,suffix, args); \
276 __MATHDECL_1(type, __CONCAT(__,function),suffix, args)
277 #define __MATHCALLX(function,suffix, args, attrib) \
278 __MATHDECLX (_Mdouble_,function,suffix, args, attrib)
279 #define __MATHDECLX(type, function,suffix, args, attrib) \
280 __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); \
281 __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)
282 #define __MATHDECL_1_IMPL(type, function, suffix, args) \
283 extern type __MATH_PRECNAME(function,suffix) args __THROW
284 #define __MATHDECL_1(type, function, suffix, args) \
285 __MATHDECL_1_IMPL(type, function, suffix, args)
286 /* Ignore the alias by default. The alias is only useful with
287 redirections. */
288 #define __MATHDECL_ALIAS(type, function, suffix, args, alias) \
289 __MATHDECL_1(type, function, suffix, args)
290
291 #define __MATHREDIR(type, function, suffix, args, to) \
292 extern type __REDIRECT_NTH (__MATH_PRECNAME (function, suffix), args, to)
293
294 #define _Mdouble_ double
295 #define __MATH_PRECNAME(name,r) __CONCAT(name,r)
296 #define __MATH_DECLARING_DOUBLE 1
297 #define __MATH_DECLARING_FLOATN 0
298 #include <bits/mathcalls-helper-functions.h>
299 #include <bits/mathcalls.h>
300 #undef _Mdouble_
301 #undef __MATH_PRECNAME
302 #undef __MATH_DECLARING_DOUBLE
303 #undef __MATH_DECLARING_FLOATN
304
305 #ifdef __USE_ISOC99
306
307
308 /* Include the file of declarations again, this time using `float'
309 instead of `double' and appending f to each function name. */
310
311 # define _Mdouble_ float
312 # define __MATH_PRECNAME(name,r) name##f##r
313 # define __MATH_DECLARING_DOUBLE 0
314 # define __MATH_DECLARING_FLOATN 0
315 # include <bits/mathcalls-helper-functions.h>
316 # include <bits/mathcalls.h>
317 # undef _Mdouble_
318 # undef __MATH_PRECNAME
319 # undef __MATH_DECLARING_DOUBLE
320 # undef __MATH_DECLARING_FLOATN
321
322 # if !(defined __NO_LONG_DOUBLE_MATH && defined _LIBC) \
323 || defined __LDBL_COMPAT \
324 || defined _LIBC_TEST
325 # ifdef __LDBL_COMPAT
326
327 # ifdef __USE_ISOC99
328 extern float __nldbl_nexttowardf (float __x, long double __y)
329 __THROW __attribute__ ((__const__));
330 # ifdef __REDIRECT_NTH
331 extern float __REDIRECT_NTH (nexttowardf, (float __x, long double __y),
332 __nldbl_nexttowardf)
333 __attribute__ ((__const__));
334 extern double __REDIRECT_NTH (nexttoward, (double __x, long double __y),
335 nextafter) __attribute__ ((__const__));
336 extern long double __REDIRECT_NTH (nexttowardl,
337 (long double __x, long double __y),
338 nextafter) __attribute__ ((__const__));
339 # endif
340 # endif
341
342 # undef __MATHDECL_1
343 # define __MATHDECL_1(type, function,suffix, args) \
344 __MATHREDIR(type, function, suffix, args, __CONCAT(function,suffix))
345
346 # elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1
347 # ifdef __REDIRECT_NTH
348 # ifdef __USE_ISOC99
349 extern float __REDIRECT_NTH (nexttowardf, (float __x, long double __y),
350 __nexttowardf_to_ieee128)
351 __attribute__ ((__const__));
352 extern double __REDIRECT_NTH (nexttoward, (double __x, long double __y),
353 __nexttoward_to_ieee128)
354 __attribute__ ((__const__));
355
356 #define __dremieee128 __remainderieee128
357 #define __gammaieee128 __lgammaieee128
358
359 # endif
360 # endif
361
362 # undef __MATHDECL_1
363 # undef __MATHDECL_ALIAS
364
365 # define __REDIRTO(function, suffix) \
366 __ ## function ## ieee128 ## suffix
367 # define __REDIRTO_ALT(function, suffix) \
368 __ ## function ## f128 ## suffix
369
370 # define __MATHDECL_1(type, function, suffix, args) \
371 __MATHREDIR (type, function, suffix, args, __REDIRTO (function, suffix))
372 # define __MATHDECL_ALIAS(type, function, suffix, args, alias) \
373 __MATHREDIR (type, function, suffix, args, __REDIRTO_ALT (alias, suffix))
374 # endif
375
376 /* Include the file of declarations again, this time using `long double'
377 instead of `double' and appending l to each function name. */
378
379 # define _Mdouble_ long double
380 # define __MATH_PRECNAME(name,r) name##l##r
381 # define __MATH_DECLARING_DOUBLE 0
382 # define __MATH_DECLARING_FLOATN 0
383 # define __MATH_DECLARE_LDOUBLE 1
384 # include <bits/mathcalls-helper-functions.h>
385 # include <bits/mathcalls.h>
386
387 # undef _Mdouble_
388 # undef __MATH_PRECNAME
389 # undef __MATH_DECLARING_DOUBLE
390 # undef __MATH_DECLARING_FLOATN
391
392 # if defined __LDBL_COMPAT \
393 || __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1
394 # undef __REDIRTO
395 # undef __REDIRTO_ALT
396 # undef __MATHDECL_1
397 # undef __MATHDECL_ALIAS
398 # define __MATHDECL_1(type, function, suffix, args) \
399 __MATHDECL_1_IMPL(type, function, suffix, args)
400 # define __MATHDECL_ALIAS(type, function, suffix, args, alias) \
401 __MATHDECL_1(type, function, suffix, args)
402 # endif
403 # endif /* !(__NO_LONG_DOUBLE_MATH && _LIBC) || __LDBL_COMPAT */
404
405 #endif /* Use ISO C99. */
406
407 /* Include the file of declarations for _FloatN and _FloatNx
408 types. */
409
410 #if __HAVE_DISTINCT_FLOAT16 || (__HAVE_FLOAT16 && !defined _LIBC)
411 # define _Mdouble_ _Float16
412 # define __MATH_PRECNAME(name,r) name##f16##r
413 # define __MATH_DECLARING_DOUBLE 0
414 # define __MATH_DECLARING_FLOATN 1
415 # if __HAVE_DISTINCT_FLOAT16
416 # include <bits/mathcalls-helper-functions.h>
417 # endif
418 # if __GLIBC_USE (IEC_60559_TYPES_EXT)
419 # include <bits/mathcalls.h>
420 # endif
421 # undef _Mdouble_
422 # undef __MATH_PRECNAME
423 # undef __MATH_DECLARING_DOUBLE
424 # undef __MATH_DECLARING_FLOATN
425 #endif /* __HAVE_DISTINCT_FLOAT16 || (__HAVE_FLOAT16 && !_LIBC). */
426
427 #if __HAVE_DISTINCT_FLOAT32 || (__HAVE_FLOAT32 && !defined _LIBC)
428 # define _Mdouble_ _Float32
429 # define __MATH_PRECNAME(name,r) name##f32##r
430 # define __MATH_DECLARING_DOUBLE 0
431 # define __MATH_DECLARING_FLOATN 1
432 # if __HAVE_DISTINCT_FLOAT32
433 # include <bits/mathcalls-helper-functions.h>
434 # endif
435 # if __GLIBC_USE (IEC_60559_TYPES_EXT)
436 # include <bits/mathcalls.h>
437 # endif
438 # undef _Mdouble_
439 # undef __MATH_PRECNAME
440 # undef __MATH_DECLARING_DOUBLE
441 # undef __MATH_DECLARING_FLOATN
442 #endif /* __HAVE_DISTINCT_FLOAT32 || (__HAVE_FLOAT32 && !_LIBC). */
443
444 #if __HAVE_DISTINCT_FLOAT64 || (__HAVE_FLOAT64 && !defined _LIBC)
445 # define _Mdouble_ _Float64
446 # define __MATH_PRECNAME(name,r) name##f64##r
447 # define __MATH_DECLARING_DOUBLE 0
448 # define __MATH_DECLARING_FLOATN 1
449 # if __HAVE_DISTINCT_FLOAT64
450 # include <bits/mathcalls-helper-functions.h>
451 # endif
452 # if __GLIBC_USE (IEC_60559_TYPES_EXT)
453 # include <bits/mathcalls.h>
454 # endif
455 # undef _Mdouble_
456 # undef __MATH_PRECNAME
457 # undef __MATH_DECLARING_DOUBLE
458 # undef __MATH_DECLARING_FLOATN
459 #endif /* __HAVE_DISTINCT_FLOAT64 || (__HAVE_FLOAT64 && !_LIBC). */
460
461 #if __HAVE_DISTINCT_FLOAT128 || (__HAVE_FLOAT128 && !defined _LIBC)
462 # define _Mdouble_ _Float128
463 # define __MATH_PRECNAME(name,r) name##f128##r
464 # define __MATH_DECLARING_DOUBLE 0
465 # define __MATH_DECLARING_FLOATN 1
466 # if __HAVE_DISTINCT_FLOAT128
467 # include <bits/mathcalls-helper-functions.h>
468 # endif
469 # if __GLIBC_USE (IEC_60559_TYPES_EXT)
470 # include <bits/mathcalls.h>
471 # endif
472 # undef _Mdouble_
473 # undef __MATH_PRECNAME
474 # undef __MATH_DECLARING_DOUBLE
475 # undef __MATH_DECLARING_FLOATN
476 #endif /* __HAVE_DISTINCT_FLOAT128 || (__HAVE_FLOAT128 && !_LIBC). */
477
478 #if __HAVE_DISTINCT_FLOAT32X || (__HAVE_FLOAT32X && !defined _LIBC)
479 # define _Mdouble_ _Float32x
480 # define __MATH_PRECNAME(name,r) name##f32x##r
481 # define __MATH_DECLARING_DOUBLE 0
482 # define __MATH_DECLARING_FLOATN 1
483 # if __HAVE_DISTINCT_FLOAT32X
484 # include <bits/mathcalls-helper-functions.h>
485 # endif
486 # if __GLIBC_USE (IEC_60559_TYPES_EXT)
487 # include <bits/mathcalls.h>
488 # endif
489 # undef _Mdouble_
490 # undef __MATH_PRECNAME
491 # undef __MATH_DECLARING_DOUBLE
492 # undef __MATH_DECLARING_FLOATN
493 #endif /* __HAVE_DISTINCT_FLOAT32X || (__HAVE_FLOAT32X && !_LIBC). */
494
495 #if __HAVE_DISTINCT_FLOAT64X || (__HAVE_FLOAT64X && !defined _LIBC)
496 # define _Mdouble_ _Float64x
497 # define __MATH_PRECNAME(name,r) name##f64x##r
498 # define __MATH_DECLARING_DOUBLE 0
499 # define __MATH_DECLARING_FLOATN 1
500 # if __HAVE_DISTINCT_FLOAT64X
501 # include <bits/mathcalls-helper-functions.h>
502 # endif
503 # if __GLIBC_USE (IEC_60559_TYPES_EXT)
504 # include <bits/mathcalls.h>
505 # endif
506 # undef _Mdouble_
507 # undef __MATH_PRECNAME
508 # undef __MATH_DECLARING_DOUBLE
509 # undef __MATH_DECLARING_FLOATN
510 #endif /* __HAVE_DISTINCT_FLOAT64X || (__HAVE_FLOAT64X && !_LIBC). */
511
512 #if __HAVE_DISTINCT_FLOAT128X || (__HAVE_FLOAT128X && !defined _LIBC)
513 # define _Mdouble_ _Float128x
514 # define __MATH_PRECNAME(name,r) name##f128x##r
515 # define __MATH_DECLARING_DOUBLE 0
516 # define __MATH_DECLARING_FLOATN 1
517 # if __HAVE_DISTINCT_FLOAT128X
518 # include <bits/mathcalls-helper-functions.h>
519 # endif
520 # if __GLIBC_USE (IEC_60559_TYPES_EXT)
521 # include <bits/mathcalls.h>
522 # endif
523 # undef _Mdouble_
524 # undef __MATH_PRECNAME
525 # undef __MATH_DECLARING_DOUBLE
526 # undef __MATH_DECLARING_FLOATN
527 #endif /* __HAVE_DISTINCT_FLOAT128X || (__HAVE_FLOAT128X && !_LIBC). */
528
529 #undef __MATHDECL_1_IMPL
530 #undef __MATHDECL_1
531 #undef __MATHDECL_ALIAS
532 #undef __MATHDECL
533 #undef __MATHCALL
534
535 /* Declare functions returning a narrower type. */
536 #define __MATHCALL_NARROW_ARGS_1 (_Marg_ __x)
537 #define __MATHCALL_NARROW_ARGS_2 (_Marg_ __x, _Marg_ __y)
538 #define __MATHCALL_NARROW_ARGS_3 (_Marg_ __x, _Marg_ __y, _Marg_ __z)
539 #define __MATHCALL_NARROW_NORMAL(func, nargs) \
540 extern _Mret_ func __MATHCALL_NARROW_ARGS_ ## nargs __THROW
541 #define __MATHCALL_NARROW_REDIR(func, redir, nargs) \
542 extern _Mret_ __REDIRECT_NTH (func, __MATHCALL_NARROW_ARGS_ ## nargs, \
543 redir)
544 #define __MATHCALL_NARROW(func, redir, nargs) \
545 __MATHCALL_NARROW_NORMAL (func, nargs)
546
547 #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
548
549 # define _Mret_ float
550 # define _Marg_ double
551 # define __MATHCALL_NAME(name) f ## name
552 # include <bits/mathcalls-narrow.h>
553 # undef _Mret_
554 # undef _Marg_
555 # undef __MATHCALL_NAME
556
557 # define _Mret_ float
558 # define _Marg_ long double
559 # define __MATHCALL_NAME(name) f ## name ## l
560 # ifdef __LDBL_COMPAT
561 # define __MATHCALL_REDIR_NAME(name) f ## name
562 # undef __MATHCALL_NARROW
563 # define __MATHCALL_NARROW(func, redir, nargs) \
564 __MATHCALL_NARROW_REDIR (func, redir, nargs)
565 # elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1
566 # define __MATHCALL_REDIR_NAME(name) __ ## f32 ## name ## ieee128
567 # undef __MATHCALL_NARROW
568 # define __MATHCALL_NARROW(func, redir, nargs) \
569 __MATHCALL_NARROW_REDIR (func, redir, nargs)
570 # endif
571 # include <bits/mathcalls-narrow.h>
572 # undef _Mret_
573 # undef _Marg_
574 # undef __MATHCALL_NAME
575 # if defined __LDBL_COMPAT \
576 || __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1
577 # undef __MATHCALL_REDIR_NAME
578 # undef __MATHCALL_NARROW
579 # define __MATHCALL_NARROW(func, redir, nargs) \
580 __MATHCALL_NARROW_NORMAL (func, nargs)
581 # endif
582
583 # define _Mret_ double
584 # define _Marg_ long double
585 # define __MATHCALL_NAME(name) d ## name ## l
586 # ifdef __LDBL_COMPAT
587 # define __MATHCALL_REDIR_NAME(name) __nldbl_d ## name ## l
588 # undef __MATHCALL_NARROW
589 # define __MATHCALL_NARROW(func, redir, nargs) \
590 __MATHCALL_NARROW_REDIR (func, redir, nargs)
591 # elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1
592 # define __MATHCALL_REDIR_NAME(name) __ ## f64 ## name ## ieee128
593 # undef __MATHCALL_NARROW
594 # define __MATHCALL_NARROW(func, redir, nargs) \
595 __MATHCALL_NARROW_REDIR (func, redir, nargs)
596 # endif
597 # include <bits/mathcalls-narrow.h>
598 # undef _Mret_
599 # undef _Marg_
600 # undef __MATHCALL_NAME
601 # if defined __LDBL_COMPAT \
602 || __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1
603 # undef __MATHCALL_REDIR_NAME
604 # undef __MATHCALL_NARROW
605 # define __MATHCALL_NARROW(func, redir, nargs) \
606 __MATHCALL_NARROW_NORMAL (func, nargs)
607 # endif
608
609 #endif
610
611 #if __GLIBC_USE (IEC_60559_TYPES_EXT)
612
613 # if __HAVE_FLOAT16 && __HAVE_FLOAT32
614 # define _Mret_ _Float16
615 # define _Marg_ _Float32
616 # define __MATHCALL_NAME(name) f16 ## name ## f32
617 # include <bits/mathcalls-narrow.h>
618 # undef _Mret_
619 # undef _Marg_
620 # undef __MATHCALL_NAME
621 # endif
622
623 # if __HAVE_FLOAT16 && __HAVE_FLOAT32X
624 # define _Mret_ _Float16
625 # define _Marg_ _Float32x
626 # define __MATHCALL_NAME(name) f16 ## name ## f32x
627 # include <bits/mathcalls-narrow.h>
628 # undef _Mret_
629 # undef _Marg_
630 # undef __MATHCALL_NAME
631 # endif
632
633 # if __HAVE_FLOAT16 && __HAVE_FLOAT64
634 # define _Mret_ _Float16
635 # define _Marg_ _Float64
636 # define __MATHCALL_NAME(name) f16 ## name ## f64
637 # include <bits/mathcalls-narrow.h>
638 # undef _Mret_
639 # undef _Marg_
640 # undef __MATHCALL_NAME
641 # endif
642
643 # if __HAVE_FLOAT16 && __HAVE_FLOAT64X
644 # define _Mret_ _Float16
645 # define _Marg_ _Float64x
646 # define __MATHCALL_NAME(name) f16 ## name ## f64x
647 # include <bits/mathcalls-narrow.h>
648 # undef _Mret_
649 # undef _Marg_
650 # undef __MATHCALL_NAME
651 # endif
652
653 # if __HAVE_FLOAT16 && __HAVE_FLOAT128
654 # define _Mret_ _Float16
655 # define _Marg_ _Float128
656 # define __MATHCALL_NAME(name) f16 ## name ## f128
657 # include <bits/mathcalls-narrow.h>
658 # undef _Mret_
659 # undef _Marg_
660 # undef __MATHCALL_NAME
661 # endif
662
663 # if __HAVE_FLOAT16 && __HAVE_FLOAT128X
664 # define _Mret_ _Float16
665 # define _Marg_ _Float128x
666 # define __MATHCALL_NAME(name) f16 ## name ## f128x
667 # include <bits/mathcalls-narrow.h>
668 # undef _Mret_
669 # undef _Marg_
670 # undef __MATHCALL_NAME
671 # endif
672
673 # if __HAVE_FLOAT32 && __HAVE_FLOAT32X
674 # define _Mret_ _Float32
675 # define _Marg_ _Float32x
676 # define __MATHCALL_NAME(name) f32 ## name ## f32x
677 # include <bits/mathcalls-narrow.h>
678 # undef _Mret_
679 # undef _Marg_
680 # undef __MATHCALL_NAME
681 # endif
682
683 # if __HAVE_FLOAT32 && __HAVE_FLOAT64
684 # define _Mret_ _Float32
685 # define _Marg_ _Float64
686 # define __MATHCALL_NAME(name) f32 ## name ## f64
687 # include <bits/mathcalls-narrow.h>
688 # undef _Mret_
689 # undef _Marg_
690 # undef __MATHCALL_NAME
691 # endif
692
693 # if __HAVE_FLOAT32 && __HAVE_FLOAT64X
694 # define _Mret_ _Float32
695 # define _Marg_ _Float64x
696 # define __MATHCALL_NAME(name) f32 ## name ## f64x
697 # include <bits/mathcalls-narrow.h>
698 # undef _Mret_
699 # undef _Marg_
700 # undef __MATHCALL_NAME
701 # endif
702
703 # if __HAVE_FLOAT32 && __HAVE_FLOAT128
704 # define _Mret_ _Float32
705 # define _Marg_ _Float128
706 # define __MATHCALL_NAME(name) f32 ## name ## f128
707 # include <bits/mathcalls-narrow.h>
708 # undef _Mret_
709 # undef _Marg_
710 # undef __MATHCALL_NAME
711 # endif
712
713 # if __HAVE_FLOAT32 && __HAVE_FLOAT128X
714 # define _Mret_ _Float32
715 # define _Marg_ _Float128x
716 # define __MATHCALL_NAME(name) f32 ## name ## f128x
717 # include <bits/mathcalls-narrow.h>
718 # undef _Mret_
719 # undef _Marg_
720 # undef __MATHCALL_NAME
721 # endif
722
723 # if __HAVE_FLOAT32X && __HAVE_FLOAT64
724 # define _Mret_ _Float32x
725 # define _Marg_ _Float64
726 # define __MATHCALL_NAME(name) f32x ## name ## f64
727 # include <bits/mathcalls-narrow.h>
728 # undef _Mret_
729 # undef _Marg_
730 # undef __MATHCALL_NAME
731 # endif
732
733 # if __HAVE_FLOAT32X && __HAVE_FLOAT64X
734 # define _Mret_ _Float32x
735 # define _Marg_ _Float64x
736 # define __MATHCALL_NAME(name) f32x ## name ## f64x
737 # include <bits/mathcalls-narrow.h>
738 # undef _Mret_
739 # undef _Marg_
740 # undef __MATHCALL_NAME
741 # endif
742
743 # if __HAVE_FLOAT32X && __HAVE_FLOAT128
744 # define _Mret_ _Float32x
745 # define _Marg_ _Float128
746 # define __MATHCALL_NAME(name) f32x ## name ## f128
747 # include <bits/mathcalls-narrow.h>
748 # undef _Mret_
749 # undef _Marg_
750 # undef __MATHCALL_NAME
751 # endif
752
753 # if __HAVE_FLOAT32X && __HAVE_FLOAT128X
754 # define _Mret_ _Float32x
755 # define _Marg_ _Float128x
756 # define __MATHCALL_NAME(name) f32x ## name ## f128x
757 # include <bits/mathcalls-narrow.h>
758 # undef _Mret_
759 # undef _Marg_
760 # undef __MATHCALL_NAME
761 # endif
762
763 # if __HAVE_FLOAT64 && __HAVE_FLOAT64X
764 # define _Mret_ _Float64
765 # define _Marg_ _Float64x
766 # define __MATHCALL_NAME(name) f64 ## name ## f64x
767 # include <bits/mathcalls-narrow.h>
768 # undef _Mret_
769 # undef _Marg_
770 # undef __MATHCALL_NAME
771 # endif
772
773 # if __HAVE_FLOAT64 && __HAVE_FLOAT128
774 # define _Mret_ _Float64
775 # define _Marg_ _Float128
776 # define __MATHCALL_NAME(name) f64 ## name ## f128
777 # include <bits/mathcalls-narrow.h>
778 # undef _Mret_
779 # undef _Marg_
780 # undef __MATHCALL_NAME
781 # endif
782
783 # if __HAVE_FLOAT64 && __HAVE_FLOAT128X
784 # define _Mret_ _Float64
785 # define _Marg_ _Float128x
786 # define __MATHCALL_NAME(name) f64 ## name ## f128x
787 # include <bits/mathcalls-narrow.h>
788 # undef _Mret_
789 # undef _Marg_
790 # undef __MATHCALL_NAME
791 # endif
792
793 # if __HAVE_FLOAT64X && __HAVE_FLOAT128
794 # define _Mret_ _Float64x
795 # define _Marg_ _Float128
796 # define __MATHCALL_NAME(name) f64x ## name ## f128
797 # include <bits/mathcalls-narrow.h>
798 # undef _Mret_
799 # undef _Marg_
800 # undef __MATHCALL_NAME
801 # endif
802
803 # if __HAVE_FLOAT64X && __HAVE_FLOAT128X
804 # define _Mret_ _Float64x
805 # define _Marg_ _Float128x
806 # define __MATHCALL_NAME(name) f64x ## name ## f128x
807 # include <bits/mathcalls-narrow.h>
808 # undef _Mret_
809 # undef _Marg_
810 # undef __MATHCALL_NAME
811 # endif
812
813 # if __HAVE_FLOAT128 && __HAVE_FLOAT128X
814 # define _Mret_ _Float128
815 # define _Marg_ _Float128x
816 # define __MATHCALL_NAME(name) f128 ## name ## f128x
817 # include <bits/mathcalls-narrow.h>
818 # undef _Mret_
819 # undef _Marg_
820 # undef __MATHCALL_NAME
821 # endif
822
823 #endif
824
825 #undef __MATHCALL_NARROW_ARGS_1
826 #undef __MATHCALL_NARROW_ARGS_2
827 #undef __MATHCALL_NARROW_ARGS_3
828 #undef __MATHCALL_NARROW_NORMAL
829 #undef __MATHCALL_NARROW_REDIR
830 #undef __MATHCALL_NARROW
831
832 #if defined __USE_MISC || defined __USE_XOPEN
833 /* This variable is used by `gamma' and `lgamma'. */
834 extern int signgam;
835 #endif
836
837 #if (__HAVE_DISTINCT_FLOAT16 \
838 || __HAVE_DISTINCT_FLOAT32 \
839 || __HAVE_DISTINCT_FLOAT64 \
840 || __HAVE_DISTINCT_FLOAT32X \
841 || __HAVE_DISTINCT_FLOAT64X \
842 || __HAVE_DISTINCT_FLOAT128X)
843 # error "Unsupported _FloatN or _FloatNx types for <math.h>."
844 #endif
845
846 /* Depending on the type of TG_ARG, call an appropriately suffixed
847 version of FUNC with arguments (including parentheses) ARGS.
848 Suffixed functions may not exist for long double if it has the same
849 format as double, or for other types with the same format as float,
850 double or long double. The behavior is undefined if the argument
851 does not have a real floating type. The definition may use a
852 conditional expression, so all suffixed versions of FUNC must
853 return the same type (FUNC may include a cast if necessary rather
854 than being a single identifier). */
855 #ifdef __NO_LONG_DOUBLE_MATH
856 # if __HAVE_DISTINCT_FLOAT128
857 # error "Distinct _Float128 without distinct long double not supported."
858 # endif
859 # define __MATH_TG(TG_ARG, FUNC, ARGS) \
860 (sizeof (TG_ARG) == sizeof (float) ? FUNC ## f ARGS : FUNC ARGS)
861 #elif __HAVE_DISTINCT_FLOAT128
862 # if __HAVE_GENERIC_SELECTION
863 # if __HAVE_FLOATN_NOT_TYPEDEF && __HAVE_FLOAT32
864 # define __MATH_TG_F32(FUNC, ARGS) _Float32: FUNC ## f ARGS,
865 # else
866 # define __MATH_TG_F32(FUNC, ARGS)
867 # endif
868 # if __HAVE_FLOATN_NOT_TYPEDEF && __HAVE_FLOAT64X
869 # if __HAVE_FLOAT64X_LONG_DOUBLE
870 # define __MATH_TG_F64X(FUNC, ARGS) _Float64x: FUNC ## l ARGS,
871 # else
872 # define __MATH_TG_F64X(FUNC, ARGS) _Float64x: FUNC ## f128 ARGS,
873 # endif
874 # else
875 # define __MATH_TG_F64X(FUNC, ARGS)
876 # endif
877 # define __MATH_TG(TG_ARG, FUNC, ARGS) \
878 _Generic ((TG_ARG), \
879 float: FUNC ## f ARGS, \
880 __MATH_TG_F32 (FUNC, ARGS) \
881 default: FUNC ARGS, \
882 long double: FUNC ## l ARGS, \
883 __MATH_TG_F64X (FUNC, ARGS) \
884 _Float128: FUNC ## f128 ARGS)
885 # else
886 # if __HAVE_FLOATN_NOT_TYPEDEF
887 # error "Non-typedef _FloatN but no _Generic."
888 # endif
889 # define __MATH_TG(TG_ARG, FUNC, ARGS) \
890 __builtin_choose_expr \
891 (__builtin_types_compatible_p (__typeof (TG_ARG), float), \
892 FUNC ## f ARGS, \
893 __builtin_choose_expr \
894 (__builtin_types_compatible_p (__typeof (TG_ARG), double), \
895 FUNC ARGS, \
896 __builtin_choose_expr \
897 (__builtin_types_compatible_p (__typeof (TG_ARG), long double), \
898 FUNC ## l ARGS, \
899 FUNC ## f128 ARGS)))
900 # endif
901 #else
902 # define __MATH_TG(TG_ARG, FUNC, ARGS) \
903 (sizeof (TG_ARG) == sizeof (float) \
904 ? FUNC ## f ARGS \
905 : sizeof (TG_ARG) == sizeof (double) \
906 ? FUNC ARGS \
907 : FUNC ## l ARGS)
908 #endif
909
910 /* ISO C99 defines some generic macros which work on any data type. */
911 #ifdef __USE_ISOC99
912
913 /* All floating-point numbers can be put in one of these categories. */
914 enum
915 {
916 FP_NAN =
917 # define FP_NAN 0
918 FP_NAN,
919 FP_INFINITE =
920 # define FP_INFINITE 1
921 FP_INFINITE,
922 FP_ZERO =
923 # define FP_ZERO 2
924 FP_ZERO,
925 FP_SUBNORMAL =
926 # define FP_SUBNORMAL 3
927 FP_SUBNORMAL,
928 FP_NORMAL =
929 # define FP_NORMAL 4
930 FP_NORMAL
931 };
932
933 /* GCC bug 66462 means we cannot use the math builtins with -fsignaling-nan,
934 so disable builtins if this is enabled. When fixed in a newer GCC,
935 the __SUPPORT_SNAN__ check may be skipped for those versions. */
936
937 /* Return number of classification appropriate for X. */
938 # if ((__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__) \
939 || __glibc_clang_prereq (2,8)) \
940 && (!defined __OPTIMIZE_SIZE__ || defined __cplusplus)
941 /* The check for __cplusplus allows the use of the builtin, even
942 when optimization for size is on. This is provided for
943 libstdc++, only to let its configure test work when it is built
944 with -Os. No further use of this definition of fpclassify is
945 expected in C++ mode, since libstdc++ provides its own version
946 of fpclassify in cmath (which undefines fpclassify). */
947 # define fpclassify(x) __builtin_fpclassify (FP_NAN, FP_INFINITE, \
948 FP_NORMAL, FP_SUBNORMAL, FP_ZERO, x)
949 # else
950 # define fpclassify(x) __MATH_TG ((x), __fpclassify, (x))
951 # endif
952
953 /* Return nonzero value if sign of X is negative. */
954 # if __GNUC_PREREQ (6,0) || __glibc_clang_prereq (3,3)
955 # define signbit(x) __builtin_signbit (x)
956 # elif defined __cplusplus
957 /* In C++ mode, __MATH_TG cannot be used, because it relies on
958 __builtin_types_compatible_p, which is a C-only builtin.
959 The check for __cplusplus allows the use of the builtin instead of
960 __MATH_TG. This is provided for libstdc++, only to let its configure
961 test work. No further use of this definition of signbit is expected
962 in C++ mode, since libstdc++ provides its own version of signbit
963 in cmath (which undefines signbit). */
964 # define signbit(x) __builtin_signbitl (x)
965 # elif __GNUC_PREREQ (4,0)
966 # define signbit(x) __MATH_TG ((x), __builtin_signbit, (x))
967 # else
968 # define signbit(x) __MATH_TG ((x), __signbit, (x))
969 # endif
970
971 /* Return nonzero value if X is not +-Inf or NaN. */
972 # if (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__) \
973 || __glibc_clang_prereq (2,8)
974 # define isfinite(x) __builtin_isfinite (x)
975 # else
976 # define isfinite(x) __MATH_TG ((x), __finite, (x))
977 # endif
978
979 /* Return nonzero value if X is neither zero, subnormal, Inf, nor NaN. */
980 # if (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__) \
981 || __glibc_clang_prereq (2,8)
982 # define isnormal(x) __builtin_isnormal (x)
983 # else
984 # define isnormal(x) (fpclassify (x) == FP_NORMAL)
985 # endif
986
987 /* Return nonzero value if X is a NaN. We could use `fpclassify' but
988 we already have this functions `__isnan' and it is faster. */
989 # if (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__) \
990 || __glibc_clang_prereq (2,8)
991 # define isnan(x) __builtin_isnan (x)
992 # else
993 # define isnan(x) __MATH_TG ((x), __isnan, (x))
994 # endif
995
996 /* Return nonzero value if X is positive or negative infinity. */
997 # if __HAVE_DISTINCT_FLOAT128 && !__GNUC_PREREQ (7,0) \
998 && !defined __SUPPORT_SNAN__ && !defined __cplusplus
999 /* Since __builtin_isinf_sign is broken for float128 before GCC 7.0,
1000 use the helper function, __isinff128, with older compilers. This is
1001 only provided for C mode, because in C++ mode, GCC has no support
1002 for __builtin_types_compatible_p (and when in C++ mode, this macro is
1003 not used anyway, because libstdc++ headers undefine it). */
1004 # define isinf(x) \
1005 (__builtin_types_compatible_p (__typeof (x), _Float128) \
1006 ? __isinff128 (x) : __builtin_isinf_sign (x))
1007 # elif (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__) \
1008 || __glibc_clang_prereq (3,7)
1009 # define isinf(x) __builtin_isinf_sign (x)
1010 # else
1011 # define isinf(x) __MATH_TG ((x), __isinf, (x))
1012 # endif
1013
1014 /* Bitmasks for the math_errhandling macro. */
1015 # define MATH_ERRNO 1 /* errno set by math functions. */
1016 # define MATH_ERREXCEPT 2 /* Exceptions raised by math functions. */
1017
1018 /* By default all math functions support both errno and exception handling
1019 (except for soft floating point implementations which may only support
1020 errno handling). If errno handling is disabled, exceptions are still
1021 supported by GLIBC. Set math_errhandling to 0 with -ffast-math (this is
1022 nonconforming but it is more useful than leaving it undefined). */
1023 # ifdef __FAST_MATH__
1024 # define math_errhandling 0
1025 # elif defined __NO_MATH_ERRNO__
1026 # define math_errhandling (MATH_ERREXCEPT)
1027 # else
1028 # define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT)
1029 # endif
1030
1031 #endif /* Use ISO C99. */
1032
1033 #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
1034 # include <bits/iscanonical.h>
1035
1036 /* Return nonzero value if X is a signaling NaN. */
1037 # ifndef __cplusplus
1038 # define issignaling(x) __MATH_TG ((x), __issignaling, (x))
1039 # else
1040 /* In C++ mode, __MATH_TG cannot be used, because it relies on
1041 __builtin_types_compatible_p, which is a C-only builtin. On the
1042 other hand, overloading provides the means to distinguish between
1043 the floating-point types. The overloading resolution will match
1044 the correct parameter (regardless of type qualifiers (i.e.: const
1045 and volatile)). */
1046 extern "C++" {
1047 inline int issignaling (float __val) { return __issignalingf (__val); }
1048 inline int issignaling (double __val) { return __issignaling (__val); }
1049 inline int
1050 issignaling (long double __val)
1051 {
1052 # ifdef __NO_LONG_DOUBLE_MATH
1053 return __issignaling (__val);
1054 # else
1055 return __issignalingl (__val);
1056 # endif
1057 }
1058 # if __HAVE_FLOAT128_UNLIKE_LDBL
1059 /* When using an IEEE 128-bit long double, _Float128 is defined as long double
1060 in C++. */
1061 inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); }
1062 # endif
1063 } /* extern C++ */
1064 # endif
1065
1066 /* Return nonzero value if X is subnormal. */
1067 # define issubnormal(x) (fpclassify (x) == FP_SUBNORMAL)
1068
1069 /* Return nonzero value if X is zero. */
1070 # ifndef __cplusplus
1071 # ifdef __SUPPORT_SNAN__
1072 # define iszero(x) (fpclassify (x) == FP_ZERO)
1073 # else
1074 # define iszero(x) (((__typeof (x)) (x)) == 0)
1075 # endif
1076 # else /* __cplusplus */
1077 extern "C++" {
1078 # ifdef __SUPPORT_SNAN__
1079 inline int
1080 iszero (float __val)
1081 {
1082 return __fpclassifyf (__val) == FP_ZERO;
1083 }
1084 inline int
1085 iszero (double __val)
1086 {
1087 return __fpclassify (__val) == FP_ZERO;
1088 }
1089 inline int
1090 iszero (long double __val)
1091 {
1092 # ifdef __NO_LONG_DOUBLE_MATH
1093 return __fpclassify (__val) == FP_ZERO;
1094 # else
1095 return __fpclassifyl (__val) == FP_ZERO;
1096 # endif
1097 }
1098 # if __HAVE_FLOAT128_UNLIKE_LDBL
1099 /* When using an IEEE 128-bit long double, _Float128 is defined as long double
1100 in C++. */
1101 inline int
1102 iszero (_Float128 __val)
1103 {
1104 return __fpclassifyf128 (__val) == FP_ZERO;
1105 }
1106 # endif
1107 # else
1108 template <class __T> inline bool
1109 iszero (__T __val)
1110 {
1111 return __val == 0;
1112 }
1113 # endif
1114 } /* extern C++ */
1115 # endif /* __cplusplus */
1116 #endif /* Use IEC_60559_BFP_EXT. */
1117
1118 #ifdef __USE_XOPEN
1119 /* X/Open wants another strange constant. */
1120 # define MAXFLOAT 3.40282347e+38F
1121 #endif
1122
1123
1124 /* Some useful constants. */
1125 #if defined __USE_MISC || defined __USE_XOPEN
1126 # define M_E 2.7182818284590452354 /* e */
1127 # define M_LOG2E 1.4426950408889634074 /* log_2 e */
1128 # define M_LOG10E 0.43429448190325182765 /* log_10 e */
1129 # define M_LN2 0.69314718055994530942 /* log_e 2 */
1130 # define M_LN10 2.30258509299404568402 /* log_e 10 */
1131 # define M_PI 3.14159265358979323846 /* pi */
1132 # define M_PI_2 1.57079632679489661923 /* pi/2 */
1133 # define M_PI_4 0.78539816339744830962 /* pi/4 */
1134 # define M_1_PI 0.31830988618379067154 /* 1/pi */
1135 # define M_2_PI 0.63661977236758134308 /* 2/pi */
1136 # define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
1137 # define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
1138 # define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
1139 #endif
1140
1141 /* The above constants are not adequate for computation using `long double's.
1142 Therefore we provide as an extension constants with similar names as a
1143 GNU extension. Provide enough digits for the 128-bit IEEE quad. */
1144 #ifdef __USE_GNU
1145 # define M_El 2.718281828459045235360287471352662498L /* e */
1146 # define M_LOG2El 1.442695040888963407359924681001892137L /* log_2 e */
1147 # define M_LOG10El 0.434294481903251827651128918916605082L /* log_10 e */
1148 # define M_LN2l 0.693147180559945309417232121458176568L /* log_e 2 */
1149 # define M_LN10l 2.302585092994045684017991454684364208L /* log_e 10 */
1150 # define M_PIl 3.141592653589793238462643383279502884L /* pi */
1151 # define M_PI_2l 1.570796326794896619231321691639751442L /* pi/2 */
1152 # define M_PI_4l 0.785398163397448309615660845819875721L /* pi/4 */
1153 # define M_1_PIl 0.318309886183790671537767526745028724L /* 1/pi */
1154 # define M_2_PIl 0.636619772367581343075535053490057448L /* 2/pi */
1155 # define M_2_SQRTPIl 1.128379167095512573896158903121545172L /* 2/sqrt(pi) */
1156 # define M_SQRT2l 1.414213562373095048801688724209698079L /* sqrt(2) */
1157 # define M_SQRT1_2l 0.707106781186547524400844362104849039L /* 1/sqrt(2) */
1158 #endif
1159
1160 #if __HAVE_FLOAT16 && defined __USE_GNU
1161 # define M_Ef16 __f16 (2.718281828459045235360287471352662498) /* e */
1162 # define M_LOG2Ef16 __f16 (1.442695040888963407359924681001892137) /* log_2 e */
1163 # define M_LOG10Ef16 __f16 (0.434294481903251827651128918916605082) /* log_10 e */
1164 # define M_LN2f16 __f16 (0.693147180559945309417232121458176568) /* log_e 2 */
1165 # define M_LN10f16 __f16 (2.302585092994045684017991454684364208) /* log_e 10 */
1166 # define M_PIf16 __f16 (3.141592653589793238462643383279502884) /* pi */
1167 # define M_PI_2f16 __f16 (1.570796326794896619231321691639751442) /* pi/2 */
1168 # define M_PI_4f16 __f16 (0.785398163397448309615660845819875721) /* pi/4 */
1169 # define M_1_PIf16 __f16 (0.318309886183790671537767526745028724) /* 1/pi */
1170 # define M_2_PIf16 __f16 (0.636619772367581343075535053490057448) /* 2/pi */
1171 # define M_2_SQRTPIf16 __f16 (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
1172 # define M_SQRT2f16 __f16 (1.414213562373095048801688724209698079) /* sqrt(2) */
1173 # define M_SQRT1_2f16 __f16 (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
1174 #endif
1175
1176 #if __HAVE_FLOAT32 && defined __USE_GNU
1177 # define M_Ef32 __f32 (2.718281828459045235360287471352662498) /* e */
1178 # define M_LOG2Ef32 __f32 (1.442695040888963407359924681001892137) /* log_2 e */
1179 # define M_LOG10Ef32 __f32 (0.434294481903251827651128918916605082) /* log_10 e */
1180 # define M_LN2f32 __f32 (0.693147180559945309417232121458176568) /* log_e 2 */
1181 # define M_LN10f32 __f32 (2.302585092994045684017991454684364208) /* log_e 10 */
1182 # define M_PIf32 __f32 (3.141592653589793238462643383279502884) /* pi */
1183 # define M_PI_2f32 __f32 (1.570796326794896619231321691639751442) /* pi/2 */
1184 # define M_PI_4f32 __f32 (0.785398163397448309615660845819875721) /* pi/4 */
1185 # define M_1_PIf32 __f32 (0.318309886183790671537767526745028724) /* 1/pi */
1186 # define M_2_PIf32 __f32 (0.636619772367581343075535053490057448) /* 2/pi */
1187 # define M_2_SQRTPIf32 __f32 (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
1188 # define M_SQRT2f32 __f32 (1.414213562373095048801688724209698079) /* sqrt(2) */
1189 # define M_SQRT1_2f32 __f32 (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
1190 #endif
1191
1192 #if __HAVE_FLOAT64 && defined __USE_GNU
1193 # define M_Ef64 __f64 (2.718281828459045235360287471352662498) /* e */
1194 # define M_LOG2Ef64 __f64 (1.442695040888963407359924681001892137) /* log_2 e */
1195 # define M_LOG10Ef64 __f64 (0.434294481903251827651128918916605082) /* log_10 e */
1196 # define M_LN2f64 __f64 (0.693147180559945309417232121458176568) /* log_e 2 */
1197 # define M_LN10f64 __f64 (2.302585092994045684017991454684364208) /* log_e 10 */
1198 # define M_PIf64 __f64 (3.141592653589793238462643383279502884) /* pi */
1199 # define M_PI_2f64 __f64 (1.570796326794896619231321691639751442) /* pi/2 */
1200 # define M_PI_4f64 __f64 (0.785398163397448309615660845819875721) /* pi/4 */
1201 # define M_1_PIf64 __f64 (0.318309886183790671537767526745028724) /* 1/pi */
1202 # define M_2_PIf64 __f64 (0.636619772367581343075535053490057448) /* 2/pi */
1203 # define M_2_SQRTPIf64 __f64 (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
1204 # define M_SQRT2f64 __f64 (1.414213562373095048801688724209698079) /* sqrt(2) */
1205 # define M_SQRT1_2f64 __f64 (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
1206 #endif
1207
1208 #if __HAVE_FLOAT128 && defined __USE_GNU
1209 # define M_Ef128 __f128 (2.718281828459045235360287471352662498) /* e */
1210 # define M_LOG2Ef128 __f128 (1.442695040888963407359924681001892137) /* log_2 e */
1211 # define M_LOG10Ef128 __f128 (0.434294481903251827651128918916605082) /* log_10 e */
1212 # define M_LN2f128 __f128 (0.693147180559945309417232121458176568) /* log_e 2 */
1213 # define M_LN10f128 __f128 (2.302585092994045684017991454684364208) /* log_e 10 */
1214 # define M_PIf128 __f128 (3.141592653589793238462643383279502884) /* pi */
1215 # define M_PI_2f128 __f128 (1.570796326794896619231321691639751442) /* pi/2 */
1216 # define M_PI_4f128 __f128 (0.785398163397448309615660845819875721) /* pi/4 */
1217 # define M_1_PIf128 __f128 (0.318309886183790671537767526745028724) /* 1/pi */
1218 # define M_2_PIf128 __f128 (0.636619772367581343075535053490057448) /* 2/pi */
1219 # define M_2_SQRTPIf128 __f128 (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
1220 # define M_SQRT2f128 __f128 (1.414213562373095048801688724209698079) /* sqrt(2) */
1221 # define M_SQRT1_2f128 __f128 (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
1222 #endif
1223
1224 #if __HAVE_FLOAT32X && defined __USE_GNU
1225 # define M_Ef32x __f32x (2.718281828459045235360287471352662498) /* e */
1226 # define M_LOG2Ef32x __f32x (1.442695040888963407359924681001892137) /* log_2 e */
1227 # define M_LOG10Ef32x __f32x (0.434294481903251827651128918916605082) /* log_10 e */
1228 # define M_LN2f32x __f32x (0.693147180559945309417232121458176568) /* log_e 2 */
1229 # define M_LN10f32x __f32x (2.302585092994045684017991454684364208) /* log_e 10 */
1230 # define M_PIf32x __f32x (3.141592653589793238462643383279502884) /* pi */
1231 # define M_PI_2f32x __f32x (1.570796326794896619231321691639751442) /* pi/2 */
1232 # define M_PI_4f32x __f32x (0.785398163397448309615660845819875721) /* pi/4 */
1233 # define M_1_PIf32x __f32x (0.318309886183790671537767526745028724) /* 1/pi */
1234 # define M_2_PIf32x __f32x (0.636619772367581343075535053490057448) /* 2/pi */
1235 # define M_2_SQRTPIf32x __f32x (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
1236 # define M_SQRT2f32x __f32x (1.414213562373095048801688724209698079) /* sqrt(2) */
1237 # define M_SQRT1_2f32x __f32x (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
1238 #endif
1239
1240 #if __HAVE_FLOAT64X && defined __USE_GNU
1241 # define M_Ef64x __f64x (2.718281828459045235360287471352662498) /* e */
1242 # define M_LOG2Ef64x __f64x (1.442695040888963407359924681001892137) /* log_2 e */
1243 # define M_LOG10Ef64x __f64x (0.434294481903251827651128918916605082) /* log_10 e */
1244 # define M_LN2f64x __f64x (0.693147180559945309417232121458176568) /* log_e 2 */
1245 # define M_LN10f64x __f64x (2.302585092994045684017991454684364208) /* log_e 10 */
1246 # define M_PIf64x __f64x (3.141592653589793238462643383279502884) /* pi */
1247 # define M_PI_2f64x __f64x (1.570796326794896619231321691639751442) /* pi/2 */
1248 # define M_PI_4f64x __f64x (0.785398163397448309615660845819875721) /* pi/4 */
1249 # define M_1_PIf64x __f64x (0.318309886183790671537767526745028724) /* 1/pi */
1250 # define M_2_PIf64x __f64x (0.636619772367581343075535053490057448) /* 2/pi */
1251 # define M_2_SQRTPIf64x __f64x (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
1252 # define M_SQRT2f64x __f64x (1.414213562373095048801688724209698079) /* sqrt(2) */
1253 # define M_SQRT1_2f64x __f64x (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
1254 #endif
1255
1256 #if __HAVE_FLOAT128X && defined __USE_GNU
1257 # error "M_* values needed for _Float128x"
1258 #endif
1259
1260 #ifdef __USE_ISOC99
1261 # if __GNUC_PREREQ (3, 1)
1262 /* ISO C99 defines some macros to compare number while taking care for
1263 unordered numbers. Many FPUs provide special instructions to support
1264 these operations. Generic support in GCC for these as builtins went
1265 in 2.97, but not all cpus added their patterns until 3.1. Therefore
1266 we enable the builtins from 3.1 onwards and use a generic implementation
1267 othwerwise. */
1268 # define isgreater(x, y) __builtin_isgreater(x, y)
1269 # define isgreaterequal(x, y) __builtin_isgreaterequal(x, y)
1270 # define isless(x, y) __builtin_isless(x, y)
1271 # define islessequal(x, y) __builtin_islessequal(x, y)
1272 # define islessgreater(x, y) __builtin_islessgreater(x, y)
1273 # define isunordered(x, y) __builtin_isunordered(x, y)
1274 # else
1275 # define isgreater(x, y) \
1276 (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
1277 !isunordered (__x, __y) && __x > __y; }))
1278 # define isgreaterequal(x, y) \
1279 (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
1280 !isunordered (__x, __y) && __x >= __y; }))
1281 # define isless(x, y) \
1282 (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
1283 !isunordered (__x, __y) && __x < __y; }))
1284 # define islessequal(x, y) \
1285 (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
1286 !isunordered (__x, __y) && __x <= __y; }))
1287 # define islessgreater(x, y) \
1288 (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
1289 !isunordered (__x, __y) && __x != __y; }))
1290 /* isunordered must always check both operands first for signaling NaNs. */
1291 # define isunordered(x, y) \
1292 (__extension__ ({ __typeof__ (x) __u = (x); __typeof__ (y) __v = (y); \
1293 __u != __v && (__u != __u || __v != __v); }))
1294 # endif
1295 #endif
1296
1297 #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
1298 /* An expression whose type has the widest of the evaluation formats
1299 of X and Y (which are of floating-point types). */
1300 # if __FLT_EVAL_METHOD__ == 2 || __FLT_EVAL_METHOD__ > 64
1301 # define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0L)
1302 # elif __FLT_EVAL_METHOD__ == 1 || __FLT_EVAL_METHOD__ > 32
1303 # define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0)
1304 # elif __FLT_EVAL_METHOD__ == 0 || __FLT_EVAL_METHOD__ == 32
1305 # define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0f)
1306 # else
1307 # define __MATH_EVAL_FMT2(x, y) ((x) + (y))
1308 # endif
1309
1310 /* Return X == Y but raising "invalid" and setting errno if X or Y is
1311 a NaN. */
1312 # if !defined __cplusplus || (__cplusplus < 201103L && !defined __GNUC__)
1313 # define iseqsig(x, y) \
1314 __MATH_TG (__MATH_EVAL_FMT2 (x, y), __iseqsig, ((x), (y)))
1315 # else
1316 /* In C++ mode, __MATH_TG cannot be used, because it relies on
1317 __builtin_types_compatible_p, which is a C-only builtin. Moreover,
1318 the comparison macros from ISO C take two floating-point arguments,
1319 which need not have the same type. Choosing what underlying function
1320 to call requires evaluating the formats of the arguments, then
1321 selecting which is wider. The macro __MATH_EVAL_FMT2 provides this
1322 information, however, only the type of the macro expansion is
1323 relevant (actually evaluating the expression would be incorrect).
1324 Thus, the type is used as a template parameter for __iseqsig_type,
1325 which calls the appropriate underlying function. */
1326 extern "C++" {
1327 template<typename> struct __iseqsig_type;
1328
1329 template<> struct __iseqsig_type<float>
1330 {
1331 static int __call (float __x, float __y) throw ()
1332 {
1333 return __iseqsigf (__x, __y);
1334 }
1335 };
1336
1337 template<> struct __iseqsig_type<double>
1338 {
1339 static int __call (double __x, double __y) throw ()
1340 {
1341 return __iseqsig (__x, __y);
1342 }
1343 };
1344
1345 template<> struct __iseqsig_type<long double>
1346 {
1347 static int __call (long double __x, long double __y) throw ()
1348 {
1349 # ifndef __NO_LONG_DOUBLE_MATH
1350 return __iseqsigl (__x, __y);
1351 # else
1352 return __iseqsig (__x, __y);
1353 # endif
1354 }
1355 };
1356
1357 # if __HAVE_FLOAT128_UNLIKE_LDBL
1358 /* When using an IEEE 128-bit long double, _Float128 is defined as long double
1359 in C++. */
1360 template<> struct __iseqsig_type<_Float128>
1361 {
1362 static int __call (_Float128 __x, _Float128 __y) throw ()
1363 {
1364 return __iseqsigf128 (__x, __y);
1365 }
1366 };
1367 # endif
1368
1369 template<typename _T1, typename _T2>
1370 inline int
1371 iseqsig (_T1 __x, _T2 __y) throw ()
1372 {
1373 # if __cplusplus >= 201103L
1374 typedef decltype (__MATH_EVAL_FMT2 (__x, __y)) _T3;
1375 # else
1376 typedef __typeof (__MATH_EVAL_FMT2 (__x, __y)) _T3;
1377 # endif
1378 return __iseqsig_type<_T3>::__call (__x, __y);
1379 }
1380
1381 } /* extern "C++" */
1382 # endif /* __cplusplus */
1383
1384 #endif
1385
1386 __END_DECLS
1387
1388
1389 #endif /* math.h */
sources.redhat.com git mirror of glibc CVS