math/tgmath.h

   1 /* Copyright (C) 1997 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 Library General Public License as
   6    published by the Free Software Foundation; either version 2 of the
   7    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    Library General Public License for more details.
  13
  14    You should have received a copy of the GNU Library General Public
  15    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  16    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17    Boston, MA 02111-1307, USA.  */
  18
  19 /*
  20  *      ISO C 9X Standard: 7.9 Type-generic math        <tgmath.h>
  21  */
  22
  23 #ifndef _TGMATH_H
  24 #define _TGMATH_H       1
  25
  26 /* Include the needed headers.  */
  27 #include <math.h>
  28 #include <complex.h>
  29
  30
  31 /* Since `complex' is currently not really implemented in most C compilers
  32    and if it is implemented, the implementations differ.  This makes it
  33    quite difficult to write a generic implementation of this header.  We
  34    do not try this for now and instead concentrate only on GNU CC.  Once
  35    we have more information support for other compilers might follow.  */
  36
  37 #if defined __GNUC__ && (__GNUC__ > 2 || __GNUC__ == 2 && __GNUC_MINOR__ >= 7)
  38
  39 /* We have two kinds of generic macros: to support functions which are
  40    only defined on real valued parameters and those which are defined
  41    for complex functions as well.  */
  42 # define __TGMATH_UNARY_REAL_ONLY(Val, Fct) \
  43      (__extension__ (sizeof (__real__ (Val)) == sizeof (double)               \
  44                      ? Fct (Val)                                              \
  45                      : (sizeof (__real__ (Val)) == sizeof (long double)       \
  46                         ? Fct##l (Val)                                        \
  47                         : Fct##f (Val))))
  48
  49 # define __TGMATH_BINARY_FIRST_REAL_ONLY(Val1, Val2, Fct) \
  50      (__extension__ (sizeof (__real__ (Val1)) == sizeof (double)              \
  51                      ? Fct (Val1, Val2)                                       \
  52                      : (sizeof (__real__ (Val1)) == sizeof (long double)      \
  53                         ? Fct##l (Val1, Val2)                                 \
  54                         : Fct##f (Val1, Val2))))
  55
  56 # define __TGMATH_BINARY_REAL_ONLY(Val1, Val2, Fct) \
  57      (__extension__ (sizeof (Val1) == sizeof (double)                         \
  58                      || sizeof (Val2) == sizeof (double)                      \
  59                      ? Fct (Val1, Val2)                                       \
  60                      : (sizeof (Val1) == sizeof (long double)                 \
  61                         || sizeof (Val2) == sizeof (long double)              \
  62                         ? Fct##l (Val1, Val2)                                 \
  63                         : Fct##f (Val1, Val2))))
  64
  65 # define __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY(Val1, Val2, Val3, Fct) \
  66      (__extension__ (sizeof (Val1) == sizeof (double)                         \
  67                      || sizeof (Val2) == sizeof (double)                      \
  68                      ? Fct (Val1, Val2, Val3)                                 \
  69                      : (sizeof (Val1) == sizeof (long double)                 \
  70                         || sizeof (Val2) == sizeof (long double)              \
  71                         ? Fct##l (Val1, Val2, Val3)                           \
  72                         : Fct##f (Val1, Val2, Val3))))
  73
  74 # define __TGMATH_UNARY_REAL_IMAG(Val, Fct, Cfct) \
  75      (__extension__ (sizeof (__real__ (Val)) == sizeof (double)               \
  76                      ? (sizeof (__real__ (Val)) == sizeof (Val)               \
  77                         ? Fct (Val)                                           \
  78                         : Cfct (Val))                                         \
  79                      : (sizeof (__real__ (Val)) == sizeof (long double)       \
  80                         ? (sizeof (__real__ (Val)) == sizeof (Val)            \
  81                            ? Fct##l (Val)                                     \
  82                            : Cfct##l (Val))                                   \
  83                         : (sizeof (__real__ (Val)) == sizeof (Val)            \
  84                            ? Fct##f (Val)                                     \
  85                            : Cfct##f (Val)))))
  86
  87 # define __TGMATH_UNARY_IMAG_ONLY(Val, Fct) \
  88      (__extension__ (sizeof (Val) == sizeof (__complex__ double)              \
  89                      ? Fct (Val)                                              \
  90                      : (sizeof (Val) == sizeof (__complex__ long double)      \
  91                         ? Fct##l (Val)                                        \
  92                         : Fct##f (Val))))
  93
  94 # define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct) \
  95      (__extension__ (sizeof (__real__ (Val1)) == sizeof (double)              \
  96                      || sizeof (__real__ (Val2)) == sizeof (double)           \
  97                      ? (sizeof (__real__ (Val1)) == sizeof (Val1)             \
  98                         && sizeof (__real__ (Val2)) == sizeof (Val2)          \
  99                         ? Fct (Val1, Val2)                                    \
 100                         : Cfct (Val1, Val2))                                  \
 101                      : (sizeof (__real__ (Val1)) == sizeof (long double)      \
 102                         || sizeof (__real__ (Val2)) == sizeof (long double)   \
 103                         ? (sizeof (__real__ (Val1)) == sizeof (Val1)          \
 104                            && sizeof (__real__ (Val2)) == sizeof (Val2)       \
 105                            ? Fct##l (Val1, Val2)                              \
 106                            : Cfct##l (Val1, Val2))                            \
 107                         : (sizeof (__real__ (Val1)) == sizeof (Val1)          \
 108                            && sizeof (__real__ (Val2)) == sizeof (Val2)       \
 109                            ? Fct##f (Val1, Val2)                              \
 110                            : Cfct##f (Val1, Val2)))))
 111 #else
 112 # error "Unsupported compiler; you cannot use <tgmath.h>"
 113 #endif
 114
 115
 116 /* Unary functions defined for real and complex values.  */
 117
 118
 119 /* Trigonometric functions.  */
 120
 121 /* Arc cosine of X.  */
 122 #define acos(Val) __TGMATH_UNARY_REAL_IMAG (Val, acos, cacos)
 123 /* Arc sine of X.  */
 124 #define asin(Val) __TGMATH_UNARY_REAL_IMAG (Val, asin, casin)
 125 /* Arc tangent of X.  */
 126 #define atan(Val) __TGMATH_UNARY_REAL_IMAG (Val, atan, catan)
 127 /* Arc tangent of Y/X.  */
 128 #define atan2(Val) __TGMATH_UNARY_REAL_ONLY (Val, atan2)
 129
 130 /* Cosine of X.  */
 131 #define cos(Val) __TGMATH_UNARY_REAL_IMAG (Val, cos, ccos)
 132 /* Sine of X.  */
 133 #define sin(Val) __TGMATH_UNARY_REAL_IMAG (Val, sin, csin)
 134 /* Tangent of X.  */
 135 #define tan(Val) __TGMATH_UNARY_REAL_IMAG (Val, tan, ctan)
 136
 137
 138 /* Hyperbolic functions.  */
 139
 140 /* Hyperbolic arc cosine of X.  */
 141 #define acosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, acosh, cacosh)
 142 /* Hyperbolic arc sine of X.  */
 143 #define asinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, asinh, casinh)
 144 /* Hyperbolic arc tangent of X.  */
 145 #define atanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, atanh, catanh)
 146
 147 /* Hyperbolic cosine of X.  */
 148 #define cosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, cosh, ccosh)
 149 /* Hyperbolic sine of X.  */
 150 #define sinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, sinh, csinh)
 151 /* Hyperbolic tangent of X.  */
 152 #define tanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, tanh, ctanh)
 153
 154
 155 /* Exponential and logarithmic functions.  */
 156
 157 /* Exponential function of X.  */
 158 #define exp(Val) __TGMATH_UNARY_REAL_IMAG (Val, exp, cexp)
 159
 160 /* Break VALUE into a normalized fraction and an integral power of 2.  */
 161 #define frexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, frexp)
 162
 163 /* X times (two to the EXP power).  */
 164 #define ldexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, ldexp)
 165
 166 /* Natural logarithm of X.  */
 167 #define log(Val) __TGMATH_UNARY_REAL_IMAG (Val, log, clog)
 168
 169 /* Base-ten logarithm of X.  */
 170 #ifdef __USE_GNU
 171 # define log10(Val) __TGMATH_UNARY_REAL_IMAG (Val, log10, __clog10)
 172 #else
 173 # define log10(Val) __TGMATH_UNARY_REAL_ONLY (Val, log10)
 174 #endif
 175
 176 /* Return exp(X) - 1.  */
 177 #define expm1(Val) __TGMATH_UNARY_REAL_ONLY (Val, expm1)
 178
 179 /* Return log(1 + X).  */
 180 #define log1p(Val) __TGMATH_UNARY_REAL_ONLY (Val, log1p)
 181
 182 /* Return the base 2 signed integral exponent of X.  */
 183 #define logb(Val) __TGMATH_UNARY_REAL_ONLY (Val, logb)
 184
 185 /* Compute base-2 exponential of X.  */
 186 #define exp2(Val) __TGMATH_UNARY_REAL_ONLY (Val, exp2)
 187
 188 /* Compute base-2 logarithm of X.  */
 189 #define log2(Val) __TGMATH_UNARY_REAL_ONLY (Val, log2)
 190
 191
 192 /* Power functions.  */
 193
 194 /* Return X to the Y power.  */
 195 #define pow(Val1, Val2) __TGMATH_BINARY_REAL_IMAG (Val1, Val2, pow, cpow)
 196
 197 /* Return the square root of X.  */
 198 #define sqrt(Val) __TGMATH_UNARY_REAL_IMAG (Val, sqrt, csqrt)
 199
 200 /* Return `sqrt(X*X + Y*Y)'.  */
 201 #define hypot(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, hypot)
 202
 203 /* Return the cube root of X.  */
 204 #define cbrt(Val) __TGMATH_UNARY_REAL_ONLY (Val, cbrt)
 205
 206
 207 /* Nearest integer, absolute value, and remainder functions.  */
 208
 209 /* Smallest integral value not less than X.  */
 210 #define ceil(Val) __TGMATH_UNARY_REAL_ONLY (Val, ceil)
 211
 212 /* Absolute value of X.  */
 213 #define fabs(Val) __TGMATH_UNARY_REAL_IMAG (Val, fabs, cabs)
 214
 215 /* Largest integer not greater than X.  */
 216 #define floor(Val) __TGMATH_UNARY_REAL_ONLY (Val, floor)
 217
 218 /* Floating-point modulo remainder of X/Y.  */
 219 #define fmod(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmod)
 220
 221 /* Round X to integral valuein floating-point format using current
 222    rounding direction, but do not raise inexact exception.  */
 223 #define nearbyint(Val) __TGMATH_UNARY_REAL_ONLY (Val, nearbyint)
 224
 225 /* Round X to nearest integral value, rounding halfway cases away from
 226    zero.  */
 227 #define round(Val) __TGMATH_UNARY_REAL_ONLY (Val, round)
 228
 229 /* Round X to the integral value in floating-point format nearest but
 230    not larger in magnitude.  */
 231 #define trunc(Val) __TGMATH_UNARY_REAL_ONLY (Val, trunc)
 232
 233 /* Compute remainder of X and Y and put in *QUO a value with sign of x/y
 234    and magnitude congruent `mod 2^n' to the magnitude of the integral
 235    quotient x/y, with n >= 3.  */
 236 #define remquo(Val1, Val2, Val3) \
 237      __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY (Val1, Val2, Val3, remquo)
 238
 239 /* Round X to nearest integral value according to current rounding
 240    direction.  */
 241 #define lrint(Val) __TGMATH_UNARY_REAL_ONLY (Val, lrint)
 242 #define llrint(Val) __TGMATH_UNARY_REAL_ONLY (Val, llrint)
 243
 244 /* Round X to nearest integral value, rounding halfway cases away from
 245    zero.  */
 246 #define lround(Val) __TGMATH_UNARY_REAL_ONLY (Val, lround)
 247 #define llround(Val) __TGMATH_UNARY_REAL_ONLY (Val, llround)
 248
 249
 250 /* Return X with its signed changed to Y's.  */
 251 #define copysign(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, copysign)
 252
 253 /* Error and gamma functions.  */
 254 #define erf(Val) __TGMATH_UNARY_REAL_ONLY (Val, erf)
 255 #define erfc(Val) __TGMATH_UNARY_REAL_ONLY (Val, erfc)
 256 #define gamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, gamma)
 257 #define lgamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, lgamma)
 258
 259
 260 /* Return the integer nearest X in the direction of the
 261    prevailing rounding mode.  */
 262 #define rint(Val) __TGMATH_UNARY_REAL_ONLY (Val, rint)
 263
 264 /* Return X + epsilon if X < Y, X - epsilon if X > Y.  */
 265 #define nextafter(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, nextafter)
 266 #define nextafterx(Val1, Val2) \
 267      __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, nextafterx)
 268
 269 /* Return the remainder of integer divison X / Y with infinite precision.  */
 270 #define remainder(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, remainder)
 271
 272 /* Return X times (2 to the Nth power).  */
 273 #define scalb(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, scalb)
 274
 275 /* Return X times (2 to the Nth power).  */
 276 #define scalbn(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbn)
 277
 278 /* Return X times (2 to the Nth power).  */
 279 #define scalbln(Val1, Val2) \
 280      __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbln)
 281
 282 /* Return the binary exponent of X, which must be nonzero.  */
 283 #define ilogb(Val) __TGMATH_UNARY_REAL_ONLY (Val, ilogb)
 284
 285
 286 /* Return positive difference between X and Y.  */
 287 #define fdim(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fdim)
 288
 289 /* Return maximum numeric value from X and Y.  */
 290 #define fmax(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmax)
 291
 292 /* Return minimum numeric value from X and Y.  */
 293 #define fmin(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmin)
 294
 295
 296 /* Absolute value, conjugates, and projection.  */
 297
 298 /* Argument value of Z.  */
 299 #define carg(Val) __TGMATH_UNARY_IMAG_ONLY (Val, carg)
 300
 301 /* Complex conjugate of Z.  */
 302 #define conj(Val) __TGMATH_UNARY_IMAG_ONLY (Val, conj)
 303
 304 /* Projection of Z onto the Riemann sphere.  */
 305 #define cproj(Val) __TGMATH_UNARY_IMAG_ONLY (Val, cproj)
 306
 307
 308 /* Decomposing complex values.  */
 309
 310 /* Imaginary part of Z.  */
 311 #define cimag(Val) __TGMATH_UNARY_IMAG_ONLY (Val, cimag)
 312
 313 /* Real part of Z.  */
 314 #define creal(Val) __TGMATH_UNARY_IMAG_ONLY (Val, creal)
 315
 316 #endif /* tgmath.h */