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 */