39#pragma GCC system_header
46#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
48#undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS
52#define _GLIBCXX_CMATH 1
81namespace std _GLIBCXX_VISIBILITY(default)
83_GLIBCXX_BEGIN_NAMESPACE_VERSION
87#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
88 inline _GLIBCXX_CONSTEXPR
float
90 {
return __builtin_acosf(__x); }
92 inline _GLIBCXX_CONSTEXPR
long double
94 {
return __builtin_acosl(__x); }
97 template<
typename _Tp>
98 inline _GLIBCXX_CONSTEXPR
99 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
102 {
return __builtin_acos(__x); }
106#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
107 inline _GLIBCXX_CONSTEXPR
float
109 {
return __builtin_asinf(__x); }
111 inline _GLIBCXX_CONSTEXPR
long double
112 asin(
long double __x)
113 {
return __builtin_asinl(__x); }
116 template<
typename _Tp>
117 inline _GLIBCXX_CONSTEXPR
118 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
121 {
return __builtin_asin(__x); }
125#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
126 inline _GLIBCXX_CONSTEXPR
float
128 {
return __builtin_atanf(__x); }
130 inline _GLIBCXX_CONSTEXPR
long double
131 atan(
long double __x)
132 {
return __builtin_atanl(__x); }
135 template<
typename _Tp>
136 inline _GLIBCXX_CONSTEXPR
137 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
140 {
return __builtin_atan(__x); }
144#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
145 inline _GLIBCXX_CONSTEXPR
float
146 atan2(
float __y,
float __x)
147 {
return __builtin_atan2f(__y, __x); }
149 inline _GLIBCXX_CONSTEXPR
long double
150 atan2(
long double __y,
long double __x)
151 {
return __builtin_atan2l(__y, __x); }
154 template<
typename _Tp,
typename _Up>
155 inline _GLIBCXX_CONSTEXPR
156 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
157 atan2(_Tp __y, _Up __x)
159 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
160 return atan2(__type(__y), __type(__x));
165#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
166 inline _GLIBCXX_CONSTEXPR
float
168 {
return __builtin_ceilf(__x); }
170 inline _GLIBCXX_CONSTEXPR
long double
171 ceil(
long double __x)
172 {
return __builtin_ceill(__x); }
175 template<
typename _Tp>
176 inline _GLIBCXX_CONSTEXPR
177 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
180 {
return __builtin_ceil(__x); }
184#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
185 inline _GLIBCXX_CONSTEXPR
float
187 {
return __builtin_cosf(__x); }
189 inline _GLIBCXX_CONSTEXPR
long double
191 {
return __builtin_cosl(__x); }
194 template<
typename _Tp>
195 inline _GLIBCXX_CONSTEXPR
196 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
199 {
return __builtin_cos(__x); }
203#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
204 inline _GLIBCXX_CONSTEXPR
float
206 {
return __builtin_coshf(__x); }
208 inline _GLIBCXX_CONSTEXPR
long double
209 cosh(
long double __x)
210 {
return __builtin_coshl(__x); }
213 template<
typename _Tp>
214 inline _GLIBCXX_CONSTEXPR
215 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
218 {
return __builtin_cosh(__x); }
222#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
223 inline _GLIBCXX_CONSTEXPR
float
225 {
return __builtin_expf(__x); }
227 inline _GLIBCXX_CONSTEXPR
long double
229 {
return __builtin_expl(__x); }
232 template<
typename _Tp>
233 inline _GLIBCXX_CONSTEXPR
234 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
237 {
return __builtin_exp(__x); }
241#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
242 inline _GLIBCXX_CONSTEXPR
float
244 {
return __builtin_fabsf(__x); }
246 inline _GLIBCXX_CONSTEXPR
long double
247 fabs(
long double __x)
248 {
return __builtin_fabsl(__x); }
251 template<
typename _Tp>
252 inline _GLIBCXX_CONSTEXPR
253 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
256 {
return __builtin_fabs(__x); }
260#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
261 inline _GLIBCXX_CONSTEXPR
float
263 {
return __builtin_floorf(__x); }
265 inline _GLIBCXX_CONSTEXPR
long double
266 floor(
long double __x)
267 {
return __builtin_floorl(__x); }
270 template<
typename _Tp>
271 inline _GLIBCXX_CONSTEXPR
272 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
275 {
return __builtin_floor(__x); }
279#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
280 inline _GLIBCXX_CONSTEXPR
float
281 fmod(
float __x,
float __y)
282 {
return __builtin_fmodf(__x, __y); }
284 inline _GLIBCXX_CONSTEXPR
long double
285 fmod(
long double __x,
long double __y)
286 {
return __builtin_fmodl(__x, __y); }
289 template<
typename _Tp,
typename _Up>
290 inline _GLIBCXX_CONSTEXPR
291 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
292 fmod(_Tp __x, _Up __y)
294 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
295 return fmod(__type(__x), __type(__y));
300#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
302 frexp(
float __x,
int* __exp)
303 {
return __builtin_frexpf(__x, __exp); }
306 frexp(
long double __x,
int* __exp)
307 {
return __builtin_frexpl(__x, __exp); }
310 template<
typename _Tp>
311 inline _GLIBCXX_CONSTEXPR
312 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
314 frexp(_Tp __x,
int* __exp)
315 {
return __builtin_frexp(__x, __exp); }
319#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
320 inline _GLIBCXX_CONSTEXPR
float
321 ldexp(
float __x,
int __exp)
322 {
return __builtin_ldexpf(__x, __exp); }
324 inline _GLIBCXX_CONSTEXPR
long double
325 ldexp(
long double __x,
int __exp)
326 {
return __builtin_ldexpl(__x, __exp); }
329 template<
typename _Tp>
330 inline _GLIBCXX_CONSTEXPR
331 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
333 ldexp(_Tp __x,
int __exp)
334 {
return __builtin_ldexp(__x, __exp); }
338#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
339 inline _GLIBCXX_CONSTEXPR
float
341 {
return __builtin_logf(__x); }
343 inline _GLIBCXX_CONSTEXPR
long double
345 {
return __builtin_logl(__x); }
348 template<
typename _Tp>
349 inline _GLIBCXX_CONSTEXPR
350 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
353 {
return __builtin_log(__x); }
357#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
358 inline _GLIBCXX_CONSTEXPR
float
360 {
return __builtin_log10f(__x); }
362 inline _GLIBCXX_CONSTEXPR
long double
363 log10(
long double __x)
364 {
return __builtin_log10l(__x); }
367 template<
typename _Tp>
368 inline _GLIBCXX_CONSTEXPR
369 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
372 {
return __builtin_log10(__x); }
376#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
378 modf(
float __x,
float* __iptr)
379 {
return __builtin_modff(__x, __iptr); }
382 modf(
long double __x,
long double* __iptr)
383 {
return __builtin_modfl(__x, __iptr); }
388#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
389 inline _GLIBCXX_CONSTEXPR
float
390 pow(
float __x,
float __y)
391 {
return __builtin_powf(__x, __y); }
393 inline _GLIBCXX_CONSTEXPR
long double
394 pow(
long double __x,
long double __y)
395 {
return __builtin_powl(__x, __y); }
397#if __cplusplus < 201103L
401 pow(
double __x,
int __i)
402 {
return __builtin_powi(__x, __i); }
405 pow(
float __x,
int __n)
406 {
return __builtin_powif(__x, __n); }
409 pow(
long double __x,
int __n)
410 {
return __builtin_powil(__x, __n); }
414 template<
typename _Tp,
typename _Up>
415 inline _GLIBCXX_CONSTEXPR
416 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
417 pow(_Tp __x, _Up __y)
419 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
420 return pow(__type(__x), __type(__y));
425#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
426 inline _GLIBCXX_CONSTEXPR
float
428 {
return __builtin_sinf(__x); }
430 inline _GLIBCXX_CONSTEXPR
long double
432 {
return __builtin_sinl(__x); }
435 template<
typename _Tp>
436 inline _GLIBCXX_CONSTEXPR
437 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
440 {
return __builtin_sin(__x); }
444#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
445 inline _GLIBCXX_CONSTEXPR
float
447 {
return __builtin_sinhf(__x); }
449 inline _GLIBCXX_CONSTEXPR
long double
450 sinh(
long double __x)
451 {
return __builtin_sinhl(__x); }
454 template<
typename _Tp>
455 inline _GLIBCXX_CONSTEXPR
456 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
459 {
return __builtin_sinh(__x); }
463#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
464 inline _GLIBCXX_CONSTEXPR
float
466 {
return __builtin_sqrtf(__x); }
468 inline _GLIBCXX_CONSTEXPR
long double
469 sqrt(
long double __x)
470 {
return __builtin_sqrtl(__x); }
473 template<
typename _Tp>
474 inline _GLIBCXX_CONSTEXPR
475 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
478 {
return __builtin_sqrt(__x); }
482#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
483 inline _GLIBCXX_CONSTEXPR
float
485 {
return __builtin_tanf(__x); }
487 inline _GLIBCXX_CONSTEXPR
long double
489 {
return __builtin_tanl(__x); }
492 template<
typename _Tp>
493 inline _GLIBCXX_CONSTEXPR
494 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
497 {
return __builtin_tan(__x); }
501#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
502 inline _GLIBCXX_CONSTEXPR
float
504 {
return __builtin_tanhf(__x); }
506 inline _GLIBCXX_CONSTEXPR
long double
507 tanh(
long double __x)
508 {
return __builtin_tanhl(__x); }
511 template<
typename _Tp>
512 inline _GLIBCXX_CONSTEXPR
513 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
516 {
return __builtin_tanh(__x); }
518#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
521 {
return _Float16(__builtin_acosf(__x)); }
525 {
return _Float16(__builtin_asinf(__x)); }
529 {
return _Float16(__builtin_atanf(__x)); }
532 atan2(_Float16 __y, _Float16 __x)
533 {
return _Float16(__builtin_atan2f(__y, __x)); }
537 {
return _Float16(__builtin_ceilf(__x)); }
541 {
return _Float16(__builtin_cosf(__x)); }
545 {
return _Float16(__builtin_coshf(__x)); }
549 {
return _Float16(__builtin_expf(__x)); }
553 {
return _Float16(__builtin_fabsf(__x)); }
557 {
return _Float16(__builtin_floorf(__x)); }
560 fmod(_Float16 __x, _Float16 __y)
561 {
return _Float16(__builtin_fmodf(__x, __y)); }
564 frexp(_Float16 __x,
int* __exp)
565 {
return _Float16(__builtin_frexpf(__x, __exp)); }
568 ldexp(_Float16 __x,
int __exp)
569 {
return _Float16(__builtin_ldexpf(__x, __exp)); }
573 {
return _Float16(__builtin_logf(__x)); }
577 {
return _Float16(__builtin_log10f(__x)); }
580 modf(_Float16 __x, _Float16* __iptr)
582 float __i, __ret = __builtin_modff(__x, &__i);
583 *__iptr = _Float16(__i);
584 return _Float16(__ret);
588 pow(_Float16 __x, _Float16 __y)
589 {
return _Float16(__builtin_powf(__x, __y)); }
593 {
return _Float16(__builtin_sinf(__x)); }
597 {
return _Float16(__builtin_sinhf(__x)); }
601 {
return _Float16(__builtin_sqrtf(__x)); }
605 {
return _Float16(__builtin_tanf(__x)); }
609 {
return _Float16(__builtin_tanhf(__x)); }
612#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
615 {
return __builtin_acosf(__x); }
619 {
return __builtin_asinf(__x); }
623 {
return __builtin_atanf(__x); }
626 atan2(_Float32 __y, _Float32 __x)
627 {
return __builtin_atan2f(__y, __x); }
631 {
return __builtin_ceilf(__x); }
635 {
return __builtin_cosf(__x); }
639 {
return __builtin_coshf(__x); }
643 {
return __builtin_expf(__x); }
647 {
return __builtin_fabsf(__x); }
651 {
return __builtin_floorf(__x); }
654 fmod(_Float32 __x, _Float32 __y)
655 {
return __builtin_fmodf(__x, __y); }
658 frexp(_Float32 __x,
int* __exp)
659 {
return __builtin_frexpf(__x, __exp); }
662 ldexp(_Float32 __x,
int __exp)
663 {
return __builtin_ldexpf(__x, __exp); }
667 {
return __builtin_logf(__x); }
671 {
return __builtin_log10f(__x); }
674 modf(_Float32 __x, _Float32* __iptr)
676 float __i, __ret = __builtin_modff(__x, &__i);
682 pow(_Float32 __x, _Float32 __y)
683 {
return __builtin_powf(__x, __y); }
687 {
return __builtin_sinf(__x); }
691 {
return __builtin_sinhf(__x); }
695 {
return __builtin_sqrtf(__x); }
699 {
return __builtin_tanf(__x); }
703 {
return __builtin_tanhf(__x); }
706#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
709 {
return __builtin_acos(__x); }
713 {
return __builtin_asin(__x); }
717 {
return __builtin_atan(__x); }
720 atan2(_Float64 __y, _Float64 __x)
721 {
return __builtin_atan2(__y, __x); }
725 {
return __builtin_ceil(__x); }
729 {
return __builtin_cos(__x); }
733 {
return __builtin_cosh(__x); }
737 {
return __builtin_exp(__x); }
741 {
return __builtin_fabs(__x); }
745 {
return __builtin_floor(__x); }
748 fmod(_Float64 __x, _Float64 __y)
749 {
return __builtin_fmod(__x, __y); }
752 frexp(_Float64 __x,
int* __exp)
753 {
return __builtin_frexp(__x, __exp); }
756 ldexp(_Float64 __x,
int __exp)
757 {
return __builtin_ldexp(__x, __exp); }
761 {
return __builtin_log(__x); }
765 {
return __builtin_log10(__x); }
768 modf(_Float64 __x, _Float64* __iptr)
770 double __i, __ret = __builtin_modf(__x, &__i);
776 pow(_Float64 __x, _Float64 __y)
777 {
return __builtin_pow(__x, __y); }
781 {
return __builtin_sin(__x); }
785 {
return __builtin_sinh(__x); }
789 {
return __builtin_sqrt(__x); }
793 {
return __builtin_tan(__x); }
797 {
return __builtin_tanh(__x); }
800#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
803 {
return __builtin_acosl(__x); }
807 {
return __builtin_asinl(__x); }
811 {
return __builtin_atanl(__x); }
814 atan2(_Float128 __y, _Float128 __x)
815 {
return __builtin_atan2l(__y, __x); }
819 {
return __builtin_ceill(__x); }
823 {
return __builtin_cosl(__x); }
827 {
return __builtin_coshl(__x); }
831 {
return __builtin_expl(__x); }
835 {
return __builtin_fabsl(__x); }
839 {
return __builtin_floorl(__x); }
842 fmod(_Float128 __x, _Float128 __y)
843 {
return __builtin_fmodl(__x, __y); }
846 frexp(_Float128 __x,
int* __exp)
847 {
return __builtin_frexpl(__x, __exp); }
850 ldexp(_Float128 __x,
int __exp)
851 {
return __builtin_ldexpl(__x, __exp); }
855 {
return __builtin_logl(__x); }
859 {
return __builtin_log10l(__x); }
862 modf(_Float128 __x, _Float128* __iptr)
864 long double __i, __ret = __builtin_modfl(__x, &__i);
870 pow(_Float128 __x, _Float128 __y)
871 {
return __builtin_powl(__x, __y); }
875 {
return __builtin_sinl(__x); }
879 {
return __builtin_sinhl(__x); }
883 {
return __builtin_sqrtl(__x); }
887 {
return __builtin_tanl(__x); }
891 {
return __builtin_tanhl(__x); }
892#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
895 {
return __builtin_acosf128(__x); }
899 {
return __builtin_asinf128(__x); }
903 {
return __builtin_atanf128(__x); }
906 atan2(_Float128 __y, _Float128 __x)
907 {
return __builtin_atan2f128(__y, __x); }
911 {
return __builtin_ceilf128(__x); }
915 {
return __builtin_cosf128(__x); }
919 {
return __builtin_coshf128(__x); }
923 {
return __builtin_expf128(__x); }
927 {
return __builtin_fabsf128(__x); }
931 {
return __builtin_floorf128(__x); }
934 fmod(_Float128 __x, _Float128 __y)
935 {
return __builtin_fmodf128(__x, __y); }
938 frexp(_Float128 __x,
int* __exp)
939 {
return __builtin_frexpf128(__x, __exp); }
942 ldexp(_Float128 __x,
int __exp)
943 {
return __builtin_ldexpf128(__x, __exp); }
947 {
return __builtin_logf128(__x); }
951 {
return __builtin_log10f128(__x); }
954 modf(_Float128 __x, _Float128* __iptr)
955 {
return __builtin_modff128(__x, __iptr); }
958 pow(_Float128 __x, _Float128 __y)
959 {
return __builtin_powf128(__x, __y); }
963 {
return __builtin_sinf128(__x); }
967 {
return __builtin_sinhf128(__x); }
971 {
return __builtin_sqrtf128(__x); }
975 {
return __builtin_tanf128(__x); }
979 {
return __builtin_tanhf128(__x); }
982#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
983 constexpr __gnu_cxx::__bfloat16_t
984 acos(__gnu_cxx::__bfloat16_t __x)
985 {
return __gnu_cxx::__bfloat16_t(__builtin_acosf(__x)); }
987 constexpr __gnu_cxx::__bfloat16_t
988 asin(__gnu_cxx::__bfloat16_t __x)
989 {
return __gnu_cxx::__bfloat16_t(__builtin_asinf(__x)); }
991 constexpr __gnu_cxx::__bfloat16_t
992 atan(__gnu_cxx::__bfloat16_t __x)
993 {
return __gnu_cxx::__bfloat16_t(__builtin_atanf(__x)); }
995 constexpr __gnu_cxx::__bfloat16_t
996 atan2(__gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __x)
997 {
return __gnu_cxx::__bfloat16_t(__builtin_atan2f(__y, __x)); }
999 constexpr __gnu_cxx::__bfloat16_t
1000 ceil(__gnu_cxx::__bfloat16_t __x)
1001 {
return __gnu_cxx::__bfloat16_t(__builtin_ceilf(__x)); }
1003 constexpr __gnu_cxx::__bfloat16_t
1004 cos(__gnu_cxx::__bfloat16_t __x)
1005 {
return __gnu_cxx::__bfloat16_t(__builtin_cosf(__x)); }
1007 constexpr __gnu_cxx::__bfloat16_t
1008 cosh(__gnu_cxx::__bfloat16_t __x)
1009 {
return __gnu_cxx::__bfloat16_t(__builtin_coshf(__x)); }
1011 constexpr __gnu_cxx::__bfloat16_t
1012 exp(__gnu_cxx::__bfloat16_t __x)
1013 {
return __gnu_cxx::__bfloat16_t(__builtin_expf(__x)); }
1015 constexpr __gnu_cxx::__bfloat16_t
1016 fabs(__gnu_cxx::__bfloat16_t __x)
1017 {
return __gnu_cxx::__bfloat16_t(__builtin_fabsf(__x)); }
1019 constexpr __gnu_cxx::__bfloat16_t
1020 floor(__gnu_cxx::__bfloat16_t __x)
1021 {
return __gnu_cxx::__bfloat16_t(__builtin_floorf(__x)); }
1023 constexpr __gnu_cxx::__bfloat16_t
1024 fmod(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1025 {
return __gnu_cxx::__bfloat16_t(__builtin_fmodf(__x, __y)); }
1027 inline __gnu_cxx::__bfloat16_t
1028 frexp(__gnu_cxx::__bfloat16_t __x,
int* __exp)
1029 {
return __gnu_cxx::__bfloat16_t(__builtin_frexpf(__x, __exp)); }
1031 constexpr __gnu_cxx::__bfloat16_t
1032 ldexp(__gnu_cxx::__bfloat16_t __x,
int __exp)
1033 {
return __gnu_cxx::__bfloat16_t(__builtin_ldexpf(__x, __exp)); }
1035 constexpr __gnu_cxx::__bfloat16_t
1036 log(__gnu_cxx::__bfloat16_t __x)
1037 {
return __gnu_cxx::__bfloat16_t(__builtin_logf(__x)); }
1039 constexpr __gnu_cxx::__bfloat16_t
1040 log10(__gnu_cxx::__bfloat16_t __x)
1041 {
return __gnu_cxx::__bfloat16_t(__builtin_log10f(__x)); }
1043 inline __gnu_cxx::__bfloat16_t
1044 modf(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t* __iptr)
1046 float __i, __ret = __builtin_modff(__x, &__i);
1047 *__iptr = __gnu_cxx::__bfloat16_t(__i);
1048 return __gnu_cxx::__bfloat16_t(__ret);
1051 constexpr __gnu_cxx::__bfloat16_t
1052 pow(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1053 {
return __gnu_cxx::__bfloat16_t(__builtin_powf(__x, __y)); }
1055 constexpr __gnu_cxx::__bfloat16_t
1056 sin(__gnu_cxx::__bfloat16_t __x)
1057 {
return __gnu_cxx::__bfloat16_t(__builtin_sinf(__x)); }
1059 constexpr __gnu_cxx::__bfloat16_t
1060 sinh(__gnu_cxx::__bfloat16_t __x)
1061 {
return __gnu_cxx::__bfloat16_t(__builtin_sinhf(__x)); }
1063 constexpr __gnu_cxx::__bfloat16_t
1064 sqrt(__gnu_cxx::__bfloat16_t __x)
1065 {
return __gnu_cxx::__bfloat16_t(__builtin_sqrtf(__x)); }
1067 constexpr __gnu_cxx::__bfloat16_t
1068 tan(__gnu_cxx::__bfloat16_t __x)
1069 {
return __gnu_cxx::__bfloat16_t(__builtin_tanf(__x)); }
1071 constexpr __gnu_cxx::__bfloat16_t
1072 tanh(__gnu_cxx::__bfloat16_t __x)
1073 {
return __gnu_cxx::__bfloat16_t(__builtin_tanhf(__x)); }
1076#if _GLIBCXX_USE_C99_MATH
1077#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
1087#undef isgreaterequal
1093#if __cplusplus >= 201103L
1095#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1097 fpclassify(
float __x)
1098 {
return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1099 FP_SUBNORMAL, FP_ZERO, __x); }
1102 fpclassify(
double __x)
1103 {
return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1104 FP_SUBNORMAL, FP_ZERO, __x); }
1107 fpclassify(
long double __x)
1108 {
return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1109 FP_SUBNORMAL, FP_ZERO, __x); }
1112#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1113 template<
typename _Tp>
1114 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1117 {
return __x != 0 ? FP_NORMAL : FP_ZERO; }
1120#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1123 {
return __builtin_isfinite(__x); }
1126 isfinite(
double __x)
1127 {
return __builtin_isfinite(__x); }
1130 isfinite(
long double __x)
1131 {
return __builtin_isfinite(__x); }
1134#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1135 template<
typename _Tp>
1136 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1142#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1145 {
return __builtin_isinf(__x); }
1147#if _GLIBCXX_HAVE_OBSOLETE_ISINF \
1148 && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
1153 {
return __builtin_isinf(__x); }
1157 isinf(
long double __x)
1158 {
return __builtin_isinf(__x); }
1161#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1162 template<
typename _Tp>
1163 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1169#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1172 {
return __builtin_isnan(__x); }
1174#if _GLIBCXX_HAVE_OBSOLETE_ISNAN \
1175 && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
1180 {
return __builtin_isnan(__x); }
1184 isnan(
long double __x)
1185 {
return __builtin_isnan(__x); }
1188#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1189 template<
typename _Tp>
1190 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1196#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1199 {
return __builtin_isnormal(__x); }
1202 isnormal(
double __x)
1203 {
return __builtin_isnormal(__x); }
1206 isnormal(
long double __x)
1207 {
return __builtin_isnormal(__x); }
1210#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1211 template<
typename _Tp>
1212 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1215 {
return __x != 0 ? true :
false; }
1218#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1222 {
return __builtin_signbit(__x); }
1226 {
return __builtin_signbit(__x); }
1229 signbit(
long double __x)
1230 {
return __builtin_signbit(__x); }
1233#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1234 template<
typename _Tp>
1235 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1238 {
return __x < 0 ? true :
false; }
1241#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1243 isgreater(
float __x,
float __y)
1244 {
return __builtin_isgreater(__x, __y); }
1247 isgreater(
double __x,
double __y)
1248 {
return __builtin_isgreater(__x, __y); }
1251 isgreater(
long double __x,
long double __y)
1252 {
return __builtin_isgreater(__x, __y); }
1255#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1256 template<
typename _Tp,
typename _Up>
1258 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1259 && __is_arithmetic<_Up>::__value),
bool>::__type
1260 isgreater(_Tp __x, _Up __y)
1262 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1263 return __builtin_isgreater(__type(__x), __type(__y));
1267#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1269 isgreaterequal(
float __x,
float __y)
1270 {
return __builtin_isgreaterequal(__x, __y); }
1273 isgreaterequal(
double __x,
double __y)
1274 {
return __builtin_isgreaterequal(__x, __y); }
1277 isgreaterequal(
long double __x,
long double __y)
1278 {
return __builtin_isgreaterequal(__x, __y); }
1281#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1282 template<
typename _Tp,
typename _Up>
1284 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1285 && __is_arithmetic<_Up>::__value),
bool>::__type
1286 isgreaterequal(_Tp __x, _Up __y)
1288 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1289 return __builtin_isgreaterequal(__type(__x), __type(__y));
1293#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1295 isless(
float __x,
float __y)
1296 {
return __builtin_isless(__x, __y); }
1299 isless(
double __x,
double __y)
1300 {
return __builtin_isless(__x, __y); }
1303 isless(
long double __x,
long double __y)
1304 {
return __builtin_isless(__x, __y); }
1307#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1308 template<
typename _Tp,
typename _Up>
1310 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1311 && __is_arithmetic<_Up>::__value),
bool>::__type
1312 isless(_Tp __x, _Up __y)
1314 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1315 return __builtin_isless(__type(__x), __type(__y));
1319#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1321 islessequal(
float __x,
float __y)
1322 {
return __builtin_islessequal(__x, __y); }
1325 islessequal(
double __x,
double __y)
1326 {
return __builtin_islessequal(__x, __y); }
1329 islessequal(
long double __x,
long double __y)
1330 {
return __builtin_islessequal(__x, __y); }
1333#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1334 template<
typename _Tp,
typename _Up>
1336 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1337 && __is_arithmetic<_Up>::__value),
bool>::__type
1338 islessequal(_Tp __x, _Up __y)
1340 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1341 return __builtin_islessequal(__type(__x), __type(__y));
1345#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1347 islessgreater(
float __x,
float __y)
1348 {
return __builtin_islessgreater(__x, __y); }
1351 islessgreater(
double __x,
double __y)
1352 {
return __builtin_islessgreater(__x, __y); }
1355 islessgreater(
long double __x,
long double __y)
1356 {
return __builtin_islessgreater(__x, __y); }
1359#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1360 template<
typename _Tp,
typename _Up>
1362 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1363 && __is_arithmetic<_Up>::__value),
bool>::__type
1364 islessgreater(_Tp __x, _Up __y)
1366 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1367 return __builtin_islessgreater(__type(__x), __type(__y));
1371#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1373 isunordered(
float __x,
float __y)
1374 {
return __builtin_isunordered(__x, __y); }
1377 isunordered(
double __x,
double __y)
1378 {
return __builtin_isunordered(__x, __y); }
1381 isunordered(
long double __x,
long double __y)
1382 {
return __builtin_isunordered(__x, __y); }
1385#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1386 template<
typename _Tp,
typename _Up>
1388 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1389 && __is_arithmetic<_Up>::__value),
bool>::__type
1390 isunordered(_Tp __x, _Up __y)
1392 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1393 return __builtin_isunordered(__type(__x), __type(__y));
1399 template<
typename _Tp>
1400 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1404 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1405 return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1406 FP_SUBNORMAL, FP_ZERO, __type(__f));
1409 template<
typename _Tp>
1410 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1414 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1415 return __builtin_isfinite(__type(__f));
1418 template<
typename _Tp>
1419 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1423 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1424 return __builtin_isinf(__type(__f));
1427 template<
typename _Tp>
1428 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1432 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1433 return __builtin_isnan(__type(__f));
1436 template<
typename _Tp>
1437 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1441 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1442 return __builtin_isnormal(__type(__f));
1445 template<
typename _Tp>
1446 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1450 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1451 return __builtin_signbit(__type(__f));
1454 template<
typename _Tp>
1455 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1457 isgreater(_Tp __f1, _Tp __f2)
1459 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1460 return __builtin_isgreater(__type(__f1), __type(__f2));
1463 template<
typename _Tp>
1464 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1466 isgreaterequal(_Tp __f1, _Tp __f2)
1468 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1469 return __builtin_isgreaterequal(__type(__f1), __type(__f2));
1472 template<
typename _Tp>
1473 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1475 isless(_Tp __f1, _Tp __f2)
1477 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1478 return __builtin_isless(__type(__f1), __type(__f2));
1481 template<
typename _Tp>
1482 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1484 islessequal(_Tp __f1, _Tp __f2)
1486 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1487 return __builtin_islessequal(__type(__f1), __type(__f2));
1490 template<
typename _Tp>
1491 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1493 islessgreater(_Tp __f1, _Tp __f2)
1495 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1496 return __builtin_islessgreater(__type(__f1), __type(__f2));
1499 template<
typename _Tp>
1500 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1502 isunordered(_Tp __f1, _Tp __f2)
1504 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1505 return __builtin_isunordered(__type(__f1), __type(__f2));
1510#ifdef __STDCPP_FLOAT16_T__
1512 fpclassify(_Float16 __x)
1513 {
return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1514 FP_SUBNORMAL, FP_ZERO, __x); }
1517 isfinite(_Float16 __x)
1518 {
return __builtin_isfinite(__x); }
1522 {
return __builtin_isinf(__x); }
1526 {
return __builtin_isnan(__x); }
1529 isnormal(_Float16 __x)
1530 {
return __builtin_isnormal(__x); }
1533 signbit(_Float16 __x)
1534 {
return __builtin_signbit(__x); }
1537 isgreater(_Float16 __x, _Float16 __y)
1538 {
return __builtin_isgreater(__x, __y); }
1541 isgreaterequal(_Float16 __x, _Float16 __y)
1542 {
return __builtin_isgreaterequal(__x, __y); }
1545 isless(_Float16 __x, _Float16 __y)
1546 {
return __builtin_isless(__x, __y); }
1549 islessequal(_Float16 __x, _Float16 __y)
1550 {
return __builtin_islessequal(__x, __y); }
1553 islessgreater(_Float16 __x, _Float16 __y)
1554 {
return __builtin_islessgreater(__x, __y); }
1557 isunordered(_Float16 __x, _Float16 __y)
1558 {
return __builtin_isunordered(__x, __y); }
1561#ifdef __STDCPP_FLOAT32_T__
1563 fpclassify(_Float32 __x)
1564 {
return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1565 FP_SUBNORMAL, FP_ZERO, __x); }
1568 isfinite(_Float32 __x)
1569 {
return __builtin_isfinite(__x); }
1573 {
return __builtin_isinf(__x); }
1577 {
return __builtin_isnan(__x); }
1580 isnormal(_Float32 __x)
1581 {
return __builtin_isnormal(__x); }
1584 signbit(_Float32 __x)
1585 {
return __builtin_signbit(__x); }
1588 isgreater(_Float32 __x, _Float32 __y)
1589 {
return __builtin_isgreater(__x, __y); }
1592 isgreaterequal(_Float32 __x, _Float32 __y)
1593 {
return __builtin_isgreaterequal(__x, __y); }
1596 isless(_Float32 __x, _Float32 __y)
1597 {
return __builtin_isless(__x, __y); }
1600 islessequal(_Float32 __x, _Float32 __y)
1601 {
return __builtin_islessequal(__x, __y); }
1604 islessgreater(_Float32 __x, _Float32 __y)
1605 {
return __builtin_islessgreater(__x, __y); }
1608 isunordered(_Float32 __x, _Float32 __y)
1609 {
return __builtin_isunordered(__x, __y); }
1612#ifdef __STDCPP_FLOAT64_T__
1614 fpclassify(_Float64 __x)
1615 {
return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1616 FP_SUBNORMAL, FP_ZERO, __x); }
1619 isfinite(_Float64 __x)
1620 {
return __builtin_isfinite(__x); }
1624 {
return __builtin_isinf(__x); }
1628 {
return __builtin_isnan(__x); }
1631 isnormal(_Float64 __x)
1632 {
return __builtin_isnormal(__x); }
1635 signbit(_Float64 __x)
1636 {
return __builtin_signbit(__x); }
1639 isgreater(_Float64 __x, _Float64 __y)
1640 {
return __builtin_isgreater(__x, __y); }
1643 isgreaterequal(_Float64 __x, _Float64 __y)
1644 {
return __builtin_isgreaterequal(__x, __y); }
1647 isless(_Float64 __x, _Float64 __y)
1648 {
return __builtin_isless(__x, __y); }
1651 islessequal(_Float64 __x, _Float64 __y)
1652 {
return __builtin_islessequal(__x, __y); }
1655 islessgreater(_Float64 __x, _Float64 __y)
1656 {
return __builtin_islessgreater(__x, __y); }
1659 isunordered(_Float64 __x, _Float64 __y)
1660 {
return __builtin_isunordered(__x, __y); }
1663#ifdef __STDCPP_FLOAT128_T__
1665 fpclassify(_Float128 __x)
1666 {
return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1667 FP_SUBNORMAL, FP_ZERO, __x); }
1670 isfinite(_Float128 __x)
1671 {
return __builtin_isfinite(__x); }
1674 isinf(_Float128 __x)
1675 {
return __builtin_isinf(__x); }
1678 isnan(_Float128 __x)
1679 {
return __builtin_isnan(__x); }
1682 isnormal(_Float128 __x)
1683 {
return __builtin_isnormal(__x); }
1686 signbit(_Float128 __x)
1687 {
return __builtin_signbit(__x); }
1690 isgreater(_Float128 __x, _Float128 __y)
1691 {
return __builtin_isgreater(__x, __y); }
1694 isgreaterequal(_Float128 __x, _Float128 __y)
1695 {
return __builtin_isgreaterequal(__x, __y); }
1698 isless(_Float128 __x, _Float128 __y)
1699 {
return __builtin_isless(__x, __y); }
1702 islessequal(_Float128 __x, _Float128 __y)
1703 {
return __builtin_islessequal(__x, __y); }
1706 islessgreater(_Float128 __x, _Float128 __y)
1707 {
return __builtin_islessgreater(__x, __y); }
1710 isunordered(_Float128 __x, _Float128 __y)
1711 {
return __builtin_isunordered(__x, __y); }
1714#ifdef __STDCPP_BFLOAT16_T__
1716 fpclassify(__gnu_cxx::__bfloat16_t __x)
1717 {
return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1718 FP_SUBNORMAL, FP_ZERO, __x); }
1721 isfinite(__gnu_cxx::__bfloat16_t __x)
1722 {
return __builtin_isfinite(__x); }
1725 isinf(__gnu_cxx::__bfloat16_t __x)
1726 {
return __builtin_isinf(__x); }
1729 isnan(__gnu_cxx::__bfloat16_t __x)
1730 {
return __builtin_isnan(__x); }
1733 isnormal(__gnu_cxx::__bfloat16_t __x)
1734 {
return __builtin_isnormal(__x); }
1737 signbit(__gnu_cxx::__bfloat16_t __x)
1738 {
return __builtin_signbit(__x); }
1741 isgreater(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1742 {
return __builtin_isgreater(__x, __y); }
1745 isgreaterequal(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1746 {
return __builtin_isgreaterequal(__x, __y); }
1749 isless(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1750 {
return __builtin_isless(__x, __y); }
1753 islessequal(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1754 {
return __builtin_islessequal(__x, __y); }
1757 islessgreater(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1758 {
return __builtin_islessgreater(__x, __y); }
1761 isunordered(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1762 {
return __builtin_isunordered(__x, __y); }
1768#if __cplusplus >= 201103L
1770#ifdef _GLIBCXX_USE_C99_MATH_TR1
1820#ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
1949#ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
1992 using ::nexttowardf;
1993 using ::nexttowardl;
2028#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2031 {
return __builtin_acoshf(__x); }
2033 constexpr long double
2034 acosh(
long double __x)
2035 {
return __builtin_acoshl(__x); }
2038#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2039 template<
typename _Tp>
2040 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2043 {
return __builtin_acosh(__x); }
2046#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2049 {
return __builtin_asinhf(__x); }
2051 constexpr long double
2052 asinh(
long double __x)
2053 {
return __builtin_asinhl(__x); }
2056#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2057 template<
typename _Tp>
2058 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2061 {
return __builtin_asinh(__x); }
2064#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2067 {
return __builtin_atanhf(__x); }
2069 constexpr long double
2070 atanh(
long double __x)
2071 {
return __builtin_atanhl(__x); }
2074#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2075 template<
typename _Tp>
2076 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2079 {
return __builtin_atanh(__x); }
2082#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2085 {
return __builtin_cbrtf(__x); }
2087 constexpr long double
2088 cbrt(
long double __x)
2089 {
return __builtin_cbrtl(__x); }
2092#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2093 template<
typename _Tp>
2094 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2097 {
return __builtin_cbrt(__x); }
2100#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2102 copysign(
float __x,
float __y)
2103 {
return __builtin_copysignf(__x, __y); }
2105 constexpr long double
2106 copysign(
long double __x,
long double __y)
2107 {
return __builtin_copysignl(__x, __y); }
2110#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2111 template<
typename _Tp,
typename _Up>
2112 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
2113 copysign(_Tp __x, _Up __y)
2115 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2116 return copysign(__type(__x), __type(__y));
2120#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2123 {
return __builtin_erff(__x); }
2125 constexpr long double
2126 erf(
long double __x)
2127 {
return __builtin_erfl(__x); }
2130#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2131 template<
typename _Tp>
2132 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2135 {
return __builtin_erf(__x); }
2138#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2141 {
return __builtin_erfcf(__x); }
2143 constexpr long double
2144 erfc(
long double __x)
2145 {
return __builtin_erfcl(__x); }
2148#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2149 template<
typename _Tp>
2150 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2153 {
return __builtin_erfc(__x); }
2156#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2159 {
return __builtin_exp2f(__x); }
2161 constexpr long double
2162 exp2(
long double __x)
2163 {
return __builtin_exp2l(__x); }
2166#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2167 template<
typename _Tp>
2168 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2171 {
return __builtin_exp2(__x); }
2174#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2177 {
return __builtin_expm1f(__x); }
2179 constexpr long double
2180 expm1(
long double __x)
2181 {
return __builtin_expm1l(__x); }
2184#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2185 template<
typename _Tp>
2186 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2189 {
return __builtin_expm1(__x); }
2192#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2194 fdim(
float __x,
float __y)
2195 {
return __builtin_fdimf(__x, __y); }
2197 constexpr long double
2198 fdim(
long double __x,
long double __y)
2199 {
return __builtin_fdiml(__x, __y); }
2202#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2203 template<
typename _Tp,
typename _Up>
2204 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
2205 fdim(_Tp __x, _Up __y)
2207 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2208 return fdim(__type(__x), __type(__y));
2212#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2214 fma(
float __x,
float __y,
float __z)
2215 {
return __builtin_fmaf(__x, __y, __z); }
2217 constexpr long double
2218 fma(
long double __x,
long double __y,
long double __z)
2219 {
return __builtin_fmal(__x, __y, __z); }
2222#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2223 template<
typename _Tp,
typename _Up,
typename _Vp>
2224 constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
2225 fma(_Tp __x, _Up __y, _Vp __z)
2227 typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
2228 return fma(__type(__x), __type(__y), __type(__z));
2232#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2234 fmax(
float __x,
float __y)
2235 {
return __builtin_fmaxf(__x, __y); }
2237 constexpr long double
2238 fmax(
long double __x,
long double __y)
2239 {
return __builtin_fmaxl(__x, __y); }
2242#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2243 template<
typename _Tp,
typename _Up>
2244 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
2245 fmax(_Tp __x, _Up __y)
2247 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2248 return fmax(__type(__x), __type(__y));
2252#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2254 fmin(
float __x,
float __y)
2255 {
return __builtin_fminf(__x, __y); }
2257 constexpr long double
2258 fmin(
long double __x,
long double __y)
2259 {
return __builtin_fminl(__x, __y); }
2262#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2263 template<
typename _Tp,
typename _Up>
2264 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
2265 fmin(_Tp __x, _Up __y)
2267 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2268 return fmin(__type(__x), __type(__y));
2272#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2274 hypot(
float __x,
float __y)
2275 {
return __builtin_hypotf(__x, __y); }
2277 constexpr long double
2278 hypot(
long double __x,
long double __y)
2279 {
return __builtin_hypotl(__x, __y); }
2282#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2283 template<
typename _Tp,
typename _Up>
2284 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
2285 hypot(_Tp __x, _Up __y)
2287 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2288 return hypot(__type(__x), __type(__y));
2292#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2295 {
return __builtin_ilogbf(__x); }
2298 ilogb(
long double __x)
2299 {
return __builtin_ilogbl(__x); }
2302#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2303 template<
typename _Tp>
2305 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2308 {
return __builtin_ilogb(__x); }
2311#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2314 {
return __builtin_lgammaf(__x); }
2316 constexpr long double
2317 lgamma(
long double __x)
2318 {
return __builtin_lgammal(__x); }
2321#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2322 template<
typename _Tp>
2323 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2326 {
return __builtin_lgamma(__x); }
2329#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2332 {
return __builtin_llrintf(__x); }
2335 llrint(
long double __x)
2336 {
return __builtin_llrintl(__x); }
2339#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2340 template<
typename _Tp>
2341 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2344 {
return __builtin_llrint(__x); }
2347#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2350 {
return __builtin_llroundf(__x); }
2353 llround(
long double __x)
2354 {
return __builtin_llroundl(__x); }
2357#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2358 template<
typename _Tp>
2359 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2362 {
return __builtin_llround(__x); }
2365#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2368 {
return __builtin_log1pf(__x); }
2370 constexpr long double
2371 log1p(
long double __x)
2372 {
return __builtin_log1pl(__x); }
2375#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2376 template<
typename _Tp>
2377 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2380 {
return __builtin_log1p(__x); }
2383#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2387 {
return __builtin_log2f(__x); }
2389 constexpr long double
2390 log2(
long double __x)
2391 {
return __builtin_log2l(__x); }
2394#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2395 template<
typename _Tp>
2396 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2399 {
return __builtin_log2(__x); }
2402#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2405 {
return __builtin_logbf(__x); }
2407 constexpr long double
2408 logb(
long double __x)
2409 {
return __builtin_logbl(__x); }
2412#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2413 template<
typename _Tp>
2414 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2417 {
return __builtin_logb(__x); }
2420#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2423 {
return __builtin_lrintf(__x); }
2426 lrint(
long double __x)
2427 {
return __builtin_lrintl(__x); }
2430#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2431 template<
typename _Tp>
2432 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2435 {
return __builtin_lrint(__x); }
2438#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2441 {
return __builtin_lroundf(__x); }
2444 lround(
long double __x)
2445 {
return __builtin_lroundl(__x); }
2448#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2449 template<
typename _Tp>
2450 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2453 {
return __builtin_lround(__x); }
2456#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2458 nearbyint(
float __x)
2459 {
return __builtin_nearbyintf(__x); }
2461 constexpr long double
2462 nearbyint(
long double __x)
2463 {
return __builtin_nearbyintl(__x); }
2466#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2467 template<
typename _Tp>
2468 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2471 {
return __builtin_nearbyint(__x); }
2474#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2476 nextafter(
float __x,
float __y)
2477 {
return __builtin_nextafterf(__x, __y); }
2479 constexpr long double
2480 nextafter(
long double __x,
long double __y)
2481 {
return __builtin_nextafterl(__x, __y); }
2484#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2485 template<
typename _Tp,
typename _Up>
2486 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
2487 nextafter(_Tp __x, _Up __y)
2489 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2490 return nextafter(__type(__x), __type(__y));
2494#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2496 nexttoward(
float __x,
long double __y)
2497 {
return __builtin_nexttowardf(__x, __y); }
2499 constexpr long double
2500 nexttoward(
long double __x,
long double __y)
2501 {
return __builtin_nexttowardl(__x, __y); }
2504#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2505 template<
typename _Tp>
2506 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2508 nexttoward(_Tp __x,
long double __y)
2509 {
return __builtin_nexttoward(__x, __y); }
2512#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2514 remainder(
float __x,
float __y)
2515 {
return __builtin_remainderf(__x, __y); }
2517 constexpr long double
2518 remainder(
long double __x,
long double __y)
2519 {
return __builtin_remainderl(__x, __y); }
2522#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2523 template<
typename _Tp,
typename _Up>
2524 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
2525 remainder(_Tp __x, _Up __y)
2527 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2528 return remainder(__type(__x), __type(__y));
2532#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2534 remquo(
float __x,
float __y,
int* __pquo)
2535 {
return __builtin_remquof(__x, __y, __pquo); }
2538 remquo(
long double __x,
long double __y,
int* __pquo)
2539 {
return __builtin_remquol(__x, __y, __pquo); }
2542#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2543 template<
typename _Tp,
typename _Up>
2544 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
2545 remquo(_Tp __x, _Up __y,
int* __pquo)
2547 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2548 return remquo(__type(__x), __type(__y), __pquo);
2552#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2555 {
return __builtin_rintf(__x); }
2557 constexpr long double
2558 rint(
long double __x)
2559 {
return __builtin_rintl(__x); }
2562#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2563 template<
typename _Tp>
2564 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2567 {
return __builtin_rint(__x); }
2570#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2573 {
return __builtin_roundf(__x); }
2575 constexpr long double
2576 round(
long double __x)
2577 {
return __builtin_roundl(__x); }
2580#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2581 template<
typename _Tp>
2582 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2585 {
return __builtin_round(__x); }
2588#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2590 scalbln(
float __x,
long __ex)
2591 {
return __builtin_scalblnf(__x, __ex); }
2593 constexpr long double
2594 scalbln(
long double __x,
long __ex)
2595 {
return __builtin_scalblnl(__x, __ex); }
2598#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2599 template<
typename _Tp>
2600 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2602 scalbln(_Tp __x,
long __ex)
2603 {
return __builtin_scalbln(__x, __ex); }
2606#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2608 scalbn(
float __x,
int __ex)
2609 {
return __builtin_scalbnf(__x, __ex); }
2611 constexpr long double
2612 scalbn(
long double __x,
int __ex)
2613 {
return __builtin_scalbnl(__x, __ex); }
2616#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2617 template<
typename _Tp>
2618 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2620 scalbn(_Tp __x,
int __ex)
2621 {
return __builtin_scalbn(__x, __ex); }
2624#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2627 {
return __builtin_tgammaf(__x); }
2629 constexpr long double
2630 tgamma(
long double __x)
2631 {
return __builtin_tgammal(__x); }
2634#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2635 template<
typename _Tp>
2636 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2639 {
return __builtin_tgamma(__x); }
2642#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2645 {
return __builtin_truncf(__x); }
2647 constexpr long double
2648 trunc(
long double __x)
2649 {
return __builtin_truncl(__x); }
2652#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2653 template<
typename _Tp>
2654 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2657 {
return __builtin_trunc(__x); }
2660#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2663 {
return _Float16(__builtin_acoshf(__x)); }
2667 {
return _Float16(__builtin_asinhf(__x)); }
2671 {
return _Float16(__builtin_atanhf(__x)); }
2675 {
return _Float16(__builtin_cbrtf(__x)); }
2678 copysign(_Float16 __x, _Float16 __y)
2679 {
return __builtin_copysignf16(__x, __y); }
2683 {
return _Float16(__builtin_erff(__x)); }
2687 {
return _Float16(__builtin_erfcf(__x)); }
2691 {
return _Float16(__builtin_exp2f(__x)); }
2695 {
return _Float16(__builtin_expm1f(__x)); }
2698 fdim(_Float16 __x, _Float16 __y)
2699 {
return _Float16(__builtin_fdimf(__x, __y)); }
2702 fma(_Float16 __x, _Float16 __y, _Float16 __z)
2703 {
return _Float16(__builtin_fmaf(__x, __y, __z)); }
2706 fmax(_Float16 __x, _Float16 __y)
2707 {
return _Float16(__builtin_fmaxf(__x, __y)); }
2710 fmin(_Float16 __x, _Float16 __y)
2711 {
return _Float16(__builtin_fminf(__x, __y)); }
2714 hypot(_Float16 __x, _Float16 __y)
2715 {
return _Float16(__builtin_hypotf(__x, __y)); }
2719 {
return _Float16(__builtin_ilogbf(__x)); }
2722 lgamma(_Float16 __x)
2723 {
return _Float16(__builtin_lgammaf(__x)); }
2726 llrint(_Float16 __x)
2727 {
return _Float16(__builtin_llrintf(__x)); }
2730 llround(_Float16 __x)
2731 {
return _Float16(__builtin_llroundf(__x)); }
2735 {
return _Float16(__builtin_log1pf(__x)); }
2740 {
return _Float16(__builtin_log2f(__x)); }
2744 {
return _Float16(__builtin_logbf(__x)); }
2748 {
return _Float16(__builtin_lrintf(__x)); }
2751 lround(_Float16 __x)
2752 {
return _Float16(__builtin_lroundf(__x)); }
2755 nearbyint(_Float16 __x)
2756 {
return _Float16(__builtin_nearbyintf(__x)); }
2759 nextafter(_Float16 __x, _Float16 __y)
2761 if (std::__is_constant_evaluated())
2762 return __builtin_nextafterf16(__x, __y);
2763#ifdef __INT16_TYPE__
2764 using __float16_int_type = __INT16_TYPE__;
2766 using __float16_int_type =
short int;
2768 __float16_int_type __hx, __hy, __ix, __iy;
2769 __builtin_memcpy(&__hx, &__x,
sizeof(__x));
2770 __builtin_memcpy(&__hy, &__y,
sizeof(__x));
2771 __ix = __hx & 0x7fff;
2772 __iy = __hy & 0x7fff;
2773 if (__ix > 0x7c00 || __iy > 0x7c00)
2779 __hy = (__hy & 0x8000) | 1;
2780 __builtin_memcpy(&__x, &__hy,
sizeof(__x));
2781 __builtin_nextafterf(0.0f, 1.0f);
2793 if (__hy >= 0 || __hx > __hy)
2798 __hy = __hx & 0x7c00;
2800 __builtin_nextafterf(__FLT_MAX__, __builtin_inff());
2801 else if (__hy < 0x0400)
2802 __builtin_nextafterf(__FLT_MIN__, 0.0f);
2803 __builtin_memcpy(&__x, &__hx,
sizeof(__x));
2808 remainder(_Float16 __x, _Float16 __y)
2809 {
return _Float16(__builtin_remainderf(__x, __y)); }
2812 remquo(_Float16 __x, _Float16 __y,
int* __pquo)
2813 {
return _Float16(__builtin_remquof(__x, __y, __pquo)); }
2817 {
return _Float16(__builtin_rintf(__x)); }
2821 {
return _Float16(__builtin_roundf(__x)); }
2824 scalbln(_Float16 __x,
long __ex)
2825 {
return _Float16(__builtin_scalblnf(__x, __ex)); }
2828 scalbn(_Float16 __x,
int __ex)
2829 {
return _Float16(__builtin_scalbnf(__x, __ex)); }
2832 tgamma(_Float16 __x)
2833 {
return _Float16(__builtin_tgammaf(__x)); }
2837 {
return _Float16(__builtin_truncf(__x)); }
2840#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2843 {
return __builtin_acoshf(__x); }
2847 {
return __builtin_asinhf(__x); }
2851 {
return __builtin_atanhf(__x); }
2855 {
return __builtin_cbrtf(__x); }
2858 copysign(_Float32 __x, _Float32 __y)
2859 {
return __builtin_copysignf(__x, __y); }
2863 {
return __builtin_erff(__x); }
2867 {
return __builtin_erfcf(__x); }
2871 {
return __builtin_exp2f(__x); }
2875 {
return __builtin_expm1f(__x); }
2878 fdim(_Float32 __x, _Float32 __y)
2879 {
return __builtin_fdimf(__x, __y); }
2882 fma(_Float32 __x, _Float32 __y, _Float32 __z)
2883 {
return __builtin_fmaf(__x, __y, __z); }
2886 fmax(_Float32 __x, _Float32 __y)
2887 {
return __builtin_fmaxf(__x, __y); }
2890 fmin(_Float32 __x, _Float32 __y)
2891 {
return __builtin_fminf(__x, __y); }
2894 hypot(_Float32 __x, _Float32 __y)
2895 {
return __builtin_hypotf(__x, __y); }
2899 {
return __builtin_ilogbf(__x); }
2902 lgamma(_Float32 __x)
2903 {
return __builtin_lgammaf(__x); }
2906 llrint(_Float32 __x)
2907 {
return __builtin_llrintf(__x); }
2910 llround(_Float32 __x)
2911 {
return __builtin_llroundf(__x); }
2915 {
return __builtin_log1pf(__x); }
2920 {
return __builtin_log2f(__x); }
2924 {
return __builtin_logbf(__x); }
2928 {
return __builtin_lrintf(__x); }
2931 lround(_Float32 __x)
2932 {
return __builtin_lroundf(__x); }
2935 nearbyint(_Float32 __x)
2936 {
return __builtin_nearbyintf(__x); }
2939 nextafter(_Float32 __x, _Float32 __y)
2940 {
return __builtin_nextafterf(__x, __y); }
2943 remainder(_Float32 __x, _Float32 __y)
2944 {
return __builtin_remainderf(__x, __y); }
2947 remquo(_Float32 __x, _Float32 __y,
int* __pquo)
2948 {
return __builtin_remquof(__x, __y, __pquo); }
2952 {
return __builtin_rintf(__x); }
2956 {
return __builtin_roundf(__x); }
2959 scalbln(_Float32 __x,
long __ex)
2960 {
return __builtin_scalblnf(__x, __ex); }
2963 scalbn(_Float32 __x,
int __ex)
2964 {
return __builtin_scalbnf(__x, __ex); }
2967 tgamma(_Float32 __x)
2968 {
return __builtin_tgammaf(__x); }
2972 {
return __builtin_truncf(__x); }
2975#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
2978 {
return __builtin_acosh(__x); }
2982 {
return __builtin_asinh(__x); }
2986 {
return __builtin_atanh(__x); }
2990 {
return __builtin_cbrt(__x); }
2993 copysign(_Float64 __x, _Float64 __y)
2994 {
return __builtin_copysign(__x, __y); }
2998 {
return __builtin_erf(__x); }
3002 {
return __builtin_erfc(__x); }
3006 {
return __builtin_exp2(__x); }
3010 {
return __builtin_expm1(__x); }
3013 fdim(_Float64 __x, _Float64 __y)
3014 {
return __builtin_fdim(__x, __y); }
3017 fma(_Float64 __x, _Float64 __y, _Float64 __z)
3018 {
return __builtin_fma(__x, __y, __z); }
3021 fmax(_Float64 __x, _Float64 __y)
3022 {
return __builtin_fmax(__x, __y); }
3025 fmin(_Float64 __x, _Float64 __y)
3026 {
return __builtin_fmin(__x, __y); }
3029 hypot(_Float64 __x, _Float64 __y)
3030 {
return __builtin_hypot(__x, __y); }
3034 {
return __builtin_ilogb(__x); }
3037 lgamma(_Float64 __x)
3038 {
return __builtin_lgamma(__x); }
3041 llrint(_Float64 __x)
3042 {
return __builtin_llrint(__x); }
3045 llround(_Float64 __x)
3046 {
return __builtin_llround(__x); }
3050 {
return __builtin_log1p(__x); }
3055 {
return __builtin_log2(__x); }
3059 {
return __builtin_logb(__x); }
3063 {
return __builtin_lrint(__x); }
3066 lround(_Float64 __x)
3067 {
return __builtin_lround(__x); }
3070 nearbyint(_Float64 __x)
3071 {
return __builtin_nearbyint(__x); }
3074 nextafter(_Float64 __x, _Float64 __y)
3075 {
return __builtin_nextafter(__x, __y); }
3078 remainder(_Float64 __x, _Float64 __y)
3079 {
return __builtin_remainder(__x, __y); }
3082 remquo(_Float64 __x, _Float64 __y,
int* __pquo)
3083 {
return __builtin_remquo(__x, __y, __pquo); }
3087 {
return __builtin_rint(__x); }
3091 {
return __builtin_round(__x); }
3094 scalbln(_Float64 __x,
long __ex)
3095 {
return __builtin_scalbln(__x, __ex); }
3098 scalbn(_Float64 __x,
int __ex)
3099 {
return __builtin_scalbn(__x, __ex); }
3102 tgamma(_Float64 __x)
3103 {
return __builtin_tgamma(__x); }
3107 {
return __builtin_trunc(__x); }
3110#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
3112 acosh(_Float128 __x)
3113 {
return __builtin_acoshl(__x); }
3116 asinh(_Float128 __x)
3117 {
return __builtin_asinhl(__x); }
3120 atanh(_Float128 __x)
3121 {
return __builtin_atanhl(__x); }
3125 {
return __builtin_cbrtl(__x); }
3128 copysign(_Float128 __x, _Float128 __y)
3129 {
return __builtin_copysignl(__x, __y); }
3133 {
return __builtin_erfl(__x); }
3137 {
return __builtin_erfcl(__x); }
3141 {
return __builtin_exp2l(__x); }
3144 expm1(_Float128 __x)
3145 {
return __builtin_expm1l(__x); }
3148 fdim(_Float128 __x, _Float128 __y)
3149 {
return __builtin_fdiml(__x, __y); }
3152 fma(_Float128 __x, _Float128 __y, _Float128 __z)
3153 {
return __builtin_fmal(__x, __y, __z); }
3156 fmax(_Float128 __x, _Float128 __y)
3157 {
return __builtin_fmaxl(__x, __y); }
3160 fmin(_Float128 __x, _Float128 __y)
3161 {
return __builtin_fminl(__x, __y); }
3164 hypot(_Float128 __x, _Float128 __y)
3165 {
return __builtin_hypotl(__x, __y); }
3168 ilogb(_Float128 __x)
3169 {
return __builtin_ilogbl(__x); }
3172 lgamma(_Float128 __x)
3173 {
return __builtin_lgammal(__x); }
3176 llrint(_Float128 __x)
3177 {
return __builtin_llrintl(__x); }
3180 llround(_Float128 __x)
3181 {
return __builtin_llroundl(__x); }
3184 log1p(_Float128 __x)
3185 {
return __builtin_log1pl(__x); }
3190 {
return __builtin_log2l(__x); }
3194 {
return __builtin_logbl(__x); }
3197 lrint(_Float128 __x)
3198 {
return __builtin_lrintl(__x); }
3201 lround(_Float128 __x)
3202 {
return __builtin_lroundl(__x); }
3205 nearbyint(_Float128 __x)
3206 {
return __builtin_nearbyintl(__x); }
3209 nextafter(_Float128 __x, _Float128 __y)
3210 {
return __builtin_nextafterl(__x, __y); }
3213 remainder(_Float128 __x, _Float128 __y)
3214 {
return __builtin_remainderl(__x, __y); }
3217 remquo(_Float128 __x, _Float128 __y,
int* __pquo)
3218 {
return __builtin_remquol(__x, __y, __pquo); }
3222 {
return __builtin_rintl(__x); }
3225 round(_Float128 __x)
3226 {
return __builtin_roundl(__x); }
3229 scalbln(_Float128 __x,
long __ex)
3230 {
return __builtin_scalblnl(__x, __ex); }
3233 scalbn(_Float128 __x,
int __ex)
3234 {
return __builtin_scalbnl(__x, __ex); }
3237 tgamma(_Float128 __x)
3238 {
return __builtin_tgammal(__x); }
3241 trunc(_Float128 __x)
3242 {
return __builtin_truncl(__x); }
3243#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
3245 acosh(_Float128 __x)
3246 {
return __builtin_acoshf128(__x); }
3249 asinh(_Float128 __x)
3250 {
return __builtin_asinhf128(__x); }
3253 atanh(_Float128 __x)
3254 {
return __builtin_atanhf128(__x); }
3258 {
return __builtin_cbrtf128(__x); }
3261 copysign(_Float128 __x, _Float128 __y)
3262 {
return __builtin_copysignf128(__x, __y); }
3266 {
return __builtin_erff128(__x); }
3270 {
return __builtin_erfcf128(__x); }
3274 {
return __builtin_exp2f128(__x); }
3277 expm1(_Float128 __x)
3278 {
return __builtin_expm1f128(__x); }
3281 fdim(_Float128 __x, _Float128 __y)
3282 {
return __builtin_fdimf128(__x, __y); }
3285 fma(_Float128 __x, _Float128 __y, _Float128 __z)
3286 {
return __builtin_fmaf128(__x, __y, __z); }
3289 fmax(_Float128 __x, _Float128 __y)
3290 {
return __builtin_fmaxf128(__x, __y); }
3293 fmin(_Float128 __x, _Float128 __y)
3294 {
return __builtin_fminf128(__x, __y); }
3297 hypot(_Float128 __x, _Float128 __y)
3298 {
return __builtin_hypotf128(__x, __y); }
3301 ilogb(_Float128 __x)
3302 {
return __builtin_ilogbf128(__x); }
3305 lgamma(_Float128 __x)
3306 {
return __builtin_lgammaf128(__x); }
3309 llrint(_Float128 __x)
3310 {
return __builtin_llrintf128(__x); }
3313 llround(_Float128 __x)
3314 {
return __builtin_llroundf128(__x); }
3317 log1p(_Float128 __x)
3318 {
return __builtin_log1pf128(__x); }
3323 {
return __builtin_log2f128(__x); }
3327 {
return __builtin_logbf128(__x); }
3330 lrint(_Float128 __x)
3331 {
return __builtin_lrintf128(__x); }
3334 lround(_Float128 __x)
3335 {
return __builtin_lroundf128(__x); }
3338 nearbyint(_Float128 __x)
3339 {
return __builtin_nearbyintf128(__x); }
3342 nextafter(_Float128 __x, _Float128 __y)
3343 {
return __builtin_nextafterf128(__x, __y); }
3346 remainder(_Float128 __x, _Float128 __y)
3347 {
return __builtin_remainderf128(__x, __y); }
3350 remquo(_Float128 __x, _Float128 __y,
int* __pquo)
3351 {
return __builtin_remquof128(__x, __y, __pquo); }
3355 {
return __builtin_rintf128(__x); }
3358 round(_Float128 __x)
3359 {
return __builtin_roundf128(__x); }
3362 scalbln(_Float128 __x,
long __ex)
3363 {
return __builtin_scalblnf128(__x, __ex); }
3366 scalbn(_Float128 __x,
int __ex)
3367 {
return __builtin_scalbnf128(__x, __ex); }
3370 tgamma(_Float128 __x)
3371 {
return __builtin_tgammaf128(__x); }
3374 trunc(_Float128 __x)
3375 {
return __builtin_truncf128(__x); }
3378#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3379 constexpr __gnu_cxx::__bfloat16_t
3380 acosh(__gnu_cxx::__bfloat16_t __x)
3381 {
return __gnu_cxx::__bfloat16_t(__builtin_acoshf(__x)); }
3383 constexpr __gnu_cxx::__bfloat16_t
3384 asinh(__gnu_cxx::__bfloat16_t __x)
3385 {
return __gnu_cxx::__bfloat16_t(__builtin_asinhf(__x)); }
3387 constexpr __gnu_cxx::__bfloat16_t
3388 atanh(__gnu_cxx::__bfloat16_t __x)
3389 {
return __gnu_cxx::__bfloat16_t(__builtin_atanhf(__x)); }
3391 constexpr __gnu_cxx::__bfloat16_t
3392 cbrt(__gnu_cxx::__bfloat16_t __x)
3393 {
return __gnu_cxx::__bfloat16_t(__builtin_cbrtf(__x)); }
3395 constexpr __gnu_cxx::__bfloat16_t
3396 copysign(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3397 {
return __gnu_cxx::__bfloat16_t(__builtin_copysignf(__x, __y)); }
3399 constexpr __gnu_cxx::__bfloat16_t
3400 erf(__gnu_cxx::__bfloat16_t __x)
3401 {
return __gnu_cxx::__bfloat16_t(__builtin_erff(__x)); }
3403 constexpr __gnu_cxx::__bfloat16_t
3404 erfc(__gnu_cxx::__bfloat16_t __x)
3405 {
return __gnu_cxx::__bfloat16_t(__builtin_erfcf(__x)); }
3407 constexpr __gnu_cxx::__bfloat16_t
3408 exp2(__gnu_cxx::__bfloat16_t __x)
3409 {
return __gnu_cxx::__bfloat16_t(__builtin_exp2f(__x)); }
3411 constexpr __gnu_cxx::__bfloat16_t
3412 expm1(__gnu_cxx::__bfloat16_t __x)
3413 {
return __gnu_cxx::__bfloat16_t(__builtin_expm1f(__x)); }
3415 constexpr __gnu_cxx::__bfloat16_t
3416 fdim(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3417 {
return __gnu_cxx::__bfloat16_t(__builtin_fdimf(__x, __y)); }
3419 constexpr __gnu_cxx::__bfloat16_t
3420 fma(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z)
3421 {
return __gnu_cxx::__bfloat16_t(__builtin_fmaf(__x, __y, __z)); }
3423 constexpr __gnu_cxx::__bfloat16_t
3424 fmax(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3425 {
return __gnu_cxx::__bfloat16_t(__builtin_fmaxf(__x, __y)); }
3427 constexpr __gnu_cxx::__bfloat16_t
3428 fmin(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3429 {
return __gnu_cxx::__bfloat16_t(__builtin_fminf(__x, __y)); }
3431 constexpr __gnu_cxx::__bfloat16_t
3432 hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3433 {
return __gnu_cxx::__bfloat16_t(__builtin_hypotf(__x, __y)); }
3436 ilogb(__gnu_cxx::__bfloat16_t __x)
3437 {
return __gnu_cxx::__bfloat16_t(__builtin_ilogbf(__x)); }
3439 constexpr __gnu_cxx::__bfloat16_t
3440 lgamma(__gnu_cxx::__bfloat16_t __x)
3441 {
return __gnu_cxx::__bfloat16_t(__builtin_lgammaf(__x)); }
3444 llrint(__gnu_cxx::__bfloat16_t __x)
3445 {
return __gnu_cxx::__bfloat16_t(__builtin_llrintf(__x)); }
3448 llround(__gnu_cxx::__bfloat16_t __x)
3449 {
return __gnu_cxx::__bfloat16_t(__builtin_llroundf(__x)); }
3451 constexpr __gnu_cxx::__bfloat16_t
3452 log1p(__gnu_cxx::__bfloat16_t __x)
3453 {
return __gnu_cxx::__bfloat16_t(__builtin_log1pf(__x)); }
3456 constexpr __gnu_cxx::__bfloat16_t
3457 log2(__gnu_cxx::__bfloat16_t __x)
3458 {
return __gnu_cxx::__bfloat16_t(__builtin_log2f(__x)); }
3460 constexpr __gnu_cxx::__bfloat16_t
3461 logb(__gnu_cxx::__bfloat16_t __x)
3462 {
return __gnu_cxx::__bfloat16_t(__builtin_logbf(__x)); }
3465 lrint(__gnu_cxx::__bfloat16_t __x)
3466 {
return __gnu_cxx::__bfloat16_t(__builtin_lrintf(__x)); }
3469 lround(__gnu_cxx::__bfloat16_t __x)
3470 {
return __gnu_cxx::__bfloat16_t(__builtin_lroundf(__x)); }
3472 constexpr __gnu_cxx::__bfloat16_t
3473 nearbyint(__gnu_cxx::__bfloat16_t __x)
3474 {
return __gnu_cxx::__bfloat16_t(__builtin_nearbyintf(__x)); }
3476 constexpr __gnu_cxx::__bfloat16_t
3477 nextafter(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3479 if (std::__is_constant_evaluated())
3480 return __builtin_nextafterf16b(__x, __y);
3481#ifdef __INT16_TYPE__
3482 using __bfloat16_int_type = __INT16_TYPE__;
3484 using __bfloat16_int_type =
short int;
3486 __bfloat16_int_type __hx, __hy, __ix, __iy;
3487 __builtin_memcpy(&__hx, &__x,
sizeof(__x));
3488 __builtin_memcpy(&__hy, &__y,
sizeof(__x));
3489 __ix = __hx & 0x7fff;
3490 __iy = __hy & 0x7fff;
3491 if (__ix > 0x7f80 || __iy > 0x7f80)
3497 __hy = (__hy & 0x8000) | 1;
3498 __builtin_memcpy(&__x, &__hy,
sizeof(__x));
3499 __builtin_nextafterf(0.0f, 1.0f);
3511 if (__hy >= 0 || __hx > __hy)
3516 __hy = __hx & 0x7f80;
3518 __builtin_nextafterf(__FLT_MAX__, __builtin_inff());
3519 else if (__hy < 0x0080)
3520 __builtin_nextafterf(__FLT_MIN__, 0.0f);
3521 __builtin_memcpy(&__x, &__hx,
sizeof(__x));
3525 constexpr __gnu_cxx::__bfloat16_t
3526 remainder(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3527 {
return __gnu_cxx::__bfloat16_t(__builtin_remainderf(__x, __y)); }
3529 inline __gnu_cxx::__bfloat16_t
3530 remquo(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y,
int* __pquo)
3531 {
return __gnu_cxx::__bfloat16_t(__builtin_remquof(__x, __y, __pquo)); }
3533 constexpr __gnu_cxx::__bfloat16_t
3534 rint(__gnu_cxx::__bfloat16_t __x)
3535 {
return __gnu_cxx::__bfloat16_t(__builtin_rintf(__x)); }
3537 constexpr __gnu_cxx::__bfloat16_t
3538 round(__gnu_cxx::__bfloat16_t __x)
3539 {
return __gnu_cxx::__bfloat16_t(__builtin_roundf(__x)); }
3541 constexpr __gnu_cxx::__bfloat16_t
3542 scalbln(__gnu_cxx::__bfloat16_t __x,
long __ex)
3543 {
return __gnu_cxx::__bfloat16_t(__builtin_scalblnf(__x, __ex)); }
3545 constexpr __gnu_cxx::__bfloat16_t
3546 scalbn(__gnu_cxx::__bfloat16_t __x,
int __ex)
3547 {
return __gnu_cxx::__bfloat16_t(__builtin_scalbnf(__x, __ex)); }
3549 constexpr __gnu_cxx::__bfloat16_t
3550 tgamma(__gnu_cxx::__bfloat16_t __x)
3551 {
return __gnu_cxx::__bfloat16_t(__builtin_tgammaf(__x)); }
3553 constexpr __gnu_cxx::__bfloat16_t
3554 trunc(__gnu_cxx::__bfloat16_t __x)
3555 {
return __gnu_cxx::__bfloat16_t(__builtin_truncf(__x)); }
3562#if __cplusplus >= 201703L
3565#define __cpp_lib_hypot 201603L
3567 template<
typename _Tp>
3569 __hypot3(_Tp __x, _Tp __y, _Tp __z)
3574 if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
3575 return __a *
std::sqrt((__x / __a) * (__x / __a)
3576 + (__y / __a) * (__y / __a)
3577 + (__z / __a) * (__z / __a));
3583 hypot(
float __x,
float __y,
float __z)
3584 {
return std::__hypot3<float>(__x, __y, __z); }
3587 hypot(
double __x,
double __y,
double __z)
3588 {
return std::__hypot3<double>(__x, __y, __z); }
3591 hypot(
long double __x,
long double __y,
long double __z)
3592 {
return std::__hypot3<long double>(__x, __y, __z); }
3594 template<
typename _Tp,
typename _Up,
typename _Vp>
3595 __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
3596 hypot(_Tp __x, _Up __y, _Vp __z)
3598 using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
3599 return std::__hypot3<__type>(__x, __y, __z);
3602#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3604 hypot(_Float16 __x, _Float16 __y, _Float16 __z)
3605 {
return std::__hypot3<_Float16>(__x, __y, __z); }
3608#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3610 hypot(_Float32 __x, _Float32 __y, _Float32 __z)
3611 {
return std::__hypot3<_Float32>(__x, __y, __z); }
3614#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3616 hypot(_Float64 __x, _Float64 __y, _Float64 __z)
3617 {
return std::__hypot3<_Float64>(__x, __y, __z); }
3620#if defined(__STDCPP_FLOAT128_T__) \
3621 && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \
3622 || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
3624 hypot(_Float128 __x, _Float128 __y, _Float128 __z)
3625 {
return std::__hypot3<_Float128>(__x, __y, __z); }
3628#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3629 inline __gnu_cxx::__bfloat16_t
3630 hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z)
3631 {
return std::__hypot3<__gnu_cxx::__bfloat16_t>(__x, __y, __z); }
3636#if __cplusplus >= 202002L
3638# define __cpp_lib_interpolate 201902L
3640 template<
typename _Fp>
3642 __lerp(_Fp __a, _Fp __b, _Fp __t)
noexcept
3644 if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
3645 return __t * __b + (1 - __t) * __a;
3652 const _Fp __x = __a + __t * (__b - __a);
3653 return (__t > 1) == (__b > __a)
3654 ? (__b < __x ? __x : __b)
3655 : (__b > __x ? __x : __b);
3659 lerp(
float __a,
float __b,
float __t)
noexcept
3660 {
return std::__lerp(__a, __b, __t); }
3663 lerp(
double __a,
double __b,
double __t)
noexcept
3664 {
return std::__lerp(__a, __b, __t); }
3666 constexpr long double
3667 lerp(
long double __a,
long double __b,
long double __t)
noexcept
3668 {
return std::__lerp(__a, __b, __t); }
3670 template<
typename _Tp,
typename _Up,
typename _Vp>
3671 constexpr __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
3672 lerp(_Tp __x, _Up __y, _Vp __z)
noexcept
3674 using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
3675 return std::__lerp<__type>(__x, __y, __z);
3678#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3680 lerp(_Float16 __x, _Float16 __y, _Float16 __z)
noexcept
3681 {
return std::__lerp<_Float16>(__x, __y, __z); }
3684#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3686 lerp(_Float32 __x, _Float32 __y, _Float32 __z)
noexcept
3687 {
return std::__lerp<_Float32>(__x, __y, __z); }
3690#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3692 lerp(_Float64 __x, _Float64 __y, _Float64 __z)
noexcept
3693 {
return std::__lerp<_Float64>(__x, __y, __z); }
3696#if defined(__STDCPP_FLOAT128_T__) \
3697 && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \
3698 || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
3700 lerp(_Float128 __x, _Float128 __y, _Float128 __z)
noexcept
3701 {
return std::__lerp<_Float128>(__x, __y, __z); }
3704#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3705 inline __gnu_cxx::__bfloat16_t
3706 lerp(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z)
noexcept
3707 {
return std::__lerp<__gnu_cxx::__bfloat16_t>(__x, __y, __z); }
3712_GLIBCXX_END_NAMESPACE_VERSION
3715#if _GLIBCXX_USE_STD_SPEC_FUNCS
constexpr enable_if_t< __and_< __is_duration< _ToDur >, __not_< treat_as_floating_point< typename _ToDur::rep > > >::value, _ToDur > round(const duration< _Rep, _Period > &__d)
complex< _Tp > log10(const complex< _Tp > &)
Return complex base 10 logarithm of z.
complex< _Tp > sin(const complex< _Tp > &)
Return complex sine of z.
complex< _Tp > log(const complex< _Tp > &)
Return complex natural logarithm of z.
complex< _Tp > tan(const complex< _Tp > &)
Return complex tangent of z.
_Tp abs(const complex< _Tp > &)
Return magnitude of z.
complex< _Tp > exp(const complex< _Tp > &)
Return complex base e exponential of z.
complex< _Tp > cosh(const complex< _Tp > &)
Return complex hyperbolic cosine of z.
complex< _Tp > tanh(const complex< _Tp > &)
Return complex hyperbolic tangent of z.
complex< _Tp > pow(const complex< _Tp > &, int)
Return x to the y'th power.
complex< _Tp > sinh(const complex< _Tp > &)
Return complex hyperbolic sine of z.
complex< _Tp > cos(const complex< _Tp > &)
Return complex cosine of z.
complex< _Tp > sqrt(const complex< _Tp > &)
Return complex square root of z.
ISO C++ entities toplevel namespace is std.
_Tp fabs(const std::complex< _Tp > &)
fabs(__z) [8.1.8].
std::complex< _Tp > asinh(const std::complex< _Tp > &)
asinh(__z) [8.1.6].
std::complex< _Tp > atan(const std::complex< _Tp > &)
atan(__z) [8.1.4].
std::complex< _Tp > atanh(const std::complex< _Tp > &)
atanh(__z) [8.1.7].
std::complex< _Tp > acosh(const std::complex< _Tp > &)
acosh(__z) [8.1.5].
std::complex< _Tp > acos(const std::complex< _Tp > &)
acos(__z) [8.1.2].
std::complex< _Tp > asin(const std::complex< _Tp > &)
asin(__z) [8.1.3].