Where Online Learning is simpler!
The C and C++ Include Header Files
cat -n /usr/include/tgmath.h
1 /* Copyright (C) 1997-2026 Free Software Foundation, Inc. 2 This file is part of the GNU C Library. 3 4 The GNU C Library is free software; you can redistribute it and/or 5 modify it under the terms of the GNU Lesser General Public 6 License as published by the Free Software Foundation; either 7 version 2.1 of the License, or (at your option) any later version. 8 9 The GNU C Library is distributed in the hope that it will be useful, 10 but WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 Lesser General Public License for more details. 13 14 You should have received a copy of the GNU Lesser General Public 15 License along with the GNU C Library; if not, see 16 <https://www.gnu.org/licenses/>. */ 17 18 /* 19 * ISO C99 Standard: 7.22 Type-generic math <tgmath.h> 20 */ 21 22 #ifndef _TGMATH_H 23 #define _TGMATH_H 1 24 25 #define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION 26 #include <bits/libc-header-start.h> 27 28 /* Include the needed headers. */ 29 #include <bits/floatn.h> 30 #include <math.h> 31 #include <complex.h> 32 33 #if __GLIBC_USE (ISOC23) 34 # define __STDC_VERSION_TGMATH_H__ 202311L 35 #endif 36 37 38 /* There are two variant implementations of type-generic macros in 39 this file: one for GCC 8 and later, using __builtin_tgmath and 40 where each macro expands each of its arguments only once, and one 41 for older GCC, using other compiler extensions but with macros 42 expanding their arguments many times (so resulting in exponential 43 blowup of the size of expansions when calls to such macros are 44 nested inside arguments to such macros). Because of a long series 45 of defect fixes made after the initial release of TS 18661-1, GCC 46 versions before GCC 13 have __builtin_tgmath semantics that, when 47 integer arguments are passed to narrowing macros returning 48 _Float32x, or non-narrowing macros with at least two generic 49 arguments, do not always correspond to the C23 semantics, so more 50 complicated macro definitions are also used in some cases for 51 versions from GCC 8 to GCC 12. */ 52 53 #define __HAVE_BUILTIN_TGMATH __GNUC_PREREQ (8, 0) 54 #define __HAVE_BUILTIN_TGMATH_C23 __GNUC_PREREQ (13, 0) 55 56 #if __GNUC_PREREQ (2, 7) 57 58 /* Certain cases of narrowing macros only need to call a single 59 function so cannot use __builtin_tgmath and do not need any 60 complicated logic. */ 61 # if __HAVE_FLOAT128X 62 # error "Unsupported _Float128x type for <tgmath.h>." 63 # endif 64 # if ((__HAVE_FLOAT64X && !__HAVE_FLOAT128) \ 65 || (__HAVE_FLOAT128 && !__HAVE_FLOAT64X)) 66 # error "Unsupported combination of types for <tgmath.h>." 67 # endif 68 # define __TGMATH_1_NARROW_D(F, X) \ 69 (F ## l (X)) 70 # define __TGMATH_2_NARROW_D(F, X, Y) \ 71 (F ## l (X, Y)) 72 # define __TGMATH_3_NARROW_D(F, X, Y, Z) \ 73 (F ## l (X, Y, Z)) 74 # define __TGMATH_1_NARROW_F64X(F, X) \ 75 (F ## f128 (X)) 76 # define __TGMATH_2_NARROW_F64X(F, X, Y) \ 77 (F ## f128 (X, Y)) 78 # define __TGMATH_3_NARROW_F64X(F, X, Y, Z) \ 79 (F ## f128 (X, Y, Z)) 80 # if !__HAVE_FLOAT128 81 # define __TGMATH_1_NARROW_F32X(F, X) \ 82 (F ## f64 (X)) 83 # define __TGMATH_2_NARROW_F32X(F, X, Y) \ 84 (F ## f64 (X, Y)) 85 # define __TGMATH_3_NARROW_F32X(F, X, Y, Z) \ 86 (F ## f64 (X, Y, Z)) 87 # endif 88 89 # if __HAVE_BUILTIN_TGMATH 90 91 # if __HAVE_FLOAT16 && __GLIBC_USE (IEC_60559_TYPES_EXT) 92 # define __TG_F16_ARG(X) X ## f16, 93 # else 94 # define __TG_F16_ARG(X) 95 # endif 96 # if __HAVE_FLOAT32 && __GLIBC_USE (IEC_60559_TYPES_EXT) 97 # define __TG_F32_ARG(X) X ## f32, 98 # else 99 # define __TG_F32_ARG(X) 100 # endif 101 # if __HAVE_FLOAT64 && __GLIBC_USE (IEC_60559_TYPES_EXT) 102 # define __TG_F64_ARG(X) X ## f64, 103 # else 104 # define __TG_F64_ARG(X) 105 # endif 106 # if __HAVE_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT) 107 # define __TG_F128_ARG(X) X ## f128, 108 # else 109 # define __TG_F128_ARG(X) 110 # endif 111 # if __HAVE_FLOAT32X && __GLIBC_USE (IEC_60559_TYPES_EXT) 112 # define __TG_F32X_ARG(X) X ## f32x, 113 # else 114 # define __TG_F32X_ARG(X) 115 # endif 116 # if __HAVE_FLOAT64X && __GLIBC_USE (IEC_60559_TYPES_EXT) 117 # define __TG_F64X_ARG(X) X ## f64x, 118 # else 119 # define __TG_F64X_ARG(X) 120 # endif 121 # if __HAVE_FLOAT128X && __GLIBC_USE (IEC_60559_TYPES_EXT) 122 # define __TG_F128X_ARG(X) X ## f128x, 123 # else 124 # define __TG_F128X_ARG(X) 125 # endif 126 127 # define __TGMATH_FUNCS(X) X ## f, X, X ## l, \ 128 __TG_F16_ARG (X) __TG_F32_ARG (X) __TG_F64_ARG (X) __TG_F128_ARG (X) \ 129 __TG_F32X_ARG (X) __TG_F64X_ARG (X) __TG_F128X_ARG (X) 130 # define __TGMATH_RCFUNCS(F, C) __TGMATH_FUNCS (F) __TGMATH_FUNCS (C) 131 # define __TGMATH_1(F, X) __builtin_tgmath (__TGMATH_FUNCS (F) (X)) 132 # define __TGMATH_2(F, X, Y) __builtin_tgmath (__TGMATH_FUNCS (F) (X), (Y)) 133 # define __TGMATH_2STD(F, X, Y) __builtin_tgmath (F ## f, F, F ## l, (X), (Y)) 134 # define __TGMATH_3(F, X, Y, Z) __builtin_tgmath (__TGMATH_FUNCS (F) \ 135 (X), (Y), (Z)) 136 # define __TGMATH_1C(F, C, X) __builtin_tgmath (__TGMATH_RCFUNCS (F, C) (X)) 137 # define __TGMATH_2C(F, C, X, Y) __builtin_tgmath (__TGMATH_RCFUNCS (F, C) \ 138 (X), (Y)) 139 140 # define __TGMATH_NARROW_FUNCS_F(X) X, X ## l, 141 # define __TGMATH_NARROW_FUNCS_F16(X) \ 142 __TG_F32_ARG (X) __TG_F64_ARG (X) __TG_F128_ARG (X) \ 143 __TG_F32X_ARG (X) __TG_F64X_ARG (X) __TG_F128X_ARG (X) 144 # define __TGMATH_NARROW_FUNCS_F32(X) \ 145 __TG_F64_ARG (X) __TG_F128_ARG (X) \ 146 __TG_F32X_ARG (X) __TG_F64X_ARG (X) __TG_F128X_ARG (X) 147 # define __TGMATH_NARROW_FUNCS_F64(X) \ 148 __TG_F128_ARG (X) \ 149 __TG_F64X_ARG (X) __TG_F128X_ARG (X) 150 # define __TGMATH_NARROW_FUNCS_F32X(X) \ 151 __TG_F64X_ARG (X) __TG_F128X_ARG (X) \ 152 __TG_F64_ARG (X) __TG_F128_ARG (X) 153 154 # define __TGMATH_1_NARROW_F(F, X) \ 155 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F (F) (X)) 156 # define __TGMATH_2_NARROW_F(F, X, Y) \ 157 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F (F) (X), (Y)) 158 # define __TGMATH_3_NARROW_F(F, X, Y, Z) \ 159 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F (F) (X), (Y), (Z)) 160 # define __TGMATH_1_NARROW_F16(F, X) \ 161 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F16 (F) (X)) 162 # define __TGMATH_2_NARROW_F16(F, X, Y) \ 163 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F16 (F) (X), (Y)) 164 # define __TGMATH_3_NARROW_F16(F, X, Y, Z) \ 165 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F16 (F) (X), (Y), (Z)) 166 # define __TGMATH_1_NARROW_F32(F, X) \ 167 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F32 (F) (X)) 168 # define __TGMATH_2_NARROW_F32(F, X, Y) \ 169 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F32 (F) (X), (Y)) 170 # define __TGMATH_3_NARROW_F32(F, X, Y, Z) \ 171 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F32 (F) (X), (Y), (Z)) 172 # define __TGMATH_1_NARROW_F64(F, X) \ 173 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F64 (F) (X)) 174 # define __TGMATH_2_NARROW_F64(F, X, Y) \ 175 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F64 (F) (X), (Y)) 176 # define __TGMATH_3_NARROW_F64(F, X, Y, Z) \ 177 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F64 (F) (X), (Y), (Z)) 178 # if __HAVE_FLOAT128 && __HAVE_BUILTIN_TGMATH_C23 179 # define __TGMATH_1_NARROW_F32X(F, X) \ 180 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F32X (F) (X)) 181 # define __TGMATH_2_NARROW_F32X(F, X, Y) \ 182 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F32X (F) (X), (Y)) 183 # define __TGMATH_3_NARROW_F32X(F, X, Y, Z) \ 184 __builtin_tgmath (__TGMATH_NARROW_FUNCS_F32X (F) (X), (Y), (Z)) 185 # endif 186 187 # endif 188 189 # if !__HAVE_BUILTIN_TGMATH_C23 190 # ifdef __NO_LONG_DOUBLE_MATH 191 # define __tgml(fct) fct 192 # else 193 # define __tgml(fct) fct ## l 194 # endif 195 196 /* __floating_type expands to 1 if TYPE is a floating type (including 197 complex floating types), 0 if TYPE is an integer type (including 198 complex integer types). __real_integer_type expands to 1 if TYPE 199 is a real integer type. __complex_integer_type expands to 1 if 200 TYPE is a complex integer type. All these macros expand to integer 201 constant expressions. All these macros can assume their argument 202 has an arithmetic type (not vector, decimal floating-point or 203 fixed-point), valid to pass to tgmath.h macros. */ 204 # if __GNUC_PREREQ (3, 1) 205 /* __builtin_classify_type expands to an integer constant expression 206 in GCC 3.1 and later. Default conversions applied to the argument 207 of __builtin_classify_type mean it always returns 1 for real 208 integer types rather than ever returning different values for 209 character, boolean or enumerated types. */ 210 # define __floating_type(type) \ 211 (__builtin_classify_type (__real__ ((type) 0)) == 8) 212 # define __real_integer_type(type) \ 213 (__builtin_classify_type ((type) 0) == 1) 214 # define __complex_integer_type(type) \ 215 (__builtin_classify_type ((type) 0) == 9 \ 216 && __builtin_classify_type (__real__ ((type) 0)) == 1) 217 # else 218 /* GCC versions predating __builtin_classify_type are also looser on 219 what counts as an integer constant expression. */ 220 # define __floating_type(type) (((type) 1.25) != 1) 221 # define __real_integer_type(type) (((type) (1.25 + _Complex_I)) == 1) 222 # define __complex_integer_type(type) \ 223 (((type) (1.25 + _Complex_I)) == (1 + _Complex_I)) 224 # endif 225 226 /* Whether an expression (of arithmetic type) has a real type. */ 227 # define __expr_is_real(E) (__builtin_classify_type (E) != 9) 228 229 /* Type T1 if E is 1, type T2 is E is 0. */ 230 # define __tgmath_type_if(T1, T2, E) \ 231 __typeof__ (*(0 ? (__typeof__ (0 ? (T2 *) 0 : (void *) (E))) 0 \ 232 : (__typeof__ (0 ? (T1 *) 0 : (void *) (!(E)))) 0)) 233 234 /* The tgmath real type for T, where E is 0 if T is an integer type 235 and 1 for a floating type. If T has a complex type, it is 236 unspecified whether the return type is real or complex (but it has 237 the correct corresponding real type). */ 238 # define __tgmath_real_type_sub(T, E) \ 239 __tgmath_type_if (T, double, E) 240 241 /* The tgmath real type of EXPR. */ 242 # define __tgmath_real_type(expr) \ 243 __tgmath_real_type_sub (__typeof__ ((__typeof__ (+(expr))) 0), \ 244 __floating_type (__typeof__ (+(expr)))) 245 246 /* The tgmath complex type for T, where E1 is 1 if T has a floating 247 type and 0 otherwise, E2 is 1 if T has a real integer type and 0 248 otherwise, and E3 is 1 if T has a complex type and 0 otherwise. */ 249 # define __tgmath_complex_type_sub(T, E1, E2, E3) \ 250 __typeof__ (*(0 \ 251 ? (__typeof__ (0 ? (T *) 0 : (void *) (!(E1)))) 0 \ 252 : (__typeof__ (0 \ 253 ? (__typeof__ (0 \ 254 ? (double *) 0 \ 255 : (void *) (!(E2)))) 0 \ 256 : (__typeof__ (0 \ 257 ? (_Complex double *) 0 \ 258 : (void *) (!(E3)))) 0)) 0)) 259 260 /* The tgmath complex type of EXPR. */ 261 # define __tgmath_complex_type(expr) \ 262 __tgmath_complex_type_sub (__typeof__ ((__typeof__ (+(expr))) 0), \ 263 __floating_type (__typeof__ (+(expr))), \ 264 __real_integer_type (__typeof__ (+(expr))), \ 265 __complex_integer_type (__typeof__ (+(expr)))) 266 267 /* The tgmath real type of EXPR1 combined with EXPR2, without handling 268 the C23 rule of interpreting integer arguments as _Float32x if any 269 argument is _FloatNx. */ 270 # define __tgmath_real_type2_base(expr1, expr2) \ 271 __typeof ((__tgmath_real_type (expr1)) 0 + (__tgmath_real_type (expr2)) 0) 272 273 /* The tgmath complex type of EXPR1 combined with EXPR2, without 274 handling the C23 rule of interpreting integer arguments as 275 _Float32x if any argument is _FloatNx. */ 276 # define __tgmath_complex_type2_base(expr1, expr2) \ 277 __typeof ((__tgmath_complex_type (expr1)) 0 \ 278 + (__tgmath_complex_type (expr2)) 0) 279 280 /* The tgmath real type of EXPR1 combined with EXPR2 and EXPR3, 281 without handling the C23 rule of interpreting integer arguments as 282 _Float32x if any argument is _FloatNx. */ 283 # define __tgmath_real_type3_base(expr1, expr2, expr3) \ 284 __typeof ((__tgmath_real_type (expr1)) 0 \ 285 + (__tgmath_real_type (expr2)) 0 \ 286 + (__tgmath_real_type (expr3)) 0) 287 288 /* The tgmath real or complex type of EXPR1 combined with EXPR2 (and 289 EXPR3 if applicable). */ 290 # if __HAVE_FLOATN_NOT_TYPEDEF 291 # define __tgmath_real_type2(expr1, expr2) \ 292 __tgmath_type_if (_Float32x, __tgmath_real_type2_base (expr1, expr2), \ 293 _Generic ((expr1) + (expr2), _Float32x: 1, default: 0)) 294 # define __tgmath_complex_type2(expr1, expr2) \ 295 __tgmath_type_if (_Float32x, \ 296 __tgmath_type_if (_Complex _Float32x, \ 297 __tgmath_complex_type2_base (expr1, \ 298 expr2), \ 299 _Generic ((expr1) + (expr2), \ 300 _Complex _Float32x: 1, \ 301 default: 0)), \ 302 _Generic ((expr1) + (expr2), _Float32x: 1, default: 0)) 303 # define __tgmath_real_type3(expr1, expr2, expr3) \ 304 __tgmath_type_if (_Float32x, \ 305 __tgmath_real_type3_base (expr1, expr2, expr3), \ 306 _Generic ((expr1) + (expr2) + (expr3), \ 307 _Float32x: 1, default: 0)) 308 # else 309 # define __tgmath_real_type2(expr1, expr2) \ 310 __tgmath_real_type2_base (expr1, expr2) 311 # define __tgmath_complex_type2(expr1, expr2) \ 312 __tgmath_complex_type2_base (expr1, expr2) 313 # define __tgmath_real_type3(expr1, expr2, expr3) \ 314 __tgmath_real_type3_base (expr1, expr2, expr3) 315 # endif 316 317 # if (__HAVE_DISTINCT_FLOAT16 \ 318 || __HAVE_DISTINCT_FLOAT32 \ 319 || __HAVE_DISTINCT_FLOAT64 \ 320 || __HAVE_DISTINCT_FLOAT32X \ 321 || __HAVE_DISTINCT_FLOAT64X \ 322 || __HAVE_DISTINCT_FLOAT128X) 323 # error "Unsupported _FloatN or _FloatNx types for <tgmath.h>." 324 # endif 325 326 /* Expand to text that checks if ARG_COMB has type _Float128, and if 327 so calls the appropriately suffixed FCT (which may include a cast), 328 or FCT and CFCT for complex functions, with arguments ARG_CALL. 329 __TGMATH_F128LD (only used in the __HAVE_FLOAT64X_LONG_DOUBLE case, 330 for narrowing macros) handles long double the same as 331 _Float128. */ 332 # if __HAVE_DISTINCT_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT) 333 # if (!__HAVE_FLOAT64X \ 334 || __HAVE_FLOAT64X_LONG_DOUBLE \ 335 || !__HAVE_FLOATN_NOT_TYPEDEF) 336 # define __TGMATH_F128(arg_comb, fct, arg_call) \ 337 __builtin_types_compatible_p (__typeof (+(arg_comb)), _Float128) \ 338 ? fct ## f128 arg_call : 339 # define __TGMATH_F128LD(arg_comb, fct, arg_call) \ 340 (__builtin_types_compatible_p (__typeof (+(arg_comb)), _Float128) \ 341 || __builtin_types_compatible_p (__typeof (+(arg_comb)), long double)) \ 342 ? fct ## f128 arg_call : 343 # define __TGMATH_CF128(arg_comb, fct, cfct, arg_call) \ 344 __builtin_types_compatible_p (__typeof (+__real__ (arg_comb)), _Float128) \ 345 ? (__expr_is_real (arg_comb) \ 346 ? fct ## f128 arg_call \ 347 : cfct ## f128 arg_call) : 348 # else 349 /* _Float64x is a distinct type at the C language level, which must be 350 handled like _Float128. */ 351 # define __TGMATH_F128(arg_comb, fct, arg_call) \ 352 (__builtin_types_compatible_p (__typeof (+(arg_comb)), _Float128) \ 353 || __builtin_types_compatible_p (__typeof (+(arg_comb)), _Float64x)) \ 354 ? fct ## f128 arg_call : 355 # define __TGMATH_CF128(arg_comb, fct, cfct, arg_call) \ 356 (__builtin_types_compatible_p (__typeof (+__real__ (arg_comb)), _Float128) \ 357 || __builtin_types_compatible_p (__typeof (+__real__ (arg_comb)), \ 358 _Float64x)) \ 359 ? (__expr_is_real (arg_comb) \ 360 ? fct ## f128 arg_call \ 361 : cfct ## f128 arg_call) : 362 # endif 363 # else 364 # define __TGMATH_F128(arg_comb, fct, arg_call) /* Nothing. */ 365 # define __TGMATH_CF128(arg_comb, fct, cfct, arg_call) /* Nothing. */ 366 # endif 367 368 # endif /* !__HAVE_BUILTIN_TGMATH_C23. */ 369 370 /* We have two kinds of generic macros: to support functions which are 371 only defined on real valued parameters and those which are defined 372 for complex functions as well. */ 373 # if __HAVE_BUILTIN_TGMATH 374 375 # define __TGMATH_UNARY_REAL_ONLY(Val, Fct) __TGMATH_1 (Fct, (Val)) 376 # define __TGMATH_UNARY_REAL_RET_ONLY(Val, Fct) __TGMATH_1 (Fct, (Val)) 377 # define __TGMATH_BINARY_FIRST_REAL_ONLY(Val1, Val2, Fct) \ 378 __TGMATH_2 (Fct, (Val1), (Val2)) 379 # define __TGMATH_BINARY_FIRST_REAL_STD_ONLY(Val1, Val2, Fct) \ 380 __TGMATH_2STD (Fct, (Val1), (Val2)) 381 # if __HAVE_BUILTIN_TGMATH_C23 382 # define __TGMATH_BINARY_REAL_ONLY(Val1, Val2, Fct) \ 383 __TGMATH_2 (Fct, (Val1), (Val2)) 384 # endif 385 # define __TGMATH_BINARY_REAL_STD_ONLY(Val1, Val2, Fct) \ 386 __TGMATH_2STD (Fct, (Val1), (Val2)) 387 # if __HAVE_BUILTIN_TGMATH_C23 388 # define __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY(Val1, Val2, Val3, Fct) \ 389 __TGMATH_3 (Fct, (Val1), (Val2), (Val3)) 390 # define __TGMATH_TERNARY_REAL_ONLY(Val1, Val2, Val3, Fct) \ 391 __TGMATH_3 (Fct, (Val1), (Val2), (Val3)) 392 # endif 393 # define __TGMATH_TERNARY_FIRST_REAL_ONLY(Val1, Val2, Val3, Fct) \ 394 __TGMATH_3 (Fct, (Val1), (Val2), (Val3)) 395 # define __TGMATH_UNARY_REAL_IMAG(Val, Fct, Cfct) \ 396 __TGMATH_1C (Fct, Cfct, (Val)) 397 # define __TGMATH_UNARY_IMAG(Val, Cfct) __TGMATH_1 (Cfct, (Val)) 398 # define __TGMATH_UNARY_REAL_IMAG_RET_REAL(Val, Fct, Cfct) \ 399 __TGMATH_1C (Fct, Cfct, (Val)) 400 # define __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME(Val, Cfct) \ 401 __TGMATH_1 (Cfct, (Val)) 402 # if __HAVE_BUILTIN_TGMATH_C23 403 # define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct) \ 404 __TGMATH_2C (Fct, Cfct, (Val1), (Val2)) 405 # endif 406 407 # endif 408 409 # if !__HAVE_BUILTIN_TGMATH 410 # define __TGMATH_UNARY_REAL_ONLY(Val, Fct) \ 411 (__extension__ ((sizeof (+(Val)) == sizeof (double) \ 412 || __builtin_classify_type (Val) != 8) \ 413 ? (__tgmath_real_type (Val)) Fct (Val) \ 414 : (sizeof (+(Val)) == sizeof (float)) \ 415 ? (__tgmath_real_type (Val)) Fct##f (Val) \ 416 : __TGMATH_F128 ((Val), (__tgmath_real_type (Val)) Fct, \ 417 (Val)) \ 418 (__tgmath_real_type (Val)) __tgml(Fct) (Val))) 419 420 # define __TGMATH_UNARY_REAL_RET_ONLY(Val, Fct) \ 421 (__extension__ ((sizeof (+(Val)) == sizeof (double) \ 422 || __builtin_classify_type (Val) != 8) \ 423 ? Fct (Val) \ 424 : (sizeof (+(Val)) == sizeof (float)) \ 425 ? Fct##f (Val) \ 426 : __TGMATH_F128 ((Val), Fct, (Val)) \ 427 __tgml(Fct) (Val))) 428 429 # define __TGMATH_BINARY_FIRST_REAL_ONLY(Val1, Val2, Fct) \ 430 (__extension__ ((sizeof (+(Val1)) == sizeof (double) \ 431 || __builtin_classify_type (Val1) != 8) \ 432 ? (__tgmath_real_type (Val1)) Fct (Val1, Val2) \ 433 : (sizeof (+(Val1)) == sizeof (float)) \ 434 ? (__tgmath_real_type (Val1)) Fct##f (Val1, Val2) \ 435 : __TGMATH_F128 ((Val1), (__tgmath_real_type (Val1)) Fct, \ 436 (Val1, Val2)) \ 437 (__tgmath_real_type (Val1)) __tgml(Fct) (Val1, Val2))) 438 439 # define __TGMATH_BINARY_FIRST_REAL_STD_ONLY(Val1, Val2, Fct) \ 440 (__extension__ ((sizeof (+(Val1)) == sizeof (double) \ 441 || __builtin_classify_type (Val1) != 8) \ 442 ? (__tgmath_real_type (Val1)) Fct (Val1, Val2) \ 443 : (sizeof (+(Val1)) == sizeof (float)) \ 444 ? (__tgmath_real_type (Val1)) Fct##f (Val1, Val2) \ 445 : (__tgmath_real_type (Val1)) __tgml(Fct) (Val1, Val2))) 446 # endif 447 448 # if !__HAVE_BUILTIN_TGMATH_C23 449 # define __TGMATH_BINARY_REAL_ONLY(Val1, Val2, Fct) \ 450 (__extension__ ((sizeof ((Val1) + (Val2)) > sizeof (double) \ 451 && __builtin_classify_type ((Val1) + (Val2)) == 8) \ 452 ? __TGMATH_F128 ((Val1) + (Val2), \ 453 (__tgmath_real_type2 (Val1, Val2)) Fct, \ 454 (Val1, Val2)) \ 455 (__tgmath_real_type2 (Val1, Val2)) \ 456 __tgml(Fct) (Val1, Val2) \ 457 : (sizeof (+(Val1)) == sizeof (double) \ 458 || sizeof (+(Val2)) == sizeof (double) \ 459 || __builtin_classify_type (Val1) != 8 \ 460 || __builtin_classify_type (Val2) != 8) \ 461 ? (__tgmath_real_type2 (Val1, Val2)) \ 462 Fct (Val1, Val2) \ 463 : (__tgmath_real_type2 (Val1, Val2)) \ 464 Fct##f (Val1, Val2))) 465 # endif 466 467 # if !__HAVE_BUILTIN_TGMATH 468 # define __TGMATH_BINARY_REAL_STD_ONLY(Val1, Val2, Fct) \ 469 (__extension__ ((sizeof ((Val1) + (Val2)) > sizeof (double) \ 470 && __builtin_classify_type ((Val1) + (Val2)) == 8) \ 471 ? (__typeof ((__tgmath_real_type (Val1)) 0 \ 472 + (__tgmath_real_type (Val2)) 0)) \ 473 __tgml(Fct) (Val1, Val2) \ 474 : (sizeof (+(Val1)) == sizeof (double) \ 475 || sizeof (+(Val2)) == sizeof (double) \ 476 || __builtin_classify_type (Val1) != 8 \ 477 || __builtin_classify_type (Val2) != 8) \ 478 ? (__typeof ((__tgmath_real_type (Val1)) 0 \ 479 + (__tgmath_real_type (Val2)) 0)) \ 480 Fct (Val1, Val2) \ 481 : (__typeof ((__tgmath_real_type (Val1)) 0 \ 482 + (__tgmath_real_type (Val2)) 0)) \ 483 Fct##f (Val1, Val2))) 484 # endif 485 486 # if !__HAVE_BUILTIN_TGMATH_C23 487 # define __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY(Val1, Val2, Val3, Fct) \ 488 (__extension__ ((sizeof ((Val1) + (Val2)) > sizeof (double) \ 489 && __builtin_classify_type ((Val1) + (Val2)) == 8) \ 490 ? __TGMATH_F128 ((Val1) + (Val2), \ 491 (__tgmath_real_type2 (Val1, Val2)) Fct, \ 492 (Val1, Val2, Val3)) \ 493 (__tgmath_real_type2 (Val1, Val2)) \ 494 __tgml(Fct) (Val1, Val2, Val3) \ 495 : (sizeof (+(Val1)) == sizeof (double) \ 496 || sizeof (+(Val2)) == sizeof (double) \ 497 || __builtin_classify_type (Val1) != 8 \ 498 || __builtin_classify_type (Val2) != 8) \ 499 ? (__tgmath_real_type2 (Val1, Val2)) \ 500 Fct (Val1, Val2, Val3) \ 501 : (__tgmath_real_type2 (Val1, Val2)) \ 502 Fct##f (Val1, Val2, Val3))) 503 504 # define __TGMATH_TERNARY_REAL_ONLY(Val1, Val2, Val3, Fct) \ 505 (__extension__ ((sizeof ((Val1) + (Val2) + (Val3)) > sizeof (double) \ 506 && __builtin_classify_type ((Val1) + (Val2) + (Val3)) \ 507 == 8) \ 508 ? __TGMATH_F128 ((Val1) + (Val2) + (Val3), \ 509 (__tgmath_real_type3 (Val1, Val2, \ 510 Val3)) Fct, \ 511 (Val1, Val2, Val3)) \ 512 (__tgmath_real_type3 (Val1, Val2, Val3)) \ 513 __tgml(Fct) (Val1, Val2, Val3) \ 514 : (sizeof (+(Val1)) == sizeof (double) \ 515 || sizeof (+(Val2)) == sizeof (double) \ 516 || sizeof (+(Val3)) == sizeof (double) \ 517 || __builtin_classify_type (Val1) != 8 \ 518 || __builtin_classify_type (Val2) != 8 \ 519 || __builtin_classify_type (Val3) != 8) \ 520 ? (__tgmath_real_type3 (Val1, Val2, Val3)) \ 521 Fct (Val1, Val2, Val3) \ 522 : (__tgmath_real_type3 (Val1, Val2, Val3)) \ 523 Fct##f (Val1, Val2, Val3))) 524 # endif 525 526 # if !__HAVE_BUILTIN_TGMATH 527 # define __TGMATH_TERNARY_FIRST_REAL_ONLY(Val1, Val2, Val3, Fct) \ 528 (__extension__ ((sizeof (+(Val1)) == sizeof (double) \ 529 || __builtin_classify_type (Val1) != 8) \ 530 ? (__tgmath_real_type (Val1)) Fct (Val1, Val2, Val3) \ 531 : (sizeof (+(Val1)) == sizeof (float)) \ 532 ? (__tgmath_real_type (Val1)) Fct##f (Val1, Val2, Val3) \ 533 : __TGMATH_F128 ((Val1), \ 534 (__tgmath_real_type (Val1)) Fct, \ 535 (Val1, Val2, Val3)) \ 536 (__tgmath_real_type (Val1)) __tgml(Fct) (Val1, Val2, \ 537 Val3))) 538 539 /* XXX This definition has to be changed as soon as the compiler understands 540 the imaginary keyword. */ 541 # define __TGMATH_UNARY_REAL_IMAG(Val, Fct, Cfct) \ 542 (__extension__ ((sizeof (+__real__ (Val)) == sizeof (double) \ 543 || __builtin_classify_type (__real__ (Val)) != 8) \ 544 ? (__expr_is_real (Val) \ 545 ? (__tgmath_complex_type (Val)) Fct (Val) \ 546 : (__tgmath_complex_type (Val)) Cfct (Val)) \ 547 : (sizeof (+__real__ (Val)) == sizeof (float)) \ 548 ? (__expr_is_real (Val) \ 549 ? (__tgmath_complex_type (Val)) Fct##f (Val) \ 550 : (__tgmath_complex_type (Val)) Cfct##f (Val)) \ 551 : __TGMATH_CF128 ((Val), \ 552 (__tgmath_complex_type (Val)) Fct, \ 553 (__tgmath_complex_type (Val)) Cfct, \ 554 (Val)) \ 555 (__expr_is_real (Val) \ 556 ? (__tgmath_complex_type (Val)) __tgml(Fct) (Val) \ 557 : (__tgmath_complex_type (Val)) __tgml(Cfct) (Val)))) 558 559 # define __TGMATH_UNARY_IMAG(Val, Cfct) \ 560 (__extension__ ((sizeof (+__real__ (Val)) == sizeof (double) \ 561 || __builtin_classify_type (__real__ (Val)) != 8) \ 562 ? (__typeof__ ((__tgmath_real_type (Val)) 0 \ 563 + _Complex_I)) Cfct (Val) \ 564 : (sizeof (+__real__ (Val)) == sizeof (float)) \ 565 ? (__typeof__ ((__tgmath_real_type (Val)) 0 \ 566 + _Complex_I)) Cfct##f (Val) \ 567 : __TGMATH_F128 (__real__ (Val), \ 568 (__typeof__ \ 569 ((__tgmath_real_type (Val)) 0 \ 570 + _Complex_I)) Cfct, (Val)) \ 571 (__typeof__ ((__tgmath_real_type (Val)) 0 \ 572 + _Complex_I)) __tgml(Cfct) (Val))) 573 574 /* XXX This definition has to be changed as soon as the compiler understands 575 the imaginary keyword. */ 576 # define __TGMATH_UNARY_REAL_IMAG_RET_REAL(Val, Fct, Cfct) \ 577 (__extension__ ((sizeof (+__real__ (Val)) == sizeof (double) \ 578 || __builtin_classify_type (__real__ (Val)) != 8) \ 579 ? (__expr_is_real (Val) \ 580 ? (__typeof__ (__real__ (__tgmath_real_type (Val)) 0))\ 581 Fct (Val) \ 582 : (__typeof__ (__real__ (__tgmath_real_type (Val)) 0))\ 583 Cfct (Val)) \ 584 : (sizeof (+__real__ (Val)) == sizeof (float)) \ 585 ? (__expr_is_real (Val) \ 586 ? (__typeof__ (__real__ (__tgmath_real_type (Val)) 0))\ 587 Fct##f (Val) \ 588 : (__typeof__ (__real__ (__tgmath_real_type (Val)) 0))\ 589 Cfct##f (Val)) \ 590 : __TGMATH_CF128 ((Val), \ 591 (__typeof__ \ 592 (__real__ \ 593 (__tgmath_real_type (Val)) 0)) Fct, \ 594 (__typeof__ \ 595 (__real__ \ 596 (__tgmath_real_type (Val)) 0)) Cfct, \ 597 (Val)) \ 598 (__expr_is_real (Val) \ 599 ? (__typeof__ (__real__ (__tgmath_real_type (Val)) 0)) \ 600 __tgml(Fct) (Val) \ 601 : (__typeof__ (__real__ (__tgmath_real_type (Val)) 0)) \ 602 __tgml(Cfct) (Val)))) 603 # define __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME(Val, Cfct) \ 604 __TGMATH_UNARY_REAL_IMAG_RET_REAL ((Val), Cfct, Cfct) 605 # endif 606 607 # if !__HAVE_BUILTIN_TGMATH_C23 608 /* XXX This definition has to be changed as soon as the compiler understands 609 the imaginary keyword. */ 610 # define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct) \ 611 (__extension__ ((sizeof (__real__ (Val1) \ 612 + __real__ (Val2)) > sizeof (double) \ 613 && __builtin_classify_type (__real__ (Val1) \ 614 + __real__ (Val2)) == 8) \ 615 ? __TGMATH_CF128 ((Val1) + (Val2), \ 616 (__tgmath_complex_type2 (Val1, Val2)) \ 617 Fct, \ 618 (__tgmath_complex_type2 (Val1, Val2)) \ 619 Cfct, \ 620 (Val1, Val2)) \ 621 (__expr_is_real ((Val1) + (Val2)) \ 622 ? (__tgmath_complex_type2 (Val1, Val2)) \ 623 __tgml(Fct) (Val1, Val2) \ 624 : (__tgmath_complex_type2 (Val1, Val2)) \ 625 __tgml(Cfct) (Val1, Val2)) \ 626 : (sizeof (+__real__ (Val1)) == sizeof (double) \ 627 || sizeof (+__real__ (Val2)) == sizeof (double) \ 628 || __builtin_classify_type (__real__ (Val1)) != 8 \ 629 || __builtin_classify_type (__real__ (Val2)) != 8) \ 630 ? (__expr_is_real ((Val1) + (Val2)) \ 631 ? (__tgmath_complex_type2 (Val1, Val2)) \ 632 Fct (Val1, Val2) \ 633 : (__tgmath_complex_type2 (Val1, Val2)) \ 634 Cfct (Val1, Val2)) \ 635 : (__expr_is_real ((Val1) + (Val2)) \ 636 ? (__tgmath_complex_type2 (Val1, Val2)) \ 637 Fct##f (Val1, Val2) \ 638 : (__tgmath_complex_type2 (Val1, Val2)) \ 639 Cfct##f (Val1, Val2)))) 640 # endif 641 642 # if !__HAVE_BUILTIN_TGMATH 643 # define __TGMATH_1_NARROW_F(F, X) \ 644 (__extension__ (sizeof ((__tgmath_real_type (X)) 0) > sizeof (double) \ 645 ? F ## l (X) \ 646 : F (X))) 647 # define __TGMATH_2_NARROW_F(F, X, Y) \ 648 (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ 649 + (__tgmath_real_type (Y)) 0) > sizeof (double) \ 650 ? F ## l (X, Y) \ 651 : F (X, Y))) 652 # define __TGMATH_3_NARROW_F(F, X, Y, Z) \ 653 (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ 654 + (__tgmath_real_type (Y)) 0 \ 655 + (__tgmath_real_type (Z)) 0) > sizeof (double) \ 656 ? F ## l (X, Y, Z) \ 657 : F (X, Y, Z))) 658 # endif 659 /* In most cases, these narrowing macro definitions based on sizeof 660 ensure that the function called has the right argument format, as 661 for other <tgmath.h> macros for compilers before GCC 8, but may not 662 have exactly the argument type (among the types with that format) 663 specified in the standard logic. 664 665 In the case of macros for _Float32x return type, when _Float64x 666 exists, _Float64 arguments should result in the *f64 function being 667 called while _Float32x, float and double arguments should result in 668 the *f64x function being called (and integer arguments are 669 considered to have type _Float32x if any argument has type 670 _FloatNx, or double otherwise). These cases cannot be 671 distinguished using sizeof (or at all if the types are typedefs 672 rather than different types, in which case we err on the side of 673 using the wider type if unsure). */ 674 # if !__HAVE_BUILTIN_TGMATH_C23 675 # if __HAVE_FLOATN_NOT_TYPEDEF 676 # define __TGMATH_NARROW_F32X_USE_F64X(X) \ 677 !__builtin_types_compatible_p (__typeof (+(X)), _Float64) 678 # else 679 # define __TGMATH_NARROW_F32X_USE_F64X(X) \ 680 (__builtin_types_compatible_p (__typeof (+(X)), double) \ 681 || __builtin_types_compatible_p (__typeof (+(X)), float) \ 682 || !__floating_type (__typeof (+(X)))) 683 # endif 684 # endif 685 # if __HAVE_FLOAT64X_LONG_DOUBLE && __HAVE_DISTINCT_FLOAT128 686 # if !__HAVE_BUILTIN_TGMATH 687 # define __TGMATH_1_NARROW_F32(F, X) \ 688 (__extension__ (sizeof ((__tgmath_real_type (X)) 0) > sizeof (_Float64) \ 689 ? __TGMATH_F128LD ((X), F, (X)) \ 690 F ## f64x (X) \ 691 : F ## f64 (X))) 692 # define __TGMATH_2_NARROW_F32(F, X, Y) \ 693 (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ 694 + (__tgmath_real_type (Y)) 0) > sizeof (_Float64) \ 695 ? __TGMATH_F128LD ((X) + (Y), F, (X, Y)) \ 696 F ## f64x (X, Y) \ 697 : F ## f64 (X, Y))) 698 # define __TGMATH_3_NARROW_F32(F, X, Y, Z) \ 699 (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ 700 + (__tgmath_real_type (Y)) 0 \ 701 + (__tgmath_real_type (Z)) 0) > sizeof (_Float64) \ 702 ? __TGMATH_F128LD ((X) + (Y) + (Z), F, (X, Y, Z)) \ 703 F ## f64x (X, Y, Z) \ 704 : F ## f64 (X, Y, Z))) 705 # define __TGMATH_1_NARROW_F64(F, X) \ 706 (__extension__ (sizeof ((__tgmath_real_type (X)) 0) > sizeof (_Float64) \ 707 ? __TGMATH_F128LD ((X), F, (X)) \ 708 F ## f64x (X) \ 709 : F ## f128 (X))) 710 # define __TGMATH_2_NARROW_F64(F, X, Y) \ 711 (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ 712 + (__tgmath_real_type (Y)) 0) > sizeof (_Float64) \ 713 ? __TGMATH_F128LD ((X) + (Y), F, (X, Y)) \ 714 F ## f64x (X, Y) \ 715 : F ## f128 (X, Y))) 716 # define __TGMATH_3_NARROW_F64(F, X, Y, Z) \ 717 (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ 718 + (__tgmath_real_type (Y)) 0 \ 719 + (__tgmath_real_type (Z)) 0) > sizeof (_Float64) \ 720 ? __TGMATH_F128LD ((X) + (Y) + (Z), F, (X, Y, Z)) \ 721 F ## f64x (X, Y, Z) \ 722 : F ## f128 (X, Y, Z))) 723 # endif 724 # if !__HAVE_BUILTIN_TGMATH_C23 725 # define __TGMATH_1_NARROW_F32X(F, X) \ 726 (__extension__ (sizeof ((__tgmath_real_type (X)) 0) > sizeof (_Float64) \ 727 || __TGMATH_NARROW_F32X_USE_F64X (X) \ 728 ? __TGMATH_F128 ((X), F, (X)) \ 729 F ## f64x (X) \ 730 : F ## f64 (X))) 731 # define __TGMATH_2_NARROW_F32X(F, X, Y) \ 732 (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ 733 + (__tgmath_real_type (Y)) 0) > sizeof (_Float64) \ 734 || __TGMATH_NARROW_F32X_USE_F64X ((X) + (Y)) \ 735 ? __TGMATH_F128 ((X) + (Y), F, (X, Y)) \ 736 F ## f64x (X, Y) \ 737 : F ## f64 (X, Y))) 738 # define __TGMATH_3_NARROW_F32X(F, X, Y, Z) \ 739 (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ 740 + (__tgmath_real_type (Y)) 0 \ 741 + (__tgmath_real_type (Z)) 0) > sizeof (_Float64) \ 742 || __TGMATH_NARROW_F32X_USE_F64X ((X) + (Y) + (Z)) \ 743 ? __TGMATH_F128 ((X) + (Y) + (Z), F, (X, Y, Z)) \ 744 F ## f64x (X, Y, Z) \ 745 : F ## f64 (X, Y, Z))) 746 # endif 747 # elif __HAVE_FLOAT128 748 # if !__HAVE_BUILTIN_TGMATH 749 # define __TGMATH_1_NARROW_F32(F, X) \ 750 (__extension__ (sizeof ((__tgmath_real_type (X)) 0) > sizeof (_Float64) \ 751 ? F ## f128 (X) \ 752 : F ## f64 (X))) 753 # define __TGMATH_2_NARROW_F32(F, X, Y) \ 754 (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ 755 + (__tgmath_real_type (Y)) 0) > sizeof (_Float64) \ 756 ? F ## f128 (X, Y) \ 757 : F ## f64 (X, Y))) 758 # define __TGMATH_3_NARROW_F32(F, X, Y, Z) \ 759 (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ 760 + (__tgmath_real_type (Y)) 0 \ 761 + (__tgmath_real_type (Z)) 0) > sizeof (_Float64) \ 762 ? F ## f128 (X, Y, Z) \ 763 : F ## f64 (X, Y, Z))) 764 # define __TGMATH_1_NARROW_F64(F, X) \ 765 (F ## f128 (X)) 766 # define __TGMATH_2_NARROW_F64(F, X, Y) \ 767 (F ## f128 (X, Y)) 768 # define __TGMATH_3_NARROW_F64(F, X, Y, Z) \ 769 (F ## f128 (X, Y, Z)) 770 # endif 771 # if !__HAVE_BUILTIN_TGMATH_C23 772 # define __TGMATH_1_NARROW_F32X(F, X) \ 773 (__extension__ (sizeof ((__tgmath_real_type (X)) 0) > sizeof (_Float32x) \ 774 || __TGMATH_NARROW_F32X_USE_F64X (X) \ 775 ? F ## f64x (X) \ 776 : F ## f64 (X))) 777 # define __TGMATH_2_NARROW_F32X(F, X, Y) \ 778 (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ 779 + (__tgmath_real_type (Y)) 0) > sizeof (_Float32x) \ 780 || __TGMATH_NARROW_F32X_USE_F64X ((X) + (Y)) \ 781 ? F ## f64x (X, Y) \ 782 : F ## f64 (X, Y))) 783 # define __TGMATH_3_NARROW_F32X(F, X, Y, Z) \ 784 (__extension__ (sizeof ((__tgmath_real_type (X)) 0 \ 785 + (__tgmath_real_type (Y)) 0 \ 786 + (__tgmath_real_type (Z)) 0) > sizeof (_Float32x) \ 787 || __TGMATH_NARROW_F32X_USE_F64X ((X) + (Y) + (Z)) \ 788 ? F ## f64x (X, Y, Z) \ 789 : F ## f64 (X, Y, Z))) 790 # endif 791 # else 792 # if !__HAVE_BUILTIN_TGMATH 793 # define __TGMATH_1_NARROW_F32(F, X) \ 794 (F ## f64 (X)) 795 # define __TGMATH_2_NARROW_F32(F, X, Y) \ 796 (F ## f64 (X, Y)) 797 # define __TGMATH_3_NARROW_F32(F, X, Y, Z) \ 798 (F ## f64 (X, Y, Z)) 799 # endif 800 # endif 801 #else 802 # error "Unsupported compiler; you cannot use <tgmath.h>" 803 #endif 804 805 806 /* Unary functions defined for real and complex values. */ 807 808 809 /* Trigonometric functions. */ 810 811 /* Arc cosine of X. */ 812 #define acos(Val) __TGMATH_UNARY_REAL_IMAG (Val, acos, cacos) 813 /* Arc sine of X. */ 814 #define asin(Val) __TGMATH_UNARY_REAL_IMAG (Val, asin, casin) 815 /* Arc tangent of X. */ 816 #define atan(Val) __TGMATH_UNARY_REAL_IMAG (Val, atan, catan) 817 /* Arc tangent of Y/X. */ 818 #define atan2(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, atan2) 819 820 /* Cosine of X. */ 821 #define cos(Val) __TGMATH_UNARY_REAL_IMAG (Val, cos, ccos) 822 /* Sine of X. */ 823 #define sin(Val) __TGMATH_UNARY_REAL_IMAG (Val, sin, csin) 824 /* Tangent of X. */ 825 #define tan(Val) __TGMATH_UNARY_REAL_IMAG (Val, tan, ctan) 826 827 #if __GLIBC_USE (IEC_60559_FUNCS_EXT_C23) 828 /* Arc cosine of X, divided by pi.. */ 829 # define acospi(Val) __TGMATH_UNARY_REAL_ONLY (Val, acospi) 830 /* Arc sine of X, divided by pi.. */ 831 # define asinpi(Val) __TGMATH_UNARY_REAL_ONLY (Val, asinpi) 832 /* Arc tangent of X, divided by pi. */ 833 # define atanpi(Val) __TGMATH_UNARY_REAL_ONLY (Val, atanpi) 834 /* Arc tangent of Y/X, divided by pi. */ 835 #define atan2pi(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, atan2pi) 836 837 /* Cosine of pi * X. */ 838 # define cospi(Val) __TGMATH_UNARY_REAL_ONLY (Val, cospi) 839 /* Sine of pi * X. */ 840 # define sinpi(Val) __TGMATH_UNARY_REAL_ONLY (Val, sinpi) 841 /* Tangent of pi * X. */ 842 # define tanpi(Val) __TGMATH_UNARY_REAL_ONLY (Val, tanpi) 843 #endif 844 845 /* Hyperbolic functions. */ 846 847 /* Hyperbolic arc cosine of X. */ 848 #define acosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, acosh, cacosh) 849 /* Hyperbolic arc sine of X. */ 850 #define asinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, asinh, casinh) 851 /* Hyperbolic arc tangent of X. */ 852 #define atanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, atanh, catanh) 853 854 /* Hyperbolic cosine of X. */ 855 #define cosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, cosh, ccosh) 856 /* Hyperbolic sine of X. */ 857 #define sinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, sinh, csinh) 858 /* Hyperbolic tangent of X. */ 859 #define tanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, tanh, ctanh) 860 861 862 /* Exponential and logarithmic functions. */ 863 864 /* Exponential function of X. */ 865 #define exp(Val) __TGMATH_UNARY_REAL_IMAG (Val, exp, cexp) 866 867 /* Break VALUE into a normalized fraction and an integral power of 2. */ 868 #define frexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, frexp) 869 870 /* X times (two to the EXP power). */ 871 #define ldexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, ldexp) 872 873 /* Natural logarithm of X. */ 874 #define log(Val) __TGMATH_UNARY_REAL_IMAG (Val, log, clog) 875 876 /* Base-ten logarithm of X. */ 877 #ifdef __USE_GNU 878 # define log10(Val) __TGMATH_UNARY_REAL_IMAG (Val, log10, clog10) 879 #else 880 # define log10(Val) __TGMATH_UNARY_REAL_ONLY (Val, log10) 881 #endif 882 883 /* Return exp(X) - 1. */ 884 #define expm1(Val) __TGMATH_UNARY_REAL_ONLY (Val, expm1) 885 886 /* Return log(1 + X). */ 887 #define log1p(Val) __TGMATH_UNARY_REAL_ONLY (Val, log1p) 888 889 /* Return the base 2 signed integral exponent of X. */ 890 #define logb(Val) __TGMATH_UNARY_REAL_ONLY (Val, logb) 891 892 /* Compute base-2 exponential of X. */ 893 #define exp2(Val) __TGMATH_UNARY_REAL_ONLY (Val, exp2) 894 895 /* Compute base-2 logarithm of X. */ 896 #define log2(Val) __TGMATH_UNARY_REAL_ONLY (Val, log2) 897 898 #if __GLIBC_USE (IEC_60559_FUNCS_EXT_C23) 899 /* Compute exponent to base ten. */ 900 #define exp10(Val) __TGMATH_UNARY_REAL_ONLY (Val, exp10) 901 902 /* Return exp2(X) - 1. */ 903 #define exp2m1(Val) __TGMATH_UNARY_REAL_ONLY (Val, exp2m1) 904 905 /* Return exp10(X) - 1. */ 906 #define exp10m1(Val) __TGMATH_UNARY_REAL_ONLY (Val, exp10m1) 907 908 /* Return log2(1 + X). */ 909 #define log2p1(Val) __TGMATH_UNARY_REAL_ONLY (Val, log2p1) 910 911 /* Return log10(1 + X). */ 912 #define log10p1(Val) __TGMATH_UNARY_REAL_ONLY (Val, log10p1) 913 914 /* Return log(1 + X). */ 915 #define logp1(Val) __TGMATH_UNARY_REAL_ONLY (Val, logp1) 916 #endif 917 918 919 /* Power functions. */ 920 921 /* Return X to the Y power. */ 922 #define pow(Val1, Val2) __TGMATH_BINARY_REAL_IMAG (Val1, Val2, pow, cpow) 923 924 /* Return the square root of X. */ 925 #define sqrt(Val) __TGMATH_UNARY_REAL_IMAG (Val, sqrt, csqrt) 926 927 /* Return `sqrt(X*X + Y*Y)'. */ 928 #define hypot(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, hypot) 929 930 /* Return the cube root of X. */ 931 #define cbrt(Val) __TGMATH_UNARY_REAL_ONLY (Val, cbrt) 932 933 #if __GLIBC_USE (IEC_60559_FUNCS_EXT_C23) 934 /* Return 1+X to the Y power. */ 935 # define compoundn(Val1, Val2) \ 936 __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, compoundn) 937 938 /* Return X to the Y power. */ 939 # define pown(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, pown) 940 941 /* Return X to the Y power. */ 942 # define powr(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, powr) 943 944 /* Return the Yth root of X. */ 945 # define rootn(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, rootn) 946 947 /* Return 1/sqrt(X). */ 948 # define rsqrt(Val) __TGMATH_UNARY_REAL_ONLY (Val, rsqrt) 949 #endif 950 951 952 /* Nearest integer, absolute value, and remainder functions. */ 953 954 /* Smallest integral value not less than X. */ 955 #define ceil(Val) __TGMATH_UNARY_REAL_ONLY (Val, ceil) 956 957 /* Absolute value of X. */ 958 #define fabs(Val) __TGMATH_UNARY_REAL_IMAG_RET_REAL (Val, fabs, cabs) 959 960 /* Largest integer not greater than X. */ 961 #define floor(Val) __TGMATH_UNARY_REAL_ONLY (Val, floor) 962 963 /* Floating-point modulo remainder of X/Y. */ 964 #define fmod(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmod) 965 966 /* Round X to integral valuein floating-point format using current 967 rounding direction, but do not raise inexact exception. */ 968 #define nearbyint(Val) __TGMATH_UNARY_REAL_ONLY (Val, nearbyint) 969 970 /* Round X to nearest integral value, rounding halfway cases away from 971 zero. */ 972 #define round(Val) __TGMATH_UNARY_REAL_ONLY (Val, round) 973 974 /* Round X to the integral value in floating-point format nearest but 975 not larger in magnitude. */ 976 #define trunc(Val) __TGMATH_UNARY_REAL_ONLY (Val, trunc) 977 978 /* Compute remainder of X and Y and put in *QUO a value with sign of x/y 979 and magnitude congruent `mod 2^n' to the magnitude of the integral 980 quotient x/y, with n >= 3. */ 981 #define remquo(Val1, Val2, Val3) \ 982 __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY (Val1, Val2, Val3, remquo) 983 984 /* Round X to nearest integral value according to current rounding 985 direction. */ 986 #define lrint(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, lrint) 987 #define llrint(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, llrint) 988 989 /* Round X to nearest integral value, rounding halfway cases away from 990 zero. */ 991 #define lround(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, lround) 992 #define llround(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, llround) 993 994 995 /* Return X with its signed changed to Y's. */ 996 #define copysign(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, copysign) 997 998 /* Error and gamma functions. */ 999 #define erf(Val) __TGMATH_UNARY_REAL_ONLY (Val, erf) 1000 #define erfc(Val) __TGMATH_UNARY_REAL_ONLY (Val, erfc) 1001 #define tgamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, tgamma) 1002 #define lgamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, lgamma) 1003 1004 1005 /* Return the integer nearest X in the direction of the 1006 prevailing rounding mode. */ 1007 #define rint(Val) __TGMATH_UNARY_REAL_ONLY (Val, rint) 1008 1009 #if __GLIBC_USE (IEC_60559_BFP_EXT_C23) 1010 /* Return X - epsilon. */ 1011 # define nextdown(Val) __TGMATH_UNARY_REAL_ONLY (Val, nextdown) 1012 /* Return X + epsilon. */ 1013 # define nextup(Val) __TGMATH_UNARY_REAL_ONLY (Val, nextup) 1014 #endif 1015 1016 /* Return X + epsilon if X < Y, X - epsilon if X > Y. */ 1017 #define nextafter(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, nextafter) 1018 #define nexttoward(Val1, Val2) \ 1019 __TGMATH_BINARY_FIRST_REAL_STD_ONLY (Val1, Val2, nexttoward) 1020 1021 /* Return the remainder of integer division X / Y with infinite precision. */ 1022 #define remainder(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, remainder) 1023 1024 /* Return X times (2 to the Nth power). */ 1025 #ifdef __USE_MISC 1026 # define scalb(Val1, Val2) __TGMATH_BINARY_REAL_STD_ONLY (Val1, Val2, scalb) 1027 #endif 1028 1029 /* Return X times (2 to the Nth power). */ 1030 #define scalbn(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbn) 1031 1032 /* Return X times (2 to the Nth power). */ 1033 #define scalbln(Val1, Val2) \ 1034 __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbln) 1035 1036 /* Return the binary exponent of X, which must be nonzero. */ 1037 #define ilogb(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, ilogb) 1038 1039 1040 /* Return positive difference between X and Y. */ 1041 #define fdim(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fdim) 1042 1043 #if __GLIBC_USE (ISOC23) && !defined __USE_GNU 1044 /* Return maximum numeric value from X and Y. */ 1045 # define fmax(Val1, Val2) __TGMATH_BINARY_REAL_STD_ONLY (Val1, Val2, fmax) 1046 1047 /* Return minimum numeric value from X and Y. */ 1048 # define fmin(Val1, Val2) __TGMATH_BINARY_REAL_STD_ONLY (Val1, Val2, fmin) 1049 #else 1050 /* Return maximum numeric value from X and Y. */ 1051 # define fmax(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmax) 1052 1053 /* Return minimum numeric value from X and Y. */ 1054 # define fmin(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmin) 1055 #endif 1056 1057 1058 /* Multiply-add function computed as a ternary operation. */ 1059 #define fma(Val1, Val2, Val3) \ 1060 __TGMATH_TERNARY_REAL_ONLY (Val1, Val2, Val3, fma) 1061 1062 #if __GLIBC_USE (IEC_60559_BFP_EXT_C23) 1063 /* Round X to nearest integer value, rounding halfway cases to even. */ 1064 # define roundeven(Val) __TGMATH_UNARY_REAL_ONLY (Val, roundeven) 1065 1066 # define fromfp(Val1, Val2, Val3) \ 1067 __TGMATH_TERNARY_FIRST_REAL_ONLY (Val1, Val2, Val3, fromfp) 1068 1069 # define ufromfp(Val1, Val2, Val3) \ 1070 __TGMATH_TERNARY_FIRST_REAL_ONLY (Val1, Val2, Val3, ufromfp) 1071 1072 # define fromfpx(Val1, Val2, Val3) \ 1073 __TGMATH_TERNARY_FIRST_REAL_ONLY (Val1, Val2, Val3, fromfpx) 1074 1075 # define ufromfpx(Val1, Val2, Val3) \ 1076 __TGMATH_TERNARY_FIRST_REAL_ONLY (Val1, Val2, Val3, ufromfpx) 1077 1078 /* Like ilogb, but returning long int. */ 1079 # define llogb(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, llogb) 1080 #endif 1081 1082 #if __GLIBC_USE (IEC_60559_BFP_EXT) 1083 /* Return value with maximum magnitude. */ 1084 # define fmaxmag(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmaxmag) 1085 1086 /* Return value with minimum magnitude. */ 1087 # define fminmag(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fminmag) 1088 #endif 1089 1090 #if __GLIBC_USE (ISOC23) 1091 /* Return maximum value from X and Y. */ 1092 # define fmaximum(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmaximum) 1093 1094 /* Return minimum value from X and Y. */ 1095 # define fminimum(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fminimum) 1096 1097 /* Return maximum numeric value from X and Y. */ 1098 # define fmaximum_num(Val1, Val2) \ 1099 __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmaximum_num) 1100 1101 /* Return minimum numeric value from X and Y. */ 1102 # define fminimum_num(Val1, Val2) \ 1103 __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fminimum_num) 1104 1105 /* Return value with maximum magnitude. */ 1106 # define fmaximum_mag(Val1, Val2) \ 1107 __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmaximum_mag) 1108 1109 /* Return value with minimum magnitude. */ 1110 # define fminimum_mag(Val1, Val2) \ 1111 __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fminimum_mag) 1112 1113 /* Return numeric value with maximum magnitude. */ 1114 # define fmaximum_mag_num(Val1, Val2) \ 1115 __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmaximum_mag_num) 1116 1117 /* Return numeric value with minimum magnitude. */ 1118 # define fminimum_mag_num(Val1, Val2) \ 1119 __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fminimum_mag_num) 1120 #endif 1121 1122 1123 /* Absolute value, conjugates, and projection. */ 1124 1125 /* Argument value of Z. */ 1126 #define carg(Val) __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME (Val, carg) 1127 1128 /* Complex conjugate of Z. */ 1129 #define conj(Val) __TGMATH_UNARY_IMAG (Val, conj) 1130 1131 /* Projection of Z onto the Riemann sphere. */ 1132 #define cproj(Val) __TGMATH_UNARY_IMAG (Val, cproj) 1133 1134 1135 /* Decomposing complex values. */ 1136 1137 /* Imaginary part of Z. */ 1138 #define cimag(Val) __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME (Val, cimag) 1139 1140 /* Real part of Z. */ 1141 #define creal(Val) __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME (Val, creal) 1142 1143 1144 /* Narrowing functions. */ 1145 1146 #if __GLIBC_USE (IEC_60559_BFP_EXT_C23) 1147 1148 /* Add. */ 1149 # define fadd(Val1, Val2) __TGMATH_2_NARROW_F (fadd, Val1, Val2) 1150 # define dadd(Val1, Val2) __TGMATH_2_NARROW_D (dadd, Val1, Val2) 1151 1152 /* Divide. */ 1153 # define fdiv(Val1, Val2) __TGMATH_2_NARROW_F (fdiv, Val1, Val2) 1154 # define ddiv(Val1, Val2) __TGMATH_2_NARROW_D (ddiv, Val1, Val2) 1155 1156 /* Multiply. */ 1157 # define fmul(Val1, Val2) __TGMATH_2_NARROW_F (fmul, Val1, Val2) 1158 # define dmul(Val1, Val2) __TGMATH_2_NARROW_D (dmul, Val1, Val2) 1159 1160 /* Subtract. */ 1161 # define fsub(Val1, Val2) __TGMATH_2_NARROW_F (fsub, Val1, Val2) 1162 # define dsub(Val1, Val2) __TGMATH_2_NARROW_D (dsub, Val1, Val2) 1163 1164 /* Square root. */ 1165 # define fsqrt(Val) __TGMATH_1_NARROW_F (fsqrt, Val) 1166 # define dsqrt(Val) __TGMATH_1_NARROW_D (dsqrt, Val) 1167 1168 /* Fused multiply-add. */ 1169 # define ffma(Val1, Val2, Val3) __TGMATH_3_NARROW_F (ffma, Val1, Val2, Val3) 1170 # define dfma(Val1, Val2, Val3) __TGMATH_3_NARROW_D (dfma, Val1, Val2, Val3) 1171 1172 #endif 1173 1174 #if __GLIBC_USE (IEC_60559_TYPES_EXT) 1175 1176 # if __HAVE_FLOAT16 1177 # define f16add(Val1, Val2) __TGMATH_2_NARROW_F16 (f16add, Val1, Val2) 1178 # define f16div(Val1, Val2) __TGMATH_2_NARROW_F16 (f16div, Val1, Val2) 1179 # define f16mul(Val1, Val2) __TGMATH_2_NARROW_F16 (f16mul, Val1, Val2) 1180 # define f16sub(Val1, Val2) __TGMATH_2_NARROW_F16 (f16sub, Val1, Val2) 1181 # define f16sqrt(Val) __TGMATH_1_NARROW_F16 (f16sqrt, Val) 1182 # define f16fma(Val1, Val2, Val3) \ 1183 __TGMATH_3_NARROW_F16 (f16fma, Val1, Val2, Val3) 1184 # endif 1185 1186 # if __HAVE_FLOAT32 1187 # define f32add(Val1, Val2) __TGMATH_2_NARROW_F32 (f32add, Val1, Val2) 1188 # define f32div(Val1, Val2) __TGMATH_2_NARROW_F32 (f32div, Val1, Val2) 1189 # define f32mul(Val1, Val2) __TGMATH_2_NARROW_F32 (f32mul, Val1, Val2) 1190 # define f32sub(Val1, Val2) __TGMATH_2_NARROW_F32 (f32sub, Val1, Val2) 1191 # define f32sqrt(Val) __TGMATH_1_NARROW_F32 (f32sqrt, Val) 1192 # define f32fma(Val1, Val2, Val3) \ 1193 __TGMATH_3_NARROW_F32 (f32fma, Val1, Val2, Val3) 1194 # endif 1195 1196 # if __HAVE_FLOAT64 && (__HAVE_FLOAT64X || __HAVE_FLOAT128) 1197 # define f64add(Val1, Val2) __TGMATH_2_NARROW_F64 (f64add, Val1, Val2) 1198 # define f64div(Val1, Val2) __TGMATH_2_NARROW_F64 (f64div, Val1, Val2) 1199 # define f64mul(Val1, Val2) __TGMATH_2_NARROW_F64 (f64mul, Val1, Val2) 1200 # define f64sub(Val1, Val2) __TGMATH_2_NARROW_F64 (f64sub, Val1, Val2) 1201 # define f64sqrt(Val) __TGMATH_1_NARROW_F64 (f64sqrt, Val) 1202 # define f64fma(Val1, Val2, Val3) \ 1203 __TGMATH_3_NARROW_F64 (f64fma, Val1, Val2, Val3) 1204 # endif 1205 1206 # if __HAVE_FLOAT32X 1207 # define f32xadd(Val1, Val2) __TGMATH_2_NARROW_F32X (f32xadd, Val1, Val2) 1208 # define f32xdiv(Val1, Val2) __TGMATH_2_NARROW_F32X (f32xdiv, Val1, Val2) 1209 # define f32xmul(Val1, Val2) __TGMATH_2_NARROW_F32X (f32xmul, Val1, Val2) 1210 # define f32xsub(Val1, Val2) __TGMATH_2_NARROW_F32X (f32xsub, Val1, Val2) 1211 # define f32xsqrt(Val) __TGMATH_1_NARROW_F32X (f32xsqrt, Val) 1212 # define f32xfma(Val1, Val2, Val3) \ 1213 __TGMATH_3_NARROW_F32X (f32xfma, Val1, Val2, Val3) 1214 # endif 1215 1216 # if __HAVE_FLOAT64X && (__HAVE_FLOAT128X || __HAVE_FLOAT128) 1217 # define f64xadd(Val1, Val2) __TGMATH_2_NARROW_F64X (f64xadd, Val1, Val2) 1218 # define f64xdiv(Val1, Val2) __TGMATH_2_NARROW_F64X (f64xdiv, Val1, Val2) 1219 # define f64xmul(Val1, Val2) __TGMATH_2_NARROW_F64X (f64xmul, Val1, Val2) 1220 # define f64xsub(Val1, Val2) __TGMATH_2_NARROW_F64X (f64xsub, Val1, Val2) 1221 # define f64xsqrt(Val) __TGMATH_1_NARROW_F64X (f64xsqrt, Val) 1222 # define f64xfma(Val1, Val2, Val3) \ 1223 __TGMATH_3_NARROW_F64X (f64xfma, Val1, Val2, Val3) 1224 # endif 1225 1226 #endif 1227 1228 #endif /* tgmath.h */
