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
|
---|