clang  10.0.0svn
tgmath.h
Go to the documentation of this file.
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 
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 */
__DEVICE__ float tanf(float __a)
static __inline unsigned char unsigned int unsigned int __y
Definition: adxintrin.h:22
__DEVICE__ float fmodf(float __a, float __b)
static float _TG_ATTRS __tg_sin(float __x)
Definition: tgmath.h:263
#define conj(__x)
Definition: tgmath.h:1303
static float _TG_ATTRS __tg_fmax(float __x, float __y)
Definition: tgmath.h:751
#define log1p(__x)
Definition: tgmath.h:953
#define fma(__x, __y, __z)
Definition: tgmath.h:742
#define cimag(__x)
Definition: tgmath.h:1274
static float _Complex _TG_ATTRS __tg_conj(float __x)
Definition: tgmath.h:1280
__DEVICE__ float acoshf(float __a)
__DEVICE__ float coshf(float __a)
#define llround(__x)
Definition: tgmath.h:919
#define cosh(__x)
Definition: tgmath.h:344
#define trunc(__x)
Definition: tgmath.h:1216
static float _TG_ATTRS __tg_cosh(float __x)
Definition: tgmath.h:321
static float _TG_ATTRS __tg_round(float __x)
Definition: tgmath.h:1137
vector signed char unaligned_vec_schar __attribute__((aligned(1)))
Zeroes the upper 128 bits (bits 255:128) of all YMM registers.
Definition: altivec.h:16347
static float _TG_ATTRS __tg_tgamma(float __x)
Definition: tgmath.h:1188
#define atanh(__x)
Definition: tgmath.h:228
__DEVICE__ float nextafterf(float __a, float __b)
static float _TG_ATTRS __tg_expm1(float __x)
Definition: tgmath.h:676
#define acos(__x)
Definition: tgmath.h:83
#define log2(__x)
Definition: tgmath.h:970
static float _TG_ATTRS __tg_nexttoward(float __x, long double __y)
Definition: tgmath.h:1062
#define frexp(__x, __y)
Definition: tgmath.h:816
#define erfc(__x)
Definition: tgmath.h:653
#define creal(__x)
Definition: tgmath.h:1361
#define fmod(__x, __y)
Definition: tgmath.h:798
__DEVICE__ int ilogbf(float __a)
__DEVICE__ float frexpf(float __a, int *__b)
#define _TG_ATTRSp
Definition: tgmath.h:28
static float _TG_ATTRS __tg_fma(float __x, float __y, float __z)
Definition: tgmath.h:728
__DEVICE__ float ceilf(float __a)
static float _TG_ATTRS __tg_exp(float __x)
Definition: tgmath.h:408
#define fmax(__x, __y)
Definition: tgmath.h:762
static float _TG_ATTRS __tg_acos(float __x)
Definition: tgmath.h:60
static float _TG_ATTRS __tg_carg(float __x)
Definition: tgmath.h:1222
static float _TG_ATTRS __tg_asinh(float __x)
Definition: tgmath.h:176
#define pow(__x, __y)
Definition: tgmath.h:490
static float _TG_ATTRS __tg_erf(float __x)
Definition: tgmath.h:625
static float _TG_ATTRS __tg_logb(float __x)
Definition: tgmath.h:976
__DEVICE__ float log2f(float __a)
#define carg(__x)
Definition: tgmath.h:1245
static float _TG_ATTRS __tg_erfc(float __x)
Definition: tgmath.h:642
static float _TG_ATTRS __tg_atan2(float __x, float __y)
Definition: tgmath.h:555
static float _TG_ATTRS __tg_log(float __x)
Definition: tgmath.h:437
__DEVICE__ float remquof(float __a, float __b, int *__c)
#define fmin(__x, __y)
Definition: tgmath.h:780
__DEVICE__ float expm1f(float __a)
static float _TG_ATTRS __tg_fdim(float __x, float __y)
Definition: tgmath.h:693
#define logb(__x)
Definition: tgmath.h:987
__DEVICE__ float asinhf(float __a)
static float _TG_ATTRS __tg_creal(float __x)
Definition: tgmath.h:1338
#define asinh(__x)
Definition: tgmath.h:199
#define cproj(__x)
Definition: tgmath.h:1332
static float _TG_ATTRS __tg_nextafter(float __x, float __y)
Definition: tgmath.h:1044
#define remainder(__x, __y)
Definition: tgmath.h:1090
__DEVICE__ float fminf(float __a, float __b)
static long long _TG_ATTRS __tg_llrint(float __x)
Definition: tgmath.h:891
static long _TG_ATTRS __tg_lrint(float __x)
Definition: tgmath.h:993
static float _TG_ATTRS __tg_lgamma(float __x)
Definition: tgmath.h:874
__DEVICE__ float sinhf(float __a)
#define tgamma(__x)
Definition: tgmath.h:1199
#define sin(__x)
Definition: tgmath.h:286
#define lrint(__x)
Definition: tgmath.h:1004
__DEVICE__ float acosf(float __a)
static float _TG_ATTRS __tg_remquo(float __x, float __y, int *__z)
Definition: tgmath.h:1097
__DEVICE__ float fmaxf(float __a, float __b)
__DEVICE__ float nearbyintf(float __a)
#define tan(__x)
Definition: tgmath.h:315
__DEVICE__ float atanf(float __a)
__DEVICE__ float logf(float __a)
#define cbrt(__x)
Definition: tgmath.h:584
__DEVICE__ float fmaf(float __a, float __b, float __c)
void _Argument_type_is_not_arithmetic
Definition: tgmath.h:33
static float _TG_ATTRS __tg_fmin(float __x, float __y)
Definition: tgmath.h:769
__DEVICE__ float atanhf(float __a)
__DEVICE__ float roundf(float __a)
#define copysign(__x, __y)
Definition: tgmath.h:618
__DEVICE__ float ldexpf(float __a, int __b)
#define nexttoward(__x, __y)
Definition: tgmath.h:1073
static float _TG_ATTRS __tg_hypot(float __x, float __y)
Definition: tgmath.h:822
__DEVICE__ long lroundf(float __a)
static float _TG_ATTRS __tg_log2(float __x)
Definition: tgmath.h:959
static float _TG_ATTRS __tg_frexp(float __x, int *__y)
Definition: tgmath.h:805
static float _TG_ATTRS __tg_log10(float __x)
Definition: tgmath.h:925
static float _TG_ATTRS __tg_nearbyint(float __x)
Definition: tgmath.h:1027
#define lgamma(__x)
Definition: tgmath.h:885
#define expm1(__x)
Definition: tgmath.h:687
static float _TG_ATTRS __tg_atan(float __x)
Definition: tgmath.h:118
__DEVICE__ float erff(float __a)
__DEVICE__ float tanhf(float __a)
__DEVICE__ float exp2f(float __a)
__DEVICE__ float fabsf(float __a)
__DEVICE__ float atan2f(float __a, float __b)
#define acosh(__x)
Definition: tgmath.h:170
static float _TG_ATTRS __tg_copysign(float __x, float __y)
Definition: tgmath.h:607
__DEVICE__ float cbrtf(float __a)
#define tanh(__x)
Definition: tgmath.h:402
static __inline unsigned char unsigned int __x
Definition: adxintrin.h:22
static long long _TG_ATTRS __tg_llround(float __x)
Definition: tgmath.h:908
static float _Complex _TG_ATTRS __tg_cproj(float __x)
Definition: tgmath.h:1309
#define log(__x)
Definition: tgmath.h:460
__DEVICE__ float expf(float __a)
__DEVICE__ float powf(float __a, float __b)
#define ldexp(__x, __y)
Definition: tgmath.h:868
__DEVICE__ float tgammaf(float __a)
static float _TG_ATTRS __tg_sinh(float __x)
Definition: tgmath.h:350
__DEVICE__ float remainderf(float __a, float __b)
static float _TG_ATTRS __tg_ldexp(float __x, int __y)
Definition: tgmath.h:857
#define rint(__x)
Definition: tgmath.h:1131
#define fdim(__x, __y)
Definition: tgmath.h:704
__DEVICE__ float truncf(float __a)
#define sinh(__x)
Definition: tgmath.h:373
#define atan2(__x, __y)
Definition: tgmath.h:566
#define round(__x)
Definition: tgmath.h:1148
#define exp2(__x)
Definition: tgmath.h:670
#define ilogb(__x)
Definition: tgmath.h:851
__DEVICE__ float asinf(float __a)
#define cos(__x)
Definition: tgmath.h:257
static float _TG_ATTRS __tg_rint(float __x)
Definition: tgmath.h:1120
__DEVICE__ float erfcf(float __a)
__DEVICE__ float scalbnf(float __a, int __b)
#define _TG_ATTRS
Definition: tgmath.h:29
#define exp(__x)
Definition: tgmath.h:431
static float _TG_ATTRS __tg_fabs(float __x)
Definition: tgmath.h:526
static float _TG_ATTRS __tg_acosh(float __x)
Definition: tgmath.h:147
#define lround(__x)
Definition: tgmath.h:1021
__DEVICE__ float sinf(float __a)
__DEVICE__ float fdimf(float __a, float __b)
#define log10(__x)
Definition: tgmath.h:936
static float _TG_ATTRS __tg_asin(float __x)
Definition: tgmath.h:89
__DEVICE__ long long llrintf(float __a)
static float _TG_ATTRS __tg_tan(float __x)
Definition: tgmath.h:292
static float _TG_ATTRS __tg_ceil(float __x)
Definition: tgmath.h:590
__DEVICE__ long lrintf(float __a)
static float _TG_ATTRS __tg_pow(float __x, float __y)
Definition: tgmath.h:466
#define ceil(__x)
Definition: tgmath.h:601
#define remquo(__x, __y, __z)
Definition: tgmath.h:1111
__DEVICE__ long long llroundf(float __a)
static float _TG_ATTRS __tg_scalbln(float __x, long __y)
Definition: tgmath.h:1171
#define asin(__x)
Definition: tgmath.h:112
#define floor(__x)
Definition: tgmath.h:722
static long _TG_ATTRS __tg_lround(float __x)
Definition: tgmath.h:1010
#define erf(__x)
Definition: tgmath.h:636
__DEVICE__ float scalblnf(float __a, long __b)
#define llrint(__x)
Definition: tgmath.h:902
__DEVICE__ float cosf(float __a)
#define nextafter(__x, __y)
Definition: tgmath.h:1055
#define nearbyint(__x)
Definition: tgmath.h:1038
static _Argument_type_is_not_arithmetic __overloadable__
Definition: tgmath.h:35
static float _TG_ATTRS __tg_cimag(float __x)
Definition: tgmath.h:1251
__DEVICE__ float logbf(float __a)
static float _TG_ATTRS __tg_remainder(float __x, float __y)
Definition: tgmath.h:1079
static float _TG_ATTRS __tg_scalbn(float __x, int __y)
Definition: tgmath.h:1154
__DEVICE__ float hypotf(float __a, float __b)
__DEVICE__ float sqrtf(float __a)
static float _TG_ATTRS __tg_exp2(float __x)
Definition: tgmath.h:659
static float _TG_ATTRS __tg_trunc(float __x)
Definition: tgmath.h:1205
static float _TG_ATTRS __tg_fmod(float __x, float __y)
Definition: tgmath.h:787
__DEVICE__ float log10f(float __a)
#define scalbn(__x, __y)
Definition: tgmath.h:1165
static int _TG_ATTRS __tg_ilogb(float __x)
Definition: tgmath.h:840
static float _TG_ATTRS __tg_floor(float __x)
Definition: tgmath.h:711
#define scalbln(__x, __y)
Definition: tgmath.h:1182
#define sqrt(__x)
Definition: tgmath.h:520
static float _TG_ATTRS __tg_log1p(float __x)
Definition: tgmath.h:942
#define fabs(__x)
Definition: tgmath.h:549
__DEVICE__ float lgammaf(float __a)
static float _TG_ATTRS __tg_cbrt(float __x)
Definition: tgmath.h:573
#define atan(__x)
Definition: tgmath.h:141
__DEVICE__ float floorf(float __f)
static float _TG_ATTRS __tg_cos(float __x)
Definition: tgmath.h:234
__DEVICE__ float log1pf(float __a)
static _Argument_type_is_not_arithmetic __tg_promote(...) __attribute__((__unavailable__
static float _TG_ATTRS __tg_sqrt(float __x)
Definition: tgmath.h:497
#define hypot(__x, __y)
Definition: tgmath.h:833
__DEVICE__ float copysignf(float __a, float __b)
__DEVICE__ float rintf(float __a)
static float _TG_ATTRS __tg_atanh(float __x)
Definition: tgmath.h:205
static float _TG_ATTRS __tg_tanh(float __x)
Definition: tgmath.h:379