--- /dev/null
+/* Declarations for math functions.
+ Copyright (C) 1991-2018 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <http://www.gnu.org/licenses/>. */
+
+/*
+ * ISO C99 Standard: 7.12 Mathematics <math.h>
+ */
+
+#ifndef _MATH_H
+#define _MATH_H 1
+
+#define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
+#include <bits/libc-header-start.h>
+
+#if defined log && defined __GNUC__
+# warning A macro called log was already defined when <math.h> was included.
+# warning This will cause compilation problems.
+#endif
+
+__BEGIN_DECLS
+
+/* Get definitions of __intmax_t and __uintmax_t. */
+#include <bits/types.h>
+
+/* Get machine-dependent vector math functions declarations. */
+#include <bits/math-vector.h>
+
+/* Gather machine dependent type support. */
+#include <bits/floatn.h>
+
+/* Value returned on overflow. With IEEE 754 floating point, this is
+ +Infinity, otherwise the largest representable positive value. */
+#if __GNUC_PREREQ (3, 3)
+# define HUGE_VAL (__builtin_huge_val ())
+#else
+/* This may provoke compiler warnings, and may not be rounded to
+ +Infinity in all IEEE 754 rounding modes, but is the best that can
+ be done in ISO C while remaining a constant expression. 10,000 is
+ greater than the maximum (decimal) exponent for all supported
+ floating-point formats and widths. */
+# define HUGE_VAL 1e10000
+#endif
+#ifdef __USE_ISOC99
+# if __GNUC_PREREQ (3, 3)
+# define HUGE_VALF (__builtin_huge_valf ())
+# define HUGE_VALL (__builtin_huge_vall ())
+# else
+# define HUGE_VALF 1e10000f
+# define HUGE_VALL 1e10000L
+# endif
+#endif
+#if __HAVE_FLOAT16 && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define HUGE_VAL_F16 (__builtin_huge_valf16 ())
+#endif
+#if __HAVE_FLOAT32 && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define HUGE_VAL_F32 (__builtin_huge_valf32 ())
+#endif
+#if __HAVE_FLOAT64 && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define HUGE_VAL_F64 (__builtin_huge_valf64 ())
+#endif
+#if __HAVE_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define HUGE_VAL_F128 (__builtin_huge_valf128 ())
+#endif
+#if __HAVE_FLOAT32X && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define HUGE_VAL_F32X (__builtin_huge_valf32x ())
+#endif
+#if __HAVE_FLOAT64X && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define HUGE_VAL_F64X (__builtin_huge_valf64x ())
+#endif
+#if __HAVE_FLOAT128X && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define HUGE_VAL_F128X (__builtin_huge_valf128x ())
+#endif
+
+#ifdef __USE_ISOC99
+/* IEEE positive infinity. */
+# if __GNUC_PREREQ (3, 3)
+# define INFINITY (__builtin_inff ())
+# else
+# define INFINITY HUGE_VALF
+# endif
+
+/* IEEE Not A Number. */
+# if __GNUC_PREREQ (3, 3)
+# define NAN (__builtin_nanf (""))
+# else
+/* This will raise an "invalid" exception outside static initializers,
+ but is the best that can be done in ISO C while remaining a
+ constant expression. */
+# define NAN (0.0f / 0.0f)
+# endif
+#endif /* __USE_ISOC99 */
+
+#if __GLIBC_USE (IEC_60559_BFP_EXT)
+/* Signaling NaN macros, if supported. */
+# if __GNUC_PREREQ (3, 3)
+# define SNANF (__builtin_nansf (""))
+# define SNAN (__builtin_nans (""))
+# define SNANL (__builtin_nansl (""))
+# endif
+#endif
+#if __HAVE_FLOAT16 && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define SNANF16 (__builtin_nansf16 (""))
+#endif
+#if __HAVE_FLOAT32 && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define SNANF32 (__builtin_nansf32 (""))
+#endif
+#if __HAVE_FLOAT64 && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define SNANF64 (__builtin_nansf64 (""))
+#endif
+#if __HAVE_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define SNANF128 (__builtin_nansf128 (""))
+#endif
+#if __HAVE_FLOAT32X && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define SNANF32X (__builtin_nansf32x (""))
+#endif
+#if __HAVE_FLOAT64X && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define SNANF64X (__builtin_nansf64x (""))
+#endif
+#if __HAVE_FLOAT128X && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define SNANF128X (__builtin_nansf128x (""))
+#endif
+
+/* Get __GLIBC_FLT_EVAL_METHOD. */
+#include <bits/flt-eval-method.h>
+
+#ifdef __USE_ISOC99
+/* Define the following typedefs.
+
+ float_t floating-point type at least as wide as `float' used
+ to evaluate `float' expressions
+ double_t floating-point type at least as wide as `double' used
+ to evaluate `double' expressions
+*/
+# if __GLIBC_FLT_EVAL_METHOD == 0 || __GLIBC_FLT_EVAL_METHOD == 16
+typedef float float_t;
+typedef double double_t;
+# elif __GLIBC_FLT_EVAL_METHOD == 1
+typedef double float_t;
+typedef double double_t;
+# elif __GLIBC_FLT_EVAL_METHOD == 2
+typedef long double float_t;
+typedef long double double_t;
+# elif __GLIBC_FLT_EVAL_METHOD == 32
+typedef _Float32 float_t;
+typedef double double_t;
+# elif __GLIBC_FLT_EVAL_METHOD == 33
+typedef _Float32x float_t;
+typedef _Float32x double_t;
+# elif __GLIBC_FLT_EVAL_METHOD == 64
+typedef _Float64 float_t;
+typedef _Float64 double_t;
+# elif __GLIBC_FLT_EVAL_METHOD == 65
+typedef _Float64x float_t;
+typedef _Float64x double_t;
+# elif __GLIBC_FLT_EVAL_METHOD == 128
+typedef _Float128 float_t;
+typedef _Float128 double_t;
+# elif __GLIBC_FLT_EVAL_METHOD == 129
+typedef _Float128x float_t;
+typedef _Float128x double_t;
+# else
+# error "Unknown __GLIBC_FLT_EVAL_METHOD"
+# endif
+#endif
+
+/* Define macros for the return values of ilogb and llogb, based on
+ __FP_LOGB0_IS_MIN and __FP_LOGBNAN_IS_MIN.
+
+ FP_ILOGB0 Expands to a value returned by `ilogb (0.0)'.
+ FP_ILOGBNAN Expands to a value returned by `ilogb (NAN)'.
+ FP_LLOGB0 Expands to a value returned by `llogb (0.0)'.
+ FP_LLOGBNAN Expands to a value returned by `llogb (NAN)'.
+
+*/
+
+#include <bits/fp-logb.h>
+#ifdef __USE_ISOC99
+# if __FP_LOGB0_IS_MIN
+# define FP_ILOGB0 (-2147483647 - 1)
+# else
+# define FP_ILOGB0 (-2147483647)
+# endif
+# if __FP_LOGBNAN_IS_MIN
+# define FP_ILOGBNAN (-2147483647 - 1)
+# else
+# define FP_ILOGBNAN 2147483647
+# endif
+#endif
+#if __GLIBC_USE (IEC_60559_BFP_EXT)
+# if __WORDSIZE == 32
+# define __FP_LONG_MAX 0x7fffffffL
+# else
+# define __FP_LONG_MAX 0x7fffffffffffffffL
+# endif
+# if __FP_LOGB0_IS_MIN
+# define FP_LLOGB0 (-__FP_LONG_MAX - 1)
+# else
+# define FP_LLOGB0 (-__FP_LONG_MAX)
+# endif
+# if __FP_LOGBNAN_IS_MIN
+# define FP_LLOGBNAN (-__FP_LONG_MAX - 1)
+# else
+# define FP_LLOGBNAN __FP_LONG_MAX
+# endif
+#endif
+
+/* Get the architecture specific values describing the floating-point
+ evaluation. The following symbols will get defined:
+
+ FP_FAST_FMA
+ FP_FAST_FMAF
+ FP_FAST_FMAL
+ If defined it indicates that the `fma' function
+ generally executes about as fast as a multiply and an add.
+ This macro is defined only iff the `fma' function is
+ implemented directly with a hardware multiply-add instructions.
+*/
+
+#include <bits/fp-fast.h>
+
+#if __GLIBC_USE (IEC_60559_BFP_EXT)
+/* Rounding direction macros for fromfp functions. */
+enum
+ {
+ FP_INT_UPWARD =
+# define FP_INT_UPWARD 0
+ FP_INT_UPWARD,
+ FP_INT_DOWNWARD =
+# define FP_INT_DOWNWARD 1
+ FP_INT_DOWNWARD,
+ FP_INT_TOWARDZERO =
+# define FP_INT_TOWARDZERO 2
+ FP_INT_TOWARDZERO,
+ FP_INT_TONEARESTFROMZERO =
+# define FP_INT_TONEARESTFROMZERO 3
+ FP_INT_TONEARESTFROMZERO,
+ FP_INT_TONEAREST =
+# define FP_INT_TONEAREST 4
+ FP_INT_TONEAREST,
+ };
+#endif
+
+/* The file <bits/mathcalls.h> contains the prototypes for all the
+ actual math functions. These macros are used for those prototypes,
+ so we can easily declare each function as both `name' and `__name',
+ and can declare the float versions `namef' and `__namef'. */
+
+#define __SIMD_DECL(function) __CONCAT (__DECL_SIMD_, function)
+
+#define __MATHCALL_VEC(function, suffix, args) \
+ __SIMD_DECL (__MATH_PRECNAME (function, suffix)) \
+ __MATHCALL (function, suffix, args)
+
+#define __MATHDECL_VEC(type, function,suffix, args) \
+ __SIMD_DECL (__MATH_PRECNAME (function, suffix)) \
+ __MATHDECL(type, function,suffix, args)
+
+#define __MATHCALL(function,suffix, args) \
+ __MATHDECL (_Mdouble_,function,suffix, args)
+#define __MATHDECL(type, function,suffix, args) \
+ __MATHDECL_1(type, function,suffix, args); \
+ __MATHDECL_1(type, __CONCAT(__,function),suffix, args)
+#define __MATHCALLX(function,suffix, args, attrib) \
+ __MATHDECLX (_Mdouble_,function,suffix, args, attrib)
+#define __MATHDECLX(type, function,suffix, args, attrib) \
+ __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); \
+ __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)
+#define __MATHDECL_1(type, function,suffix, args) \
+ extern type __MATH_PRECNAME(function,suffix) args __THROW
+
+#define _Mdouble_ double
+#define __MATH_PRECNAME(name,r) __CONCAT(name,r)
+#define __MATH_DECLARING_DOUBLE 1
+#define __MATH_DECLARING_FLOATN 0
+#include <bits/mathcalls-helper-functions.h>
+#include <bits/mathcalls.h>
+#undef _Mdouble_
+#undef __MATH_PRECNAME
+#undef __MATH_DECLARING_DOUBLE
+#undef __MATH_DECLARING_FLOATN
+
+#ifdef __USE_ISOC99
+
+
+/* Include the file of declarations again, this time using `float'
+ instead of `double' and appending f to each function name. */
+
+# define _Mdouble_ float
+# define __MATH_PRECNAME(name,r) name##f##r
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 0
+# include <bits/mathcalls-helper-functions.h>
+# include <bits/mathcalls.h>
+# undef _Mdouble_
+# undef __MATH_PRECNAME
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+
+# if !(defined __NO_LONG_DOUBLE_MATH && defined _LIBC) \
+ || defined __LDBL_COMPAT \
+ || defined _LIBC_TEST
+# ifdef __LDBL_COMPAT
+
+# ifdef __USE_ISOC99
+extern float __nldbl_nexttowardf (float __x, long double __y)
+ __THROW __attribute__ ((__const__));
+# ifdef __REDIRECT_NTH
+extern float __REDIRECT_NTH (nexttowardf, (float __x, long double __y),
+ __nldbl_nexttowardf)
+ __attribute__ ((__const__));
+extern double __REDIRECT_NTH (nexttoward, (double __x, long double __y),
+ nextafter) __attribute__ ((__const__));
+extern long double __REDIRECT_NTH (nexttowardl,
+ (long double __x, long double __y),
+ nextafter) __attribute__ ((__const__));
+# endif
+# endif
+
+# undef __MATHDECL_1
+# define __MATHDECL_2(type, function,suffix, args, alias) \
+ extern type __REDIRECT_NTH(__MATH_PRECNAME(function,suffix), \
+ args, alias)
+# define __MATHDECL_1(type, function,suffix, args) \
+ __MATHDECL_2(type, function,suffix, args, __CONCAT(function,suffix))
+# endif
+
+/* Include the file of declarations again, this time using `long double'
+ instead of `double' and appending l to each function name. */
+
+# define _Mdouble_ long double
+# define __MATH_PRECNAME(name,r) name##l##r
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 0
+# define __MATH_DECLARE_LDOUBLE 1
+# include <bits/mathcalls-helper-functions.h>
+# include <bits/mathcalls.h>
+# undef _Mdouble_
+# undef __MATH_PRECNAME
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+
+# endif /* !(__NO_LONG_DOUBLE_MATH && _LIBC) || __LDBL_COMPAT */
+
+#endif /* Use ISO C99. */
+
+/* Include the file of declarations for _FloatN and _FloatNx
+ types. */
+
+#if __HAVE_DISTINCT_FLOAT16 || (__HAVE_FLOAT16 && !defined _LIBC)
+# define _Mdouble_ _Float16
+# define __MATH_PRECNAME(name,r) name##f16##r
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 1
+# if __HAVE_DISTINCT_FLOAT16
+# include <bits/mathcalls-helper-functions.h>
+# endif
+# if __GLIBC_USE (IEC_60559_TYPES_EXT)
+# include <bits/mathcalls.h>
+# endif
+# undef _Mdouble_
+# undef __MATH_PRECNAME
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+#endif /* __HAVE_DISTINCT_FLOAT16 || (__HAVE_FLOAT16 && !_LIBC). */
+
+#if __HAVE_DISTINCT_FLOAT32 || (__HAVE_FLOAT32 && !defined _LIBC)
+# define _Mdouble_ _Float32
+# define __MATH_PRECNAME(name,r) name##f32##r
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 1
+# if __HAVE_DISTINCT_FLOAT32
+# include <bits/mathcalls-helper-functions.h>
+# endif
+# if __GLIBC_USE (IEC_60559_TYPES_EXT)
+# include <bits/mathcalls.h>
+# endif
+# undef _Mdouble_
+# undef __MATH_PRECNAME
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+#endif /* __HAVE_DISTINCT_FLOAT32 || (__HAVE_FLOAT32 && !_LIBC). */
+
+#if __HAVE_DISTINCT_FLOAT64 || (__HAVE_FLOAT64 && !defined _LIBC)
+# define _Mdouble_ _Float64
+# define __MATH_PRECNAME(name,r) name##f64##r
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 1
+# if __HAVE_DISTINCT_FLOAT64
+# include <bits/mathcalls-helper-functions.h>
+# endif
+# if __GLIBC_USE (IEC_60559_TYPES_EXT)
+# include <bits/mathcalls.h>
+# endif
+# undef _Mdouble_
+# undef __MATH_PRECNAME
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+#endif /* __HAVE_DISTINCT_FLOAT64 || (__HAVE_FLOAT64 && !_LIBC). */
+
+#if __HAVE_DISTINCT_FLOAT128 || (__HAVE_FLOAT128 && !defined _LIBC)
+# define _Mdouble_ _Float128
+# define __MATH_PRECNAME(name,r) name##f128##r
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 1
+# if __HAVE_DISTINCT_FLOAT128
+# include <bits/mathcalls-helper-functions.h>
+# endif
+# if __GLIBC_USE (IEC_60559_TYPES_EXT)
+# include <bits/mathcalls.h>
+# endif
+# undef _Mdouble_
+# undef __MATH_PRECNAME
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+#endif /* __HAVE_DISTINCT_FLOAT128 || (__HAVE_FLOAT128 && !_LIBC). */
+
+#if __HAVE_DISTINCT_FLOAT32X || (__HAVE_FLOAT32X && !defined _LIBC)
+# define _Mdouble_ _Float32x
+# define __MATH_PRECNAME(name,r) name##f32x##r
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 1
+# if __HAVE_DISTINCT_FLOAT32X
+# include <bits/mathcalls-helper-functions.h>
+# endif
+# if __GLIBC_USE (IEC_60559_TYPES_EXT)
+# include <bits/mathcalls.h>
+# endif
+# undef _Mdouble_
+# undef __MATH_PRECNAME
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+#endif /* __HAVE_DISTINCT_FLOAT32X || (__HAVE_FLOAT32X && !_LIBC). */
+
+#if __HAVE_DISTINCT_FLOAT64X || (__HAVE_FLOAT64X && !defined _LIBC)
+# define _Mdouble_ _Float64x
+# define __MATH_PRECNAME(name,r) name##f64x##r
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 1
+# if __HAVE_DISTINCT_FLOAT64X
+# include <bits/mathcalls-helper-functions.h>
+# endif
+# if __GLIBC_USE (IEC_60559_TYPES_EXT)
+# include <bits/mathcalls.h>
+# endif
+# undef _Mdouble_
+# undef __MATH_PRECNAME
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+#endif /* __HAVE_DISTINCT_FLOAT64X || (__HAVE_FLOAT64X && !_LIBC). */
+
+#if __HAVE_DISTINCT_FLOAT128X || (__HAVE_FLOAT128X && !defined _LIBC)
+# define _Mdouble_ _Float128x
+# define __MATH_PRECNAME(name,r) name##f128x##r
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 1
+# if __HAVE_DISTINCT_FLOAT128X
+# include <bits/mathcalls-helper-functions.h>
+# endif
+# if __GLIBC_USE (IEC_60559_TYPES_EXT)
+# include <bits/mathcalls.h>
+# endif
+# undef _Mdouble_
+# undef __MATH_PRECNAME
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+#endif /* __HAVE_DISTINCT_FLOAT128X || (__HAVE_FLOAT128X && !_LIBC). */
+
+#undef __MATHDECL_1
+#undef __MATHDECL
+#undef __MATHCALL
+
+/* Declare functions returning a narrower type. */
+#define __MATHCALL_NARROW_ARGS_1 (_Marg_ __x)
+#define __MATHCALL_NARROW_ARGS_2 (_Marg_ __x, _Marg_ __y)
+#define __MATHCALL_NARROW_ARGS_3 (_Marg_ __x, _Marg_ __y, _Marg_ __z)
+#define __MATHCALL_NARROW_NORMAL(func, nargs) \
+ extern _Mret_ func __MATHCALL_NARROW_ARGS_ ## nargs __THROW
+#define __MATHCALL_NARROW_REDIR(func, redir, nargs) \
+ extern _Mret_ __REDIRECT_NTH (func, __MATHCALL_NARROW_ARGS_ ## nargs, \
+ redir)
+#define __MATHCALL_NARROW(func, redir, nargs) \
+ __MATHCALL_NARROW_NORMAL (func, nargs)
+
+#if __GLIBC_USE (IEC_60559_BFP_EXT)
+
+# define _Mret_ float
+# define _Marg_ double
+# define __MATHCALL_NAME(name) f ## name
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+
+# define _Mret_ float
+# define _Marg_ long double
+# define __MATHCALL_NAME(name) f ## name ## l
+# ifdef __LDBL_COMPAT
+# define __MATHCALL_REDIR_NAME(name) f ## name
+# undef __MATHCALL_NARROW
+# define __MATHCALL_NARROW(func, redir, nargs) \
+ __MATHCALL_NARROW_REDIR (func, redir, nargs)
+# endif
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# ifdef __LDBL_COMPAT
+# undef __MATHCALL_REDIR_NAME
+# undef __MATHCALL_NARROW
+# define __MATHCALL_NARROW(func, redir, nargs) \
+ __MATHCALL_NARROW_NORMAL (func, nargs)
+# endif
+
+# define _Mret_ double
+# define _Marg_ long double
+# define __MATHCALL_NAME(name) d ## name ## l
+# ifdef __LDBL_COMPAT
+# define __MATHCALL_REDIR_NAME(name) __nldbl_d ## name ## l
+# undef __MATHCALL_NARROW
+# define __MATHCALL_NARROW(func, redir, nargs) \
+ __MATHCALL_NARROW_REDIR (func, redir, nargs)
+# endif
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# ifdef __LDBL_COMPAT
+# undef __MATHCALL_REDIR_NAME
+# undef __MATHCALL_NARROW
+# define __MATHCALL_NARROW(func, redir, nargs) \
+ __MATHCALL_NARROW_NORMAL (func, nargs)
+# endif
+
+#endif
+
+#if __GLIBC_USE (IEC_60559_TYPES_EXT)
+
+# if __HAVE_FLOAT16 && __HAVE_FLOAT32
+# define _Mret_ _Float16
+# define _Marg_ _Float32
+# define __MATHCALL_NAME(name) f16 ## name ## f32
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT16 && __HAVE_FLOAT32X
+# define _Mret_ _Float16
+# define _Marg_ _Float32x
+# define __MATHCALL_NAME(name) f16 ## name ## f32x
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT16 && __HAVE_FLOAT64
+# define _Mret_ _Float16
+# define _Marg_ _Float64
+# define __MATHCALL_NAME(name) f16 ## name ## f64
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT16 && __HAVE_FLOAT64X
+# define _Mret_ _Float16
+# define _Marg_ _Float64x
+# define __MATHCALL_NAME(name) f16 ## name ## f64x
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT16 && __HAVE_FLOAT128
+# define _Mret_ _Float16
+# define _Marg_ _Float128
+# define __MATHCALL_NAME(name) f16 ## name ## f128
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT16 && __HAVE_FLOAT128X
+# define _Mret_ _Float16
+# define _Marg_ _Float128x
+# define __MATHCALL_NAME(name) f16 ## name ## f128x
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT32 && __HAVE_FLOAT32X
+# define _Mret_ _Float32
+# define _Marg_ _Float32x
+# define __MATHCALL_NAME(name) f32 ## name ## f32x
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT32 && __HAVE_FLOAT64
+# define _Mret_ _Float32
+# define _Marg_ _Float64
+# define __MATHCALL_NAME(name) f32 ## name ## f64
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT32 && __HAVE_FLOAT64X
+# define _Mret_ _Float32
+# define _Marg_ _Float64x
+# define __MATHCALL_NAME(name) f32 ## name ## f64x
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT32 && __HAVE_FLOAT128
+# define _Mret_ _Float32
+# define _Marg_ _Float128
+# define __MATHCALL_NAME(name) f32 ## name ## f128
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT32 && __HAVE_FLOAT128X
+# define _Mret_ _Float32
+# define _Marg_ _Float128x
+# define __MATHCALL_NAME(name) f32 ## name ## f128x
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT32X && __HAVE_FLOAT64
+# define _Mret_ _Float32x
+# define _Marg_ _Float64
+# define __MATHCALL_NAME(name) f32x ## name ## f64
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT32X && __HAVE_FLOAT64X
+# define _Mret_ _Float32x
+# define _Marg_ _Float64x
+# define __MATHCALL_NAME(name) f32x ## name ## f64x
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT32X && __HAVE_FLOAT128
+# define _Mret_ _Float32x
+# define _Marg_ _Float128
+# define __MATHCALL_NAME(name) f32x ## name ## f128
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT32X && __HAVE_FLOAT128X
+# define _Mret_ _Float32x
+# define _Marg_ _Float128x
+# define __MATHCALL_NAME(name) f32x ## name ## f128x
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT64 && __HAVE_FLOAT64X
+# define _Mret_ _Float64
+# define _Marg_ _Float64x
+# define __MATHCALL_NAME(name) f64 ## name ## f64x
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT64 && __HAVE_FLOAT128
+# define _Mret_ _Float64
+# define _Marg_ _Float128
+# define __MATHCALL_NAME(name) f64 ## name ## f128
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT64 && __HAVE_FLOAT128X
+# define _Mret_ _Float64
+# define _Marg_ _Float128x
+# define __MATHCALL_NAME(name) f64 ## name ## f128x
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT64X && __HAVE_FLOAT128
+# define _Mret_ _Float64x
+# define _Marg_ _Float128
+# define __MATHCALL_NAME(name) f64x ## name ## f128
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT64X && __HAVE_FLOAT128X
+# define _Mret_ _Float64x
+# define _Marg_ _Float128x
+# define __MATHCALL_NAME(name) f64x ## name ## f128x
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+# if __HAVE_FLOAT128 && __HAVE_FLOAT128X
+# define _Mret_ _Float128
+# define _Marg_ _Float128x
+# define __MATHCALL_NAME(name) f128 ## name ## f128x
+# include <bits/mathcalls-narrow.h>
+# undef _Mret_
+# undef _Marg_
+# undef __MATHCALL_NAME
+# endif
+
+#endif
+
+#undef __MATHCALL_NARROW_ARGS_1
+#undef __MATHCALL_NARROW_ARGS_2
+#undef __MATHCALL_NARROW_ARGS_3
+#undef __MATHCALL_NARROW_NORMAL
+#undef __MATHCALL_NARROW_REDIR
+#undef __MATHCALL_NARROW
+
+#if defined __USE_MISC || defined __USE_XOPEN
+/* This variable is used by `gamma' and `lgamma'. */
+extern int signgam;
+#endif
+
+#if (__HAVE_DISTINCT_FLOAT16 \
+ || __HAVE_DISTINCT_FLOAT32 \
+ || __HAVE_DISTINCT_FLOAT64 \
+ || __HAVE_DISTINCT_FLOAT32X \
+ || __HAVE_DISTINCT_FLOAT64X \
+ || __HAVE_DISTINCT_FLOAT128X)
+# error "Unsupported _FloatN or _FloatNx types for <math.h>."
+#endif
+
+/* Depending on the type of TG_ARG, call an appropriately suffixed
+ version of FUNC with arguments (including parentheses) ARGS.
+ Suffixed functions may not exist for long double if it has the same
+ format as double, or for other types with the same format as float,
+ double or long double. The behavior is undefined if the argument
+ does not have a real floating type. The definition may use a
+ conditional expression, so all suffixed versions of FUNC must
+ return the same type (FUNC may include a cast if necessary rather
+ than being a single identifier). */
+#ifdef __NO_LONG_DOUBLE_MATH
+# if __HAVE_DISTINCT_FLOAT128
+# error "Distinct _Float128 without distinct long double not supported."
+# endif
+# define __MATH_TG(TG_ARG, FUNC, ARGS) \
+ (sizeof (TG_ARG) == sizeof (float) ? FUNC ## f ARGS : FUNC ARGS)
+#elif __HAVE_DISTINCT_FLOAT128
+# if __HAVE_GENERIC_SELECTION
+# if __HAVE_FLOATN_NOT_TYPEDEF && __HAVE_FLOAT32
+# define __MATH_TG_F32(FUNC, ARGS) _Float32: FUNC ## f ARGS,
+# else
+# define __MATH_TG_F32(FUNC, ARGS)
+# endif
+# if __HAVE_FLOATN_NOT_TYPEDEF && __HAVE_FLOAT64X
+# if __HAVE_FLOAT64X_LONG_DOUBLE
+# define __MATH_TG_F64X(FUNC, ARGS) _Float64x: FUNC ## l ARGS,
+# else
+# define __MATH_TG_F64X(FUNC, ARGS) _Float64x: FUNC ## f128 ARGS,
+# endif
+# else
+# define __MATH_TG_F64X(FUNC, ARGS)
+# endif
+# define __MATH_TG(TG_ARG, FUNC, ARGS) \
+ _Generic ((TG_ARG), \
+ float: FUNC ## f ARGS, \
+ __MATH_TG_F32 (FUNC, ARGS) \
+ default: FUNC ARGS, \
+ long double: FUNC ## l ARGS, \
+ __MATH_TG_F64X (FUNC, ARGS) \
+ _Float128: FUNC ## f128 ARGS)
+# else
+# if __HAVE_FLOATN_NOT_TYPEDEF
+# error "Non-typedef _FloatN but no _Generic."
+# endif
+# define __MATH_TG(TG_ARG, FUNC, ARGS) \
+ __builtin_choose_expr \
+ (__builtin_types_compatible_p (__typeof (TG_ARG), float), \
+ FUNC ## f ARGS, \
+ __builtin_choose_expr \
+ (__builtin_types_compatible_p (__typeof (TG_ARG), double), \
+ FUNC ARGS, \
+ __builtin_choose_expr \
+ (__builtin_types_compatible_p (__typeof (TG_ARG), long double), \
+ FUNC ## l ARGS, \
+ FUNC ## f128 ARGS)))
+# endif
+#else
+# define __MATH_TG(TG_ARG, FUNC, ARGS) \
+ (sizeof (TG_ARG) == sizeof (float) \
+ ? FUNC ## f ARGS \
+ : sizeof (TG_ARG) == sizeof (double) \
+ ? FUNC ARGS \
+ : FUNC ## l ARGS)
+#endif
+
+/* ISO C99 defines some generic macros which work on any data type. */
+#ifdef __USE_ISOC99
+
+/* All floating-point numbers can be put in one of these categories. */
+enum
+ {
+ FP_NAN =
+# define FP_NAN 0
+ FP_NAN,
+ FP_INFINITE =
+# define FP_INFINITE 1
+ FP_INFINITE,
+ FP_ZERO =
+# define FP_ZERO 2
+ FP_ZERO,
+ FP_SUBNORMAL =
+# define FP_SUBNORMAL 3
+ FP_SUBNORMAL,
+ FP_NORMAL =
+# define FP_NORMAL 4
+ FP_NORMAL
+ };
+
+/* GCC bug 66462 means we cannot use the math builtins with -fsignaling-nan,
+ so disable builtins if this is enabled. When fixed in a newer GCC,
+ the __SUPPORT_SNAN__ check may be skipped for those versions. */
+
+/* Return number of classification appropriate for X. */
+# if __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__ \
+ && (!defined __OPTIMIZE_SIZE__ || defined __cplusplus)
+ /* The check for __cplusplus allows the use of the builtin, even
+ when optimization for size is on. This is provided for
+ libstdc++, only to let its configure test work when it is built
+ with -Os. No further use of this definition of fpclassify is
+ expected in C++ mode, since libstdc++ provides its own version
+ of fpclassify in cmath (which undefines fpclassify). */
+# define fpclassify(x) __builtin_fpclassify (FP_NAN, FP_INFINITE, \
+ FP_NORMAL, FP_SUBNORMAL, FP_ZERO, x)
+# else
+# define fpclassify(x) __MATH_TG ((x), __fpclassify, (x))
+# endif
+
+/* Return nonzero value if sign of X is negative. */
+# if __GNUC_PREREQ (6,0)
+# define signbit(x) __builtin_signbit (x)
+# elif defined __cplusplus
+ /* In C++ mode, __MATH_TG cannot be used, because it relies on
+ __builtin_types_compatible_p, which is a C-only builtin.
+ The check for __cplusplus allows the use of the builtin instead of
+ __MATH_TG. This is provided for libstdc++, only to let its configure
+ test work. No further use of this definition of signbit is expected
+ in C++ mode, since libstdc++ provides its own version of signbit
+ in cmath (which undefines signbit). */
+# define signbit(x) __builtin_signbitl (x)
+# elif __GNUC_PREREQ (4,0)
+# define signbit(x) __MATH_TG ((x), __builtin_signbit, (x))
+# else
+# define signbit(x) __MATH_TG ((x), __signbit, (x))
+# endif
+
+/* Return nonzero value if X is not +-Inf or NaN. */
+# if __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__
+# define isfinite(x) __builtin_isfinite (x)
+# else
+# define isfinite(x) __MATH_TG ((x), __finite, (x))
+# endif
+
+/* Return nonzero value if X is neither zero, subnormal, Inf, nor NaN. */
+# if __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__
+# define isnormal(x) __builtin_isnormal (x)
+# else
+# define isnormal(x) (fpclassify (x) == FP_NORMAL)
+# endif
+
+/* Return nonzero value if X is a NaN. We could use `fpclassify' but
+ we already have this functions `__isnan' and it is faster. */
+# if __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__
+# define isnan(x) __builtin_isnan (x)
+# else
+# define isnan(x) __MATH_TG ((x), __isnan, (x))
+# endif
+
+/* Return nonzero value if X is positive or negative infinity. */
+# if __HAVE_DISTINCT_FLOAT128 && !__GNUC_PREREQ (7,0) \
+ && !defined __SUPPORT_SNAN__ && !defined __cplusplus
+ /* Since __builtin_isinf_sign is broken for float128 before GCC 7.0,
+ use the helper function, __isinff128, with older compilers. This is
+ only provided for C mode, because in C++ mode, GCC has no support
+ for __builtin_types_compatible_p (and when in C++ mode, this macro is
+ not used anyway, because libstdc++ headers undefine it). */
+# define isinf(x) \
+ (__builtin_types_compatible_p (__typeof (x), _Float128) \
+ ? __isinff128 (x) : __builtin_isinf_sign (x))
+# elif __GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__
+# define isinf(x) __builtin_isinf_sign (x)
+# else
+# define isinf(x) __MATH_TG ((x), __isinf, (x))
+# endif
+
+/* Bitmasks for the math_errhandling macro. */
+# define MATH_ERRNO 1 /* errno set by math functions. */
+# define MATH_ERREXCEPT 2 /* Exceptions raised by math functions. */
+
+/* By default all math functions support both errno and exception handling
+ (except for soft floating point implementations which may only support
+ errno handling). If errno handling is disabled, exceptions are still
+ supported by GLIBC. Set math_errhandling to 0 with -ffast-math (this is
+ nonconforming but it is more useful than leaving it undefined). */
+# ifdef __FAST_MATH__
+# define math_errhandling 0
+# elif defined __NO_MATH_ERRNO__
+# define math_errhandling (MATH_ERREXCEPT)
+# else
+# define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT)
+# endif
+
+#endif /* Use ISO C99. */
+
+#if __GLIBC_USE (IEC_60559_BFP_EXT)
+# include <bits/iscanonical.h>
+
+/* Return nonzero value if X is a signaling NaN. */
+# ifndef __cplusplus
+# define issignaling(x) __MATH_TG ((x), __issignaling, (x))
+# else
+ /* In C++ mode, __MATH_TG cannot be used, because it relies on
+ __builtin_types_compatible_p, which is a C-only builtin. On the
+ other hand, overloading provides the means to distinguish between
+ the floating-point types. The overloading resolution will match
+ the correct parameter (regardless of type qualifiers (i.e.: const
+ and volatile)). */
+extern "C++" {
+inline int issignaling (float __val) { return __issignalingf (__val); }
+inline int issignaling (double __val) { return __issignaling (__val); }
+inline int
+issignaling (long double __val)
+{
+# ifdef __NO_LONG_DOUBLE_MATH
+ return __issignaling (__val);
+# else
+ return __issignalingl (__val);
+# endif
+}
+# if __HAVE_FLOAT128_UNLIKE_LDBL
+/* When using an IEEE 128-bit long double, _Float128 is defined as long double
+ in C++. */
+inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); }
+# endif
+} /* extern C++ */
+# endif
+
+/* Return nonzero value if X is subnormal. */
+# define issubnormal(x) (fpclassify (x) == FP_SUBNORMAL)
+
+/* Return nonzero value if X is zero. */
+# ifndef __cplusplus
+# ifdef __SUPPORT_SNAN__
+# define iszero(x) (fpclassify (x) == FP_ZERO)
+# else
+# define iszero(x) (((__typeof (x)) (x)) == 0)
+# endif
+# else /* __cplusplus */
+extern "C++" {
+# ifdef __SUPPORT_SNAN__
+inline int
+iszero (float __val)
+{
+ return __fpclassifyf (__val) == FP_ZERO;
+}
+inline int
+iszero (double __val)
+{
+ return __fpclassify (__val) == FP_ZERO;
+}
+inline int
+iszero (long double __val)
+{
+# ifdef __NO_LONG_DOUBLE_MATH
+ return __fpclassify (__val) == FP_ZERO;
+# else
+ return __fpclassifyl (__val) == FP_ZERO;
+# endif
+}
+# if __HAVE_FLOAT128_UNLIKE_LDBL
+ /* When using an IEEE 128-bit long double, _Float128 is defined as long double
+ in C++. */
+inline int
+iszero (_Float128 __val)
+{
+ return __fpclassifyf128 (__val) == FP_ZERO;
+}
+# endif
+# else
+template <class __T> inline bool
+iszero (__T __val)
+{
+ return __val == 0;
+}
+# endif
+} /* extern C++ */
+# endif /* __cplusplus */
+#endif /* Use IEC_60559_BFP_EXT. */
+
+#ifdef __USE_XOPEN
+/* X/Open wants another strange constant. */
+# define MAXFLOAT 3.40282347e+38F
+#endif
+
+
+/* Some useful constants. */
+#if defined __USE_MISC || defined __USE_XOPEN
+# define M_E 2.7182818284590452354 /* e */
+# define M_LOG2E 1.4426950408889634074 /* log_2 e */
+# define M_LOG10E 0.43429448190325182765 /* log_10 e */
+# define M_LN2 0.69314718055994530942 /* log_e 2 */
+# define M_LN10 2.30258509299404568402 /* log_e 10 */
+# define M_PI 3.14159265358979323846 /* pi */
+# define M_PI_2 1.57079632679489661923 /* pi/2 */
+# define M_PI_4 0.78539816339744830962 /* pi/4 */
+# define M_1_PI 0.31830988618379067154 /* 1/pi */
+# define M_2_PI 0.63661977236758134308 /* 2/pi */
+# define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
+# define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
+# define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
+#endif
+
+/* The above constants are not adequate for computation using `long double's.
+ Therefore we provide as an extension constants with similar names as a
+ GNU extension. Provide enough digits for the 128-bit IEEE quad. */
+#ifdef __USE_GNU
+# define M_El 2.718281828459045235360287471352662498L /* e */
+# define M_LOG2El 1.442695040888963407359924681001892137L /* log_2 e */
+# define M_LOG10El 0.434294481903251827651128918916605082L /* log_10 e */
+# define M_LN2l 0.693147180559945309417232121458176568L /* log_e 2 */
+# define M_LN10l 2.302585092994045684017991454684364208L /* log_e 10 */
+# define M_PIl 3.141592653589793238462643383279502884L /* pi */
+# define M_PI_2l 1.570796326794896619231321691639751442L /* pi/2 */
+# define M_PI_4l 0.785398163397448309615660845819875721L /* pi/4 */
+# define M_1_PIl 0.318309886183790671537767526745028724L /* 1/pi */
+# define M_2_PIl 0.636619772367581343075535053490057448L /* 2/pi */
+# define M_2_SQRTPIl 1.128379167095512573896158903121545172L /* 2/sqrt(pi) */
+# define M_SQRT2l 1.414213562373095048801688724209698079L /* sqrt(2) */
+# define M_SQRT1_2l 0.707106781186547524400844362104849039L /* 1/sqrt(2) */
+#endif
+
+#if __HAVE_FLOAT16 && defined __USE_GNU
+# define M_Ef16 __f16 (2.718281828459045235360287471352662498) /* e */
+# define M_LOG2Ef16 __f16 (1.442695040888963407359924681001892137) /* log_2 e */
+# define M_LOG10Ef16 __f16 (0.434294481903251827651128918916605082) /* log_10 e */
+# define M_LN2f16 __f16 (0.693147180559945309417232121458176568) /* log_e 2 */
+# define M_LN10f16 __f16 (2.302585092994045684017991454684364208) /* log_e 10 */
+# define M_PIf16 __f16 (3.141592653589793238462643383279502884) /* pi */
+# define M_PI_2f16 __f16 (1.570796326794896619231321691639751442) /* pi/2 */
+# define M_PI_4f16 __f16 (0.785398163397448309615660845819875721) /* pi/4 */
+# define M_1_PIf16 __f16 (0.318309886183790671537767526745028724) /* 1/pi */
+# define M_2_PIf16 __f16 (0.636619772367581343075535053490057448) /* 2/pi */
+# define M_2_SQRTPIf16 __f16 (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
+# define M_SQRT2f16 __f16 (1.414213562373095048801688724209698079) /* sqrt(2) */
+# define M_SQRT1_2f16 __f16 (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
+#endif
+
+#if __HAVE_FLOAT32 && defined __USE_GNU
+# define M_Ef32 __f32 (2.718281828459045235360287471352662498) /* e */
+# define M_LOG2Ef32 __f32 (1.442695040888963407359924681001892137) /* log_2 e */
+# define M_LOG10Ef32 __f32 (0.434294481903251827651128918916605082) /* log_10 e */
+# define M_LN2f32 __f32 (0.693147180559945309417232121458176568) /* log_e 2 */
+# define M_LN10f32 __f32 (2.302585092994045684017991454684364208) /* log_e 10 */
+# define M_PIf32 __f32 (3.141592653589793238462643383279502884) /* pi */
+# define M_PI_2f32 __f32 (1.570796326794896619231321691639751442) /* pi/2 */
+# define M_PI_4f32 __f32 (0.785398163397448309615660845819875721) /* pi/4 */
+# define M_1_PIf32 __f32 (0.318309886183790671537767526745028724) /* 1/pi */
+# define M_2_PIf32 __f32 (0.636619772367581343075535053490057448) /* 2/pi */
+# define M_2_SQRTPIf32 __f32 (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
+# define M_SQRT2f32 __f32 (1.414213562373095048801688724209698079) /* sqrt(2) */
+# define M_SQRT1_2f32 __f32 (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
+#endif
+
+#if __HAVE_FLOAT64 && defined __USE_GNU
+# define M_Ef64 __f64 (2.718281828459045235360287471352662498) /* e */
+# define M_LOG2Ef64 __f64 (1.442695040888963407359924681001892137) /* log_2 e */
+# define M_LOG10Ef64 __f64 (0.434294481903251827651128918916605082) /* log_10 e */
+# define M_LN2f64 __f64 (0.693147180559945309417232121458176568) /* log_e 2 */
+# define M_LN10f64 __f64 (2.302585092994045684017991454684364208) /* log_e 10 */
+# define M_PIf64 __f64 (3.141592653589793238462643383279502884) /* pi */
+# define M_PI_2f64 __f64 (1.570796326794896619231321691639751442) /* pi/2 */
+# define M_PI_4f64 __f64 (0.785398163397448309615660845819875721) /* pi/4 */
+# define M_1_PIf64 __f64 (0.318309886183790671537767526745028724) /* 1/pi */
+# define M_2_PIf64 __f64 (0.636619772367581343075535053490057448) /* 2/pi */
+# define M_2_SQRTPIf64 __f64 (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
+# define M_SQRT2f64 __f64 (1.414213562373095048801688724209698079) /* sqrt(2) */
+# define M_SQRT1_2f64 __f64 (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
+#endif
+
+#if __HAVE_FLOAT128 && defined __USE_GNU
+# define M_Ef128 __f128 (2.718281828459045235360287471352662498) /* e */
+# define M_LOG2Ef128 __f128 (1.442695040888963407359924681001892137) /* log_2 e */
+# define M_LOG10Ef128 __f128 (0.434294481903251827651128918916605082) /* log_10 e */
+# define M_LN2f128 __f128 (0.693147180559945309417232121458176568) /* log_e 2 */
+# define M_LN10f128 __f128 (2.302585092994045684017991454684364208) /* log_e 10 */
+# define M_PIf128 __f128 (3.141592653589793238462643383279502884) /* pi */
+# define M_PI_2f128 __f128 (1.570796326794896619231321691639751442) /* pi/2 */
+# define M_PI_4f128 __f128 (0.785398163397448309615660845819875721) /* pi/4 */
+# define M_1_PIf128 __f128 (0.318309886183790671537767526745028724) /* 1/pi */
+# define M_2_PIf128 __f128 (0.636619772367581343075535053490057448) /* 2/pi */
+# define M_2_SQRTPIf128 __f128 (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
+# define M_SQRT2f128 __f128 (1.414213562373095048801688724209698079) /* sqrt(2) */
+# define M_SQRT1_2f128 __f128 (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
+#endif
+
+#if __HAVE_FLOAT32X && defined __USE_GNU
+# define M_Ef32x __f32x (2.718281828459045235360287471352662498) /* e */
+# define M_LOG2Ef32x __f32x (1.442695040888963407359924681001892137) /* log_2 e */
+# define M_LOG10Ef32x __f32x (0.434294481903251827651128918916605082) /* log_10 e */
+# define M_LN2f32x __f32x (0.693147180559945309417232121458176568) /* log_e 2 */
+# define M_LN10f32x __f32x (2.302585092994045684017991454684364208) /* log_e 10 */
+# define M_PIf32x __f32x (3.141592653589793238462643383279502884) /* pi */
+# define M_PI_2f32x __f32x (1.570796326794896619231321691639751442) /* pi/2 */
+# define M_PI_4f32x __f32x (0.785398163397448309615660845819875721) /* pi/4 */
+# define M_1_PIf32x __f32x (0.318309886183790671537767526745028724) /* 1/pi */
+# define M_2_PIf32x __f32x (0.636619772367581343075535053490057448) /* 2/pi */
+# define M_2_SQRTPIf32x __f32x (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
+# define M_SQRT2f32x __f32x (1.414213562373095048801688724209698079) /* sqrt(2) */
+# define M_SQRT1_2f32x __f32x (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
+#endif
+
+#if __HAVE_FLOAT64X && defined __USE_GNU
+# define M_Ef64x __f64x (2.718281828459045235360287471352662498) /* e */
+# define M_LOG2Ef64x __f64x (1.442695040888963407359924681001892137) /* log_2 e */
+# define M_LOG10Ef64x __f64x (0.434294481903251827651128918916605082) /* log_10 e */
+# define M_LN2f64x __f64x (0.693147180559945309417232121458176568) /* log_e 2 */
+# define M_LN10f64x __f64x (2.302585092994045684017991454684364208) /* log_e 10 */
+# define M_PIf64x __f64x (3.141592653589793238462643383279502884) /* pi */
+# define M_PI_2f64x __f64x (1.570796326794896619231321691639751442) /* pi/2 */
+# define M_PI_4f64x __f64x (0.785398163397448309615660845819875721) /* pi/4 */
+# define M_1_PIf64x __f64x (0.318309886183790671537767526745028724) /* 1/pi */
+# define M_2_PIf64x __f64x (0.636619772367581343075535053490057448) /* 2/pi */
+# define M_2_SQRTPIf64x __f64x (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
+# define M_SQRT2f64x __f64x (1.414213562373095048801688724209698079) /* sqrt(2) */
+# define M_SQRT1_2f64x __f64x (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
+#endif
+
+#if __HAVE_FLOAT128X && defined __USE_GNU
+# error "M_* values needed for _Float128x"
+#endif
+
+/* When compiling in strict ISO C compatible mode we must not use the
+ inline functions since they, among other things, do not set the
+ `errno' variable correctly. */
+#if defined __STRICT_ANSI__ && !defined __NO_MATH_INLINES
+# define __NO_MATH_INLINES 1
+#endif
+
+#ifdef __USE_ISOC99
+# if __GNUC_PREREQ (3, 1)
+/* ISO C99 defines some macros to compare number while taking care for
+ unordered numbers. Many FPUs provide special instructions to support
+ these operations. Generic support in GCC for these as builtins went
+ in 2.97, but not all cpus added their patterns until 3.1. Therefore
+ we enable the builtins from 3.1 onwards and use a generic implementation
+ othwerwise. */
+# define isgreater(x, y) __builtin_isgreater(x, y)
+# define isgreaterequal(x, y) __builtin_isgreaterequal(x, y)
+# define isless(x, y) __builtin_isless(x, y)
+# define islessequal(x, y) __builtin_islessequal(x, y)
+# define islessgreater(x, y) __builtin_islessgreater(x, y)
+# define isunordered(x, y) __builtin_isunordered(x, y)
+# else
+# define isgreater(x, y) \
+ (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
+ !isunordered (__x, __y) && __x > __y; }))
+# define isgreaterequal(x, y) \
+ (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
+ !isunordered (__x, __y) && __x >= __y; }))
+# define isless(x, y) \
+ (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
+ !isunordered (__x, __y) && __x < __y; }))
+# define islessequal(x, y) \
+ (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
+ !isunordered (__x, __y) && __x <= __y; }))
+# define islessgreater(x, y) \
+ (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
+ !isunordered (__x, __y) && __x != __y; }))
+/* isunordered must always check both operands first for signaling NaNs. */
+# define isunordered(x, y) \
+ (__extension__ ({ __typeof__ (x) __u = (x); __typeof__ (y) __v = (y); \
+ __u != __v && (__u != __u || __v != __v); }))
+# endif
+#endif
+
+/* Get machine-dependent inline versions (if there are any). */
+#ifdef __USE_EXTERN_INLINES
+# include <bits/mathinline.h>
+#endif
+
+/* Define special entry points to use when the compiler got told to
+ only expect finite results. */
+#if defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ > 0
+
+/* Include bits/math-finite.h for double. */
+# define _Mdouble_ double
+# define __MATH_DECLARING_DOUBLE 1
+# define __MATH_DECLARING_FLOATN 0
+# define __REDIRFROM_X(function, reentrant) \
+ function ## reentrant
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## reentrant ## _finite
+# include <bits/math-finite.h>
+# undef _Mdouble_
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+# undef __REDIRFROM_X
+# undef __REDIRTO_X
+
+/* When __USE_ISOC99 is defined, include math-finite for float and
+ long double, as well. */
+# ifdef __USE_ISOC99
+
+/* Include bits/math-finite.h for float. */
+# define _Mdouble_ float
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 0
+# define __REDIRFROM_X(function, reentrant) \
+ function ## f ## reentrant
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## f ## reentrant ## _finite
+# include <bits/math-finite.h>
+# undef _Mdouble_
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+# undef __REDIRFROM_X
+# undef __REDIRTO_X
+
+/* Include bits/math-finite.h for long double. */
+# ifdef __MATH_DECLARE_LDOUBLE
+# define _Mdouble_ long double
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 0
+# define __REDIRFROM_X(function, reentrant) \
+ function ## l ## reentrant
+# ifdef __NO_LONG_DOUBLE_MATH
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## reentrant ## _finite
+# else
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## l ## reentrant ## _finite
+# endif
+# include <bits/math-finite.h>
+# undef _Mdouble_
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+# undef __REDIRFROM_X
+# undef __REDIRTO_X
+# endif
+
+# endif /* __USE_ISOC99. */
+
+/* Include bits/math-finite.h for _FloatN and _FloatNx. */
+
+# if (__HAVE_DISTINCT_FLOAT16 || (__HAVE_FLOAT16 && !defined _LIBC)) \
+ && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define _Mdouble_ _Float16
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 1
+# define __REDIRFROM_X(function, reentrant) \
+ function ## f16 ## reentrant
+# if __HAVE_DISTINCT_FLOAT16
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## f16 ## reentrant ## _finite
+# else
+# error "non-disinct _Float16"
+# endif
+# include <bits/math-finite.h>
+# undef _Mdouble_
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+# undef __REDIRFROM_X
+# undef __REDIRTO_X
+# endif
+
+# if (__HAVE_DISTINCT_FLOAT32 || (__HAVE_FLOAT32 && !defined _LIBC)) \
+ && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define _Mdouble_ _Float32
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 1
+# define __REDIRFROM_X(function, reentrant) \
+ function ## f32 ## reentrant
+# if __HAVE_DISTINCT_FLOAT32
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## f32 ## reentrant ## _finite
+# else
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## f ## reentrant ## _finite
+# endif
+# include <bits/math-finite.h>
+# undef _Mdouble_
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+# undef __REDIRFROM_X
+# undef __REDIRTO_X
+# endif
+
+# if (__HAVE_DISTINCT_FLOAT64 || (__HAVE_FLOAT64 && !defined _LIBC)) \
+ && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define _Mdouble_ _Float64
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 1
+# define __REDIRFROM_X(function, reentrant) \
+ function ## f64 ## reentrant
+# if __HAVE_DISTINCT_FLOAT64
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## f64 ## reentrant ## _finite
+# else
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## reentrant ## _finite
+# endif
+# include <bits/math-finite.h>
+# undef _Mdouble_
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+# undef __REDIRFROM_X
+# undef __REDIRTO_X
+# endif
+
+# if (__HAVE_DISTINCT_FLOAT128 || (__HAVE_FLOAT128 && !defined _LIBC)) \
+ && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define _Mdouble_ _Float128
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 1
+# define __REDIRFROM_X(function, reentrant) \
+ function ## f128 ## reentrant
+# if __HAVE_DISTINCT_FLOAT128
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## f128 ## reentrant ## _finite
+# else
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## l ## reentrant ## _finite
+# endif
+# include <bits/math-finite.h>
+# undef _Mdouble_
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+# undef __REDIRFROM_X
+# undef __REDIRTO_X
+# endif
+
+# if (__HAVE_DISTINCT_FLOAT32X || (__HAVE_FLOAT32X && !defined _LIBC)) \
+ && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define _Mdouble_ _Float32x
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 1
+# define __REDIRFROM_X(function, reentrant) \
+ function ## f32x ## reentrant
+# if __HAVE_DISTINCT_FLOAT32X
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## f32x ## reentrant ## _finite
+# else
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## reentrant ## _finite
+# endif
+# include <bits/math-finite.h>
+# undef _Mdouble_
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+# undef __REDIRFROM_X
+# undef __REDIRTO_X
+# endif
+
+# if (__HAVE_DISTINCT_FLOAT64X || (__HAVE_FLOAT64X && !defined _LIBC)) \
+ && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define _Mdouble_ _Float64x
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 1
+# define __REDIRFROM_X(function, reentrant) \
+ function ## f64x ## reentrant
+# if __HAVE_DISTINCT_FLOAT64X
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## f64x ## reentrant ## _finite
+# elif __HAVE_FLOAT64X_LONG_DOUBLE
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## l ## reentrant ## _finite
+# else
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## f128 ## reentrant ## _finite
+# endif
+# include <bits/math-finite.h>
+# undef _Mdouble_
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+# undef __REDIRFROM_X
+# undef __REDIRTO_X
+# endif
+
+# if (__HAVE_DISTINCT_FLOAT128X || (__HAVE_FLOAT128X && !defined _LIBC)) \
+ && __GLIBC_USE (IEC_60559_TYPES_EXT)
+# define _Mdouble_ _Float128x
+# define __MATH_DECLARING_DOUBLE 0
+# define __MATH_DECLARING_FLOATN 1
+# define __REDIRFROM_X(function, reentrant) \
+ function ## f128x ## reentrant
+# if __HAVE_DISTINCT_FLOAT128X
+# define __REDIRTO_X(function, reentrant) \
+ __ ## function ## f128x ## reentrant ## _finite
+# else
+# error "non-disinct _Float128x"
+# endif
+# include <bits/math-finite.h>
+# undef _Mdouble_
+# undef __MATH_DECLARING_DOUBLE
+# undef __MATH_DECLARING_FLOATN
+# undef __REDIRFROM_X
+# undef __REDIRTO_X
+# endif
+
+#endif /* __FINITE_MATH_ONLY__ > 0. */
+
+#if __GLIBC_USE (IEC_60559_BFP_EXT)
+/* An expression whose type has the widest of the evaluation formats
+ of X and Y (which are of floating-point types). */
+# if __FLT_EVAL_METHOD__ == 2 || __FLT_EVAL_METHOD__ > 64
+# define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0L)
+# elif __FLT_EVAL_METHOD__ == 1 || __FLT_EVAL_METHOD__ > 32
+# define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0)
+# elif __FLT_EVAL_METHOD__ == 0 || __FLT_EVAL_METHOD__ == 32
+# define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0f)
+# else
+# define __MATH_EVAL_FMT2(x, y) ((x) + (y))
+# endif
+
+/* Return X == Y but raising "invalid" and setting errno if X or Y is
+ a NaN. */
+# if !defined __cplusplus || (__cplusplus < 201103L && !defined __GNUC__)
+# define iseqsig(x, y) \
+ __MATH_TG (__MATH_EVAL_FMT2 (x, y), __iseqsig, ((x), (y)))
+# else
+/* In C++ mode, __MATH_TG cannot be used, because it relies on
+ __builtin_types_compatible_p, which is a C-only builtin. Moreover,
+ the comparison macros from ISO C take two floating-point arguments,
+ which need not have the same type. Choosing what underlying function
+ to call requires evaluating the formats of the arguments, then
+ selecting which is wider. The macro __MATH_EVAL_FMT2 provides this
+ information, however, only the type of the macro expansion is
+ relevant (actually evaluating the expression would be incorrect).
+ Thus, the type is used as a template parameter for __iseqsig_type,
+ which calls the appropriate underlying function. */
+extern "C++" {
+template<typename> struct __iseqsig_type;
+
+template<> struct __iseqsig_type<float>
+{
+ static int __call (float __x, float __y) throw ()
+ {
+ return __iseqsigf (__x, __y);
+ }
+};
+
+template<> struct __iseqsig_type<double>
+{
+ static int __call (double __x, double __y) throw ()
+ {
+ return __iseqsig (__x, __y);
+ }
+};
+
+template<> struct __iseqsig_type<long double>
+{
+ static int __call (long double __x, long double __y) throw ()
+ {
+# ifndef __NO_LONG_DOUBLE_MATH
+ return __iseqsigl (__x, __y);
+# else
+ return __iseqsig (__x, __y);
+# endif
+ }
+};
+
+# if __HAVE_FLOAT128_UNLIKE_LDBL
+ /* When using an IEEE 128-bit long double, _Float128 is defined as long double
+ in C++. */
+template<> struct __iseqsig_type<_Float128>
+{
+ static int __call (_Float128 __x, _Float128 __y) throw ()
+ {
+ return __iseqsigf128 (__x, __y);
+ }
+};
+# endif
+
+template<typename _T1, typename _T2>
+inline int
+iseqsig (_T1 __x, _T2 __y) throw ()
+{
+# if __cplusplus >= 201103L
+ typedef decltype (__MATH_EVAL_FMT2 (__x, __y)) _T3;
+# else
+ typedef __typeof (__MATH_EVAL_FMT2 (__x, __y)) _T3;
+# endif
+ return __iseqsig_type<_T3>::__call (__x, __y);
+}
+
+} /* extern "C++" */
+# endif /* __cplusplus */
+
+#endif
+
+__END_DECLS
+
+
+#endif /* math.h */
projects / cross.git / blobdiff