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