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