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