math/tgmath.h

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