设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 技术交流 › C\C++交流 › 新手求助
返回列表 发新帖
查看: 2260|回复: 9

[已解决]新手求助

[复制链接]
mjl455
发表于 2022-11-15 21:24:44 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x
请根据圆的半径计算圆的面积。圆周率π使用math库导入，并将其不四舍五入保留4位小数（直接截取π的4位小数）。

输入格式:
请输入一个数值，可以是整数或者小数。

输出格式:
输出计算的圆面积，
第一行直接输出结果
第二行只输出两位小数

输入样例:
25
输出样例:
1963.4375000000002
1963.44
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
Python (pypy3)

最佳答案
月排行榜 / 总排行榜
人造人
2022-11-15 21:32:25
mjl455 发表于 2022-11-15 21:27
import math

a=25
  1. >>> import math
  2. >>> math.pi
  3. 3.141592653589793
  4. >>> type(math.pi)
  5. <class 'float'>
  6. >>> str(math.pi)
  7. '3.141592653589793'
  8. >>> str(math.pi)[:5]
  9. '3.141'
  10. >>> str(math.pi)[:6]
  11. '3.1415'
  12. >>> float(str(math.pi)[:6])
  13. 3.1415
  14. >>>
复制代码
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复

使用道具 举报

mjl455
 楼主| 发表于 2022-11-15 21:27:25 | 显示全部楼层
import math

a=25
c=math.pi*a*a
print(c)
print('%.2f'%c)这个Π怎么保留四位小数
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

人造人
发表于 2022-11-15 21:32:25 | 显示全部楼层    本楼为最佳答案   
mjl455 发表于 2022-11-15 21:27
import math

a=25
  1. >>> import math
  2. >>> math.pi
  3. 3.141592653589793
  4. >>> type(math.pi)
  5. <class 'float'>
  6. >>> str(math.pi)
  7. '3.141592653589793'
  8. >>> str(math.pi)[:5]
  9. '3.141'
  10. >>> str(math.pi)[:6]
  11. '3.1415'
  12. >>> float(str(math.pi)[:6])
  13. 3.1415
  14. >>>
复制代码
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

两手空空儿
发表于 2022-11-15 21:41:19 | 显示全部楼层
这~~是C么？  我完了，看不懂！~~~~
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

jhq999
发表于 2022-11-15 22:03:49 | 显示全部楼层
两手空空儿 发表于 2022-11-15 21:41
这~~是C么？  我完了，看不懂！~~~~

python
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

两手空空儿
发表于 2022-11-15 22:13:50 | 显示全部楼层
呼~~~~~~~~~~我还去找了半天math.h，也没找到PI
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

人造人
发表于 2022-11-15 22:49:16 | 显示全部楼层
两手空空儿 发表于 2022-11-15 22:13
呼~~~~~~~~~~我还去找了半天math.h，也没找到PI

C也有

  1. sh-5.1$ ls
  2. main.c
  3. sh-5.1$ cat main.c
  4. #include <stdio.h>
  5. #include <math.h>

  7. int main(void) {
  8.     printf("%f\n", M_PI);
  9.     return 0;
  10. }
  11. sh-5.1$ gcc -g -Wall -o main main.c
  12. sh-5.1$ ls
  13. main  main.c
  14. sh-5.1$ ./main
  15. 3.141593
  16. sh-5.1$
复制代码
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

两手空空儿
发表于 2022-11-16 09:11:00 | 显示全部楼层
人造人 发表于 2022-11-15 22:49
C也有

从哪里能看到完整的.h文件的内容啊，我从网上找的只列出了函数
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

