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