1557 lines
52 KiB
C++
1557 lines
52 KiB
C++
/* 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 */
|