人造人
发表于 2022-11-16 09:26:27 | 显示全部楼层
两手空空儿 发表于 2022-11-16 09:11
从哪里能看到完整的.h文件的内容啊，我从网上找的只列出了函数
  1. sh-5.1$ cat /usr/include/math.h
  2. /* Declarations for math functions.
  3.    Copyright (C) 1991-2022 Free Software Foundation, Inc.
  4.    This file is part of the GNU C Library.

  6.    The GNU C Library is free software; you can redistribute it and/or
  7.    modify it under the terms of the GNU Lesser General Public
  8.    License as published by the Free Software Foundation; either
  9.    version 2.1 of the License, or (at your option) any later version.

  11.    The GNU C Library is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.    Lesser General Public License for more details.

  16.    You should have received a copy of the GNU Lesser General Public
  17.    License along with the GNU C Library; if not, see
  18.    <https://www.gnu.org/licenses/>.  */

  20. /*
  21. *        ISO C99 Standard: 7.12 Mathematics        <math.h>
  22. */

  24. #ifndef        _MATH_H
  25. #define        _MATH_H        1

  27. #define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
  28. #include <bits/libc-header-start.h>

  30. #if defined log && defined __GNUC__
  31. # warning A macro called log was already defined when <math.h> was included.
  32. # warning This will cause compilation problems.
  33. #endif

  35. __BEGIN_DECLS

  37. /* Get definitions of __intmax_t and __uintmax_t.  */
  38. #include <bits/types.h>

  40. /* Get machine-dependent vector math functions declarations.  */
  41. #include <bits/math-vector.h>

  43. /* Gather machine dependent type support.  */
  44. #include <bits/floatn.h>

  46. /* Value returned on overflow.  With IEEE 754 floating point, this is
  47.    +Infinity, otherwise the largest representable positive value.  */
  48. #if __GNUC_PREREQ (3, 3)
  49. # define HUGE_VAL (__builtin_huge_val ())
  50. #else
  51. /* This may provoke compiler warnings, and may not be rounded to
  52.    +Infinity in all IEEE 754 rounding modes, but is the best that can
  53.    be done in ISO C while remaining a constant expression.  10,000 is
  54.    greater than the maximum (decimal) exponent for all supported
  55.    floating-point formats and widths.  */
  56. # define HUGE_VAL 1e10000
  57. #endif
  58. #ifdef __USE_ISOC99
  59. # if __GNUC_PREREQ (3, 3)
  60. #  define HUGE_VALF (__builtin_huge_valf ())
  61. #  define HUGE_VALL (__builtin_huge_vall ())
  62. # else
  63. #  define HUGE_VALF 1e10000f
  64. #  define HUGE_VALL 1e10000L
  65. # endif
  66. #endif
  67. #if __HAVE_FLOAT16 && __GLIBC_USE (IEC_60559_TYPES_EXT)
  68. # define HUGE_VAL_F16 (__builtin_huge_valf16 ())
  69. #endif
  70. #if __HAVE_FLOAT32 && __GLIBC_USE (IEC_60559_TYPES_EXT)
  71. # define HUGE_VAL_F32 (__builtin_huge_valf32 ())
  72. #endif
  73. #if __HAVE_FLOAT64 && __GLIBC_USE (IEC_60559_TYPES_EXT)
  74. # define HUGE_VAL_F64 (__builtin_huge_valf64 ())
  75. #endif
  76. #if __HAVE_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT)
  77. # define HUGE_VAL_F128 (__builtin_huge_valf128 ())
  78. #endif
  79. #if __HAVE_FLOAT32X && __GLIBC_USE (IEC_60559_TYPES_EXT)
  80. # define HUGE_VAL_F32X (__builtin_huge_valf32x ())
  81. #endif
  82. #if __HAVE_FLOAT64X && __GLIBC_USE (IEC_60559_TYPES_EXT)
  83. # define HUGE_VAL_F64X (__builtin_huge_valf64x ())
  84. #endif
  85. #if __HAVE_FLOAT128X && __GLIBC_USE (IEC_60559_TYPES_EXT)
  86. # define HUGE_VAL_F128X (__builtin_huge_valf128x ())
  87. #endif

  89. #ifdef __USE_ISOC99
  90. /* IEEE positive infinity.  */
  91. # if __GNUC_PREREQ (3, 3)
  92. #  define INFINITY (__builtin_inff ())
  93. # else
  94. #  define INFINITY HUGE_VALF
  95. # endif

  97. /* IEEE Not A Number.  */
  98. # if __GNUC_PREREQ (3, 3)
  99. #  define NAN (__builtin_nanf (""))
  100. # else
  101. /* This will raise an "invalid" exception outside static initializers,
  102.    but is the best that can be done in ISO C while remaining a
  103.    constant expression.  */
  104. #  define NAN (0.0f / 0.0f)
  105. # endif
  106. #endif /* __USE_ISOC99 */

  108. #if __GLIBC_USE (IEC_60559_BFP_EXT)
  109. /* Signaling NaN macros, if supported.  */
  110. # if __GNUC_PREREQ (3, 3)
  111. #  define SNANF (__builtin_nansf (""))
  112. #  define SNAN (__builtin_nans (""))
  113. #  define SNANL (__builtin_nansl (""))
  114. # endif
  115. #endif
  116. #if (__HAVE_FLOAT16                                        \
  117.      && __GLIBC_USE (IEC_60559_TYPES_EXT)                \
  118.      && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))
  119. # define SNANF16 (__builtin_nansf16 (""))
  120. #endif
  121. #if (__HAVE_FLOAT32                                        \
  122.      && __GLIBC_USE (IEC_60559_TYPES_EXT)                \
  123.      && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))
  124. # define SNANF32 (__builtin_nansf32 (""))
  125. #endif
  126. #if (__HAVE_FLOAT64                                        \
  127.      && __GLIBC_USE (IEC_60559_TYPES_EXT)                \
  128.      && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))
  129. # define SNANF64 (__builtin_nansf64 (""))
  130. #endif
  131. #if (__HAVE_FLOAT128                                        \
  132.      && __GLIBC_USE (IEC_60559_TYPES_EXT)                \
  133.      && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))
  134. # define SNANF128 (__builtin_nansf128 (""))
  135. #endif
  136. #if (__HAVE_FLOAT32X                                        \
  137.      && __GLIBC_USE (IEC_60559_TYPES_EXT)                \
  138.      && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))
  139. # define SNANF32X (__builtin_nansf32x (""))
  140. #endif
  141. #if (__HAVE_FLOAT64X                                        \
  142.      && __GLIBC_USE (IEC_60559_TYPES_EXT)                \
  143.      && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))
  144. # define SNANF64X (__builtin_nansf64x (""))
  145. #endif
  146. #if (__HAVE_FLOAT128X                                        \
  147.      && __GLIBC_USE (IEC_60559_TYPES_EXT)                \
  148.      && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))
  149. # define SNANF128X (__builtin_nansf128x (""))
  150. #endif

  152. /* Get __GLIBC_FLT_EVAL_METHOD.  */
  153. #include <bits/flt-eval-method.h>

  155. #ifdef __USE_ISOC99
  156. /* Define the following typedefs.

  158.     float_t        floating-point type at least as wide as `float' used
  159.                 to evaluate `float' expressions
  160.     double_t        floating-point type at least as wide as `double' used
  161.                 to evaluate `double' expressions
  162. */
  163. # if __GLIBC_FLT_EVAL_METHOD == 0 || __GLIBC_FLT_EVAL_METHOD == 16
  164. typedef float float_t;
  165. typedef double double_t;
  166. # elif __GLIBC_FLT_EVAL_METHOD == 1
  167. typedef double float_t;
  168. typedef double double_t;
  169. # elif __GLIBC_FLT_EVAL_METHOD == 2
  170. typedef long double float_t;
  171. typedef long double double_t;
  172. # elif __GLIBC_FLT_EVAL_METHOD == 32
  173. typedef _Float32 float_t;
  174. typedef double double_t;
  175. # elif __GLIBC_FLT_EVAL_METHOD == 33
  176. typedef _Float32x float_t;
  177. typedef _Float32x double_t;
  178. # elif __GLIBC_FLT_EVAL_METHOD == 64
  179. typedef _Float64 float_t;
  180. typedef _Float64 double_t;
  181. # elif __GLIBC_FLT_EVAL_METHOD == 65
  182. typedef _Float64x float_t;
  183. typedef _Float64x double_t;
  184. # elif __GLIBC_FLT_EVAL_METHOD == 128
  185. typedef _Float128 float_t;
  186. typedef _Float128 double_t;
  187. # elif __GLIBC_FLT_EVAL_METHOD == 129
  188. typedef _Float128x float_t;
  189. typedef _Float128x double_t;
  190. # else
  191. #  error "Unknown __GLIBC_FLT_EVAL_METHOD"
  192. # endif
  193. #endif

  195. /* Define macros for the return values of ilogb and llogb, based on
  196.    __FP_LOGB0_IS_MIN and __FP_LOGBNAN_IS_MIN.

  198.     FP_ILOGB0        Expands to a value returned by `ilogb (0.0)'.
  199.     FP_ILOGBNAN        Expands to a value returned by `ilogb (NAN)'.
  200.     FP_LLOGB0        Expands to a value returned by `llogb (0.0)'.
  201.     FP_LLOGBNAN        Expands to a value returned by `llogb (NAN)'.

  203. */

  205. #include <bits/fp-logb.h>
  206. #ifdef __USE_ISOC99
  207. # if __FP_LOGB0_IS_MIN
  208. #  define FP_ILOGB0        (-2147483647 - 1)
  209. # else
  210. #  define FP_ILOGB0        (-2147483647)
  211. # endif
  212. # if __FP_LOGBNAN_IS_MIN
  213. #  define FP_ILOGBNAN        (-2147483647 - 1)
  214. # else
  215. #  define FP_ILOGBNAN        2147483647
  216. # endif
  217. #endif
  218. #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
  219. # if __WORDSIZE == 32
  220. #  define __FP_LONG_MAX 0x7fffffffL
  221. # else
  222. #  define __FP_LONG_MAX 0x7fffffffffffffffL
  223. # endif
  224. # if __FP_LOGB0_IS_MIN
  225. #  define FP_LLOGB0        (-__FP_LONG_MAX - 1)
  226. # else
  227. #  define FP_LLOGB0        (-__FP_LONG_MAX)
  228. # endif
  229. # if __FP_LOGBNAN_IS_MIN
  230. #  define FP_LLOGBNAN        (-__FP_LONG_MAX - 1)
  231. # else
  232. #  define FP_LLOGBNAN        __FP_LONG_MAX
  233. # endif
  234. #endif

  236. /* Get the architecture specific values describing the floating-point
  237.    evaluation.  The following symbols will get defined:

  239.     FP_FAST_FMA
  240.     FP_FAST_FMAF
  241.     FP_FAST_FMAL
  242.                 If defined it indicates that the `fma' function
  243.                 generally executes about as fast as a multiply and an add.
  244.                 This macro is defined only iff the `fma' function is
  245.                 implemented directly with a hardware multiply-add instructions.
  246. */

  248. #include <bits/fp-fast.h>

  250. #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
  251. /* Rounding direction macros for fromfp functions.  */
  252. enum
  253.   {
  254.     FP_INT_UPWARD =
  255. # define FP_INT_UPWARD 0
  256.       FP_INT_UPWARD,
  257.     FP_INT_DOWNWARD =
  258. # define FP_INT_DOWNWARD 1
  259.       FP_INT_DOWNWARD,
  260.     FP_INT_TOWARDZERO =
  261. # define FP_INT_TOWARDZERO 2
  262.       FP_INT_TOWARDZERO,
  263.     FP_INT_TONEARESTFROMZERO =
  264. # define FP_INT_TONEARESTFROMZERO 3
  265.       FP_INT_TONEARESTFROMZERO,
  266.     FP_INT_TONEAREST =
  267. # define FP_INT_TONEAREST 4
  268.       FP_INT_TONEAREST,
  269.   };
  270. #endif

  272. /* The file <bits/mathcalls.h> contains the prototypes for all the
  273.    actual math functions.  These macros are used for those prototypes,
  274.    so we can easily declare each function as both `name' and `__name',
  275.    and can declare the float versions `namef' and `__namef'.  */

  277. #define __SIMD_DECL(function) __CONCAT (__DECL_SIMD_, function)

  279. #define __MATHCALL_VEC(function, suffix, args)         \
  280.   __SIMD_DECL (__MATH_PRECNAME (function, suffix)) \
  281.   __MATHCALL (function, suffix, args)

  283. #define __MATHDECL_VEC(type, function,suffix, args) \
  284.   __SIMD_DECL (__MATH_PRECNAME (function, suffix)) \
  285.   __MATHDECL(type, function,suffix, args)

  287. #define __MATHCALL(function,suffix, args)        \
  288.   __MATHDECL (_Mdouble_,function,suffix, args)
  289. #define __MATHDECL(type, function,suffix, args) \
  290.   __MATHDECL_1(type, function,suffix, args); \
  291.   __MATHDECL_1(type, __CONCAT(__,function),suffix, args)
  292. #define __MATHCALLX(function,suffix, args, attrib)        \
  293.   __MATHDECLX (_Mdouble_,function,suffix, args, attrib)
  294. #define __MATHDECLX(type, function,suffix, args, attrib) \
  295.   __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); \
  296.   __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)
  297. #define __MATHDECL_1_IMPL(type, function, suffix, args) \
  298.   extern type __MATH_PRECNAME(function,suffix) args __THROW
  299. #define __MATHDECL_1(type, function, suffix, args) \
  300.   __MATHDECL_1_IMPL(type, function, suffix, args)
  301. /* Ignore the alias by default.  The alias is only useful with
  302.    redirections.  */
  303. #define __MATHDECL_ALIAS(type, function, suffix, args, alias) \
  304.   __MATHDECL_1(type, function, suffix, args)

  306. #define __MATHREDIR(type, function, suffix, args, to) \
  307.   extern type __REDIRECT_NTH (__MATH_PRECNAME (function, suffix), args, to)

  309. #define _Mdouble_                double
  310. #define __MATH_PRECNAME(name,r)        __CONCAT(name,r)
  311. #define __MATH_DECLARING_DOUBLE  1
  312. #define __MATH_DECLARING_FLOATN  0
  313. #include <bits/mathcalls-helper-functions.h>
  314. #include <bits/mathcalls.h>
  315. #undef        _Mdouble_
  316. #undef        __MATH_PRECNAME
  317. #undef __MATH_DECLARING_DOUBLE
  318. #undef __MATH_DECLARING_FLOATN

  320. #ifdef __USE_ISOC99


  323. /* Include the file of declarations again, this time using `float'
  324.    instead of `double' and appending f to each function name.  */

  326. # define _Mdouble_                float
  327. # define __MATH_PRECNAME(name,r) name##f##r
  328. # define __MATH_DECLARING_DOUBLE  0
  329. # define __MATH_DECLARING_FLOATN  0
  330. # include <bits/mathcalls-helper-functions.h>
  331. # include <bits/mathcalls.h>
  332. # undef        _Mdouble_
  333. # undef        __MATH_PRECNAME
  334. # undef __MATH_DECLARING_DOUBLE
  335. # undef __MATH_DECLARING_FLOATN

  337. # if !(defined __NO_LONG_DOUBLE_MATH && defined _LIBC) \
  338.      || defined __LDBL_COMPAT \
  339.      || defined _LIBC_TEST
  340. #  ifdef __LDBL_COMPAT

  342. #   ifdef __USE_ISOC99
  343. extern float __nldbl_nexttowardf (float __x, long double __y)
  344.                                   __THROW __attribute__ ((__const__));
  345. #    ifdef __REDIRECT_NTH
  346. extern float __REDIRECT_NTH (nexttowardf, (float __x, long double __y),
  347.                              __nldbl_nexttowardf)
  348.      __attribute__ ((__const__));
  349. extern double __REDIRECT_NTH (nexttoward, (double __x, long double __y),
  350.                               nextafter) __attribute__ ((__const__));
  351. extern long double __REDIRECT_NTH (nexttowardl,
  352.                                    (long double __x, long double __y),
  353.                                    nextafter) __attribute__ ((__const__));
  354. #    endif
  355. #   endif

  357. #   undef __MATHDECL_1
  358. #   define __MATHDECL_1(type, function,suffix, args) \
  359.   __MATHREDIR(type, function, suffix, args, __CONCAT(function,suffix))

  361. #  elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1
  362. #   ifdef __REDIRECT_NTH
  363. #    ifdef __USE_ISOC99
  364. extern float __REDIRECT_NTH (nexttowardf, (float __x, long double __y),
  365.                             __nexttowardf_to_ieee128)
  366.   __attribute__ ((__const__));
  367. extern double __REDIRECT_NTH (nexttoward, (double __x, long double __y),
  368.                              __nexttoward_to_ieee128)
  369.   __attribute__ ((__const__));

  371. #define __dremieee128 __remainderieee128
  372. #define __gammaieee128 __lgammaieee128

  374. #    endif
  375. #   endif

  377. #   undef __MATHDECL_1
  378. #   undef __MATHDECL_ALIAS

  380. #   define __REDIRTO(function, suffix) \
  381.   __ ## function ## ieee128 ## suffix
  382. #   define __REDIRTO_ALT(function, suffix) \
  383.   __ ## function ## f128 ## suffix

  385. #   define __MATHDECL_1(type, function, suffix, args) \
  386.   __MATHREDIR (type, function, suffix, args, __REDIRTO (function, suffix))
  387. #   define __MATHDECL_ALIAS(type, function, suffix, args, alias) \
  388.   __MATHREDIR (type, function, suffix, args, __REDIRTO_ALT (alias, suffix))
  389. #  endif

  391. /* Include the file of declarations again, this time using `long double'
  392.    instead of `double' and appending l to each function name.  */

  394. #  define _Mdouble_                long double
  395. #  define __MATH_PRECNAME(name,r) name##l##r
  396. #  define __MATH_DECLARING_DOUBLE  0
  397. #  define __MATH_DECLARING_FLOATN  0
  398. #  define __MATH_DECLARE_LDOUBLE   1
  399. #  include <bits/mathcalls-helper-functions.h>
  400. #  include <bits/mathcalls.h>

  402. #  undef _Mdouble_
  403. #  undef __MATH_PRECNAME
  404. #  undef __MATH_DECLARING_DOUBLE
  405. #  undef __MATH_DECLARING_FLOATN

  407. #  if defined __LDBL_COMPAT \
  408.       || __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1
  409. #   undef __REDIRTO
  410. #   undef __REDIRTO_ALT
  411. #   undef __MATHDECL_1
  412. #   undef __MATHDECL_ALIAS
  413. #   define __MATHDECL_1(type, function, suffix, args) \
  414.   __MATHDECL_1_IMPL(type, function, suffix, args)
  415. #   define __MATHDECL_ALIAS(type, function, suffix, args, alias) \
  416.   __MATHDECL_1(type, function, suffix, args)
  417. #  endif
  418. # endif /* !(__NO_LONG_DOUBLE_MATH && _LIBC) || __LDBL_COMPAT */

  420. #endif        /* Use ISO C99.  */

  422. /* Include the file of declarations for _FloatN and _FloatNx
  423.    types.  */

  425. #if __HAVE_DISTINCT_FLOAT16 || (__HAVE_FLOAT16 && !defined _LIBC)
  426. # define _Mdouble_                _Float16
  427. # define __MATH_PRECNAME(name,r) name##f16##r
  428. # define __MATH_DECLARING_DOUBLE  0
  429. # define __MATH_DECLARING_FLOATN  1
  430. # if __HAVE_DISTINCT_FLOAT16
  431. #  include <bits/mathcalls-helper-functions.h>
  432. # endif
  433. # if __GLIBC_USE (IEC_60559_TYPES_EXT)
  434. #  include <bits/mathcalls.h>
  435. # endif
  436. # undef _Mdouble_
  437. # undef __MATH_PRECNAME
  438. # undef __MATH_DECLARING_DOUBLE
  439. # undef __MATH_DECLARING_FLOATN
  440. #endif /* __HAVE_DISTINCT_FLOAT16 || (__HAVE_FLOAT16 && !_LIBC).  */

  442. #if __HAVE_DISTINCT_FLOAT32 || (__HAVE_FLOAT32 && !defined _LIBC)
  443. # define _Mdouble_                _Float32
  444. # define __MATH_PRECNAME(name,r) name##f32##r
  445. # define __MATH_DECLARING_DOUBLE  0
  446. # define __MATH_DECLARING_FLOATN  1
  447. # if __HAVE_DISTINCT_FLOAT32
  448. #  include <bits/mathcalls-helper-functions.h>
  449. # endif
  450. # if __GLIBC_USE (IEC_60559_TYPES_EXT)
  451. #  include <bits/mathcalls.h>
  452. # endif
  453. # undef _Mdouble_
  454. # undef __MATH_PRECNAME
  455. # undef __MATH_DECLARING_DOUBLE
  456. # undef __MATH_DECLARING_FLOATN
  457. #endif /* __HAVE_DISTINCT_FLOAT32 || (__HAVE_FLOAT32 && !_LIBC).  */

  459. #if __HAVE_DISTINCT_FLOAT64 || (__HAVE_FLOAT64 && !defined _LIBC)
  460. # define _Mdouble_                _Float64
  461. # define __MATH_PRECNAME(name,r) name##f64##r
  462. # define __MATH_DECLARING_DOUBLE  0
  463. # define __MATH_DECLARING_FLOATN  1
  464. # if __HAVE_DISTINCT_FLOAT64
  465. #  include <bits/mathcalls-helper-functions.h>
  466. # endif
  467. # if __GLIBC_USE (IEC_60559_TYPES_EXT)
  468. #  include <bits/mathcalls.h>
  469. # endif
  470. # undef _Mdouble_
  471. # undef __MATH_PRECNAME
  472. # undef __MATH_DECLARING_DOUBLE
  473. # undef __MATH_DECLARING_FLOATN
  474. #endif /* __HAVE_DISTINCT_FLOAT64 || (__HAVE_FLOAT64 && !_LIBC).  */

  476. #if __HAVE_DISTINCT_FLOAT128 || (__HAVE_FLOAT128 && !defined _LIBC)
  477. # define _Mdouble_                _Float128
  478. # define __MATH_PRECNAME(name,r) name##f128##r
  479. # define __MATH_DECLARING_DOUBLE  0
  480. # define __MATH_DECLARING_FLOATN  1
  481. # if __HAVE_DISTINCT_FLOAT128
  482. #  include <bits/mathcalls-helper-functions.h>
  483. # endif
  484. # if __GLIBC_USE (IEC_60559_TYPES_EXT)
  485. #  include <bits/mathcalls.h>
  486. # endif
  487. # undef _Mdouble_
  488. # undef __MATH_PRECNAME
  489. # undef __MATH_DECLARING_DOUBLE
  490. # undef __MATH_DECLARING_FLOATN
  491. #endif /* __HAVE_DISTINCT_FLOAT128 || (__HAVE_FLOAT128 && !_LIBC).  */

  493. #if __HAVE_DISTINCT_FLOAT32X || (__HAVE_FLOAT32X && !defined _LIBC)
  494. # define _Mdouble_                _Float32x
  495. # define __MATH_PRECNAME(name,r) name##f32x##r
  496. # define __MATH_DECLARING_DOUBLE  0
  497. # define __MATH_DECLARING_FLOATN  1
  498. # if __HAVE_DISTINCT_FLOAT32X
  499. #  include <bits/mathcalls-helper-functions.h>
  500. # endif
  501. # if __GLIBC_USE (IEC_60559_TYPES_EXT)
  502. #  include <bits/mathcalls.h>
  503. # endif
  504. # undef _Mdouble_
  505. # undef __MATH_PRECNAME
  506. # undef __MATH_DECLARING_DOUBLE
  507. # undef __MATH_DECLARING_FLOATN
  508. #endif /* __HAVE_DISTINCT_FLOAT32X || (__HAVE_FLOAT32X && !_LIBC).  */

  510. #if __HAVE_DISTINCT_FLOAT64X || (__HAVE_FLOAT64X && !defined _LIBC)
  511. # define _Mdouble_                _Float64x
  512. # define __MATH_PRECNAME(name,r) name##f64x##r
  513. # define __MATH_DECLARING_DOUBLE  0
  514. # define __MATH_DECLARING_FLOATN  1
  515. # if __HAVE_DISTINCT_FLOAT64X
  516. #  include <bits/mathcalls-helper-functions.h>
  517. # endif
  518. # if __GLIBC_USE (IEC_60559_TYPES_EXT)
  519. #  include <bits/mathcalls.h>
  520. # endif
  521. # undef _Mdouble_
  522. # undef __MATH_PRECNAME
  523. # undef __MATH_DECLARING_DOUBLE
  524. # undef __MATH_DECLARING_FLOATN
  525. #endif /* __HAVE_DISTINCT_FLOAT64X || (__HAVE_FLOAT64X && !_LIBC).  */

  527. #if __HAVE_DISTINCT_FLOAT128X || (__HAVE_FLOAT128X && !defined _LIBC)
  528. # define _Mdouble_                _Float128x
  529. # define __MATH_PRECNAME(name,r) name##f128x##r
  530. # define __MATH_DECLARING_DOUBLE  0
  531. # define __MATH_DECLARING_FLOATN  1
  532. # if __HAVE_DISTINCT_FLOAT128X
  533. #  include <bits/mathcalls-helper-functions.h>
  534. # endif
  535. # if __GLIBC_USE (IEC_60559_TYPES_EXT)
  536. #  include <bits/mathcalls.h>
  537. # endif
  538. # undef _Mdouble_
  539. # undef __MATH_PRECNAME
  540. # undef __MATH_DECLARING_DOUBLE
  541. # undef __MATH_DECLARING_FLOATN
  542. #endif /* __HAVE_DISTINCT_FLOAT128X || (__HAVE_FLOAT128X && !_LIBC).  */

  544. #undef        __MATHDECL_1_IMPL
  545. #undef        __MATHDECL_1
  546. #undef        __MATHDECL_ALIAS
  547. #undef        __MATHDECL
  548. #undef        __MATHCALL

  550. /* Declare functions returning a narrower type.  */
  551. #define __MATHCALL_NARROW_ARGS_1 (_Marg_ __x)
  552. #define __MATHCALL_NARROW_ARGS_2 (_Marg_ __x, _Marg_ __y)
  553. #define __MATHCALL_NARROW_ARGS_3 (_Marg_ __x, _Marg_ __y, _Marg_ __z)
  554. #define __MATHCALL_NARROW_NORMAL(func, nargs)                        \
  555.   extern _Mret_ func __MATHCALL_NARROW_ARGS_ ## nargs __THROW
  556. #define __MATHCALL_NARROW_REDIR(func, redir, nargs)                        \
  557.   extern _Mret_ __REDIRECT_NTH (func, __MATHCALL_NARROW_ARGS_ ## nargs, \
  558.                                 redir)
  559. #define __MATHCALL_NARROW(func, redir, nargs)        \
  560.   __MATHCALL_NARROW_NORMAL (func, nargs)

  562. #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)

  564. # define _Mret_ float
  565. # define _Marg_ double
  566. # define __MATHCALL_NAME(name) f ## name
  567. # include <bits/mathcalls-narrow.h>
  568. # undef _Mret_
  569. # undef _Marg_
  570. # undef __MATHCALL_NAME

  572. # define _Mret_ float
  573. # define _Marg_ long double
  574. # define __MATHCALL_NAME(name) f ## name ## l
  575. # ifdef __LDBL_COMPAT
  576. #  define __MATHCALL_REDIR_NAME(name) f ## name
  577. #  define __MATHCALL_REDIR_NAME2(name) f ## name
  578. #  undef __MATHCALL_NARROW
  579. #  define __MATHCALL_NARROW(func, redir, nargs) \
  580.   __MATHCALL_NARROW_REDIR (func, redir, nargs)
  581. # elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1
  582. #  define __MATHCALL_REDIR_NAME(name) __ ## f32 ## name ## ieee128
  583. #  define __MATHCALL_REDIR_NAME2(name) __ ## f32 ## name ## ieee128
  584. #  undef __MATHCALL_NARROW
  585. #  define __MATHCALL_NARROW(func, redir, nargs) \
  586.   __MATHCALL_NARROW_REDIR (func, redir, nargs)
  587. # endif
  588. # include <bits/mathcalls-narrow.h>
  589. # undef _Mret_
  590. # undef _Marg_
  591. # undef __MATHCALL_NAME
  592. # if defined __LDBL_COMPAT \
  593.      || __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1
  594. #  undef __MATHCALL_REDIR_NAME
  595. #  undef __MATHCALL_REDIR_NAME2
  596. #  undef __MATHCALL_NARROW
  597. #  define __MATHCALL_NARROW(func, redir, nargs) \
  598.   __MATHCALL_NARROW_NORMAL (func, nargs)
  599. # endif

  601. # define _Mret_ double
  602. # define _Marg_ long double
  603. # define __MATHCALL_NAME(name) d ## name ## l
  604. # ifdef __LDBL_COMPAT
  605. #  define __MATHCALL_REDIR_NAME(name) __nldbl_d ## name ## l
  606. #  define __MATHCALL_REDIR_NAME2(name) name
  607. #  undef __MATHCALL_NARROW
  608. #  define __MATHCALL_NARROW(func, redir, nargs) \
  609.   __MATHCALL_NARROW_REDIR (func, redir, nargs)
  610. # elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1
  611. #  define __MATHCALL_REDIR_NAME(name) __ ## f64 ## name ## ieee128
  612. #  define __MATHCALL_REDIR_NAME2(name) __ ## f64 ## name ## ieee128
  613. #  undef __MATHCALL_NARROW
  614. #  define __MATHCALL_NARROW(func, redir, nargs) \
  615.   __MATHCALL_NARROW_REDIR (func, redir, nargs)
  616. # endif
  617. # include <bits/mathcalls-narrow.h>
  618. # undef _Mret_
  619. # undef _Marg_
  620. # undef __MATHCALL_NAME
  621. # if defined __LDBL_COMPAT \
  622.      || __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1
  623. #  undef __MATHCALL_REDIR_NAME
  624. #  undef __MATHCALL_REDIR_NAME2
  625. #  undef __MATHCALL_NARROW
  626. #  define __MATHCALL_NARROW(func, redir, nargs) \
  627.   __MATHCALL_NARROW_NORMAL (func, nargs)
  628. # endif

  630. #endif

  632. #if __GLIBC_USE (IEC_60559_TYPES_EXT)

  634. # if __HAVE_FLOAT16 && __HAVE_FLOAT32
  635. #  define _Mret_ _Float16
  636. #  define _Marg_ _Float32
  637. #  define __MATHCALL_NAME(name) f16 ## name ## f32
  638. #  include <bits/mathcalls-narrow.h>
  639. #  undef _Mret_
  640. #  undef _Marg_
  641. #  undef __MATHCALL_NAME
  642. # endif

  644. # if __HAVE_FLOAT16 && __HAVE_FLOAT32X
  645. #  define _Mret_ _Float16
  646. #  define _Marg_ _Float32x
  647. #  define __MATHCALL_NAME(name) f16 ## name ## f32x
  648. #  include <bits/mathcalls-narrow.h>
  649. #  undef _Mret_
  650. #  undef _Marg_
  651. #  undef __MATHCALL_NAME
  652. # endif

  654. # if __HAVE_FLOAT16 && __HAVE_FLOAT64
  655. #  define _Mret_ _Float16
  656. #  define _Marg_ _Float64
  657. #  define __MATHCALL_NAME(name) f16 ## name ## f64
  658. #  include <bits/mathcalls-narrow.h>
  659. #  undef _Mret_
  660. #  undef _Marg_
  661. #  undef __MATHCALL_NAME
  662. # endif

  664. # if __HAVE_FLOAT16 && __HAVE_FLOAT64X
  665. #  define _Mret_ _Float16
  666. #  define _Marg_ _Float64x
  667. #  define __MATHCALL_NAME(name) f16 ## name ## f64x
  668. #  include <bits/mathcalls-narrow.h>
  669. #  undef _Mret_
  670. #  undef _Marg_
  671. #  undef __MATHCALL_NAME
  672. # endif

  674. # if __HAVE_FLOAT16 && __HAVE_FLOAT128
  675. #  define _Mret_ _Float16
  676. #  define _Marg_ _Float128
  677. #  define __MATHCALL_NAME(name) f16 ## name ## f128
  678. #  include <bits/mathcalls-narrow.h>
  679. #  undef _Mret_
  680. #  undef _Marg_
  681. #  undef __MATHCALL_NAME
  682. # endif

  684. # if __HAVE_FLOAT16 && __HAVE_FLOAT128X
  685. #  define _Mret_ _Float16
  686. #  define _Marg_ _Float128x
  687. #  define __MATHCALL_NAME(name) f16 ## name ## f128x
  688. #  include <bits/mathcalls-narrow.h>
  689. #  undef _Mret_
  690. #  undef _Marg_
  691. #  undef __MATHCALL_NAME
  692. # endif

  694. # if __HAVE_FLOAT32 && __HAVE_FLOAT32X
  695. #  define _Mret_ _Float32
  696. #  define _Marg_ _Float32x
  697. #  define __MATHCALL_NAME(name) f32 ## name ## f32x
  698. #  include <bits/mathcalls-narrow.h>
  699. #  undef _Mret_
  700. #  undef _Marg_
  701. #  undef __MATHCALL_NAME
  702. # endif

  704. # if __HAVE_FLOAT32 && __HAVE_FLOAT64
  705. #  define _Mret_ _Float32
  706. #  define _Marg_ _Float64
  707. #  define __MATHCALL_NAME(name) f32 ## name ## f64
  708. #  include <bits/mathcalls-narrow.h>
  709. #  undef _Mret_
  710. #  undef _Marg_
  711. #  undef __MATHCALL_NAME
  712. # endif

  714. # if __HAVE_FLOAT32 && __HAVE_FLOAT64X
  715. #  define _Mret_ _Float32
  716. #  define _Marg_ _Float64x
  717. #  define __MATHCALL_NAME(name) f32 ## name ## f64x
  718. #  include <bits/mathcalls-narrow.h>
  719. #  undef _Mret_
  720. #  undef _Marg_
  721. #  undef __MATHCALL_NAME
  722. # endif

  724. # if __HAVE_FLOAT32 && __HAVE_FLOAT128
  725. #  define _Mret_ _Float32
  726. #  define _Marg_ _Float128
  727. #  define __MATHCALL_NAME(name) f32 ## name ## f128
  728. #  include <bits/mathcalls-narrow.h>
  729. #  undef _Mret_
  730. #  undef _Marg_
  731. #  undef __MATHCALL_NAME
  732. # endif

  734. # if __HAVE_FLOAT32 && __HAVE_FLOAT128X
  735. #  define _Mret_ _Float32
  736. #  define _Marg_ _Float128x
  737. #  define __MATHCALL_NAME(name) f32 ## name ## f128x
  738. #  include <bits/mathcalls-narrow.h>
  739. #  undef _Mret_
  740. #  undef _Marg_
  741. #  undef __MATHCALL_NAME
  742. # endif

  744. # if __HAVE_FLOAT32X && __HAVE_FLOAT64
  745. #  define _Mret_ _Float32x
  746. #  define _Marg_ _Float64
  747. #  define __MATHCALL_NAME(name) f32x ## name ## f64
  748. #  include <bits/mathcalls-narrow.h>
  749. #  undef _Mret_
  750. #  undef _Marg_
  751. #  undef __MATHCALL_NAME
  752. # endif

  754. # if __HAVE_FLOAT32X && __HAVE_FLOAT64X
  755. #  define _Mret_ _Float32x
  756. #  define _Marg_ _Float64x
  757. #  define __MATHCALL_NAME(name) f32x ## name ## f64x
  758. #  include <bits/mathcalls-narrow.h>
  759. #  undef _Mret_
  760. #  undef _Marg_
  761. #  undef __MATHCALL_NAME
  762. # endif

  764. # if __HAVE_FLOAT32X && __HAVE_FLOAT128
  765. #  define _Mret_ _Float32x
  766. #  define _Marg_ _Float128
  767. #  define __MATHCALL_NAME(name) f32x ## name ## f128
  768. #  include <bits/mathcalls-narrow.h>
  769. #  undef _Mret_
  770. #  undef _Marg_
  771. #  undef __MATHCALL_NAME
  772. # endif

  774. # if __HAVE_FLOAT32X && __HAVE_FLOAT128X
  775. #  define _Mret_ _Float32x
  776. #  define _Marg_ _Float128x
  777. #  define __MATHCALL_NAME(name) f32x ## name ## f128x
  778. #  include <bits/mathcalls-narrow.h>
  779. #  undef _Mret_
  780. #  undef _Marg_
  781. #  undef __MATHCALL_NAME
  782. # endif

  784. # if __HAVE_FLOAT64 && __HAVE_FLOAT64X
  785. #  define _Mret_ _Float64
  786. #  define _Marg_ _Float64x
  787. #  define __MATHCALL_NAME(name) f64 ## name ## f64x
  788. #  include <bits/mathcalls-narrow.h>
  789. #  undef _Mret_
  790. #  undef _Marg_
  791. #  undef __MATHCALL_NAME
  792. # endif

  794. # if __HAVE_FLOAT64 && __HAVE_FLOAT128
  795. #  define _Mret_ _Float64
  796. #  define _Marg_ _Float128
  797. #  define __MATHCALL_NAME(name) f64 ## name ## f128
  798. #  include <bits/mathcalls-narrow.h>
  799. #  undef _Mret_
  800. #  undef _Marg_
  801. #  undef __MATHCALL_NAME
  802. # endif

  804. # if __HAVE_FLOAT64 && __HAVE_FLOAT128X
  805. #  define _Mret_ _Float64
  806. #  define _Marg_ _Float128x
  807. #  define __MATHCALL_NAME(name) f64 ## name ## f128x
  808. #  include <bits/mathcalls-narrow.h>
  809. #  undef _Mret_
  810. #  undef _Marg_
  811. #  undef __MATHCALL_NAME
  812. # endif

  814. # if __HAVE_FLOAT64X && __HAVE_FLOAT128
  815. #  define _Mret_ _Float64x
  816. #  define _Marg_ _Float128
  817. #  define __MATHCALL_NAME(name) f64x ## name ## f128
  818. #  include <bits/mathcalls-narrow.h>
  819. #  undef _Mret_
  820. #  undef _Marg_
  821. #  undef __MATHCALL_NAME
  822. # endif

  824. # if __HAVE_FLOAT64X && __HAVE_FLOAT128X
  825. #  define _Mret_ _Float64x
  826. #  define _Marg_ _Float128x
  827. #  define __MATHCALL_NAME(name) f64x ## name ## f128x
  828. #  include <bits/mathcalls-narrow.h>
  829. #  undef _Mret_
  830. #  undef _Marg_
  831. #  undef __MATHCALL_NAME
  832. # endif

  834. # if __HAVE_FLOAT128 && __HAVE_FLOAT128X
  835. #  define _Mret_ _Float128
  836. #  define _Marg_ _Float128x
  837. #  define __MATHCALL_NAME(name) f128 ## name ## f128x
  838. #  include <bits/mathcalls-narrow.h>
  839. #  undef _Mret_
  840. #  undef _Marg_
  841. #  undef __MATHCALL_NAME
  842. # endif

  844. #endif

  846. #undef __MATHCALL_NARROW_ARGS_1
  847. #undef __MATHCALL_NARROW_ARGS_2
  848. #undef __MATHCALL_NARROW_ARGS_3
  849. #undef __MATHCALL_NARROW_NORMAL
  850. #undef __MATHCALL_NARROW_REDIR
  851. #undef __MATHCALL_NARROW

  853. #if defined __USE_MISC || defined __USE_XOPEN
  854. /* This variable is used by `gamma' and `lgamma'.  */
  855. extern int signgam;
  856. #endif

  858. #if (__HAVE_DISTINCT_FLOAT16                        \
  859.      || __HAVE_DISTINCT_FLOAT32                        \
  860.      || __HAVE_DISTINCT_FLOAT64                        \
  861.      || __HAVE_DISTINCT_FLOAT32X                \
  862.      || __HAVE_DISTINCT_FLOAT64X                \
  863.      || __HAVE_DISTINCT_FLOAT128X)
  864. # error "Unsupported _FloatN or _FloatNx types for <math.h>."
  865. #endif

  867. /* Depending on the type of TG_ARG, call an appropriately suffixed
  868.    version of FUNC with arguments (including parentheses) ARGS.
  869.    Suffixed functions may not exist for long double if it has the same
  870.    format as double, or for other types with the same format as float,
  871.    double or long double.  The behavior is undefined if the argument
  872.    does not have a real floating type.  The definition may use a
  873.    conditional expression, so all suffixed versions of FUNC must
  874.    return the same type (FUNC may include a cast if necessary rather
  875.    than being a single identifier).  */
  876. #ifdef __NO_LONG_DOUBLE_MATH
  877. # if __HAVE_DISTINCT_FLOAT128
  878. #  error "Distinct _Float128 without distinct long double not supported."
  879. # endif
  880. # define __MATH_TG(TG_ARG, FUNC, ARGS)                                        \
  881.   (sizeof (TG_ARG) == sizeof (float) ? FUNC ## f ARGS : FUNC ARGS)
  882. #elif __HAVE_DISTINCT_FLOAT128
  883. # if __HAVE_GENERIC_SELECTION
  884. #  if __HAVE_FLOATN_NOT_TYPEDEF && __HAVE_FLOAT32
  885. #   define __MATH_TG_F32(FUNC, ARGS) _Float32: FUNC ## f ARGS,
  886. #  else
  887. #   define __MATH_TG_F32(FUNC, ARGS)
  888. #  endif
  889. #  if __HAVE_FLOATN_NOT_TYPEDEF && __HAVE_FLOAT64X
  890. #   if __HAVE_FLOAT64X_LONG_DOUBLE
  891. #    define __MATH_TG_F64X(FUNC, ARGS) _Float64x: FUNC ## l ARGS,
  892. #   else
  893. #    define __MATH_TG_F64X(FUNC, ARGS) _Float64x: FUNC ## f128 ARGS,
  894. #   endif
  895. #  else
  896. #   define __MATH_TG_F64X(FUNC, ARGS)
  897. #  endif
  898. #  define __MATH_TG(TG_ARG, FUNC, ARGS)        \
  899.      _Generic ((TG_ARG),                        \
  900.                float: FUNC ## f ARGS,                \
  901.                __MATH_TG_F32 (FUNC, ARGS)        \
  902.                default: FUNC ARGS,                \
  903.                long double: FUNC ## l ARGS,        \
  904.                __MATH_TG_F64X (FUNC, ARGS)        \
  905.                _Float128: FUNC ## f128 ARGS)
  906. # else
  907. #  if __HAVE_FLOATN_NOT_TYPEDEF
  908. #   error "Non-typedef _FloatN but no _Generic."
  909. #  endif
  910. #  define __MATH_TG(TG_ARG, FUNC, ARGS)                                        \
  911.      __builtin_choose_expr                                                \
  912.      (__builtin_types_compatible_p (__typeof (TG_ARG), float),                \
  913.       FUNC ## f ARGS,                                                        \
  914.       __builtin_choose_expr                                                \
  915.       (__builtin_types_compatible_p (__typeof (TG_ARG), double),        \
  916.        FUNC ARGS,                                                        \
  917.        __builtin_choose_expr                                                \
  918.        (__builtin_types_compatible_p (__typeof (TG_ARG), long double),        \
  919.         FUNC ## l ARGS,                                                        \
  920.         FUNC ## f128 ARGS)))
  921. # endif
  922. #else
  923. # define __MATH_TG(TG_ARG, FUNC, ARGS)                \
  924.   (sizeof (TG_ARG) == sizeof (float)                \
  925.    ? FUNC ## f ARGS                                \
  926.    : sizeof (TG_ARG) == sizeof (double)                \
  927.    ? FUNC ARGS                                        \
  928.    : FUNC ## l ARGS)
  929. #endif

  931. /* ISO C99 defines some generic macros which work on any data type.  */
  932. #ifdef __USE_ISOC99

  934. /* All floating-point numbers can be put in one of these categories.  */
  935. enum
  936.   {
  937.     FP_NAN =
  938. # define FP_NAN 0
  939.       FP_NAN,
  940.     FP_INFINITE =
  941. # define FP_INFINITE 1
  942.       FP_INFINITE,
  943.     FP_ZERO =
  944. # define FP_ZERO 2
  945.       FP_ZERO,
  946.     FP_SUBNORMAL =
  947. # define FP_SUBNORMAL 3
  948.       FP_SUBNORMAL,
  949.     FP_NORMAL =
  950. # define FP_NORMAL 4
  951.       FP_NORMAL
  952.   };

  954. /* GCC bug 66462 means we cannot use the math builtins with -fsignaling-nan,
  955.    so disable builtins if this is enabled.  When fixed in a newer GCC,
  956.    the __SUPPORT_SNAN__ check may be skipped for those versions.  */

  958. /* Return number of classification appropriate for X.  */
  959. # if ((__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__)                      \
  960.       || __glibc_clang_prereq (2,8))                                              \
  961.      && (!defined __OPTIMIZE_SIZE__ || defined __cplusplus)
  962.      /* The check for __cplusplus allows the use of the builtin, even
  963.         when optimization for size is on.  This is provided for
  964.         libstdc++, only to let its configure test work when it is built
  965.         with -Os.  No further use of this definition of fpclassify is
  966.         expected in C++ mode, since libstdc++ provides its own version
  967.         of fpclassify in cmath (which undefines fpclassify).  */
  968. #  define fpclassify(x) __builtin_fpclassify (FP_NAN, FP_INFINITE,              \
  969.      FP_NORMAL, FP_SUBNORMAL, FP_ZERO, x)
  970. # else
  971. #  define fpclassify(x) __MATH_TG ((x), __fpclassify, (x))
  972. # endif

  974. /* Return nonzero value if sign of X is negative.  */
  975. # if __GNUC_PREREQ (6,0) || __glibc_clang_prereq (3,3)
  976. #  define signbit(x) __builtin_signbit (x)
  977. # elif defined __cplusplus
  978.   /* In C++ mode, __MATH_TG cannot be used, because it relies on
  979.      __builtin_types_compatible_p, which is a C-only builtin.
  980.      The check for __cplusplus allows the use of the builtin instead of
  981.      __MATH_TG. This is provided for libstdc++, only to let its configure
  982.      test work. No further use of this definition of signbit is expected
  983.      in C++ mode, since libstdc++ provides its own version of signbit
  984.      in cmath (which undefines signbit). */
  985. #  define signbit(x) __builtin_signbitl (x)
  986. # elif __GNUC_PREREQ (4,0)
  987. #  define signbit(x) __MATH_TG ((x), __builtin_signbit, (x))
  988. # else
  989. #  define signbit(x) __MATH_TG ((x), __signbit, (x))
  990. # endif

  992. /* Return nonzero value if X is not +-Inf or NaN.  */
  993. # if (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__) \
  994.      || __glibc_clang_prereq (2,8)
  995. #  define isfinite(x) __builtin_isfinite (x)
  996. # else
  997. #  define isfinite(x) __MATH_TG ((x), __finite, (x))
  998. # endif

  1000. /* Return nonzero value if X is neither zero, subnormal, Inf, nor NaN.  */
  1001. # if (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__) \
  1002.      || __glibc_clang_prereq (2,8)
  1003. #  define isnormal(x) __builtin_isnormal (x)
  1004. # else
  1005. #  define isnormal(x) (fpclassify (x) == FP_NORMAL)
  1006. # endif

  1008. /* Return nonzero value if X is a NaN.  We could use `fpclassify' but
  1009.    we already have this functions `__isnan' and it is faster.  */
  1010. # if (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__) \
  1011.      || __glibc_clang_prereq (2,8)
  1012. #  define isnan(x) __builtin_isnan (x)
  1013. # else
  1014. #  define isnan(x) __MATH_TG ((x), __isnan, (x))
  1015. # endif

  1017. /* Return nonzero value if X is positive or negative infinity.  */
  1018. # if __HAVE_DISTINCT_FLOAT128 && !__GNUC_PREREQ (7,0) \
  1019.      && !defined __SUPPORT_SNAN__ && !defined __cplusplus
  1020.    /* Since __builtin_isinf_sign is broken for float128 before GCC 7.0,
  1021.       use the helper function, __isinff128, with older compilers.  This is
  1022.       only provided for C mode, because in C++ mode, GCC has no support
  1023.       for __builtin_types_compatible_p (and when in C++ mode, this macro is
  1024.       not used anyway, because libstdc++ headers undefine it).  */
  1025. #  define isinf(x) \
  1026.     (__builtin_types_compatible_p (__typeof (x), _Float128) \
  1027.      ? __isinff128 (x) : __builtin_isinf_sign (x))
  1028. # elif (__GNUC_PREREQ (4,4) && !defined __SUPPORT_SNAN__) \
  1029.        || __glibc_clang_prereq (3,7)
  1030. #  define isinf(x) __builtin_isinf_sign (x)
  1031. # else
  1032. #  define isinf(x) __MATH_TG ((x), __isinf, (x))
  1033. # endif

  1035. /* Bitmasks for the math_errhandling macro.  */
  1036. # define MATH_ERRNO        1        /* errno set by math functions.  */
  1037. # define MATH_ERREXCEPT        2        /* Exceptions raised by math functions.  */

  1039. /* By default all math functions support both errno and exception handling
  1040.    (except for soft floating point implementations which may only support
  1041.    errno handling).  If errno handling is disabled, exceptions are still
  1042.    supported by GLIBC.  Set math_errhandling to 0 with -ffast-math (this is
  1043.    nonconforming but it is more useful than leaving it undefined).  */
  1044. # ifdef __FAST_MATH__
  1045. #  define math_errhandling        0
  1046. # elif defined __NO_MATH_ERRNO__
  1047. #  define math_errhandling        (MATH_ERREXCEPT)
  1048. # else
  1049. #  define math_errhandling        (MATH_ERRNO | MATH_ERREXCEPT)
  1050. # endif

  1052. #endif /* Use ISO C99.  */

  1054. #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
  1055. # include <bits/iscanonical.h>

  1057. /* Return nonzero value if X is a signaling NaN.  */
  1058. # ifndef __cplusplus
  1059. #  define issignaling(x) __MATH_TG ((x), __issignaling, (x))
  1060. # else
  1061.    /* In C++ mode, __MATH_TG cannot be used, because it relies on
  1062.       __builtin_types_compatible_p, which is a C-only builtin.  On the
  1063.       other hand, overloading provides the means to distinguish between
  1064.       the floating-point types.  The overloading resolution will match
  1065.       the correct parameter (regardless of type qualifiers (i.e.: const
  1066.       and volatile)).  */
  1067. extern "C++" {
  1068. inline int issignaling (float __val) { return __issignalingf (__val); }
  1069. inline int issignaling (double __val) { return __issignaling (__val); }
  1070. inline int
  1071. issignaling (long double __val)
  1072. {
  1073. #  ifdef __NO_LONG_DOUBLE_MATH
  1074.   return __issignaling (__val);
  1075. #  else
  1076.   return __issignalingl (__val);
  1077. #  endif
  1078. }
  1079. #  if __HAVE_FLOAT128_UNLIKE_LDBL
  1080. /* When using an IEEE 128-bit long double, _Float128 is defined as long double
  1081.    in C++.  */
  1082. inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); }
  1083. #  endif
  1084. } /* extern C++ */
  1085. # endif

  1087. /* Return nonzero value if X is subnormal.  */
  1088. # define issubnormal(x) (fpclassify (x) == FP_SUBNORMAL)

  1090. /* Return nonzero value if X is zero.  */
  1091. # ifndef __cplusplus
  1092. #  ifdef __SUPPORT_SNAN__
  1093. #   define iszero(x) (fpclassify (x) == FP_ZERO)
  1094. #  else
  1095. #   define iszero(x) (((__typeof (x)) (x)) == 0)
  1096. #  endif
  1097. # else        /* __cplusplus */
  1098. extern "C++" {
  1099. #  ifdef __SUPPORT_SNAN__
  1100. inline int
  1101. iszero (float __val)
  1102. {
  1103.   return __fpclassifyf (__val) == FP_ZERO;
  1104. }
  1105. inline int
  1106. iszero (double __val)
  1107. {
  1108.   return __fpclassify (__val) == FP_ZERO;
  1109. }
  1110. inline int
  1111. iszero (long double __val)
  1112. {
  1113. #   ifdef __NO_LONG_DOUBLE_MATH
  1114.   return __fpclassify (__val) == FP_ZERO;
  1115. #   else
  1116.   return __fpclassifyl (__val) == FP_ZERO;
  1117. #   endif
  1118. }
  1119. #   if __HAVE_FLOAT128_UNLIKE_LDBL
  1120.   /* When using an IEEE 128-bit long double, _Float128 is defined as long double
  1121.      in C++.  */
  1122. inline int
  1123. iszero (_Float128 __val)
  1124. {
  1125.   return __fpclassifyf128 (__val) == FP_ZERO;
  1126. }
  1127. #   endif
  1128. #  else
  1129. template <class __T> inline bool
  1130. iszero (__T __val)
  1131. {
  1132.   return __val == 0;
  1133. }
  1134. #  endif
  1135. } /* extern C++ */
  1136. # endif        /* __cplusplus */
  1137. #endif /* Use IEC_60559_BFP_EXT.  */

  1139. #ifdef __USE_XOPEN
  1140. /* X/Open wants another strange constant.  */
  1141. # define MAXFLOAT        3.40282347e+38F
  1142. #endif


  1145. /* Some useful constants.  */
  1146. #if defined __USE_MISC || defined __USE_XOPEN
  1147. # define M_E                2.7182818284590452354        /* e */
  1148. # define M_LOG2E        1.4426950408889634074        /* log_2 e */
  1149. # define M_LOG10E        0.43429448190325182765        /* log_10 e */
  1150. # define M_LN2                0.69314718055994530942        /* log_e 2 */
  1151. # define M_LN10                2.30258509299404568402        /* log_e 10 */
  1152. # define M_PI                3.14159265358979323846        /* pi */
  1153. # define M_PI_2                1.57079632679489661923        /* pi/2 */
  1154. # define M_PI_4                0.78539816339744830962        /* pi/4 */
  1155. # define M_1_PI                0.31830988618379067154        /* 1/pi */
  1156. # define M_2_PI                0.63661977236758134308        /* 2/pi */
  1157. # define M_2_SQRTPI        1.12837916709551257390        /* 2/sqrt(pi) */
  1158. # define M_SQRT2        1.41421356237309504880        /* sqrt(2) */
  1159. # define M_SQRT1_2        0.70710678118654752440        /* 1/sqrt(2) */
  1160. #endif

  1162. /* GNU extension to provide float constants with similar names.  */
  1163. #ifdef __USE_GNU
  1164. # define M_Ef                2.7182818284590452354f        /* e */
  1165. # define M_LOG2Ef        1.4426950408889634074f        /* log_2 e */
  1166. # define M_LOG10Ef        0.43429448190325182765f        /* log_10 e */
  1167. # define M_LN2f                0.69314718055994530942f        /* log_e 2 */
  1168. # define M_LN10f        2.30258509299404568402f        /* log_e 10 */
  1169. # define M_PIf                3.14159265358979323846f        /* pi */
  1170. # define M_PI_2f        1.57079632679489661923f        /* pi/2 */
  1171. # define M_PI_4f        0.78539816339744830962f        /* pi/4 */
  1172. # define M_1_PIf        0.31830988618379067154f        /* 1/pi */
  1173. # define M_2_PIf        0.63661977236758134308f        /* 2/pi */
  1174. # define M_2_SQRTPIf        1.12837916709551257390f        /* 2/sqrt(pi) */
  1175. # define M_SQRT2f        1.41421356237309504880f        /* sqrt(2) */
  1176. # define M_SQRT1_2f        0.70710678118654752440f        /* 1/sqrt(2) */
  1177. #endif

  1179. /* The above constants are not adequate for computation using `long double's.
  1180.    Therefore we provide as an extension constants with similar names as a
  1181.    GNU extension.  Provide enough digits for the 128-bit IEEE quad.  */
  1182. #ifdef __USE_GNU
  1183. # define M_El                2.718281828459045235360287471352662498L /* e */
  1184. # define M_LOG2El        1.442695040888963407359924681001892137L /* log_2 e */
  1185. # define M_LOG10El        0.434294481903251827651128918916605082L /* log_10 e */
  1186. # define M_LN2l                0.693147180559945309417232121458176568L /* log_e 2 */
  1187. # define M_LN10l        2.302585092994045684017991454684364208L /* log_e 10 */
  1188. # define M_PIl                3.141592653589793238462643383279502884L /* pi */
  1189. # define M_PI_2l        1.570796326794896619231321691639751442L /* pi/2 */
  1190. # define M_PI_4l        0.785398163397448309615660845819875721L /* pi/4 */
  1191. # define M_1_PIl        0.318309886183790671537767526745028724L /* 1/pi */
  1192. # define M_2_PIl        0.636619772367581343075535053490057448L /* 2/pi */
  1193. # define M_2_SQRTPIl        1.128379167095512573896158903121545172L /* 2/sqrt(pi) */
  1194. # define M_SQRT2l        1.414213562373095048801688724209698079L /* sqrt(2) */
  1195. # define M_SQRT1_2l        0.707106781186547524400844362104849039L /* 1/sqrt(2) */
  1196. #endif

  1198. #if __HAVE_FLOAT16 && defined __USE_GNU
  1199. # define M_Ef16                __f16 (2.718281828459045235360287471352662498) /* e */
  1200. # define M_LOG2Ef16        __f16 (1.442695040888963407359924681001892137) /* log_2 e */
  1201. # define M_LOG10Ef16        __f16 (0.434294481903251827651128918916605082) /* log_10 e */
  1202. # define M_LN2f16        __f16 (0.693147180559945309417232121458176568) /* log_e 2 */
  1203. # define M_LN10f16        __f16 (2.302585092994045684017991454684364208) /* log_e 10 */
  1204. # define M_PIf16        __f16 (3.141592653589793238462643383279502884) /* pi */
  1205. # define M_PI_2f16        __f16 (1.570796326794896619231321691639751442) /* pi/2 */
  1206. # define M_PI_4f16        __f16 (0.785398163397448309615660845819875721) /* pi/4 */
  1207. # define M_1_PIf16        __f16 (0.318309886183790671537767526745028724) /* 1/pi */
  1208. # define M_2_PIf16        __f16 (0.636619772367581343075535053490057448) /* 2/pi */
  1209. # define M_2_SQRTPIf16        __f16 (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
  1210. # define M_SQRT2f16        __f16 (1.414213562373095048801688724209698079) /* sqrt(2) */
  1211. # define M_SQRT1_2f16        __f16 (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
  1212. #endif

  1214. #if __HAVE_FLOAT32 && defined __USE_GNU
  1215. # define M_Ef32                __f32 (2.718281828459045235360287471352662498) /* e */
  1216. # define M_LOG2Ef32        __f32 (1.442695040888963407359924681001892137) /* log_2 e */
  1217. # define M_LOG10Ef32        __f32 (0.434294481903251827651128918916605082) /* log_10 e */
  1218. # define M_LN2f32        __f32 (0.693147180559945309417232121458176568) /* log_e 2 */
  1219. # define M_LN10f32        __f32 (2.302585092994045684017991454684364208) /* log_e 10 */
  1220. # define M_PIf32        __f32 (3.141592653589793238462643383279502884) /* pi */
  1221. # define M_PI_2f32        __f32 (1.570796326794896619231321691639751442) /* pi/2 */
  1222. # define M_PI_4f32        __f32 (0.785398163397448309615660845819875721) /* pi/4 */
  1223. # define M_1_PIf32        __f32 (0.318309886183790671537767526745028724) /* 1/pi */
  1224. # define M_2_PIf32        __f32 (0.636619772367581343075535053490057448) /* 2/pi */
  1225. # define M_2_SQRTPIf32        __f32 (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
  1226. # define M_SQRT2f32        __f32 (1.414213562373095048801688724209698079) /* sqrt(2) */
  1227. # define M_SQRT1_2f32        __f32 (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
  1228. #endif

  1230. #if __HAVE_FLOAT64 && defined __USE_GNU
  1231. # define M_Ef64                __f64 (2.718281828459045235360287471352662498) /* e */
  1232. # define M_LOG2Ef64        __f64 (1.442695040888963407359924681001892137) /* log_2 e */
  1233. # define M_LOG10Ef64        __f64 (0.434294481903251827651128918916605082) /* log_10 e */
  1234. # define M_LN2f64        __f64 (0.693147180559945309417232121458176568) /* log_e 2 */
  1235. # define M_LN10f64        __f64 (2.302585092994045684017991454684364208) /* log_e 10 */
  1236. # define M_PIf64        __f64 (3.141592653589793238462643383279502884) /* pi */
  1237. # define M_PI_2f64        __f64 (1.570796326794896619231321691639751442) /* pi/2 */
  1238. # define M_PI_4f64        __f64 (0.785398163397448309615660845819875721) /* pi/4 */
  1239. # define M_1_PIf64        __f64 (0.318309886183790671537767526745028724) /* 1/pi */
  1240. # define M_2_PIf64        __f64 (0.636619772367581343075535053490057448) /* 2/pi */
  1241. # define M_2_SQRTPIf64        __f64 (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
  1242. # define M_SQRT2f64        __f64 (1.414213562373095048801688724209698079) /* sqrt(2) */
  1243. # define M_SQRT1_2f64        __f64 (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
  1244. #endif

  1246. #if __HAVE_FLOAT128 && defined __USE_GNU
  1247. # define M_Ef128        __f128 (2.718281828459045235360287471352662498) /* e */
  1248. # define M_LOG2Ef128        __f128 (1.442695040888963407359924681001892137) /* log_2 e */
  1249. # define M_LOG10Ef128        __f128 (0.434294481903251827651128918916605082) /* log_10 e */
  1250. # define M_LN2f128        __f128 (0.693147180559945309417232121458176568) /* log_e 2 */
  1251. # define M_LN10f128        __f128 (2.302585092994045684017991454684364208) /* log_e 10 */
  1252. # define M_PIf128        __f128 (3.141592653589793238462643383279502884) /* pi */
  1253. # define M_PI_2f128        __f128 (1.570796326794896619231321691639751442) /* pi/2 */
  1254. # define M_PI_4f128        __f128 (0.785398163397448309615660845819875721) /* pi/4 */
  1255. # define M_1_PIf128        __f128 (0.318309886183790671537767526745028724) /* 1/pi */
  1256. # define M_2_PIf128        __f128 (0.636619772367581343075535053490057448) /* 2/pi */
  1257. # define M_2_SQRTPIf128        __f128 (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
  1258. # define M_SQRT2f128        __f128 (1.414213562373095048801688724209698079) /* sqrt(2) */
  1259. # define M_SQRT1_2f128        __f128 (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
  1260. #endif

  1262. #if __HAVE_FLOAT32X && defined __USE_GNU
  1263. # define M_Ef32x        __f32x (2.718281828459045235360287471352662498) /* e */
  1264. # define M_LOG2Ef32x        __f32x (1.442695040888963407359924681001892137) /* log_2 e */
  1265. # define M_LOG10Ef32x        __f32x (0.434294481903251827651128918916605082) /* log_10 e */
  1266. # define M_LN2f32x        __f32x (0.693147180559945309417232121458176568) /* log_e 2 */
  1267. # define M_LN10f32x        __f32x (2.302585092994045684017991454684364208) /* log_e 10 */
  1268. # define M_PIf32x        __f32x (3.141592653589793238462643383279502884) /* pi */
  1269. # define M_PI_2f32x        __f32x (1.570796326794896619231321691639751442) /* pi/2 */
  1270. # define M_PI_4f32x        __f32x (0.785398163397448309615660845819875721) /* pi/4 */
  1271. # define M_1_PIf32x        __f32x (0.318309886183790671537767526745028724) /* 1/pi */
  1272. # define M_2_PIf32x        __f32x (0.636619772367581343075535053490057448) /* 2/pi */
  1273. # define M_2_SQRTPIf32x        __f32x (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
  1274. # define M_SQRT2f32x        __f32x (1.414213562373095048801688724209698079) /* sqrt(2) */
  1275. # define M_SQRT1_2f32x        __f32x (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
  1276. #endif

  1278. #if __HAVE_FLOAT64X && defined __USE_GNU
  1279. # define M_Ef64x        __f64x (2.718281828459045235360287471352662498) /* e */
  1280. # define M_LOG2Ef64x        __f64x (1.442695040888963407359924681001892137) /* log_2 e */
  1281. # define M_LOG10Ef64x        __f64x (0.434294481903251827651128918916605082) /* log_10 e */
  1282. # define M_LN2f64x        __f64x (0.693147180559945309417232121458176568) /* log_e 2 */
  1283. # define M_LN10f64x        __f64x (2.302585092994045684017991454684364208) /* log_e 10 */
  1284. # define M_PIf64x        __f64x (3.141592653589793238462643383279502884) /* pi */
  1285. # define M_PI_2f64x        __f64x (1.570796326794896619231321691639751442) /* pi/2 */
  1286. # define M_PI_4f64x        __f64x (0.785398163397448309615660845819875721) /* pi/4 */
  1287. # define M_1_PIf64x        __f64x (0.318309886183790671537767526745028724) /* 1/pi */
  1288. # define M_2_PIf64x        __f64x (0.636619772367581343075535053490057448) /* 2/pi */
  1289. # define M_2_SQRTPIf64x        __f64x (1.128379167095512573896158903121545172) /* 2/sqrt(pi) */
  1290. # define M_SQRT2f64x        __f64x (1.414213562373095048801688724209698079) /* sqrt(2) */
  1291. # define M_SQRT1_2f64x        __f64x (0.707106781186547524400844362104849039) /* 1/sqrt(2) */
  1292. #endif

  1294. #if __HAVE_FLOAT128X && defined __USE_GNU
  1295. # error "M_* values needed for _Float128x"
  1296. #endif

  1298. #ifdef __USE_ISOC99
  1299. # if __GNUC_PREREQ (3, 1)
  1300. /* ISO C99 defines some macros to compare number while taking care for
  1301.    unordered numbers.  Many FPUs provide special instructions to support
  1302.    these operations.  Generic support in GCC for these as builtins went
  1303.    in 2.97, but not all cpus added their patterns until 3.1.  Therefore
  1304.    we enable the builtins from 3.1 onwards and use a generic implementation
  1305.    othwerwise.  */
  1306. #  define isgreater(x, y)        __builtin_isgreater(x, y)
  1307. #  define isgreaterequal(x, y)        __builtin_isgreaterequal(x, y)
  1308. #  define isless(x, y)                __builtin_isless(x, y)
  1309. #  define islessequal(x, y)        __builtin_islessequal(x, y)
  1310. #  define islessgreater(x, y)        __builtin_islessgreater(x, y)
  1311. #  define isunordered(x, y)        __builtin_isunordered(x, y)
  1312. # else
  1313. #  define isgreater(x, y) \
  1314.   (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
  1315.                     !isunordered (__x, __y) && __x > __y; }))
  1316. #  define isgreaterequal(x, y) \
  1317.   (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
  1318.                     !isunordered (__x, __y) && __x >= __y; }))
  1319. #  define isless(x, y) \
  1320.   (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
  1321.                     !isunordered (__x, __y) && __x < __y; }))
  1322. #  define islessequal(x, y) \
  1323.   (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
  1324.                     !isunordered (__x, __y) && __x <= __y; }))
  1325. #  define islessgreater(x, y) \
  1326.   (__extension__ ({ __typeof__ (x) __x = (x); __typeof__ (y) __y = (y); \
  1327.                     !isunordered (__x, __y) && __x != __y; }))
  1328. /* isunordered must always check both operands first for signaling NaNs.  */
  1329. #  define isunordered(x, y) \
  1330.   (__extension__ ({ __typeof__ (x) __u = (x); __typeof__ (y) __v = (y); \
  1331.                     __u != __v && (__u != __u || __v != __v); }))
  1332. # endif
  1333. #endif

  1335. #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
  1336. /* An expression whose type has the widest of the evaluation formats
  1337.    of X and Y (which are of floating-point types).  */
  1338. # if __FLT_EVAL_METHOD__ == 2 || __FLT_EVAL_METHOD__ > 64
  1339. #  define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0L)
  1340. # elif __FLT_EVAL_METHOD__ == 1 || __FLT_EVAL_METHOD__ > 32
  1341. #  define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0)
  1342. # elif __FLT_EVAL_METHOD__ == 0 || __FLT_EVAL_METHOD__ == 32
  1343. #  define __MATH_EVAL_FMT2(x, y) ((x) + (y) + 0.0f)
  1344. # else
  1345. #  define __MATH_EVAL_FMT2(x, y) ((x) + (y))
  1346. # endif

  1348. /* Return X == Y but raising "invalid" and setting errno if X or Y is
  1349.    a NaN.  */
  1350. # if !defined __cplusplus || (__cplusplus < 201103L && !defined __GNUC__)
  1351. #  define iseqsig(x, y) \
  1352.    __MATH_TG (__MATH_EVAL_FMT2 (x, y), __iseqsig, ((x), (y)))
  1353. # else
  1354. /* In C++ mode, __MATH_TG cannot be used, because it relies on
  1355.    __builtin_types_compatible_p, which is a C-only builtin.  Moreover,
  1356.    the comparison macros from ISO C take two floating-point arguments,
  1357.    which need not have the same type.  Choosing what underlying function
  1358.    to call requires evaluating the formats of the arguments, then
  1359.    selecting which is wider.  The macro __MATH_EVAL_FMT2 provides this
  1360.    information, however, only the type of the macro expansion is
  1361.    relevant (actually evaluating the expression would be incorrect).
  1362.    Thus, the type is used as a template parameter for __iseqsig_type,
  1363.    which calls the appropriate underlying function.  */
  1364. extern "C++" {
  1365. template<typename> struct __iseqsig_type;

  1367. template<> struct __iseqsig_type<float>
  1368. {
  1369.   static int __call (float __x, float __y) throw ()
  1370.   {
  1371.     return __iseqsigf (__x, __y);
  1372.   }
  1373. };

  1375. template<> struct __iseqsig_type<double>
  1376. {
  1377.   static int __call (double __x, double __y) throw ()
  1378.   {
  1379.     return __iseqsig (__x, __y);
  1380.   }
  1381. };

  1383. template<> struct __iseqsig_type<long double>
  1384. {
  1385.   static int __call (long double __x, long double __y) throw ()
  1386.   {
  1387. #  ifndef __NO_LONG_DOUBLE_MATH
  1388.     return __iseqsigl (__x, __y);
  1389. #  else
  1390.     return __iseqsig (__x, __y);
  1391. #  endif
  1392.   }
  1393. };

  1395. #  if __HAVE_FLOAT128_UNLIKE_LDBL
  1396.   /* When using an IEEE 128-bit long double, _Float128 is defined as long double
  1397.      in C++.  */
  1398. template<> struct __iseqsig_type<_Float128>
  1399. {
  1400.   static int __call (_Float128 __x, _Float128 __y) throw ()
  1401.   {
  1402.     return __iseqsigf128 (__x, __y);
  1403.   }
  1404. };
  1405. #  endif

  1407. template<typename _T1, typename _T2>
  1408. inline int
  1409. iseqsig (_T1 __x, _T2 __y) throw ()
  1410. {
  1411. #  if __cplusplus >= 201103L
  1412.   typedef decltype (__MATH_EVAL_FMT2 (__x, __y)) _T3;
  1413. #  else
  1414.   typedef __typeof (__MATH_EVAL_FMT2 (__x, __y)) _T3;
  1415. #  endif
  1416.   return __iseqsig_type<_T3>::__call (__x, __y);
  1417. }

  1419. } /* extern "C++" */
  1420. # endif /* __cplusplus */

  1422. #endif

  1424. __END_DECLS


  1427. #endif /* math.h  */
  1428. sh-5.1$
复制代码
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

两手空空儿
发表于 2022-11-16 09:36:42 | 显示全部楼层
打开了一片新大陆。。。。。。。。眼花缭乱
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2024-5-19 11:23

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表