1/* Copyright (C) 1997-2024 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 C2X 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_C2X __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_C2X
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_C2X
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 C2X 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 C2X 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 C2X 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_C2X. */
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_C2X
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_C2X
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_C2X
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_C2X
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_C2X
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_C2X
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_C2X
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_C2X
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_C2X
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
821/* Hyperbolic functions. */
822
823/* Hyperbolic arc cosine of X. */
824#define acosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, acosh, cacosh)
825/* Hyperbolic arc sine of X. */
826#define asinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, asinh, casinh)
827/* Hyperbolic arc tangent of X. */
828#define atanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, atanh, catanh)
829
830/* Hyperbolic cosine of X. */
831#define cosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, cosh, ccosh)
832/* Hyperbolic sine of X. */
833#define sinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, sinh, csinh)
834/* Hyperbolic tangent of X. */
835#define tanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, tanh, ctanh)
836
837
838/* Exponential and logarithmic functions. */
839
840/* Exponential function of X. */
841#define exp(Val) __TGMATH_UNARY_REAL_IMAG (Val, exp, cexp)
842
843/* Break VALUE into a normalized fraction and an integral power of 2. */
844#define frexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, frexp)
845
846/* X times (two to the EXP power). */
847#define ldexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, ldexp)
848
849/* Natural logarithm of X. */
850#define log(Val) __TGMATH_UNARY_REAL_IMAG (Val, log, clog)
851
852/* Base-ten logarithm of X. */
853#ifdef __USE_GNU
854# define log10(Val) __TGMATH_UNARY_REAL_IMAG (Val, log10, clog10)
855#else
856# define log10(Val) __TGMATH_UNARY_REAL_ONLY (Val, log10)
857#endif
858
859/* Return exp(X) - 1. */
860#define expm1(Val) __TGMATH_UNARY_REAL_ONLY (Val, expm1)
861
862/* Return log(1 + X). */
863#define log1p(Val) __TGMATH_UNARY_REAL_ONLY (Val, log1p)
864
865/* Return the base 2 signed integral exponent of X. */
866#define logb(Val) __TGMATH_UNARY_REAL_ONLY (Val, logb)
867
868/* Compute base-2 exponential of X. */
869#define exp2(Val) __TGMATH_UNARY_REAL_ONLY (Val, exp2)
870
871/* Compute base-2 logarithm of X. */
872#define log2(Val) __TGMATH_UNARY_REAL_ONLY (Val, log2)
873
874#if __GLIBC_USE (IEC_60559_FUNCS_EXT_C2X)
875/* Compute exponent to base ten. */
876#define exp10(Val) __TGMATH_UNARY_REAL_ONLY (Val, exp10)
877#endif
878
879
880/* Power functions. */
881
882/* Return X to the Y power. */
883#define pow(Val1, Val2) __TGMATH_BINARY_REAL_IMAG (Val1, Val2, pow, cpow)
884
885/* Return the square root of X. */
886#define sqrt(Val) __TGMATH_UNARY_REAL_IMAG (Val, sqrt, csqrt)
887
888/* Return `sqrt(X*X + Y*Y)'. */
889#define hypot(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, hypot)
890
891/* Return the cube root of X. */
892#define cbrt(Val) __TGMATH_UNARY_REAL_ONLY (Val, cbrt)
893
894
895/* Nearest integer, absolute value, and remainder functions. */
896
897/* Smallest integral value not less than X. */
898#define ceil(Val) __TGMATH_UNARY_REAL_ONLY (Val, ceil)
899
900/* Absolute value of X. */
901#define fabs(Val) __TGMATH_UNARY_REAL_IMAG_RET_REAL (Val, fabs, cabs)
902
903/* Largest integer not greater than X. */
904#define floor(Val) __TGMATH_UNARY_REAL_ONLY (Val, floor)
905
906/* Floating-point modulo remainder of X/Y. */
907#define fmod(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmod)
908
909/* Round X to integral valuein floating-point format using current
910 rounding direction, but do not raise inexact exception. */
911#define nearbyint(Val) __TGMATH_UNARY_REAL_ONLY (Val, nearbyint)
912
913/* Round X to nearest integral value, rounding halfway cases away from
914 zero. */
915#define round(Val) __TGMATH_UNARY_REAL_ONLY (Val, round)
916
917/* Round X to the integral value in floating-point format nearest but
918 not larger in magnitude. */
919#define trunc(Val) __TGMATH_UNARY_REAL_ONLY (Val, trunc)
920
921/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
922 and magnitude congruent `mod 2^n' to the magnitude of the integral
923 quotient x/y, with n >= 3. */
924#define remquo(Val1, Val2, Val3) \
925 __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY (Val1, Val2, Val3, remquo)
926
927/* Round X to nearest integral value according to current rounding
928 direction. */
929#define lrint(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, lrint)
930#define llrint(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, llrint)
931
932/* Round X to nearest integral value, rounding halfway cases away from
933 zero. */
934#define lround(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, lround)
935#define llround(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, llround)
936
937
938/* Return X with its signed changed to Y's. */
939#define copysign(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, copysign)
940
941/* Error and gamma functions. */
942#define erf(Val) __TGMATH_UNARY_REAL_ONLY (Val, erf)
943#define erfc(Val) __TGMATH_UNARY_REAL_ONLY (Val, erfc)
944#define tgamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, tgamma)
945#define lgamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, lgamma)
946
947
948/* Return the integer nearest X in the direction of the
949 prevailing rounding mode. */
950#define rint(Val) __TGMATH_UNARY_REAL_ONLY (Val, rint)
951
952#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
953/* Return X - epsilon. */
954# define nextdown(Val) __TGMATH_UNARY_REAL_ONLY (Val, nextdown)
955/* Return X + epsilon. */
956# define nextup(Val) __TGMATH_UNARY_REAL_ONLY (Val, nextup)
957#endif
958
959/* Return X + epsilon if X < Y, X - epsilon if X > Y. */
960#define nextafter(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, nextafter)
961#define nexttoward(Val1, Val2) \
962 __TGMATH_BINARY_FIRST_REAL_STD_ONLY (Val1, Val2, nexttoward)
963
964/* Return the remainder of integer division X / Y with infinite precision. */
965#define remainder(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, remainder)
966
967/* Return X times (2 to the Nth power). */
968#ifdef __USE_MISC
969# define scalb(Val1, Val2) __TGMATH_BINARY_REAL_STD_ONLY (Val1, Val2, scalb)
970#endif
971
972/* Return X times (2 to the Nth power). */
973#define scalbn(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbn)
974
975/* Return X times (2 to the Nth power). */
976#define scalbln(Val1, Val2) \
977 __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbln)
978
979/* Return the binary exponent of X, which must be nonzero. */
980#define ilogb(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, ilogb)
981
982
983/* Return positive difference between X and Y. */
984#define fdim(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fdim)
985
986#if __GLIBC_USE (ISOC2X) && !defined __USE_GNU
987/* Return maximum numeric value from X and Y. */
988# define fmax(Val1, Val2) __TGMATH_BINARY_REAL_STD_ONLY (Val1, Val2, fmax)
989
990/* Return minimum numeric value from X and Y. */
991# define fmin(Val1, Val2) __TGMATH_BINARY_REAL_STD_ONLY (Val1, Val2, fmin)
992#else
993/* Return maximum numeric value from X and Y. */
994# define fmax(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmax)
995
996/* Return minimum numeric value from X and Y. */
997# define fmin(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmin)
998#endif
999
1000
1001/* Multiply-add function computed as a ternary operation. */
1002#define fma(Val1, Val2, Val3) \
1003 __TGMATH_TERNARY_REAL_ONLY (Val1, Val2, Val3, fma)
1004
1005#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
1006/* Round X to nearest integer value, rounding halfway cases to even. */
1007# define roundeven(Val) __TGMATH_UNARY_REAL_ONLY (Val, roundeven)
1008
1009# define fromfp(Val1, Val2, Val3) \
1010 __TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, fromfp)
1011
1012# define ufromfp(Val1, Val2, Val3) \
1013 __TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, ufromfp)
1014
1015# define fromfpx(Val1, Val2, Val3) \
1016 __TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, fromfpx)
1017
1018# define ufromfpx(Val1, Val2, Val3) \
1019 __TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, ufromfpx)
1020
1021/* Like ilogb, but returning long int. */
1022# define llogb(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, llogb)
1023#endif
1024
1025#if __GLIBC_USE (IEC_60559_BFP_EXT)
1026/* Return value with maximum magnitude. */
1027# define fmaxmag(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmaxmag)
1028
1029/* Return value with minimum magnitude. */
1030# define fminmag(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fminmag)
1031#endif
1032
1033#if __GLIBC_USE (ISOC2X)
1034/* Return maximum value from X and Y. */
1035# define fmaximum(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmaximum)
1036
1037/* Return minimum value from X and Y. */
1038# define fminimum(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fminimum)
1039
1040/* Return maximum numeric value from X and Y. */
1041# define fmaximum_num(Val1, Val2) \
1042 __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmaximum_num)
1043
1044/* Return minimum numeric value from X and Y. */
1045# define fminimum_num(Val1, Val2) \
1046 __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fminimum_num)
1047
1048/* Return value with maximum magnitude. */
1049# define fmaximum_mag(Val1, Val2) \
1050 __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmaximum_mag)
1051
1052/* Return value with minimum magnitude. */
1053# define fminimum_mag(Val1, Val2) \
1054 __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fminimum_mag)
1055
1056/* Return numeric value with maximum magnitude. */
1057# define fmaximum_mag_num(Val1, Val2) \
1058 __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmaximum_mag_num)
1059
1060/* Return numeric value with minimum magnitude. */
1061# define fminimum_mag_num(Val1, Val2) \
1062 __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fminimum_mag_num)
1063#endif
1064
1065
1066/* Absolute value, conjugates, and projection. */
1067
1068/* Argument value of Z. */
1069#define carg(Val) __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME (Val, carg)
1070
1071/* Complex conjugate of Z. */
1072#define conj(Val) __TGMATH_UNARY_IMAG (Val, conj)
1073
1074/* Projection of Z onto the Riemann sphere. */
1075#define cproj(Val) __TGMATH_UNARY_IMAG (Val, cproj)
1076
1077
1078/* Decomposing complex values. */
1079
1080/* Imaginary part of Z. */
1081#define cimag(Val) __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME (Val, cimag)
1082
1083/* Real part of Z. */
1084#define creal(Val) __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME (Val, creal)
1085
1086
1087/* Narrowing functions. */
1088
1089#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X)
1090
1091/* Add. */
1092# define fadd(Val1, Val2) __TGMATH_2_NARROW_F (fadd, Val1, Val2)
1093# define dadd(Val1, Val2) __TGMATH_2_NARROW_D (dadd, Val1, Val2)
1094
1095/* Divide. */
1096# define fdiv(Val1, Val2) __TGMATH_2_NARROW_F (fdiv, Val1, Val2)
1097# define ddiv(Val1, Val2) __TGMATH_2_NARROW_D (ddiv, Val1, Val2)
1098
1099/* Multiply. */
1100# define fmul(Val1, Val2) __TGMATH_2_NARROW_F (fmul, Val1, Val2)
1101# define dmul(Val1, Val2) __TGMATH_2_NARROW_D (dmul, Val1, Val2)
1102
1103/* Subtract. */
1104# define fsub(Val1, Val2) __TGMATH_2_NARROW_F (fsub, Val1, Val2)
1105# define dsub(Val1, Val2) __TGMATH_2_NARROW_D (dsub, Val1, Val2)
1106
1107/* Square root. */
1108# define fsqrt(Val) __TGMATH_1_NARROW_F (fsqrt, Val)
1109# define dsqrt(Val) __TGMATH_1_NARROW_D (dsqrt, Val)
1110
1111/* Fused multiply-add. */
1112# define ffma(Val1, Val2, Val3) __TGMATH_3_NARROW_F (ffma, Val1, Val2, Val3)
1113# define dfma(Val1, Val2, Val3) __TGMATH_3_NARROW_D (dfma, Val1, Val2, Val3)
1114
1115#endif
1116
1117#if __GLIBC_USE (IEC_60559_TYPES_EXT)
1118
1119# if __HAVE_FLOAT16
1120# define f16add(Val1, Val2) __TGMATH_2_NARROW_F16 (f16add, Val1, Val2)
1121# define f16div(Val1, Val2) __TGMATH_2_NARROW_F16 (f16div, Val1, Val2)
1122# define f16mul(Val1, Val2) __TGMATH_2_NARROW_F16 (f16mul, Val1, Val2)
1123# define f16sub(Val1, Val2) __TGMATH_2_NARROW_F16 (f16sub, Val1, Val2)
1124# define f16sqrt(Val) __TGMATH_1_NARROW_F16 (f16sqrt, Val)
1125# define f16fma(Val1, Val2, Val3) \
1126 __TGMATH_3_NARROW_F16 (f16fma, Val1, Val2, Val3)
1127# endif
1128
1129# if __HAVE_FLOAT32
1130# define f32add(Val1, Val2) __TGMATH_2_NARROW_F32 (f32add, Val1, Val2)
1131# define f32div(Val1, Val2) __TGMATH_2_NARROW_F32 (f32div, Val1, Val2)
1132# define f32mul(Val1, Val2) __TGMATH_2_NARROW_F32 (f32mul, Val1, Val2)
1133# define f32sub(Val1, Val2) __TGMATH_2_NARROW_F32 (f32sub, Val1, Val2)
1134# define f32sqrt(Val) __TGMATH_1_NARROW_F32 (f32sqrt, Val)
1135# define f32fma(Val1, Val2, Val3) \
1136 __TGMATH_3_NARROW_F32 (f32fma, Val1, Val2, Val3)
1137# endif
1138
1139# if __HAVE_FLOAT64 && (__HAVE_FLOAT64X || __HAVE_FLOAT128)
1140# define f64add(Val1, Val2) __TGMATH_2_NARROW_F64 (f64add, Val1, Val2)
1141# define f64div(Val1, Val2) __TGMATH_2_NARROW_F64 (f64div, Val1, Val2)
1142# define f64mul(Val1, Val2) __TGMATH_2_NARROW_F64 (f64mul, Val1, Val2)
1143# define f64sub(Val1, Val2) __TGMATH_2_NARROW_F64 (f64sub, Val1, Val2)
1144# define f64sqrt(Val) __TGMATH_1_NARROW_F64 (f64sqrt, Val)
1145# define f64fma(Val1, Val2, Val3) \
1146 __TGMATH_3_NARROW_F64 (f64fma, Val1, Val2, Val3)
1147# endif
1148
1149# if __HAVE_FLOAT32X
1150# define f32xadd(Val1, Val2) __TGMATH_2_NARROW_F32X (f32xadd, Val1, Val2)
1151# define f32xdiv(Val1, Val2) __TGMATH_2_NARROW_F32X (f32xdiv, Val1, Val2)
1152# define f32xmul(Val1, Val2) __TGMATH_2_NARROW_F32X (f32xmul, Val1, Val2)
1153# define f32xsub(Val1, Val2) __TGMATH_2_NARROW_F32X (f32xsub, Val1, Val2)
1154# define f32xsqrt(Val) __TGMATH_1_NARROW_F32X (f32xsqrt, Val)
1155# define f32xfma(Val1, Val2, Val3) \
1156 __TGMATH_3_NARROW_F32X (f32xfma, Val1, Val2, Val3)
1157# endif
1158
1159# if __HAVE_FLOAT64X && (__HAVE_FLOAT128X || __HAVE_FLOAT128)
1160# define f64xadd(Val1, Val2) __TGMATH_2_NARROW_F64X (f64xadd, Val1, Val2)
1161# define f64xdiv(Val1, Val2) __TGMATH_2_NARROW_F64X (f64xdiv, Val1, Val2)
1162# define f64xmul(Val1, Val2) __TGMATH_2_NARROW_F64X (f64xmul, Val1, Val2)
1163# define f64xsub(Val1, Val2) __TGMATH_2_NARROW_F64X (f64xsub, Val1, Val2)
1164# define f64xsqrt(Val) __TGMATH_1_NARROW_F64X (f64xsqrt, Val)
1165# define f64xfma(Val1, Val2, Val3) \
1166 __TGMATH_3_NARROW_F64X (f64xfma, Val1, Val2, Val3)
1167# endif
1168
1169#endif
1170
1171#endif /* tgmath.h */
1172

source code of glibc/math/tgmath.h