|
150
|
1 /*===---- tgmath.h - Standard header for type generic math ----------------===*\
|
|
|
2 *
|
|
|
3 * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
4 * See https://llvm.org/LICENSE.txt for license information.
|
|
|
5 * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
6 *
|
|
|
7 \*===----------------------------------------------------------------------===*/
|
|
|
8
|
|
|
9 #ifndef __CLANG_TGMATH_H
|
|
|
10 #define __CLANG_TGMATH_H
|
|
|
11
|
|
|
12 /* C99 7.22 Type-generic math <tgmath.h>. */
|
|
|
13 #include <math.h>
|
|
|
14
|
|
|
15 /*
|
|
|
16 * Allow additional definitions and implementation-defined values on Apple
|
|
|
17 * platforms. This is done after #include <math.h> to avoid depcycle conflicts
|
|
|
18 * between libcxx and darwin in C++ modules builds.
|
|
|
19 */
|
|
|
20 #if defined(__APPLE__) && __STDC_HOSTED__ && __has_include_next(<tgmath.h>)
|
|
|
21 # include_next <tgmath.h>
|
|
|
22 #else
|
|
|
23
|
|
|
24 /* C++ handles type genericity with overloading in math.h. */
|
|
|
25 #ifndef __cplusplus
|
|
|
26 #include <complex.h>
|
|
|
27
|
|
|
28 #define _TG_ATTRSp __attribute__((__overloadable__))
|
|
|
29 #define _TG_ATTRS __attribute__((__overloadable__, __always_inline__))
|
|
|
30
|
|
|
31 // promotion
|
|
|
32
|
|
|
33 typedef void _Argument_type_is_not_arithmetic;
|
|
|
34 static _Argument_type_is_not_arithmetic __tg_promote(...)
|
|
|
35 __attribute__((__unavailable__,__overloadable__));
|
|
|
36 static double _TG_ATTRSp __tg_promote(int);
|
|
|
37 static double _TG_ATTRSp __tg_promote(unsigned int);
|
|
|
38 static double _TG_ATTRSp __tg_promote(long);
|
|
|
39 static double _TG_ATTRSp __tg_promote(unsigned long);
|
|
|
40 static double _TG_ATTRSp __tg_promote(long long);
|
|
|
41 static double _TG_ATTRSp __tg_promote(unsigned long long);
|
|
|
42 static float _TG_ATTRSp __tg_promote(float);
|
|
|
43 static double _TG_ATTRSp __tg_promote(double);
|
|
|
44 static long double _TG_ATTRSp __tg_promote(long double);
|
|
|
45 static float _Complex _TG_ATTRSp __tg_promote(float _Complex);
|
|
|
46 static double _Complex _TG_ATTRSp __tg_promote(double _Complex);
|
|
|
47 static long double _Complex _TG_ATTRSp __tg_promote(long double _Complex);
|
|
|
48
|
|
|
49 #define __tg_promote1(__x) (__typeof__(__tg_promote(__x)))
|
|
|
50 #define __tg_promote2(__x, __y) (__typeof__(__tg_promote(__x) + \
|
|
|
51 __tg_promote(__y)))
|
|
|
52 #define __tg_promote3(__x, __y, __z) (__typeof__(__tg_promote(__x) + \
|
|
|
53 __tg_promote(__y) + \
|
|
|
54 __tg_promote(__z)))
|
|
|
55
|
|
|
56 // acos
|
|
|
57
|
|
|
58 static float
|
|
|
59 _TG_ATTRS
|
|
|
60 __tg_acos(float __x) {return acosf(__x);}
|
|
|
61
|
|
|
62 static double
|
|
|
63 _TG_ATTRS
|
|
|
64 __tg_acos(double __x) {return acos(__x);}
|
|
|
65
|
|
|
66 static long double
|
|
|
67 _TG_ATTRS
|
|
|
68 __tg_acos(long double __x) {return acosl(__x);}
|
|
|
69
|
|
|
70 static float _Complex
|
|
|
71 _TG_ATTRS
|
|
|
72 __tg_acos(float _Complex __x) {return cacosf(__x);}
|
|
|
73
|
|
|
74 static double _Complex
|
|
|
75 _TG_ATTRS
|
|
|
76 __tg_acos(double _Complex __x) {return cacos(__x);}
|
|
|
77
|
|
|
78 static long double _Complex
|
|
|
79 _TG_ATTRS
|
|
|
80 __tg_acos(long double _Complex __x) {return cacosl(__x);}
|
|
|
81
|
|
|
82 #undef acos
|
|
|
83 #define acos(__x) __tg_acos(__tg_promote1((__x))(__x))
|
|
|
84
|
|
|
85 // asin
|
|
|
86
|
|
|
87 static float
|
|
|
88 _TG_ATTRS
|
|
|
89 __tg_asin(float __x) {return asinf(__x);}
|
|
|
90
|
|
|
91 static double
|
|
|
92 _TG_ATTRS
|
|
|
93 __tg_asin(double __x) {return asin(__x);}
|
|
|
94
|
|
|
95 static long double
|
|
|
96 _TG_ATTRS
|
|
|
97 __tg_asin(long double __x) {return asinl(__x);}
|
|
|
98
|
|
|
99 static float _Complex
|
|
|
100 _TG_ATTRS
|
|
|
101 __tg_asin(float _Complex __x) {return casinf(__x);}
|
|
|
102
|
|
|
103 static double _Complex
|
|
|
104 _TG_ATTRS
|
|
|
105 __tg_asin(double _Complex __x) {return casin(__x);}
|
|
|
106
|
|
|
107 static long double _Complex
|
|
|
108 _TG_ATTRS
|
|
|
109 __tg_asin(long double _Complex __x) {return casinl(__x);}
|
|
|
110
|
|
|
111 #undef asin
|
|
|
112 #define asin(__x) __tg_asin(__tg_promote1((__x))(__x))
|
|
|
113
|
|
|
114 // atan
|
|
|
115
|
|
|
116 static float
|
|
|
117 _TG_ATTRS
|
|
|
118 __tg_atan(float __x) {return atanf(__x);}
|
|
|
119
|
|
|
120 static double
|
|
|
121 _TG_ATTRS
|
|
|
122 __tg_atan(double __x) {return atan(__x);}
|
|
|
123
|
|
|
124 static long double
|
|
|
125 _TG_ATTRS
|
|
|
126 __tg_atan(long double __x) {return atanl(__x);}
|
|
|
127
|
|
|
128 static float _Complex
|
|
|
129 _TG_ATTRS
|
|
|
130 __tg_atan(float _Complex __x) {return catanf(__x);}
|
|
|
131
|
|
|
132 static double _Complex
|
|
|
133 _TG_ATTRS
|
|
|
134 __tg_atan(double _Complex __x) {return catan(__x);}
|
|
|
135
|
|
|
136 static long double _Complex
|
|
|
137 _TG_ATTRS
|
|
|
138 __tg_atan(long double _Complex __x) {return catanl(__x);}
|
|
|
139
|
|
|
140 #undef atan
|
|
|
141 #define atan(__x) __tg_atan(__tg_promote1((__x))(__x))
|
|
|
142
|
|
|
143 // acosh
|
|
|
144
|
|
|
145 static float
|
|
|
146 _TG_ATTRS
|
|
|
147 __tg_acosh(float __x) {return acoshf(__x);}
|
|
|
148
|
|
|
149 static double
|
|
|
150 _TG_ATTRS
|
|
|
151 __tg_acosh(double __x) {return acosh(__x);}
|
|
|
152
|
|
|
153 static long double
|
|
|
154 _TG_ATTRS
|
|
|
155 __tg_acosh(long double __x) {return acoshl(__x);}
|
|
|
156
|
|
|
157 static float _Complex
|
|
|
158 _TG_ATTRS
|
|
|
159 __tg_acosh(float _Complex __x) {return cacoshf(__x);}
|
|
|
160
|
|
|
161 static double _Complex
|
|
|
162 _TG_ATTRS
|
|
|
163 __tg_acosh(double _Complex __x) {return cacosh(__x);}
|
|
|
164
|
|
|
165 static long double _Complex
|
|
|
166 _TG_ATTRS
|
|
|
167 __tg_acosh(long double _Complex __x) {return cacoshl(__x);}
|
|
|
168
|
|
|
169 #undef acosh
|
|
|
170 #define acosh(__x) __tg_acosh(__tg_promote1((__x))(__x))
|
|
|
171
|
|
|
172 // asinh
|
|
|
173
|
|
|
174 static float
|
|
|
175 _TG_ATTRS
|
|
|
176 __tg_asinh(float __x) {return asinhf(__x);}
|
|
|
177
|
|
|
178 static double
|
|
|
179 _TG_ATTRS
|
|
|
180 __tg_asinh(double __x) {return asinh(__x);}
|
|
|
181
|
|
|
182 static long double
|
|
|
183 _TG_ATTRS
|
|
|
184 __tg_asinh(long double __x) {return asinhl(__x);}
|
|
|
185
|
|
|
186 static float _Complex
|
|
|
187 _TG_ATTRS
|
|
|
188 __tg_asinh(float _Complex __x) {return casinhf(__x);}
|
|
|
189
|
|
|
190 static double _Complex
|
|
|
191 _TG_ATTRS
|
|
|
192 __tg_asinh(double _Complex __x) {return casinh(__x);}
|
|
|
193
|
|
|
194 static long double _Complex
|
|
|
195 _TG_ATTRS
|
|
|
196 __tg_asinh(long double _Complex __x) {return casinhl(__x);}
|
|
|
197
|
|
|
198 #undef asinh
|
|
|
199 #define asinh(__x) __tg_asinh(__tg_promote1((__x))(__x))
|
|
|
200
|
|
|
201 // atanh
|
|
|
202
|
|
|
203 static float
|
|
|
204 _TG_ATTRS
|
|
|
205 __tg_atanh(float __x) {return atanhf(__x);}
|
|
|
206
|
|
|
207 static double
|
|
|
208 _TG_ATTRS
|
|
|
209 __tg_atanh(double __x) {return atanh(__x);}
|
|
|
210
|
|
|
211 static long double
|
|
|
212 _TG_ATTRS
|
|
|
213 __tg_atanh(long double __x) {return atanhl(__x);}
|
|
|
214
|
|
|
215 static float _Complex
|
|
|
216 _TG_ATTRS
|
|
|
217 __tg_atanh(float _Complex __x) {return catanhf(__x);}
|
|
|
218
|
|
|
219 static double _Complex
|
|
|
220 _TG_ATTRS
|
|
|
221 __tg_atanh(double _Complex __x) {return catanh(__x);}
|
|
|
222
|
|
|
223 static long double _Complex
|
|
|
224 _TG_ATTRS
|
|
|
225 __tg_atanh(long double _Complex __x) {return catanhl(__x);}
|
|
|
226
|
|
|
227 #undef atanh
|
|
|
228 #define atanh(__x) __tg_atanh(__tg_promote1((__x))(__x))
|
|
|
229
|
|
|
230 // cos
|
|
|
231
|
|
|
232 static float
|
|
|
233 _TG_ATTRS
|
|
|
234 __tg_cos(float __x) {return cosf(__x);}
|
|
|
235
|
|
|
236 static double
|
|
|
237 _TG_ATTRS
|
|
|
238 __tg_cos(double __x) {return cos(__x);}
|
|
|
239
|
|
|
240 static long double
|
|
|
241 _TG_ATTRS
|
|
|
242 __tg_cos(long double __x) {return cosl(__x);}
|
|
|
243
|
|
|
244 static float _Complex
|
|
|
245 _TG_ATTRS
|
|
|
246 __tg_cos(float _Complex __x) {return ccosf(__x);}
|
|
|
247
|
|
|
248 static double _Complex
|
|
|
249 _TG_ATTRS
|
|
|
250 __tg_cos(double _Complex __x) {return ccos(__x);}
|
|
|
251
|
|
|
252 static long double _Complex
|
|
|
253 _TG_ATTRS
|
|
|
254 __tg_cos(long double _Complex __x) {return ccosl(__x);}
|
|
|
255
|
|
|
256 #undef cos
|
|
|
257 #define cos(__x) __tg_cos(__tg_promote1((__x))(__x))
|
|
|
258
|
|
|
259 // sin
|
|
|
260
|
|
|
261 static float
|
|
|
262 _TG_ATTRS
|
|
|
263 __tg_sin(float __x) {return sinf(__x);}
|
|
|
264
|
|
|
265 static double
|
|
|
266 _TG_ATTRS
|
|
|
267 __tg_sin(double __x) {return sin(__x);}
|
|
|
268
|
|
|
269 static long double
|
|
|
270 _TG_ATTRS
|
|
|
271 __tg_sin(long double __x) {return sinl(__x);}
|
|
|
272
|
|
|
273 static float _Complex
|
|
|
274 _TG_ATTRS
|
|
|
275 __tg_sin(float _Complex __x) {return csinf(__x);}
|
|
|
276
|
|
|
277 static double _Complex
|
|
|
278 _TG_ATTRS
|
|
|
279 __tg_sin(double _Complex __x) {return csin(__x);}
|
|
|
280
|
|
|
281 static long double _Complex
|
|
|
282 _TG_ATTRS
|
|
|
283 __tg_sin(long double _Complex __x) {return csinl(__x);}
|
|
|
284
|
|
|
285 #undef sin
|
|
|
286 #define sin(__x) __tg_sin(__tg_promote1((__x))(__x))
|
|
|
287
|
|
|
288 // tan
|
|
|
289
|
|
|
290 static float
|
|
|
291 _TG_ATTRS
|
|
|
292 __tg_tan(float __x) {return tanf(__x);}
|
|
|
293
|
|
|
294 static double
|
|
|
295 _TG_ATTRS
|
|
|
296 __tg_tan(double __x) {return tan(__x);}
|
|
|
297
|
|
|
298 static long double
|
|
|
299 _TG_ATTRS
|
|
|
300 __tg_tan(long double __x) {return tanl(__x);}
|
|
|
301
|
|
|
302 static float _Complex
|
|
|
303 _TG_ATTRS
|
|
|
304 __tg_tan(float _Complex __x) {return ctanf(__x);}
|
|
|
305
|
|
|
306 static double _Complex
|
|
|
307 _TG_ATTRS
|
|
|
308 __tg_tan(double _Complex __x) {return ctan(__x);}
|
|
|
309
|
|
|
310 static long double _Complex
|
|
|
311 _TG_ATTRS
|
|
|
312 __tg_tan(long double _Complex __x) {return ctanl(__x);}
|
|
|
313
|
|
|
314 #undef tan
|
|
|
315 #define tan(__x) __tg_tan(__tg_promote1((__x))(__x))
|
|
|
316
|
|
|
317 // cosh
|
|
|
318
|
|
|
319 static float
|
|
|
320 _TG_ATTRS
|
|
|
321 __tg_cosh(float __x) {return coshf(__x);}
|
|
|
322
|
|
|
323 static double
|
|
|
324 _TG_ATTRS
|
|
|
325 __tg_cosh(double __x) {return cosh(__x);}
|
|
|
326
|
|
|
327 static long double
|
|
|
328 _TG_ATTRS
|
|
|
329 __tg_cosh(long double __x) {return coshl(__x);}
|
|
|
330
|
|
|
331 static float _Complex
|
|
|
332 _TG_ATTRS
|
|
|
333 __tg_cosh(float _Complex __x) {return ccoshf(__x);}
|
|
|
334
|
|
|
335 static double _Complex
|
|
|
336 _TG_ATTRS
|
|
|
337 __tg_cosh(double _Complex __x) {return ccosh(__x);}
|
|
|
338
|
|
|
339 static long double _Complex
|
|
|
340 _TG_ATTRS
|
|
|
341 __tg_cosh(long double _Complex __x) {return ccoshl(__x);}
|
|
|
342
|
|
|
343 #undef cosh
|
|
|
344 #define cosh(__x) __tg_cosh(__tg_promote1((__x))(__x))
|
|
|
345
|
|
|
346 // sinh
|
|
|
347
|
|
|
348 static float
|
|
|
349 _TG_ATTRS
|
|
|
350 __tg_sinh(float __x) {return sinhf(__x);}
|
|
|
351
|
|
|
352 static double
|
|
|
353 _TG_ATTRS
|
|
|
354 __tg_sinh(double __x) {return sinh(__x);}
|
|
|
355
|
|
|
356 static long double
|
|
|
357 _TG_ATTRS
|
|
|
358 __tg_sinh(long double __x) {return sinhl(__x);}
|
|
|
359
|
|
|
360 static float _Complex
|
|
|
361 _TG_ATTRS
|
|
|
362 __tg_sinh(float _Complex __x) {return csinhf(__x);}
|
|
|
363
|
|
|
364 static double _Complex
|
|
|
365 _TG_ATTRS
|
|
|
366 __tg_sinh(double _Complex __x) {return csinh(__x);}
|
|
|
367
|
|
|
368 static long double _Complex
|
|
|
369 _TG_ATTRS
|
|
|
370 __tg_sinh(long double _Complex __x) {return csinhl(__x);}
|
|
|
371
|
|
|
372 #undef sinh
|
|
|
373 #define sinh(__x) __tg_sinh(__tg_promote1((__x))(__x))
|
|
|
374
|
|
|
375 // tanh
|
|
|
376
|
|
|
377 static float
|
|
|
378 _TG_ATTRS
|
|
|
379 __tg_tanh(float __x) {return tanhf(__x);}
|
|
|
380
|
|
|
381 static double
|
|
|
382 _TG_ATTRS
|
|
|
383 __tg_tanh(double __x) {return tanh(__x);}
|
|
|
384
|
|
|
385 static long double
|
|
|
386 _TG_ATTRS
|
|
|
387 __tg_tanh(long double __x) {return tanhl(__x);}
|
|
|
388
|
|
|
389 static float _Complex
|
|
|
390 _TG_ATTRS
|
|
|
391 __tg_tanh(float _Complex __x) {return ctanhf(__x);}
|
|
|
392
|
|
|
393 static double _Complex
|
|
|
394 _TG_ATTRS
|
|
|
395 __tg_tanh(double _Complex __x) {return ctanh(__x);}
|
|
|
396
|
|
|
397 static long double _Complex
|
|
|
398 _TG_ATTRS
|
|
|
399 __tg_tanh(long double _Complex __x) {return ctanhl(__x);}
|
|
|
400
|
|
|
401 #undef tanh
|
|
|
402 #define tanh(__x) __tg_tanh(__tg_promote1((__x))(__x))
|
|
|
403
|
|
|
404 // exp
|
|
|
405
|
|
|
406 static float
|
|
|
407 _TG_ATTRS
|
|
|
408 __tg_exp(float __x) {return expf(__x);}
|
|
|
409
|
|
|
410 static double
|
|
|
411 _TG_ATTRS
|
|
|
412 __tg_exp(double __x) {return exp(__x);}
|
|
|
413
|
|
|
414 static long double
|
|
|
415 _TG_ATTRS
|
|
|
416 __tg_exp(long double __x) {return expl(__x);}
|
|
|
417
|
|
|
418 static float _Complex
|
|
|
419 _TG_ATTRS
|
|
|
420 __tg_exp(float _Complex __x) {return cexpf(__x);}
|
|
|
421
|
|
|
422 static double _Complex
|
|
|
423 _TG_ATTRS
|
|
|
424 __tg_exp(double _Complex __x) {return cexp(__x);}
|
|
|
425
|
|
|
426 static long double _Complex
|
|
|
427 _TG_ATTRS
|
|
|
428 __tg_exp(long double _Complex __x) {return cexpl(__x);}
|
|
|
429
|
|
|
430 #undef exp
|
|
|
431 #define exp(__x) __tg_exp(__tg_promote1((__x))(__x))
|
|
|
432
|
|
|
433 // log
|
|
|
434
|
|
|
435 static float
|
|
|
436 _TG_ATTRS
|
|
|
437 __tg_log(float __x) {return logf(__x);}
|
|
|
438
|
|
|
439 static double
|
|
|
440 _TG_ATTRS
|
|
|
441 __tg_log(double __x) {return log(__x);}
|
|
|
442
|
|
|
443 static long double
|
|
|
444 _TG_ATTRS
|
|
|
445 __tg_log(long double __x) {return logl(__x);}
|
|
|
446
|
|
|
447 static float _Complex
|
|
|
448 _TG_ATTRS
|
|
|
449 __tg_log(float _Complex __x) {return clogf(__x);}
|
|
|
450
|
|
|
451 static double _Complex
|
|
|
452 _TG_ATTRS
|
|
|
453 __tg_log(double _Complex __x) {return clog(__x);}
|
|
|
454
|
|
|
455 static long double _Complex
|
|
|
456 _TG_ATTRS
|
|
|
457 __tg_log(long double _Complex __x) {return clogl(__x);}
|
|
|
458
|
|
|
459 #undef log
|
|
|
460 #define log(__x) __tg_log(__tg_promote1((__x))(__x))
|
|
|
461
|
|
|
462 // pow
|
|
|
463
|
|
|
464 static float
|
|
|
465 _TG_ATTRS
|
|
|
466 __tg_pow(float __x, float __y) {return powf(__x, __y);}
|
|
|
467
|
|
|
468 static double
|
|
|
469 _TG_ATTRS
|
|
|
470 __tg_pow(double __x, double __y) {return pow(__x, __y);}
|
|
|
471
|
|
|
472 static long double
|
|
|
473 _TG_ATTRS
|
|
|
474 __tg_pow(long double __x, long double __y) {return powl(__x, __y);}
|
|
|
475
|
|
|
476 static float _Complex
|
|
|
477 _TG_ATTRS
|
|
|
478 __tg_pow(float _Complex __x, float _Complex __y) {return cpowf(__x, __y);}
|
|
|
479
|
|
|
480 static double _Complex
|
|
|
481 _TG_ATTRS
|
|
|
482 __tg_pow(double _Complex __x, double _Complex __y) {return cpow(__x, __y);}
|
|
|
483
|
|
|
484 static long double _Complex
|
|
|
485 _TG_ATTRS
|
|
|
486 __tg_pow(long double _Complex __x, long double _Complex __y)
|
|
|
487 {return cpowl(__x, __y);}
|
|
|
488
|
|
|
489 #undef pow
|
|
|
490 #define pow(__x, __y) __tg_pow(__tg_promote2((__x), (__y))(__x), \
|
|
|
491 __tg_promote2((__x), (__y))(__y))
|
|
|
492
|
|
|
493 // sqrt
|
|
|
494
|
|
|
495 static float
|
|
|
496 _TG_ATTRS
|
|
|
497 __tg_sqrt(float __x) {return sqrtf(__x);}
|
|
|
498
|
|
|
499 static double
|
|
|
500 _TG_ATTRS
|
|
|
501 __tg_sqrt(double __x) {return sqrt(__x);}
|
|
|
502
|
|
|
503 static long double
|
|
|
504 _TG_ATTRS
|
|
|
505 __tg_sqrt(long double __x) {return sqrtl(__x);}
|
|
|
506
|
|
|
507 static float _Complex
|
|
|
508 _TG_ATTRS
|
|
|
509 __tg_sqrt(float _Complex __x) {return csqrtf(__x);}
|
|
|
510
|
|
|
511 static double _Complex
|
|
|
512 _TG_ATTRS
|
|
|
513 __tg_sqrt(double _Complex __x) {return csqrt(__x);}
|
|
|
514
|
|
|
515 static long double _Complex
|
|
|
516 _TG_ATTRS
|
|
|
517 __tg_sqrt(long double _Complex __x) {return csqrtl(__x);}
|
|
|
518
|
|
|
519 #undef sqrt
|
|
|
520 #define sqrt(__x) __tg_sqrt(__tg_promote1((__x))(__x))
|
|
|
521
|
|
|
522 // fabs
|
|
|
523
|
|
|
524 static float
|
|
|
525 _TG_ATTRS
|
|
|
526 __tg_fabs(float __x) {return fabsf(__x);}
|
|
|
527
|
|
|
528 static double
|
|
|
529 _TG_ATTRS
|
|
|
530 __tg_fabs(double __x) {return fabs(__x);}
|
|
|
531
|
|
|
532 static long double
|
|
|
533 _TG_ATTRS
|
|
|
534 __tg_fabs(long double __x) {return fabsl(__x);}
|
|
|
535
|
|
|
536 static float
|
|
|
537 _TG_ATTRS
|
|
|
538 __tg_fabs(float _Complex __x) {return cabsf(__x);}
|
|
|
539
|
|
|
540 static double
|
|
|
541 _TG_ATTRS
|
|
|
542 __tg_fabs(double _Complex __x) {return cabs(__x);}
|
|
|
543
|
|
|
544 static long double
|
|
|
545 _TG_ATTRS
|
|
|
546 __tg_fabs(long double _Complex __x) {return cabsl(__x);}
|
|
|
547
|
|
|
548 #undef fabs
|
|
|
549 #define fabs(__x) __tg_fabs(__tg_promote1((__x))(__x))
|
|
|
550
|
|
|
551 // atan2
|
|
|
552
|
|
|
553 static float
|
|
|
554 _TG_ATTRS
|
|
|
555 __tg_atan2(float __x, float __y) {return atan2f(__x, __y);}
|
|
|
556
|
|
|
557 static double
|
|
|
558 _TG_ATTRS
|
|
|
559 __tg_atan2(double __x, double __y) {return atan2(__x, __y);}
|
|
|
560
|
|
|
561 static long double
|
|
|
562 _TG_ATTRS
|
|
|
563 __tg_atan2(long double __x, long double __y) {return atan2l(__x, __y);}
|
|
|
564
|
|
|
565 #undef atan2
|
|
|
566 #define atan2(__x, __y) __tg_atan2(__tg_promote2((__x), (__y))(__x), \
|
|
|
567 __tg_promote2((__x), (__y))(__y))
|
|
|
568
|
|
|
569 // cbrt
|
|
|
570
|
|
|
571 static float
|
|
|
572 _TG_ATTRS
|
|
|
573 __tg_cbrt(float __x) {return cbrtf(__x);}
|
|
|
574
|
|
|
575 static double
|
|
|
576 _TG_ATTRS
|
|
|
577 __tg_cbrt(double __x) {return cbrt(__x);}
|
|
|
578
|
|
|
579 static long double
|
|
|
580 _TG_ATTRS
|
|
|
581 __tg_cbrt(long double __x) {return cbrtl(__x);}
|
|
|
582
|
|
|
583 #undef cbrt
|
|
|
584 #define cbrt(__x) __tg_cbrt(__tg_promote1((__x))(__x))
|
|
|
585
|
|
|
586 // ceil
|
|
|
587
|
|
|
588 static float
|
|
|
589 _TG_ATTRS
|
|
|
590 __tg_ceil(float __x) {return ceilf(__x);}
|
|
|
591
|
|
|
592 static double
|
|
|
593 _TG_ATTRS
|
|
|
594 __tg_ceil(double __x) {return ceil(__x);}
|
|
|
595
|
|
|
596 static long double
|
|
|
597 _TG_ATTRS
|
|
|
598 __tg_ceil(long double __x) {return ceill(__x);}
|
|
|
599
|
|
|
600 #undef ceil
|
|
|
601 #define ceil(__x) __tg_ceil(__tg_promote1((__x))(__x))
|
|
|
602
|
|
|
603 // copysign
|
|
|
604
|
|
|
605 static float
|
|
|
606 _TG_ATTRS
|
|
|
607 __tg_copysign(float __x, float __y) {return copysignf(__x, __y);}
|
|
|
608
|
|
|
609 static double
|
|
|
610 _TG_ATTRS
|
|
|
611 __tg_copysign(double __x, double __y) {return copysign(__x, __y);}
|
|
|
612
|
|
|
613 static long double
|
|
|
614 _TG_ATTRS
|
|
|
615 __tg_copysign(long double __x, long double __y) {return copysignl(__x, __y);}
|
|
|
616
|
|
|
617 #undef copysign
|
|
|
618 #define copysign(__x, __y) __tg_copysign(__tg_promote2((__x), (__y))(__x), \
|
|
|
619 __tg_promote2((__x), (__y))(__y))
|
|
|
620
|
|
|
621 // erf
|
|
|
622
|
|
|
623 static float
|
|
|
624 _TG_ATTRS
|
|
|
625 __tg_erf(float __x) {return erff(__x);}
|
|
|
626
|
|
|
627 static double
|
|
|
628 _TG_ATTRS
|
|
|
629 __tg_erf(double __x) {return erf(__x);}
|
|
|
630
|
|
|
631 static long double
|
|
|
632 _TG_ATTRS
|
|
|
633 __tg_erf(long double __x) {return erfl(__x);}
|
|
|
634
|
|
|
635 #undef erf
|
|
|
636 #define erf(__x) __tg_erf(__tg_promote1((__x))(__x))
|
|
|
637
|
|
|
638 // erfc
|
|
|
639
|
|
|
640 static float
|
|
|
641 _TG_ATTRS
|
|
|
642 __tg_erfc(float __x) {return erfcf(__x);}
|
|
|
643
|
|
|
644 static double
|
|
|
645 _TG_ATTRS
|
|
|
646 __tg_erfc(double __x) {return erfc(__x);}
|
|
|
647
|
|
|
648 static long double
|
|
|
649 _TG_ATTRS
|
|
|
650 __tg_erfc(long double __x) {return erfcl(__x);}
|
|
|
651
|
|
|
652 #undef erfc
|
|
|
653 #define erfc(__x) __tg_erfc(__tg_promote1((__x))(__x))
|
|
|
654
|
|
|
655 // exp2
|
|
|
656
|
|
|
657 static float
|
|
|
658 _TG_ATTRS
|
|
|
659 __tg_exp2(float __x) {return exp2f(__x);}
|
|
|
660
|
|
|
661 static double
|
|
|
662 _TG_ATTRS
|
|
|
663 __tg_exp2(double __x) {return exp2(__x);}
|
|
|
664
|
|
|
665 static long double
|
|
|
666 _TG_ATTRS
|
|
|
667 __tg_exp2(long double __x) {return exp2l(__x);}
|
|
|
668
|
|
|
669 #undef exp2
|
|
|
670 #define exp2(__x) __tg_exp2(__tg_promote1((__x))(__x))
|
|
|
671
|
|
|
672 // expm1
|
|
|
673
|
|
|
674 static float
|
|
|
675 _TG_ATTRS
|
|
|
676 __tg_expm1(float __x) {return expm1f(__x);}
|
|
|
677
|
|
|
678 static double
|
|
|
679 _TG_ATTRS
|
|
|
680 __tg_expm1(double __x) {return expm1(__x);}
|
|
|
681
|
|
|
682 static long double
|
|
|
683 _TG_ATTRS
|
|
|
684 __tg_expm1(long double __x) {return expm1l(__x);}
|
|
|
685
|
|
|
686 #undef expm1
|
|
|
687 #define expm1(__x) __tg_expm1(__tg_promote1((__x))(__x))
|
|
|
688
|
|
|
689 // fdim
|
|
|
690
|
|
|
691 static float
|
|
|
692 _TG_ATTRS
|
|
|
693 __tg_fdim(float __x, float __y) {return fdimf(__x, __y);}
|
|
|
694
|
|
|
695 static double
|
|
|
696 _TG_ATTRS
|
|
|
697 __tg_fdim(double __x, double __y) {return fdim(__x, __y);}
|
|
|
698
|
|
|
699 static long double
|
|
|
700 _TG_ATTRS
|
|
|
701 __tg_fdim(long double __x, long double __y) {return fdiml(__x, __y);}
|
|
|
702
|
|
|
703 #undef fdim
|
|
|
704 #define fdim(__x, __y) __tg_fdim(__tg_promote2((__x), (__y))(__x), \
|
|
|
705 __tg_promote2((__x), (__y))(__y))
|
|
|
706
|
|
|
707 // floor
|
|
|
708
|
|
|
709 static float
|
|
|
710 _TG_ATTRS
|
|
|
711 __tg_floor(float __x) {return floorf(__x);}
|
|
|
712
|
|
|
713 static double
|
|
|
714 _TG_ATTRS
|
|
|
715 __tg_floor(double __x) {return floor(__x);}
|
|
|
716
|
|
|
717 static long double
|
|
|
718 _TG_ATTRS
|
|
|
719 __tg_floor(long double __x) {return floorl(__x);}
|
|
|
720
|
|
|
721 #undef floor
|
|
|
722 #define floor(__x) __tg_floor(__tg_promote1((__x))(__x))
|
|
|
723
|
|
|
724 // fma
|
|
|
725
|
|
|
726 static float
|
|
|
727 _TG_ATTRS
|
|
|
728 __tg_fma(float __x, float __y, float __z)
|
|
|
729 {return fmaf(__x, __y, __z);}
|
|
|
730
|
|
|
731 static double
|
|
|
732 _TG_ATTRS
|
|
|
733 __tg_fma(double __x, double __y, double __z)
|
|
|
734 {return fma(__x, __y, __z);}
|
|
|
735
|
|
|
736 static long double
|
|
|
737 _TG_ATTRS
|
|
|
738 __tg_fma(long double __x,long double __y, long double __z)
|
|
|
739 {return fmal(__x, __y, __z);}
|
|
|
740
|
|
|
741 #undef fma
|
|
|
742 #define fma(__x, __y, __z) \
|
|
|
743 __tg_fma(__tg_promote3((__x), (__y), (__z))(__x), \
|
|
|
744 __tg_promote3((__x), (__y), (__z))(__y), \
|
|
|
745 __tg_promote3((__x), (__y), (__z))(__z))
|
|
|
746
|
|
|
747 // fmax
|
|
|
748
|
|
|
749 static float
|
|
|
750 _TG_ATTRS
|
|
|
751 __tg_fmax(float __x, float __y) {return fmaxf(__x, __y);}
|
|
|
752
|
|
|
753 static double
|
|
|
754 _TG_ATTRS
|
|
|
755 __tg_fmax(double __x, double __y) {return fmax(__x, __y);}
|
|
|
756
|
|
|
757 static long double
|
|
|
758 _TG_ATTRS
|
|
|
759 __tg_fmax(long double __x, long double __y) {return fmaxl(__x, __y);}
|
|
|
760
|
|
|
761 #undef fmax
|
|
|
762 #define fmax(__x, __y) __tg_fmax(__tg_promote2((__x), (__y))(__x), \
|
|
|
763 __tg_promote2((__x), (__y))(__y))
|
|
|
764
|
|
|
765 // fmin
|
|
|
766
|
|
|
767 static float
|
|
|
768 _TG_ATTRS
|
|
|
769 __tg_fmin(float __x, float __y) {return fminf(__x, __y);}
|
|
|
770
|
|
|
771 static double
|
|
|
772 _TG_ATTRS
|
|
|
773 __tg_fmin(double __x, double __y) {return fmin(__x, __y);}
|
|
|
774
|
|
|
775 static long double
|
|
|
776 _TG_ATTRS
|
|
|
777 __tg_fmin(long double __x, long double __y) {return fminl(__x, __y);}
|
|
|
778
|
|
|
779 #undef fmin
|
|
|
780 #define fmin(__x, __y) __tg_fmin(__tg_promote2((__x), (__y))(__x), \
|
|
|
781 __tg_promote2((__x), (__y))(__y))
|
|
|
782
|
|
|
783 // fmod
|
|
|
784
|
|
|
785 static float
|
|
|
786 _TG_ATTRS
|
|
|
787 __tg_fmod(float __x, float __y) {return fmodf(__x, __y);}
|
|
|
788
|
|
|
789 static double
|
|
|
790 _TG_ATTRS
|
|
|
791 __tg_fmod(double __x, double __y) {return fmod(__x, __y);}
|
|
|
792
|
|
|
793 static long double
|
|
|
794 _TG_ATTRS
|
|
|
795 __tg_fmod(long double __x, long double __y) {return fmodl(__x, __y);}
|
|
|
796
|
|
|
797 #undef fmod
|
|
|
798 #define fmod(__x, __y) __tg_fmod(__tg_promote2((__x), (__y))(__x), \
|
|
|
799 __tg_promote2((__x), (__y))(__y))
|
|
|
800
|
|
|
801 // frexp
|
|
|
802
|
|
|
803 static float
|
|
|
804 _TG_ATTRS
|
|
|
805 __tg_frexp(float __x, int* __y) {return frexpf(__x, __y);}
|
|
|
806
|
|
|
807 static double
|
|
|
808 _TG_ATTRS
|
|
|
809 __tg_frexp(double __x, int* __y) {return frexp(__x, __y);}
|
|
|
810
|
|
|
811 static long double
|
|
|
812 _TG_ATTRS
|
|
|
813 __tg_frexp(long double __x, int* __y) {return frexpl(__x, __y);}
|
|
|
814
|
|
|
815 #undef frexp
|
|
|
816 #define frexp(__x, __y) __tg_frexp(__tg_promote1((__x))(__x), __y)
|
|
|
817
|
|
|
818 // hypot
|
|
|
819
|
|
|
820 static float
|
|
|
821 _TG_ATTRS
|
|
|
822 __tg_hypot(float __x, float __y) {return hypotf(__x, __y);}
|
|
|
823
|
|
|
824 static double
|
|
|
825 _TG_ATTRS
|
|
|
826 __tg_hypot(double __x, double __y) {return hypot(__x, __y);}
|
|
|
827
|
|
|
828 static long double
|
|
|
829 _TG_ATTRS
|
|
|
830 __tg_hypot(long double __x, long double __y) {return hypotl(__x, __y);}
|
|
|
831
|
|
|
832 #undef hypot
|
|
|
833 #define hypot(__x, __y) __tg_hypot(__tg_promote2((__x), (__y))(__x), \
|
|
|
834 __tg_promote2((__x), (__y))(__y))
|
|
|
835
|
|
|
836 // ilogb
|
|
|
837
|
|
|
838 static int
|
|
|
839 _TG_ATTRS
|
|
|
840 __tg_ilogb(float __x) {return ilogbf(__x);}
|
|
|
841
|
|
|
842 static int
|
|
|
843 _TG_ATTRS
|
|
|
844 __tg_ilogb(double __x) {return ilogb(__x);}
|
|
|
845
|
|
|
846 static int
|
|
|
847 _TG_ATTRS
|
|
|
848 __tg_ilogb(long double __x) {return ilogbl(__x);}
|
|
|
849
|
|
|
850 #undef ilogb
|
|
|
851 #define ilogb(__x) __tg_ilogb(__tg_promote1((__x))(__x))
|
|
|
852
|
|
|
853 // ldexp
|
|
|
854
|
|
|
855 static float
|
|
|
856 _TG_ATTRS
|
|
|
857 __tg_ldexp(float __x, int __y) {return ldexpf(__x, __y);}
|
|
|
858
|
|
|
859 static double
|
|
|
860 _TG_ATTRS
|
|
|
861 __tg_ldexp(double __x, int __y) {return ldexp(__x, __y);}
|
|
|
862
|
|
|
863 static long double
|
|
|
864 _TG_ATTRS
|
|
|
865 __tg_ldexp(long double __x, int __y) {return ldexpl(__x, __y);}
|
|
|
866
|
|
|
867 #undef ldexp
|
|
|
868 #define ldexp(__x, __y) __tg_ldexp(__tg_promote1((__x))(__x), __y)
|
|
|
869
|
|
|
870 // lgamma
|
|
|
871
|
|
|
872 static float
|
|
|
873 _TG_ATTRS
|
|
|
874 __tg_lgamma(float __x) {return lgammaf(__x);}
|
|
|
875
|
|
|
876 static double
|
|
|
877 _TG_ATTRS
|
|
|
878 __tg_lgamma(double __x) {return lgamma(__x);}
|
|
|
879
|
|
|
880 static long double
|
|
|
881 _TG_ATTRS
|
|
|
882 __tg_lgamma(long double __x) {return lgammal(__x);}
|
|
|
883
|
|
|
884 #undef lgamma
|
|
|
885 #define lgamma(__x) __tg_lgamma(__tg_promote1((__x))(__x))
|
|
|
886
|
|
|
887 // llrint
|
|
|
888
|
|
|
889 static long long
|
|
|
890 _TG_ATTRS
|
|
|
891 __tg_llrint(float __x) {return llrintf(__x);}
|
|
|
892
|
|
|
893 static long long
|
|
|
894 _TG_ATTRS
|
|
|
895 __tg_llrint(double __x) {return llrint(__x);}
|
|
|
896
|
|
|
897 static long long
|
|
|
898 _TG_ATTRS
|
|
|
899 __tg_llrint(long double __x) {return llrintl(__x);}
|
|
|
900
|
|
|
901 #undef llrint
|
|
|
902 #define llrint(__x) __tg_llrint(__tg_promote1((__x))(__x))
|
|
|
903
|
|
|
904 // llround
|
|
|
905
|
|
|
906 static long long
|
|
|
907 _TG_ATTRS
|
|
|
908 __tg_llround(float __x) {return llroundf(__x);}
|
|
|
909
|
|
|
910 static long long
|
|
|
911 _TG_ATTRS
|
|
|
912 __tg_llround(double __x) {return llround(__x);}
|
|
|
913
|
|
|
914 static long long
|
|
|
915 _TG_ATTRS
|
|
|
916 __tg_llround(long double __x) {return llroundl(__x);}
|
|
|
917
|
|
|
918 #undef llround
|
|
|
919 #define llround(__x) __tg_llround(__tg_promote1((__x))(__x))
|
|
|
920
|
|
|
921 // log10
|
|
|
922
|
|
|
923 static float
|
|
|
924 _TG_ATTRS
|
|
|
925 __tg_log10(float __x) {return log10f(__x);}
|
|
|
926
|
|
|
927 static double
|
|
|
928 _TG_ATTRS
|
|
|
929 __tg_log10(double __x) {return log10(__x);}
|
|
|
930
|
|
|
931 static long double
|
|
|
932 _TG_ATTRS
|
|
|
933 __tg_log10(long double __x) {return log10l(__x);}
|
|
|
934
|
|
|
935 #undef log10
|
|
|
936 #define log10(__x) __tg_log10(__tg_promote1((__x))(__x))
|
|
|
937
|
|
|
938 // log1p
|
|
|
939
|
|
|
940 static float
|
|
|
941 _TG_ATTRS
|
|
|
942 __tg_log1p(float __x) {return log1pf(__x);}
|
|
|
943
|
|
|
944 static double
|
|
|
945 _TG_ATTRS
|
|
|
946 __tg_log1p(double __x) {return log1p(__x);}
|
|
|
947
|
|
|
948 static long double
|
|
|
949 _TG_ATTRS
|
|
|
950 __tg_log1p(long double __x) {return log1pl(__x);}
|
|
|
951
|
|
|
952 #undef log1p
|
|
|
953 #define log1p(__x) __tg_log1p(__tg_promote1((__x))(__x))
|
|
|
954
|
|
|
955 // log2
|
|
|
956
|
|
|
957 static float
|
|
|
958 _TG_ATTRS
|
|
|
959 __tg_log2(float __x) {return log2f(__x);}
|
|
|
960
|
|
|
961 static double
|
|
|
962 _TG_ATTRS
|
|
|
963 __tg_log2(double __x) {return log2(__x);}
|
|
|
964
|
|
|
965 static long double
|
|
|
966 _TG_ATTRS
|
|
|
967 __tg_log2(long double __x) {return log2l(__x);}
|
|
|
968
|
|
|
969 #undef log2
|
|
|
970 #define log2(__x) __tg_log2(__tg_promote1((__x))(__x))
|
|
|
971
|
|
|
972 // logb
|
|
|
973
|
|
|
974 static float
|
|
|
975 _TG_ATTRS
|
|
|
976 __tg_logb(float __x) {return logbf(__x);}
|
|
|
977
|
|
|
978 static double
|
|
|
979 _TG_ATTRS
|
|
|
980 __tg_logb(double __x) {return logb(__x);}
|
|
|
981
|
|
|
982 static long double
|
|
|
983 _TG_ATTRS
|
|
|
984 __tg_logb(long double __x) {return logbl(__x);}
|
|
|
985
|
|
|
986 #undef logb
|
|
|
987 #define logb(__x) __tg_logb(__tg_promote1((__x))(__x))
|
|
|
988
|
|
|
989 // lrint
|
|
|
990
|
|
|
991 static long
|
|
|
992 _TG_ATTRS
|
|
|
993 __tg_lrint(float __x) {return lrintf(__x);}
|
|
|
994
|
|
|
995 static long
|
|
|
996 _TG_ATTRS
|
|
|
997 __tg_lrint(double __x) {return lrint(__x);}
|
|
|
998
|
|
|
999 static long
|
|
|
1000 _TG_ATTRS
|
|
|
1001 __tg_lrint(long double __x) {return lrintl(__x);}
|
|
|
1002
|
|
|
1003 #undef lrint
|
|
|
1004 #define lrint(__x) __tg_lrint(__tg_promote1((__x))(__x))
|
|
|
1005
|
|
|
1006 // lround
|
|
|
1007
|
|
|
1008 static long
|
|
|
1009 _TG_ATTRS
|
|
|
1010 __tg_lround(float __x) {return lroundf(__x);}
|
|
|
1011
|
|
|
1012 static long
|
|
|
1013 _TG_ATTRS
|
|
|
1014 __tg_lround(double __x) {return lround(__x);}
|
|
|
1015
|
|
|
1016 static long
|
|
|
1017 _TG_ATTRS
|
|
|
1018 __tg_lround(long double __x) {return lroundl(__x);}
|
|
|
1019
|
|
|
1020 #undef lround
|
|
|
1021 #define lround(__x) __tg_lround(__tg_promote1((__x))(__x))
|
|
|
1022
|
|
|
1023 // nearbyint
|
|
|
1024
|
|
|
1025 static float
|
|
|
1026 _TG_ATTRS
|
|
|
1027 __tg_nearbyint(float __x) {return nearbyintf(__x);}
|
|
|
1028
|
|
|
1029 static double
|
|
|
1030 _TG_ATTRS
|
|
|
1031 __tg_nearbyint(double __x) {return nearbyint(__x);}
|
|
|
1032
|
|
|
1033 static long double
|
|
|
1034 _TG_ATTRS
|
|
|
1035 __tg_nearbyint(long double __x) {return nearbyintl(__x);}
|
|
|
1036
|
|
|
1037 #undef nearbyint
|
|
|
1038 #define nearbyint(__x) __tg_nearbyint(__tg_promote1((__x))(__x))
|
|
|
1039
|
|
|
1040 // nextafter
|
|
|
1041
|
|
|
1042 static float
|
|
|
1043 _TG_ATTRS
|
|
|
1044 __tg_nextafter(float __x, float __y) {return nextafterf(__x, __y);}
|
|
|
1045
|
|
|
1046 static double
|
|
|
1047 _TG_ATTRS
|
|
|
1048 __tg_nextafter(double __x, double __y) {return nextafter(__x, __y);}
|
|
|
1049
|
|
|
1050 static long double
|
|
|
1051 _TG_ATTRS
|
|
|
1052 __tg_nextafter(long double __x, long double __y) {return nextafterl(__x, __y);}
|
|
|
1053
|
|
|
1054 #undef nextafter
|
|
|
1055 #define nextafter(__x, __y) __tg_nextafter(__tg_promote2((__x), (__y))(__x), \
|
|
|
1056 __tg_promote2((__x), (__y))(__y))
|
|
|
1057
|
|
|
1058 // nexttoward
|
|
|
1059
|
|
|
1060 static float
|
|
|
1061 _TG_ATTRS
|
|
|
1062 __tg_nexttoward(float __x, long double __y) {return nexttowardf(__x, __y);}
|
|
|
1063
|
|
|
1064 static double
|
|
|
1065 _TG_ATTRS
|
|
|
1066 __tg_nexttoward(double __x, long double __y) {return nexttoward(__x, __y);}
|
|
|
1067
|
|
|
1068 static long double
|
|
|
1069 _TG_ATTRS
|
|
|
1070 __tg_nexttoward(long double __x, long double __y) {return nexttowardl(__x, __y);}
|
|
|
1071
|
|
|
1072 #undef nexttoward
|
|
|
1073 #define nexttoward(__x, __y) __tg_nexttoward(__tg_promote1((__x))(__x), (__y))
|
|
|
1074
|
|
|
1075 // remainder
|
|
|
1076
|
|
|
1077 static float
|
|
|
1078 _TG_ATTRS
|
|
|
1079 __tg_remainder(float __x, float __y) {return remainderf(__x, __y);}
|
|
|
1080
|
|
|
1081 static double
|
|
|
1082 _TG_ATTRS
|
|
|
1083 __tg_remainder(double __x, double __y) {return remainder(__x, __y);}
|
|
|
1084
|
|
|
1085 static long double
|
|
|
1086 _TG_ATTRS
|
|
|
1087 __tg_remainder(long double __x, long double __y) {return remainderl(__x, __y);}
|
|
|
1088
|
|
|
1089 #undef remainder
|
|
|
1090 #define remainder(__x, __y) __tg_remainder(__tg_promote2((__x), (__y))(__x), \
|
|
|
1091 __tg_promote2((__x), (__y))(__y))
|
|
|
1092
|
|
|
1093 // remquo
|
|
|
1094
|
|
|
1095 static float
|
|
|
1096 _TG_ATTRS
|
|
|
1097 __tg_remquo(float __x, float __y, int* __z)
|
|
|
1098 {return remquof(__x, __y, __z);}
|
|
|
1099
|
|
|
1100 static double
|
|
|
1101 _TG_ATTRS
|
|
|
1102 __tg_remquo(double __x, double __y, int* __z)
|
|
|
1103 {return remquo(__x, __y, __z);}
|
|
|
1104
|
|
|
1105 static long double
|
|
|
1106 _TG_ATTRS
|
|
|
1107 __tg_remquo(long double __x,long double __y, int* __z)
|
|
|
1108 {return remquol(__x, __y, __z);}
|
|
|
1109
|
|
|
1110 #undef remquo
|
|
|
1111 #define remquo(__x, __y, __z) \
|
|
|
1112 __tg_remquo(__tg_promote2((__x), (__y))(__x), \
|
|
|
1113 __tg_promote2((__x), (__y))(__y), \
|
|
|
1114 (__z))
|
|
|
1115
|
|
|
1116 // rint
|
|
|
1117
|
|
|
1118 static float
|
|
|
1119 _TG_ATTRS
|
|
|
1120 __tg_rint(float __x) {return rintf(__x);}
|
|
|
1121
|
|
|
1122 static double
|
|
|
1123 _TG_ATTRS
|
|
|
1124 __tg_rint(double __x) {return rint(__x);}
|
|
|
1125
|
|
|
1126 static long double
|
|
|
1127 _TG_ATTRS
|
|
|
1128 __tg_rint(long double __x) {return rintl(__x);}
|
|
|
1129
|
|
|
1130 #undef rint
|
|
|
1131 #define rint(__x) __tg_rint(__tg_promote1((__x))(__x))
|
|
|
1132
|
|
|
1133 // round
|
|
|
1134
|
|
|
1135 static float
|
|
|
1136 _TG_ATTRS
|
|
|
1137 __tg_round(float __x) {return roundf(__x);}
|
|
|
1138
|
|
|
1139 static double
|
|
|
1140 _TG_ATTRS
|
|
|
1141 __tg_round(double __x) {return round(__x);}
|
|
|
1142
|
|
|
1143 static long double
|
|
|
1144 _TG_ATTRS
|
|
|
1145 __tg_round(long double __x) {return roundl(__x);}
|
|
|
1146
|
|
|
1147 #undef round
|
|
|
1148 #define round(__x) __tg_round(__tg_promote1((__x))(__x))
|
|
|
1149
|
|
|
1150 // scalbn
|
|
|
1151
|
|
|
1152 static float
|
|
|
1153 _TG_ATTRS
|
|
|
1154 __tg_scalbn(float __x, int __y) {return scalbnf(__x, __y);}
|
|
|
1155
|
|
|
1156 static double
|
|
|
1157 _TG_ATTRS
|
|
|
1158 __tg_scalbn(double __x, int __y) {return scalbn(__x, __y);}
|
|
|
1159
|
|
|
1160 static long double
|
|
|
1161 _TG_ATTRS
|
|
|
1162 __tg_scalbn(long double __x, int __y) {return scalbnl(__x, __y);}
|
|
|
1163
|
|
|
1164 #undef scalbn
|
|
|
1165 #define scalbn(__x, __y) __tg_scalbn(__tg_promote1((__x))(__x), __y)
|
|
|
1166
|
|
|
1167 // scalbln
|
|
|
1168
|
|
|
1169 static float
|
|
|
1170 _TG_ATTRS
|
|
|
1171 __tg_scalbln(float __x, long __y) {return scalblnf(__x, __y);}
|
|
|
1172
|
|
|
1173 static double
|
|
|
1174 _TG_ATTRS
|
|
|
1175 __tg_scalbln(double __x, long __y) {return scalbln(__x, __y);}
|
|
|
1176
|
|
|
1177 static long double
|
|
|
1178 _TG_ATTRS
|
|
|
1179 __tg_scalbln(long double __x, long __y) {return scalblnl(__x, __y);}
|
|
|
1180
|
|
|
1181 #undef scalbln
|
|
|
1182 #define scalbln(__x, __y) __tg_scalbln(__tg_promote1((__x))(__x), __y)
|
|
|
1183
|
|
|
1184 // tgamma
|
|
|
1185
|
|
|
1186 static float
|
|
|
1187 _TG_ATTRS
|
|
|
1188 __tg_tgamma(float __x) {return tgammaf(__x);}
|
|
|
1189
|
|
|
1190 static double
|
|
|
1191 _TG_ATTRS
|
|
|
1192 __tg_tgamma(double __x) {return tgamma(__x);}
|
|
|
1193
|
|
|
1194 static long double
|
|
|
1195 _TG_ATTRS
|
|
|
1196 __tg_tgamma(long double __x) {return tgammal(__x);}
|
|
|
1197
|
|
|
1198 #undef tgamma
|
|
|
1199 #define tgamma(__x) __tg_tgamma(__tg_promote1((__x))(__x))
|
|
|
1200
|
|
|
1201 // trunc
|
|
|
1202
|
|
|
1203 static float
|
|
|
1204 _TG_ATTRS
|
|
|
1205 __tg_trunc(float __x) {return truncf(__x);}
|
|
|
1206
|
|
|
1207 static double
|
|
|
1208 _TG_ATTRS
|
|
|
1209 __tg_trunc(double __x) {return trunc(__x);}
|
|
|
1210
|
|
|
1211 static long double
|
|
|
1212 _TG_ATTRS
|
|
|
1213 __tg_trunc(long double __x) {return truncl(__x);}
|
|
|
1214
|
|
|
1215 #undef trunc
|
|
|
1216 #define trunc(__x) __tg_trunc(__tg_promote1((__x))(__x))
|
|
|
1217
|
|
|
1218 // carg
|
|
|
1219
|
|
|
1220 static float
|
|
|
1221 _TG_ATTRS
|
|
|
1222 __tg_carg(float __x) {return atan2f(0.F, __x);}
|
|
|
1223
|
|
|
1224 static double
|
|
|
1225 _TG_ATTRS
|
|
|
1226 __tg_carg(double __x) {return atan2(0., __x);}
|
|
|
1227
|
|
|
1228 static long double
|
|
|
1229 _TG_ATTRS
|
|
|
1230 __tg_carg(long double __x) {return atan2l(0.L, __x);}
|
|
|
1231
|
|
|
1232 static float
|
|
|
1233 _TG_ATTRS
|
|
|
1234 __tg_carg(float _Complex __x) {return cargf(__x);}
|
|
|
1235
|
|
|
1236 static double
|
|
|
1237 _TG_ATTRS
|
|
|
1238 __tg_carg(double _Complex __x) {return carg(__x);}
|
|
|
1239
|
|
|
1240 static long double
|
|
|
1241 _TG_ATTRS
|
|
|
1242 __tg_carg(long double _Complex __x) {return cargl(__x);}
|
|
|
1243
|
|
|
1244 #undef carg
|
|
|
1245 #define carg(__x) __tg_carg(__tg_promote1((__x))(__x))
|
|
|
1246
|
|
|
1247 // cimag
|
|
|
1248
|
|
|
1249 static float
|
|
|
1250 _TG_ATTRS
|
|
|
1251 __tg_cimag(float __x) {return 0;}
|
|
|
1252
|
|
|
1253 static double
|
|
|
1254 _TG_ATTRS
|
|
|
1255 __tg_cimag(double __x) {return 0;}
|
|
|
1256
|
|
|
1257 static long double
|
|
|
1258 _TG_ATTRS
|
|
|
1259 __tg_cimag(long double __x) {return 0;}
|
|
|
1260
|
|
|
1261 static float
|
|
|
1262 _TG_ATTRS
|
|
|
1263 __tg_cimag(float _Complex __x) {return cimagf(__x);}
|
|
|
1264
|
|
|
1265 static double
|
|
|
1266 _TG_ATTRS
|
|
|
1267 __tg_cimag(double _Complex __x) {return cimag(__x);}
|
|
|
1268
|
|
|
1269 static long double
|
|
|
1270 _TG_ATTRS
|
|
|
1271 __tg_cimag(long double _Complex __x) {return cimagl(__x);}
|
|
|
1272
|
|
|
1273 #undef cimag
|
|
|
1274 #define cimag(__x) __tg_cimag(__tg_promote1((__x))(__x))
|
|
|
1275
|
|
|
1276 // conj
|
|
|
1277
|
|
|
1278 static float _Complex
|
|
|
1279 _TG_ATTRS
|
|
|
1280 __tg_conj(float __x) {return __x;}
|
|
|
1281
|
|
|
1282 static double _Complex
|
|
|
1283 _TG_ATTRS
|
|
|
1284 __tg_conj(double __x) {return __x;}
|
|
|
1285
|
|
|
1286 static long double _Complex
|
|
|
1287 _TG_ATTRS
|
|
|
1288 __tg_conj(long double __x) {return __x;}
|
|
|
1289
|
|
|
1290 static float _Complex
|
|
|
1291 _TG_ATTRS
|
|
|
1292 __tg_conj(float _Complex __x) {return conjf(__x);}
|
|
|
1293
|
|
|
1294 static double _Complex
|
|
|
1295 _TG_ATTRS
|
|
|
1296 __tg_conj(double _Complex __x) {return conj(__x);}
|
|
|
1297
|
|
|
1298 static long double _Complex
|
|
|
1299 _TG_ATTRS
|
|
|
1300 __tg_conj(long double _Complex __x) {return conjl(__x);}
|
|
|
1301
|
|
|
1302 #undef conj
|
|
|
1303 #define conj(__x) __tg_conj(__tg_promote1((__x))(__x))
|
|
|
1304
|
|
|
1305 // cproj
|
|
|
1306
|
|
|
1307 static float _Complex
|
|
|
1308 _TG_ATTRS
|
|
|
1309 __tg_cproj(float __x) {return cprojf(__x);}
|
|
|
1310
|
|
|
1311 static double _Complex
|
|
|
1312 _TG_ATTRS
|
|
|
1313 __tg_cproj(double __x) {return cproj(__x);}
|
|
|
1314
|
|
|
1315 static long double _Complex
|
|
|
1316 _TG_ATTRS
|
|
|
1317 __tg_cproj(long double __x) {return cprojl(__x);}
|
|
|
1318
|
|
|
1319 static float _Complex
|
|
|
1320 _TG_ATTRS
|
|
|
1321 __tg_cproj(float _Complex __x) {return cprojf(__x);}
|
|
|
1322
|
|
|
1323 static double _Complex
|
|
|
1324 _TG_ATTRS
|
|
|
1325 __tg_cproj(double _Complex __x) {return cproj(__x);}
|
|
|
1326
|
|
|
1327 static long double _Complex
|
|
|
1328 _TG_ATTRS
|
|
|
1329 __tg_cproj(long double _Complex __x) {return cprojl(__x);}
|
|
|
1330
|
|
|
1331 #undef cproj
|
|
|
1332 #define cproj(__x) __tg_cproj(__tg_promote1((__x))(__x))
|
|
|
1333
|
|
|
1334 // creal
|
|
|
1335
|
|
|
1336 static float
|
|
|
1337 _TG_ATTRS
|
|
|
1338 __tg_creal(float __x) {return __x;}
|
|
|
1339
|
|
|
1340 static double
|
|
|
1341 _TG_ATTRS
|
|
|
1342 __tg_creal(double __x) {return __x;}
|
|
|
1343
|
|
|
1344 static long double
|
|
|
1345 _TG_ATTRS
|
|
|
1346 __tg_creal(long double __x) {return __x;}
|
|
|
1347
|
|
|
1348 static float
|
|
|
1349 _TG_ATTRS
|
|
|
1350 __tg_creal(float _Complex __x) {return crealf(__x);}
|
|
|
1351
|
|
|
1352 static double
|
|
|
1353 _TG_ATTRS
|
|
|
1354 __tg_creal(double _Complex __x) {return creal(__x);}
|
|
|
1355
|
|
|
1356 static long double
|
|
|
1357 _TG_ATTRS
|
|
|
1358 __tg_creal(long double _Complex __x) {return creall(__x);}
|
|
|
1359
|
|
|
1360 #undef creal
|
|
|
1361 #define creal(__x) __tg_creal(__tg_promote1((__x))(__x))
|
|
|
1362
|
|
|
1363 #undef _TG_ATTRSp
|
|
|
1364 #undef _TG_ATTRS
|
|
|
1365
|
|
|
1366 #endif /* __cplusplus */
|
|
|
1367 #endif /* __has_include_next */
|
|
|
1368 #endif /* __CLANG_TGMATH_H */
|
