]>
Commit | Line | Data |
---|---|---|
320054e8 DG |
1 | #ifndef _TGMATH_H |
2 | #define _TGMATH_H | |
3 | ||
4 | /* | |
5 | the return types are only correct with gcc (__GNUC__) | |
6 | otherwise they are long double or long double complex | |
7 | ||
8 | the long double version of a function is never chosen when | |
9 | sizeof(double) == sizeof(long double) | |
10 | (but the return type is set correctly with gcc) | |
11 | */ | |
12 | ||
13 | #include <math.h> | |
14 | #include <complex.h> | |
15 | ||
16 | #define __IS_FP(x) (sizeof((x)+1ULL) == sizeof((x)+1.0f)) | |
17 | #define __IS_CX(x) (__IS_FP(x) && sizeof(x) == sizeof((x)+I)) | |
18 | #define __IS_REAL(x) (__IS_FP(x) && 2*sizeof(x) == sizeof((x)+I)) | |
19 | ||
20 | #define __FLT(x) (__IS_REAL(x) && sizeof(x) == sizeof(float)) | |
21 | #define __LDBL(x) (__IS_REAL(x) && sizeof(x) == sizeof(long double) && sizeof(long double) != sizeof(double)) | |
22 | ||
23 | #define __FLTCX(x) (__IS_CX(x) && sizeof(x) == sizeof(float complex)) | |
24 | #define __DBLCX(x) (__IS_CX(x) && sizeof(x) == sizeof(double complex)) | |
25 | #define __LDBLCX(x) (__IS_CX(x) && sizeof(x) == sizeof(long double complex) && sizeof(long double) != sizeof(double)) | |
26 | ||
27 | /* return type */ | |
28 | ||
29 | #ifdef __GNUC__ | |
30 | /* | |
31 | the result must be casted to the right type | |
32 | (otherwise the result type is determined by the conversion | |
33 | rules applied to all the function return types so it is long | |
34 | double or long double complex except for integral functions) | |
35 | ||
36 | this cannot be done in c99, so the typeof gcc extension is | |
37 | used and that the type of ?: depends on wether an operand is | |
38 | a null pointer constant or not | |
39 | (in c11 _Generic can be used) | |
40 | ||
41 | the c arguments below must be integer constant expressions | |
42 | so they can be in null pointer constants | |
43 | (__IS_FP above was carefully chosen this way) | |
44 | */ | |
45 | /* if c then t else void */ | |
46 | #define __type1(c,t) __typeof__(*(0?(t*)0:(void*)!(c))) | |
47 | /* if c then t1 else t2 */ | |
48 | #define __type2(c,t1,t2) __typeof__(*(0?(__type1(c,t1)*)0:(__type1(!(c),t2)*)0)) | |
49 | /* cast to double when x is integral, otherwise use typeof(x) */ | |
50 | #define __RETCAST(x) ( \ | |
51 | __type2(__IS_FP(x), __typeof__(x), double)) | |
52 | /* 2 args case, should work for complex types (cpow) */ | |
53 | #define __RETCAST_2(x, y) ( \ | |
54 | __type2(__IS_FP(x) && __IS_FP(y), \ | |
55 | __typeof__((x)+(y)), \ | |
56 | __typeof__((x)+(y)+1.0))) | |
57 | /* 3 args case (fma only) */ | |
58 | #define __RETCAST_3(x, y, z) ( \ | |
59 | __type2(__IS_FP(x) && __IS_FP(y) && __IS_FP(z), \ | |
60 | __typeof__((x)+(y)+(z)), \ | |
61 | __typeof__((x)+(y)+(z)+1.0))) | |
62 | /* drop complex from the type of x */ | |
63 | /* TODO: wrong when sizeof(long double)==sizeof(double) */ | |
64 | #define __RETCAST_REAL(x) ( \ | |
65 | __type2(__IS_FP(x) && sizeof((x)+I) == sizeof(float complex), float, \ | |
66 | __type2(sizeof((x)+1.0+I) == sizeof(double complex), double, \ | |
67 | long double))) | |
68 | /* add complex to the type of x */ | |
69 | #define __RETCAST_CX(x) (__typeof__(__RETCAST(x)0+I)) | |
70 | #else | |
71 | #define __RETCAST(x) | |
72 | #define __RETCAST_2(x, y) | |
73 | #define __RETCAST_3(x, y, z) | |
74 | #define __RETCAST_REAL(x) | |
75 | #define __RETCAST_CX(x) | |
76 | #endif | |
77 | ||
78 | /* function selection */ | |
79 | ||
80 | #define __tg_real_nocast(fun, x) ( \ | |
81 | __FLT(x) ? fun ## f (x) : \ | |
82 | __LDBL(x) ? fun ## l (x) : \ | |
83 | fun(x) ) | |
84 | ||
85 | #define __tg_real(fun, x) (__RETCAST(x)__tg_real_nocast(fun, x)) | |
86 | ||
87 | #define __tg_real_2_1(fun, x, y) (__RETCAST(x)( \ | |
88 | __FLT(x) ? fun ## f (x, y) : \ | |
89 | __LDBL(x) ? fun ## l (x, y) : \ | |
90 | fun(x, y) )) | |
91 | ||
92 | #define __tg_real_2(fun, x, y) (__RETCAST_2(x, y)( \ | |
93 | __FLT(x) && __FLT(y) ? fun ## f (x, y) : \ | |
94 | __LDBL((x)+(y)) ? fun ## l (x, y) : \ | |
95 | fun(x, y) )) | |
96 | ||
97 | #define __tg_complex(fun, x) (__RETCAST_CX(x)( \ | |
98 | __FLTCX((x)+I) && __IS_FP(x) ? fun ## f (x) : \ | |
99 | __LDBLCX((x)+I) ? fun ## l (x) : \ | |
100 | fun(x) )) | |
101 | ||
102 | #define __tg_complex_retreal(fun, x) (__RETCAST_REAL(x)( \ | |
103 | __FLTCX((x)+I) && __IS_FP(x) ? fun ## f (x) : \ | |
104 | __LDBLCX((x)+I) ? fun ## l (x) : \ | |
105 | fun(x) )) | |
106 | ||
107 | #define __tg_real_complex(fun, x) (__RETCAST(x)( \ | |
108 | __FLTCX(x) ? c ## fun ## f (x) : \ | |
109 | __DBLCX(x) ? c ## fun (x) : \ | |
110 | __LDBLCX(x) ? c ## fun ## l (x) : \ | |
111 | __FLT(x) ? fun ## f (x) : \ | |
112 | __LDBL(x) ? fun ## l (x) : \ | |
113 | fun(x) )) | |
114 | ||
115 | /* special cases */ | |
116 | ||
117 | #define __tg_real_remquo(x, y, z) (__RETCAST_2(x, y)( \ | |
118 | __FLT(x) && __FLT(y) ? remquof(x, y, z) : \ | |
119 | __LDBL((x)+(y)) ? remquol(x, y, z) : \ | |
120 | remquo(x, y, z) )) | |
121 | ||
122 | #define __tg_real_fma(x, y, z) (__RETCAST_3(x, y, z)( \ | |
123 | __FLT(x) && __FLT(y) && __FLT(z) ? fmaf(x, y, z) : \ | |
124 | __LDBL((x)+(y)+(z)) ? fmal(x, y, z) : \ | |
125 | fma(x, y, z) )) | |
126 | ||
127 | #define __tg_real_complex_pow(x, y) (__RETCAST_2(x, y)( \ | |
128 | __FLTCX((x)+(y)) && __IS_FP(x) && __IS_FP(y) ? cpowf(x, y) : \ | |
129 | __FLTCX((x)+(y)) ? cpow(x, y) : \ | |
130 | __DBLCX((x)+(y)) ? cpow(x, y) : \ | |
131 | __LDBLCX((x)+(y)) ? cpowl(x, y) : \ | |
132 | __FLT(x) && __FLT(y) ? powf(x, y) : \ | |
133 | __LDBL((x)+(y)) ? powl(x, y) : \ | |
134 | pow(x, y) )) | |
135 | ||
136 | #define __tg_real_complex_fabs(x) (__RETCAST_REAL(x)( \ | |
137 | __FLTCX(x) ? cabsf(x) : \ | |
138 | __DBLCX(x) ? cabs(x) : \ | |
139 | __LDBLCX(x) ? cabsl(x) : \ | |
140 | __FLT(x) ? fabsf(x) : \ | |
141 | __LDBL(x) ? fabsl(x) : \ | |
142 | fabs(x) )) | |
143 | ||
144 | /* suppress any macros in math.h or complex.h */ | |
145 | ||
146 | #undef acos | |
147 | #undef acosh | |
148 | #undef asin | |
149 | #undef asinh | |
150 | #undef atan | |
151 | #undef atan2 | |
152 | #undef atanh | |
153 | #undef carg | |
154 | #undef cbrt | |
155 | #undef ceil | |
156 | #undef cimag | |
157 | #undef conj | |
158 | #undef copysign | |
159 | #undef cos | |
160 | #undef cosh | |
161 | #undef cproj | |
162 | #undef creal | |
163 | #undef erf | |
164 | #undef erfc | |
165 | #undef exp | |
166 | #undef exp2 | |
167 | #undef expm1 | |
168 | #undef fabs | |
169 | #undef fdim | |
170 | #undef floor | |
171 | #undef fma | |
172 | #undef fmax | |
173 | #undef fmin | |
174 | #undef fmod | |
175 | #undef frexp | |
176 | #undef hypot | |
177 | #undef ilogb | |
178 | #undef ldexp | |
179 | #undef lgamma | |
180 | #undef llrint | |
181 | #undef llround | |
182 | #undef log | |
183 | #undef log10 | |
184 | #undef log1p | |
185 | #undef log2 | |
186 | #undef logb | |
187 | #undef lrint | |
188 | #undef lround | |
189 | #undef nearbyint | |
190 | #undef nextafter | |
191 | #undef nexttoward | |
192 | #undef pow | |
193 | #undef remainder | |
194 | #undef remquo | |
195 | #undef rint | |
196 | #undef round | |
197 | #undef scalbln | |
198 | #undef scalbn | |
199 | #undef sin | |
200 | #undef sinh | |
201 | #undef sqrt | |
202 | #undef tan | |
203 | #undef tanh | |
204 | #undef tgamma | |
205 | #undef trunc | |
206 | ||
207 | /* tg functions */ | |
208 | ||
209 | #define acos(x) __tg_real_complex(acos, (x)) | |
210 | #define acosh(x) __tg_real_complex(acosh, (x)) | |
211 | #define asin(x) __tg_real_complex(asin, (x)) | |
212 | #define asinh(x) __tg_real_complex(asinh, (x)) | |
213 | #define atan(x) __tg_real_complex(atan, (x)) | |
214 | #define atan2(x,y) __tg_real_2(atan2, (x), (y)) | |
215 | #define atanh(x) __tg_real_complex(atanh, (x)) | |
216 | #define carg(x) __tg_complex_retreal(carg, (x)) | |
217 | #define cbrt(x) __tg_real(cbrt, (x)) | |
218 | #define ceil(x) __tg_real(ceil, (x)) | |
219 | #define cimag(x) __tg_complex_retreal(cimag, (x)) | |
220 | #define conj(x) __tg_complex(conj, (x)) | |
221 | #define copysign(x,y) __tg_real_2(copysign, (x), (y)) | |
222 | #define cos(x) __tg_real_complex(cos, (x)) | |
223 | #define cosh(x) __tg_real_complex(cosh, (x)) | |
224 | #define cproj(x) __tg_complex(cproj, (x)) | |
225 | #define creal(x) __tg_complex_retreal(creal, (x)) | |
226 | #define erf(x) __tg_real(erf, (x)) | |
227 | #define erfc(x) __tg_real(erfc, (x)) | |
228 | #define exp(x) __tg_real_complex(exp, (x)) | |
229 | #define exp2(x) __tg_real(exp2, (x)) | |
230 | #define expm1(x) __tg_real(expm1, (x)) | |
231 | #define fabs(x) __tg_real_complex_fabs(x) | |
232 | #define fdim(x,y) __tg_real_2(fdim, (x), (y)) | |
233 | #define floor(x) __tg_real(floor, (x)) | |
234 | #define fma(x,y,z) __tg_real_fma((x), (y), (z)) | |
235 | #define fmax(x,y) __tg_real_2(fmax, (x), (y)) | |
236 | #define fmin(x,y) __tg_real_2(fmin, (x), (y)) | |
237 | #define fmod(x,y) __tg_real_2(fmod, (x), (y)) | |
238 | #define frexp(x,y) __tg_real_2_1(frexp, (x), (y)) | |
239 | #define hypot(x,y) __tg_real_2(hypot, (x), (y)) | |
240 | #define ilogb(x) __tg_real_nocast(ilogb, (x)) | |
241 | #define ldexp(x,y) __tg_real_2_1(ldexp, (x), (y)) | |
242 | #define lgamma(x) __tg_real(lgamma, (x)) | |
243 | #define llrint(x) __tg_real_nocast(llrint, (x)) | |
244 | #define llround(x) __tg_real_nocast(llround, (x)) | |
245 | #define log(x) __tg_real_complex(log, (x)) | |
246 | #define log10(x) __tg_real(log10, (x)) | |
247 | #define log1p(x) __tg_real(log1p, (x)) | |
248 | #define log2(x) __tg_real(log2, (x)) | |
249 | #define logb(x) __tg_real(logb, (x)) | |
250 | #define lrint(x) __tg_real_nocast(lrint, (x)) | |
251 | #define lround(x) __tg_real_nocast(lround, (x)) | |
252 | #define nearbyint(x) __tg_real(nearbyint, (x)) | |
253 | #define nextafter(x,y) __tg_real_2(nextafter, (x), (y)) | |
254 | #define nexttoward(x,y) __tg_real_2(nexttoward, (x), (y)) | |
255 | #define pow(x,y) __tg_real_complex_pow((x), (y)) | |
256 | #define remainder(x,y) __tg_real_2(remainder, (x), (y)) | |
257 | #define remquo(x,y,z) __tg_real_remquo((x), (y), (z)) | |
258 | #define rint(x) __tg_real(rint, (x)) | |
259 | #define round(x) __tg_real(round, (x)) | |
260 | #define scalbln(x,y) __tg_real_2_1(scalbln, (x), (y)) | |
261 | #define scalbn(x,y) __tg_real_2_1(scalbn, (x), (y)) | |
262 | #define sin(x) __tg_real_complex(sin, (x)) | |
263 | #define sinh(x) __tg_real_complex(sinh, (x)) | |
264 | #define sqrt(x) __tg_real_complex(sqrt, (x)) | |
265 | #define tan(x) __tg_real_complex(tan, (x)) | |
266 | #define tanh(x) __tg_real_complex(tanh, (x)) | |
267 | #define tgamma(x) __tg_real(tgamma, (x)) | |
268 | #define trunc(x) __tg_real(trunc, (x)) | |
269 | ||
270 | #endif |