76513f7ea83227a7c4a299573f258ca3b927b9dd
[kopensolaris-gnu/glibc.git] / math / tgmath.h
1 /* Copyright (C) 1997, 1998 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 (Val) == sizeof (double)                          \
44                      ? Fct (Val)                                              \
45                      : (sizeof (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 (Val1) > sizeof (double)                          \
51                      ? Fct##l (Val1, Val2)                                    \
52                      : (sizeof (Val1) == sizeof (double)                      \
53                         ? Fct (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##l (Val1, Val2)                                    \
60                      : (sizeof (Val1) == sizeof (double)                      \
61                         || sizeof (Val2) == sizeof (double)                   \
62                         ? Fct (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##l (Val1, Val2, Val3)                              \
69                      : (sizeof (Val1) == sizeof (double)                      \
70                         || sizeof (Val2) == sizeof (double)                   \
71                         ? Fct (Val1, Val2, Val3)                              \
72                         : Fct##f (Val1, Val2, Val3))))
73
74 # define __TGMATH_TERNARY_REAL_ONLY(Val1, Val2, Val3, Fct) \
75      (__extension__ (sizeof (Val1) > sizeof (double)                          \
76                      || sizeof (Val2) > sizeof (double)                       \
77                      || sizeof (Val3) > sizeof (double)                       \
78                      ? Fct##l (Val1, Val2, Val3)                              \
79                      : (sizeof (Val1) == sizeof (double)                      \
80                         || sizeof (Val2) == sizeof (double)                   \
81                         || sizeof (Val3) == sizeof (double)                   \
82                         ? Fct (Val1, Val2, Val3)                              \
83                         : Fct##f (Val1, Val2, Val3))))
84
85 # define __TGMATH_UNARY_REAL_IMAG(Val, Fct, Cfct) \
86      (__extension__ (sizeof (__real__ (Val)) > sizeof (double)                \
87                      ? (sizeof (__real__ (Val)) == sizeof (Val)               \
88                         ? Fct##l (Val)                                        \
89                         : Cfct##l (Val))                                      \
90                      : (sizeof (__real__ (Val)) == sizeof (double)            \
91                         ? (sizeof (__real__ (Val)) == sizeof (Val)            \
92                            ? Fct (Val)                                        \
93                            : Cfct (Val))                                      \
94                         : (sizeof (__real__ (Val)) == sizeof (Val)            \
95                            ? Fct##f (Val)                                     \
96                            : Cfct##f (Val)))))
97
98 /* XXX This definition has to be changed as soon as the compiler understands
99    the imaginary keyword.  */
100 # define __TGMATH_UNARY_IMAG_ONLY(Val, Fct) \
101      (__extension__ (sizeof (Val) > sizeof (__complex__ double)               \
102                      ? Fct##l (Val)                                           \
103                      : (sizeof (Val) == sizeof (__complex__ double)           \
104                         ? Fct (Val)                                           \
105                         : Fct##f (Val))))
106
107 # define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct) \
108      (__extension__ (sizeof (__real__ (Val1)) > sizeof (double)               \
109                      || sizeof (__real__ (Val2)) > sizeof (double)            \
110                      ? (sizeof (__real__ (Val1)) == sizeof (Val1)             \
111                         && sizeof (__real__ (Val2)) == sizeof (Val2)          \
112                         ? Fct##l (Val1, Val2)                                 \
113                         : Cfct##l (Val1, Val2))                               \
114                      : (sizeof (__real__ (Val1)) == sizeof (double)           \
115                         || sizeof (__real__ (Val2)) == sizeof (double)        \
116                         ? (sizeof (__real__ (Val1)) == sizeof (Val1)          \
117                            && sizeof (__real__ (Val2)) == sizeof (Val2)       \
118                            ? Fct (Val1, Val2)                                 \
119                            : Cfct (Val1, Val2))                               \
120                         : (sizeof (__real__ (Val1)) == sizeof (Val1)          \
121                            && sizeof (__real__ (Val2)) == sizeof (Val2)       \
122                            ? Fct##f (Val1, Val2)                              \
123                            : Cfct##f (Val1, Val2)))))
124 #else
125 # error "Unsupported compiler; you cannot use <tgmath.h>"
126 #endif
127
128
129 /* Unary functions defined for real and complex values.  */
130
131
132 /* Trigonometric functions.  */
133
134 /* Arc cosine of X.  */
135 #define acos(Val) __TGMATH_UNARY_REAL_IMAG (Val, acos, cacos)
136 /* Arc sine of X.  */
137 #define asin(Val) __TGMATH_UNARY_REAL_IMAG (Val, asin, casin)
138 /* Arc tangent of X.  */
139 #define atan(Val) __TGMATH_UNARY_REAL_IMAG (Val, atan, catan)
140 /* Arc tangent of Y/X.  */
141 #define atan2(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, atan2)
142
143 /* Cosine of X.  */
144 #define cos(Val) __TGMATH_UNARY_REAL_IMAG (Val, cos, ccos)
145 /* Sine of X.  */
146 #define sin(Val) __TGMATH_UNARY_REAL_IMAG (Val, sin, csin)
147 /* Tangent of X.  */
148 #define tan(Val) __TGMATH_UNARY_REAL_IMAG (Val, tan, ctan)
149
150
151 /* Hyperbolic functions.  */
152
153 /* Hyperbolic arc cosine of X.  */
154 #define acosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, acosh, cacosh)
155 /* Hyperbolic arc sine of X.  */
156 #define asinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, asinh, casinh)
157 /* Hyperbolic arc tangent of X.  */
158 #define atanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, atanh, catanh)
159
160 /* Hyperbolic cosine of X.  */
161 #define cosh(Val) __TGMATH_UNARY_REAL_IMAG (Val, cosh, ccosh)
162 /* Hyperbolic sine of X.  */
163 #define sinh(Val) __TGMATH_UNARY_REAL_IMAG (Val, sinh, csinh)
164 /* Hyperbolic tangent of X.  */
165 #define tanh(Val) __TGMATH_UNARY_REAL_IMAG (Val, tanh, ctanh)
166
167
168 /* Exponential and logarithmic functions.  */
169
170 /* Exponential function of X.  */
171 #define exp(Val) __TGMATH_UNARY_REAL_IMAG (Val, exp, cexp)
172
173 /* Break VALUE into a normalized fraction and an integral power of 2.  */
174 #define frexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, frexp)
175
176 /* X times (two to the EXP power).  */
177 #define ldexp(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, ldexp)
178
179 /* Natural logarithm of X.  */
180 #define log(Val) __TGMATH_UNARY_REAL_IMAG (Val, log, clog)
181
182 /* Base-ten logarithm of X.  */
183 #ifdef __USE_GNU
184 # define log10(Val) __TGMATH_UNARY_REAL_IMAG (Val, log10, __clog10)
185 #else
186 # define log10(Val) __TGMATH_UNARY_REAL_ONLY (Val, log10)
187 #endif
188
189 /* Return exp(X) - 1.  */
190 #define expm1(Val) __TGMATH_UNARY_REAL_ONLY (Val, expm1)
191
192 /* Return log(1 + X).  */
193 #define log1p(Val) __TGMATH_UNARY_REAL_ONLY (Val, log1p)
194
195 /* Return the base 2 signed integral exponent of X.  */
196 #define logb(Val) __TGMATH_UNARY_REAL_ONLY (Val, logb)
197
198 /* Compute base-2 exponential of X.  */
199 #define exp2(Val) __TGMATH_UNARY_REAL_ONLY (Val, exp2)
200
201 /* Compute base-2 logarithm of X.  */
202 #define log2(Val) __TGMATH_UNARY_REAL_ONLY (Val, log2)
203
204
205 /* Power functions.  */
206
207 /* Return X to the Y power.  */
208 #define pow(Val1, Val2) __TGMATH_BINARY_REAL_IMAG (Val1, Val2, pow, cpow)
209
210 /* Return the square root of X.  */
211 #define sqrt(Val) __TGMATH_UNARY_REAL_IMAG (Val, sqrt, csqrt)
212
213 /* Return `sqrt(X*X + Y*Y)'.  */
214 #define hypot(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, hypot)
215
216 /* Return the cube root of X.  */
217 #define cbrt(Val) __TGMATH_UNARY_REAL_ONLY (Val, cbrt)
218
219
220 /* Nearest integer, absolute value, and remainder functions.  */
221
222 /* Smallest integral value not less than X.  */
223 #define ceil(Val) __TGMATH_UNARY_REAL_ONLY (Val, ceil)
224
225 /* Absolute value of X.  */
226 #define fabs(Val) __TGMATH_UNARY_REAL_IMAG (Val, fabs, cabs)
227
228 /* Largest integer not greater than X.  */
229 #define floor(Val) __TGMATH_UNARY_REAL_ONLY (Val, floor)
230
231 /* Floating-point modulo remainder of X/Y.  */
232 #define fmod(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmod)
233
234 /* Round X to integral valuein floating-point format using current
235    rounding direction, but do not raise inexact exception.  */
236 #define nearbyint(Val) __TGMATH_UNARY_REAL_ONLY (Val, nearbyint)
237
238 /* Round X to nearest integral value, rounding halfway cases away from
239    zero.  */
240 #define round(Val) __TGMATH_UNARY_REAL_ONLY (Val, round)
241
242 /* Round X to the integral value in floating-point format nearest but
243    not larger in magnitude.  */
244 #define trunc(Val) __TGMATH_UNARY_REAL_ONLY (Val, trunc)
245
246 /* Compute remainder of X and Y and put in *QUO a value with sign of x/y
247    and magnitude congruent `mod 2^n' to the magnitude of the integral
248    quotient x/y, with n >= 3.  */
249 #define remquo(Val1, Val2, Val3) \
250      __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY (Val1, Val2, Val3, remquo)
251
252 /* Round X to nearest integral value according to current rounding
253    direction.  */
254 #define lrint(Val) __TGMATH_UNARY_REAL_ONLY (Val, lrint)
255 #define llrint(Val) __TGMATH_UNARY_REAL_ONLY (Val, llrint)
256
257 /* Round X to nearest integral value, rounding halfway cases away from
258    zero.  */
259 #define lround(Val) __TGMATH_UNARY_REAL_ONLY (Val, lround)
260 #define llround(Val) __TGMATH_UNARY_REAL_ONLY (Val, llround)
261
262
263 /* Return X with its signed changed to Y's.  */
264 #define copysign(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, copysign)
265
266 /* Error and gamma functions.  */
267 #define erf(Val) __TGMATH_UNARY_REAL_ONLY (Val, erf)
268 #define erfc(Val) __TGMATH_UNARY_REAL_ONLY (Val, erfc)
269 #define gamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, gamma)
270 #define lgamma(Val) __TGMATH_UNARY_REAL_ONLY (Val, lgamma)
271
272
273 /* Return the integer nearest X in the direction of the
274    prevailing rounding mode.  */
275 #define rint(Val) __TGMATH_UNARY_REAL_ONLY (Val, rint)
276
277 /* Return X + epsilon if X < Y, X - epsilon if X > Y.  */
278 #define nextafter(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, nextafter)
279 #define nextafterx(Val1, Val2) \
280      __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, nextafterx)
281
282 /* Return the remainder of integer divison X / Y with infinite precision.  */
283 #define remainder(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, remainder)
284
285 /* Return X times (2 to the Nth power).  */
286 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED
287 #define scalb(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, scalb)
288 #endif
289
290 /* Return X times (2 to the Nth power).  */
291 #define scalbn(Val1, Val2) __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbn)
292
293 /* Return X times (2 to the Nth power).  */
294 #define scalbln(Val1, Val2) \
295      __TGMATH_BINARY_FIRST_REAL_ONLY (Val1, Val2, scalbln)
296
297 /* Return the binary exponent of X, which must be nonzero.  */
298 #define ilogb(Val) __TGMATH_UNARY_REAL_ONLY (Val, ilogb)
299
300
301 /* Return positive difference between X and Y.  */
302 #define fdim(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fdim)
303
304 /* Return maximum numeric value from X and Y.  */
305 #define fmax(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmax)
306
307 /* Return minimum numeric value from X and Y.  */
308 #define fmin(Val1, Val2) __TGMATH_BINARY_REAL_ONLY (Val1, Val2, fmin)
309
310
311 /* Multiply-add function computed as a ternary operation.  */
312 #define fma(Vat1, Val2, Val3) \
313      __TGMATH_TERNARY_REAL_ONLY (Val1, Val2, Val3, fma)
314
315
316 /* Absolute value, conjugates, and projection.  */
317
318 /* Argument value of Z.  */
319 #define carg(Val) __TGMATH_UNARY_IMAG_ONLY (Val, carg)
320
321 /* Complex conjugate of Z.  */
322 #define conj(Val) __TGMATH_UNARY_IMAG_ONLY (Val, conj)
323
324 /* Projection of Z onto the Riemann sphere.  */
325 #define cproj(Val) __TGMATH_UNARY_IMAG_ONLY (Val, cproj)
326
327
328 /* Decomposing complex values.  */
329
330 /* Imaginary part of Z.  */
331 #define cimag(Val) __TGMATH_UNARY_IMAG_ONLY (Val, cimag)
332
333 /* Real part of Z.  */
334 #define creal(Val) __TGMATH_UNARY_IMAG_ONLY (Val, creal)
335
336 #endif /* tgmath.h */