Debian Codegraph @

llvm-project/clang/lib/Headers/tgmath.h

raw
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 */