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