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); }
156#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
157 inline _GLIBCXX_CONSTEXPR
float
159 {
return __builtin_ceilf(__x); }
161 inline _GLIBCXX_CONSTEXPR
long double
162 ceil(
long double __x)
163 {
return __builtin_ceill(__x); }
166 template<
typename _Tp>
167 inline _GLIBCXX_CONSTEXPR
168 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
171 {
return __builtin_ceil(__x); }
175#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
176 inline _GLIBCXX_CONSTEXPR
float
178 {
return __builtin_cosf(__x); }
180 inline _GLIBCXX_CONSTEXPR
long double
182 {
return __builtin_cosl(__x); }
185 template<
typename _Tp>
186 inline _GLIBCXX_CONSTEXPR
187 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
190 {
return __builtin_cos(__x); }
194#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
195 inline _GLIBCXX_CONSTEXPR
float
197 {
return __builtin_coshf(__x); }
199 inline _GLIBCXX_CONSTEXPR
long double
200 cosh(
long double __x)
201 {
return __builtin_coshl(__x); }
204 template<
typename _Tp>
205 inline _GLIBCXX_CONSTEXPR
206 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
209 {
return __builtin_cosh(__x); }
213#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
214 inline _GLIBCXX_CONSTEXPR
float
216 {
return __builtin_expf(__x); }
218 inline _GLIBCXX_CONSTEXPR
long double
220 {
return __builtin_expl(__x); }
223 template<
typename _Tp>
224 inline _GLIBCXX_CONSTEXPR
225 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
228 {
return __builtin_exp(__x); }
232#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
233 inline _GLIBCXX_CONSTEXPR
float
235 {
return __builtin_fabsf(__x); }
237 inline _GLIBCXX_CONSTEXPR
long double
238 fabs(
long double __x)
239 {
return __builtin_fabsl(__x); }
242 template<
typename _Tp>
243 inline _GLIBCXX_CONSTEXPR
244 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
247 {
return __builtin_fabs(__x); }
251#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
252 inline _GLIBCXX_CONSTEXPR
float
254 {
return __builtin_floorf(__x); }
256 inline _GLIBCXX_CONSTEXPR
long double
257 floor(
long double __x)
258 {
return __builtin_floorl(__x); }
261 template<
typename _Tp>
262 inline _GLIBCXX_CONSTEXPR
263 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
266 {
return __builtin_floor(__x); }
270#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
271 inline _GLIBCXX_CONSTEXPR
float
272 fmod(
float __x,
float __y)
273 {
return __builtin_fmodf(__x, __y); }
275 inline _GLIBCXX_CONSTEXPR
long double
276 fmod(
long double __x,
long double __y)
277 {
return __builtin_fmodl(__x, __y); }
282#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
284 frexp(
float __x,
int* __exp)
285 {
return __builtin_frexpf(__x, __exp); }
288 frexp(
long double __x,
int* __exp)
289 {
return __builtin_frexpl(__x, __exp); }
292 template<
typename _Tp>
293 inline _GLIBCXX_CONSTEXPR
294 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
296 frexp(_Tp __x,
int* __exp)
297 {
return __builtin_frexp(__x, __exp); }
301#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
302 inline _GLIBCXX_CONSTEXPR
float
303 ldexp(
float __x,
int __exp)
304 {
return __builtin_ldexpf(__x, __exp); }
306 inline _GLIBCXX_CONSTEXPR
long double
307 ldexp(
long double __x,
int __exp)
308 {
return __builtin_ldexpl(__x, __exp); }
311 template<
typename _Tp>
312 inline _GLIBCXX_CONSTEXPR
313 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
315 ldexp(_Tp __x,
int __exp)
316 {
return __builtin_ldexp(__x, __exp); }
320#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
321 inline _GLIBCXX_CONSTEXPR
float
323 {
return __builtin_logf(__x); }
325 inline _GLIBCXX_CONSTEXPR
long double
327 {
return __builtin_logl(__x); }
330 template<
typename _Tp>
331 inline _GLIBCXX_CONSTEXPR
332 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
335 {
return __builtin_log(__x); }
339#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
340 inline _GLIBCXX_CONSTEXPR
float
342 {
return __builtin_log10f(__x); }
344 inline _GLIBCXX_CONSTEXPR
long double
345 log10(
long double __x)
346 {
return __builtin_log10l(__x); }
349 template<
typename _Tp>
350 inline _GLIBCXX_CONSTEXPR
351 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
354 {
return __builtin_log10(__x); }
358#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
360 modf(
float __x,
float* __iptr)
361 {
return __builtin_modff(__x, __iptr); }
364 modf(
long double __x,
long double* __iptr)
365 {
return __builtin_modfl(__x, __iptr); }
370#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
371 inline _GLIBCXX_CONSTEXPR
float
372 pow(
float __x,
float __y)
373 {
return __builtin_powf(__x, __y); }
375 inline _GLIBCXX_CONSTEXPR
long double
376 pow(
long double __x,
long double __y)
377 {
return __builtin_powl(__x, __y); }
379#if __cplusplus < 201103L
383 pow(
double __x,
int __i)
384 {
return __builtin_powi(__x, __i); }
387 pow(
float __x,
int __n)
388 {
return __builtin_powif(__x, __n); }
391 pow(
long double __x,
int __n)
392 {
return __builtin_powil(__x, __n); }
398#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
399 inline _GLIBCXX_CONSTEXPR
float
401 {
return __builtin_sinf(__x); }
403 inline _GLIBCXX_CONSTEXPR
long double
405 {
return __builtin_sinl(__x); }
408 template<
typename _Tp>
409 inline _GLIBCXX_CONSTEXPR
410 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
413 {
return __builtin_sin(__x); }
417#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
418 inline _GLIBCXX_CONSTEXPR
float
420 {
return __builtin_sinhf(__x); }
422 inline _GLIBCXX_CONSTEXPR
long double
423 sinh(
long double __x)
424 {
return __builtin_sinhl(__x); }
427 template<
typename _Tp>
428 inline _GLIBCXX_CONSTEXPR
429 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
432 {
return __builtin_sinh(__x); }
436#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
437 inline _GLIBCXX_CONSTEXPR
float
439 {
return __builtin_sqrtf(__x); }
441 inline _GLIBCXX_CONSTEXPR
long double
442 sqrt(
long double __x)
443 {
return __builtin_sqrtl(__x); }
446 template<
typename _Tp>
447 inline _GLIBCXX_CONSTEXPR
448 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
451 {
return __builtin_sqrt(__x); }
455#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
456 inline _GLIBCXX_CONSTEXPR
float
458 {
return __builtin_tanf(__x); }
460 inline _GLIBCXX_CONSTEXPR
long double
462 {
return __builtin_tanl(__x); }
465 template<
typename _Tp>
466 inline _GLIBCXX_CONSTEXPR
467 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
470 {
return __builtin_tan(__x); }
474#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
475 inline _GLIBCXX_CONSTEXPR
float
477 {
return __builtin_tanhf(__x); }
479 inline _GLIBCXX_CONSTEXPR
long double
480 tanh(
long double __x)
481 {
return __builtin_tanhl(__x); }
484 template<
typename _Tp>
485 inline _GLIBCXX_CONSTEXPR
486 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
489 {
return __builtin_tanh(__x); }
491#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
494 {
return _Float16(__builtin_acosf(__x)); }
498 {
return _Float16(__builtin_asinf(__x)); }
502 {
return _Float16(__builtin_atanf(__x)); }
505 atan2(_Float16 __y, _Float16 __x)
506 {
return _Float16(__builtin_atan2f(__y, __x)); }
510 {
return _Float16(__builtin_ceilf(__x)); }
514 {
return _Float16(__builtin_cosf(__x)); }
518 {
return _Float16(__builtin_coshf(__x)); }
522 {
return _Float16(__builtin_expf(__x)); }
526 {
return _Float16(__builtin_fabsf(__x)); }
530 {
return _Float16(__builtin_floorf(__x)); }
533 fmod(_Float16 __x, _Float16 __y)
534 {
return _Float16(__builtin_fmodf(__x, __y)); }
537 frexp(_Float16 __x,
int* __exp)
538 {
return _Float16(__builtin_frexpf(__x, __exp)); }
541 ldexp(_Float16 __x,
int __exp)
542 {
return _Float16(__builtin_ldexpf(__x, __exp)); }
546 {
return _Float16(__builtin_logf(__x)); }
550 {
return _Float16(__builtin_log10f(__x)); }
553 modf(_Float16 __x, _Float16* __iptr)
555 float __i, __ret = __builtin_modff(__x, &__i);
556 *__iptr = _Float16(__i);
557 return _Float16(__ret);
561 pow(_Float16 __x, _Float16 __y)
562 {
return _Float16(__builtin_powf(__x, __y)); }
566 {
return _Float16(__builtin_sinf(__x)); }
570 {
return _Float16(__builtin_sinhf(__x)); }
574 {
return _Float16(__builtin_sqrtf(__x)); }
578 {
return _Float16(__builtin_tanf(__x)); }
582 {
return _Float16(__builtin_tanhf(__x)); }
585#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
588 {
return __builtin_acosf(__x); }
592 {
return __builtin_asinf(__x); }
596 {
return __builtin_atanf(__x); }
599 atan2(_Float32 __y, _Float32 __x)
600 {
return __builtin_atan2f(__y, __x); }
604 {
return __builtin_ceilf(__x); }
608 {
return __builtin_cosf(__x); }
612 {
return __builtin_coshf(__x); }
616 {
return __builtin_expf(__x); }
620 {
return __builtin_fabsf(__x); }
624 {
return __builtin_floorf(__x); }
627 fmod(_Float32 __x, _Float32 __y)
628 {
return __builtin_fmodf(__x, __y); }
631 frexp(_Float32 __x,
int* __exp)
632 {
return __builtin_frexpf(__x, __exp); }
635 ldexp(_Float32 __x,
int __exp)
636 {
return __builtin_ldexpf(__x, __exp); }
640 {
return __builtin_logf(__x); }
644 {
return __builtin_log10f(__x); }
647 modf(_Float32 __x, _Float32* __iptr)
649 float __i, __ret = __builtin_modff(__x, &__i);
655 pow(_Float32 __x, _Float32 __y)
656 {
return __builtin_powf(__x, __y); }
660 {
return __builtin_sinf(__x); }
664 {
return __builtin_sinhf(__x); }
668 {
return __builtin_sqrtf(__x); }
672 {
return __builtin_tanf(__x); }
676 {
return __builtin_tanhf(__x); }
679#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
682 {
return __builtin_acos(__x); }
686 {
return __builtin_asin(__x); }
690 {
return __builtin_atan(__x); }
693 atan2(_Float64 __y, _Float64 __x)
694 {
return __builtin_atan2(__y, __x); }
698 {
return __builtin_ceil(__x); }
702 {
return __builtin_cos(__x); }
706 {
return __builtin_cosh(__x); }
710 {
return __builtin_exp(__x); }
714 {
return __builtin_fabs(__x); }
718 {
return __builtin_floor(__x); }
721 fmod(_Float64 __x, _Float64 __y)
722 {
return __builtin_fmod(__x, __y); }
725 frexp(_Float64 __x,
int* __exp)
726 {
return __builtin_frexp(__x, __exp); }
729 ldexp(_Float64 __x,
int __exp)
730 {
return __builtin_ldexp(__x, __exp); }
734 {
return __builtin_log(__x); }
738 {
return __builtin_log10(__x); }
741 modf(_Float64 __x, _Float64* __iptr)
743 double __i, __ret = __builtin_modf(__x, &__i);
749 pow(_Float64 __x, _Float64 __y)
750 {
return __builtin_pow(__x, __y); }
754 {
return __builtin_sin(__x); }
758 {
return __builtin_sinh(__x); }
762 {
return __builtin_sqrt(__x); }
766 {
return __builtin_tan(__x); }
770 {
return __builtin_tanh(__x); }
773#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
776 {
return __builtin_acosl(__x); }
780 {
return __builtin_asinl(__x); }
784 {
return __builtin_atanl(__x); }
787 atan2(_Float128 __y, _Float128 __x)
788 {
return __builtin_atan2l(__y, __x); }
792 {
return __builtin_ceill(__x); }
796 {
return __builtin_cosl(__x); }
800 {
return __builtin_coshl(__x); }
804 {
return __builtin_expl(__x); }
808 {
return __builtin_fabsl(__x); }
812 {
return __builtin_floorl(__x); }
815 fmod(_Float128 __x, _Float128 __y)
816 {
return __builtin_fmodl(__x, __y); }
819 frexp(_Float128 __x,
int* __exp)
820 {
return __builtin_frexpl(__x, __exp); }
823 ldexp(_Float128 __x,
int __exp)
824 {
return __builtin_ldexpl(__x, __exp); }
828 {
return __builtin_logl(__x); }
832 {
return __builtin_log10l(__x); }
835 modf(_Float128 __x, _Float128* __iptr)
837 long double __i, __ret = __builtin_modfl(__x, &__i);
843 pow(_Float128 __x, _Float128 __y)
844 {
return __builtin_powl(__x, __y); }
848 {
return __builtin_sinl(__x); }
852 {
return __builtin_sinhl(__x); }
856 {
return __builtin_sqrtl(__x); }
860 {
return __builtin_tanl(__x); }
864 {
return __builtin_tanhl(__x); }
865#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
868 {
return __builtin_acosf128(__x); }
872 {
return __builtin_asinf128(__x); }
876 {
return __builtin_atanf128(__x); }
879 atan2(_Float128 __y, _Float128 __x)
880 {
return __builtin_atan2f128(__y, __x); }
884 {
return __builtin_ceilf128(__x); }
888 {
return __builtin_cosf128(__x); }
892 {
return __builtin_coshf128(__x); }
896 {
return __builtin_expf128(__x); }
900 {
return __builtin_fabsf128(__x); }
904 {
return __builtin_floorf128(__x); }
907 fmod(_Float128 __x, _Float128 __y)
908 {
return __builtin_fmodf128(__x, __y); }
911 frexp(_Float128 __x,
int* __exp)
912 {
return __builtin_frexpf128(__x, __exp); }
915 ldexp(_Float128 __x,
int __exp)
916 {
return __builtin_ldexpf128(__x, __exp); }
920 {
return __builtin_logf128(__x); }
924 {
return __builtin_log10f128(__x); }
927 modf(_Float128 __x, _Float128* __iptr)
928 {
return __builtin_modff128(__x, __iptr); }
931 pow(_Float128 __x, _Float128 __y)
932 {
return __builtin_powf128(__x, __y); }
936 {
return __builtin_sinf128(__x); }
940 {
return __builtin_sinhf128(__x); }
944 {
return __builtin_sqrtf128(__x); }
948 {
return __builtin_tanf128(__x); }
952 {
return __builtin_tanhf128(__x); }
955#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
956 constexpr __gnu_cxx::__bfloat16_t
957 acos(__gnu_cxx::__bfloat16_t __x)
958 {
return __gnu_cxx::__bfloat16_t(__builtin_acosf(__x)); }
960 constexpr __gnu_cxx::__bfloat16_t
961 asin(__gnu_cxx::__bfloat16_t __x)
962 {
return __gnu_cxx::__bfloat16_t(__builtin_asinf(__x)); }
964 constexpr __gnu_cxx::__bfloat16_t
965 atan(__gnu_cxx::__bfloat16_t __x)
966 {
return __gnu_cxx::__bfloat16_t(__builtin_atanf(__x)); }
968 constexpr __gnu_cxx::__bfloat16_t
969 atan2(__gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __x)
970 {
return __gnu_cxx::__bfloat16_t(__builtin_atan2f(__y, __x)); }
972 constexpr __gnu_cxx::__bfloat16_t
973 ceil(__gnu_cxx::__bfloat16_t __x)
974 {
return __gnu_cxx::__bfloat16_t(__builtin_ceilf(__x)); }
976 constexpr __gnu_cxx::__bfloat16_t
977 cos(__gnu_cxx::__bfloat16_t __x)
978 {
return __gnu_cxx::__bfloat16_t(__builtin_cosf(__x)); }
980 constexpr __gnu_cxx::__bfloat16_t
981 cosh(__gnu_cxx::__bfloat16_t __x)
982 {
return __gnu_cxx::__bfloat16_t(__builtin_coshf(__x)); }
984 constexpr __gnu_cxx::__bfloat16_t
985 exp(__gnu_cxx::__bfloat16_t __x)
986 {
return __gnu_cxx::__bfloat16_t(__builtin_expf(__x)); }
988 constexpr __gnu_cxx::__bfloat16_t
989 fabs(__gnu_cxx::__bfloat16_t __x)
990 {
return __gnu_cxx::__bfloat16_t(__builtin_fabsf(__x)); }
992 constexpr __gnu_cxx::__bfloat16_t
993 floor(__gnu_cxx::__bfloat16_t __x)
994 {
return __gnu_cxx::__bfloat16_t(__builtin_floorf(__x)); }
996 constexpr __gnu_cxx::__bfloat16_t
997 fmod(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
998 {
return __gnu_cxx::__bfloat16_t(__builtin_fmodf(__x, __y)); }
1000 inline __gnu_cxx::__bfloat16_t
1001 frexp(__gnu_cxx::__bfloat16_t __x,
int* __exp)
1002 {
return __gnu_cxx::__bfloat16_t(__builtin_frexpf(__x, __exp)); }
1004 constexpr __gnu_cxx::__bfloat16_t
1005 ldexp(__gnu_cxx::__bfloat16_t __x,
int __exp)
1006 {
return __gnu_cxx::__bfloat16_t(__builtin_ldexpf(__x, __exp)); }
1008 constexpr __gnu_cxx::__bfloat16_t
1009 log(__gnu_cxx::__bfloat16_t __x)
1010 {
return __gnu_cxx::__bfloat16_t(__builtin_logf(__x)); }
1012 constexpr __gnu_cxx::__bfloat16_t
1013 log10(__gnu_cxx::__bfloat16_t __x)
1014 {
return __gnu_cxx::__bfloat16_t(__builtin_log10f(__x)); }
1016 inline __gnu_cxx::__bfloat16_t
1017 modf(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t* __iptr)
1019 float __i, __ret = __builtin_modff(__x, &__i);
1020 *__iptr = __gnu_cxx::__bfloat16_t(__i);
1021 return __gnu_cxx::__bfloat16_t(__ret);
1024 constexpr __gnu_cxx::__bfloat16_t
1025 pow(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1026 {
return __gnu_cxx::__bfloat16_t(__builtin_powf(__x, __y)); }
1028 constexpr __gnu_cxx::__bfloat16_t
1029 sin(__gnu_cxx::__bfloat16_t __x)
1030 {
return __gnu_cxx::__bfloat16_t(__builtin_sinf(__x)); }
1032 constexpr __gnu_cxx::__bfloat16_t
1033 sinh(__gnu_cxx::__bfloat16_t __x)
1034 {
return __gnu_cxx::__bfloat16_t(__builtin_sinhf(__x)); }
1036 constexpr __gnu_cxx::__bfloat16_t
1037 sqrt(__gnu_cxx::__bfloat16_t __x)
1038 {
return __gnu_cxx::__bfloat16_t(__builtin_sqrtf(__x)); }
1040 constexpr __gnu_cxx::__bfloat16_t
1041 tan(__gnu_cxx::__bfloat16_t __x)
1042 {
return __gnu_cxx::__bfloat16_t(__builtin_tanf(__x)); }
1044 constexpr __gnu_cxx::__bfloat16_t
1045 tanh(__gnu_cxx::__bfloat16_t __x)
1046 {
return __gnu_cxx::__bfloat16_t(__builtin_tanhf(__x)); }
1049 template<
typename _Tp,
typename _Up>
1050 inline _GLIBCXX_CONSTEXPR
1051 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1052 atan2(_Tp __y, _Up __x)
1054 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1055 return atan2(__type(__y), __type(__x));
1058 template<
typename _Tp,
typename _Up>
1059 inline _GLIBCXX_CONSTEXPR
1060 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1061 fmod(_Tp __x, _Up __y)
1063 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1064 return fmod(__type(__x), __type(__y));
1067 template<
typename _Tp,
typename _Up>
1068 inline _GLIBCXX_CONSTEXPR
1069 typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1070 pow(_Tp __x, _Up __y)
1072 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1073 return pow(__type(__x), __type(__y));
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_FP
2113 {
return __builtin_erff(__x); }
2115 constexpr long double
2116 erf(
long double __x)
2117 {
return __builtin_erfl(__x); }
2120#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2121 template<
typename _Tp>
2122 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2125 {
return __builtin_erf(__x); }
2128#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2131 {
return __builtin_erfcf(__x); }
2133 constexpr long double
2134 erfc(
long double __x)
2135 {
return __builtin_erfcl(__x); }
2138#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2139 template<
typename _Tp>
2140 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2143 {
return __builtin_erfc(__x); }
2146#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2149 {
return __builtin_exp2f(__x); }
2151 constexpr long double
2152 exp2(
long double __x)
2153 {
return __builtin_exp2l(__x); }
2156#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2157 template<
typename _Tp>
2158 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2161 {
return __builtin_exp2(__x); }
2164#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2167 {
return __builtin_expm1f(__x); }
2169 constexpr long double
2170 expm1(
long double __x)
2171 {
return __builtin_expm1l(__x); }
2174#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2175 template<
typename _Tp>
2176 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2179 {
return __builtin_expm1(__x); }
2182#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2184 fdim(
float __x,
float __y)
2185 {
return __builtin_fdimf(__x, __y); }
2187 constexpr long double
2188 fdim(
long double __x,
long double __y)
2189 {
return __builtin_fdiml(__x, __y); }
2192#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2194 fma(
float __x,
float __y,
float __z)
2195 {
return __builtin_fmaf(__x, __y, __z); }
2197 constexpr long double
2198 fma(
long double __x,
long double __y,
long double __z)
2199 {
return __builtin_fmal(__x, __y, __z); }
2202#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2204 fmax(
float __x,
float __y)
2205 {
return __builtin_fmaxf(__x, __y); }
2207 constexpr long double
2208 fmax(
long double __x,
long double __y)
2209 {
return __builtin_fmaxl(__x, __y); }
2212#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2214 fmin(
float __x,
float __y)
2215 {
return __builtin_fminf(__x, __y); }
2217 constexpr long double
2218 fmin(
long double __x,
long double __y)
2219 {
return __builtin_fminl(__x, __y); }
2222#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2224 hypot(
float __x,
float __y)
2225 {
return __builtin_hypotf(__x, __y); }
2227 constexpr long double
2228 hypot(
long double __x,
long double __y)
2229 {
return __builtin_hypotl(__x, __y); }
2232#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2235 {
return __builtin_ilogbf(__x); }
2238 ilogb(
long double __x)
2239 {
return __builtin_ilogbl(__x); }
2242#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2243 template<
typename _Tp>
2245 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2248 {
return __builtin_ilogb(__x); }
2251#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2254 {
return __builtin_lgammaf(__x); }
2256 constexpr long double
2257 lgamma(
long double __x)
2258 {
return __builtin_lgammal(__x); }
2261#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2262 template<
typename _Tp>
2263 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2266 {
return __builtin_lgamma(__x); }
2269#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2272 {
return __builtin_llrintf(__x); }
2275 llrint(
long double __x)
2276 {
return __builtin_llrintl(__x); }
2279#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2280 template<
typename _Tp>
2281 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2284 {
return __builtin_llrint(__x); }
2287#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2290 {
return __builtin_llroundf(__x); }
2293 llround(
long double __x)
2294 {
return __builtin_llroundl(__x); }
2297#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2298 template<
typename _Tp>
2299 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2302 {
return __builtin_llround(__x); }
2305#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2308 {
return __builtin_log1pf(__x); }
2310 constexpr long double
2311 log1p(
long double __x)
2312 {
return __builtin_log1pl(__x); }
2315#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2316 template<
typename _Tp>
2317 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2320 {
return __builtin_log1p(__x); }
2323#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2327 {
return __builtin_log2f(__x); }
2329 constexpr long double
2330 log2(
long double __x)
2331 {
return __builtin_log2l(__x); }
2334#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2335 template<
typename _Tp>
2336 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2339 {
return __builtin_log2(__x); }
2342#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2345 {
return __builtin_logbf(__x); }
2347 constexpr long double
2348 logb(
long double __x)
2349 {
return __builtin_logbl(__x); }
2352#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2353 template<
typename _Tp>
2354 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2357 {
return __builtin_logb(__x); }
2360#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2363 {
return __builtin_lrintf(__x); }
2366 lrint(
long double __x)
2367 {
return __builtin_lrintl(__x); }
2370#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2371 template<
typename _Tp>
2372 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2375 {
return __builtin_lrint(__x); }
2378#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2381 {
return __builtin_lroundf(__x); }
2384 lround(
long double __x)
2385 {
return __builtin_lroundl(__x); }
2388#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2389 template<
typename _Tp>
2390 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2393 {
return __builtin_lround(__x); }
2396#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2398 nearbyint(
float __x)
2399 {
return __builtin_nearbyintf(__x); }
2401 constexpr long double
2402 nearbyint(
long double __x)
2403 {
return __builtin_nearbyintl(__x); }
2406#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2407 template<
typename _Tp>
2408 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2411 {
return __builtin_nearbyint(__x); }
2414#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2416 nextafter(
float __x,
float __y)
2417 {
return __builtin_nextafterf(__x, __y); }
2419 constexpr long double
2420 nextafter(
long double __x,
long double __y)
2421 {
return __builtin_nextafterl(__x, __y); }
2424#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2426 nexttoward(
float __x,
long double __y)
2427 {
return __builtin_nexttowardf(__x, __y); }
2429 constexpr long double
2430 nexttoward(
long double __x,
long double __y)
2431 {
return __builtin_nexttowardl(__x, __y); }
2434#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2435 template<
typename _Tp>
2436 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2438 nexttoward(_Tp __x,
long double __y)
2439 {
return __builtin_nexttoward(__x, __y); }
2442#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2444 remainder(
float __x,
float __y)
2445 {
return __builtin_remainderf(__x, __y); }
2447 constexpr long double
2448 remainder(
long double __x,
long double __y)
2449 {
return __builtin_remainderl(__x, __y); }
2452#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2454 remquo(
float __x,
float __y,
int* __pquo)
2455 {
return __builtin_remquof(__x, __y, __pquo); }
2458 remquo(
long double __x,
long double __y,
int* __pquo)
2459 {
return __builtin_remquol(__x, __y, __pquo); }
2462#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2465 {
return __builtin_rintf(__x); }
2467 constexpr long double
2468 rint(
long double __x)
2469 {
return __builtin_rintl(__x); }
2472#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2473 template<
typename _Tp>
2474 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2477 {
return __builtin_rint(__x); }
2480#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2483 {
return __builtin_roundf(__x); }
2485 constexpr long double
2486 round(
long double __x)
2487 {
return __builtin_roundl(__x); }
2490#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2491 template<
typename _Tp>
2492 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2495 {
return __builtin_round(__x); }
2498#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2500 scalbln(
float __x,
long __ex)
2501 {
return __builtin_scalblnf(__x, __ex); }
2503 constexpr long double
2504 scalbln(
long double __x,
long __ex)
2505 {
return __builtin_scalblnl(__x, __ex); }
2508#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2509 template<
typename _Tp>
2510 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2512 scalbln(_Tp __x,
long __ex)
2513 {
return __builtin_scalbln(__x, __ex); }
2516#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2518 scalbn(
float __x,
int __ex)
2519 {
return __builtin_scalbnf(__x, __ex); }
2521 constexpr long double
2522 scalbn(
long double __x,
int __ex)
2523 {
return __builtin_scalbnl(__x, __ex); }
2526#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2527 template<
typename _Tp>
2528 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2530 scalbn(_Tp __x,
int __ex)
2531 {
return __builtin_scalbn(__x, __ex); }
2534#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2537 {
return __builtin_tgammaf(__x); }
2539 constexpr long double
2540 tgamma(
long double __x)
2541 {
return __builtin_tgammal(__x); }
2544#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2545 template<
typename _Tp>
2546 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2549 {
return __builtin_tgamma(__x); }
2552#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2555 {
return __builtin_truncf(__x); }
2557 constexpr long double
2558 trunc(
long double __x)
2559 {
return __builtin_truncl(__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_trunc(__x); }
2570#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2573 {
return _Float16(__builtin_acoshf(__x)); }
2577 {
return _Float16(__builtin_asinhf(__x)); }
2581 {
return _Float16(__builtin_atanhf(__x)); }
2585 {
return _Float16(__builtin_cbrtf(__x)); }
2588 copysign(_Float16 __x, _Float16 __y)
2589 {
return __builtin_copysignf16(__x, __y); }
2593 {
return _Float16(__builtin_erff(__x)); }
2597 {
return _Float16(__builtin_erfcf(__x)); }
2601 {
return _Float16(__builtin_exp2f(__x)); }
2605 {
return _Float16(__builtin_expm1f(__x)); }
2608 fdim(_Float16 __x, _Float16 __y)
2609 {
return _Float16(__builtin_fdimf(__x, __y)); }
2612 fma(_Float16 __x, _Float16 __y, _Float16 __z)
2613 {
return _Float16(__builtin_fmaf(__x, __y, __z)); }
2616 fmax(_Float16 __x, _Float16 __y)
2617 {
return _Float16(__builtin_fmaxf(__x, __y)); }
2620 fmin(_Float16 __x, _Float16 __y)
2621 {
return _Float16(__builtin_fminf(__x, __y)); }
2624 hypot(_Float16 __x, _Float16 __y)
2625 {
return _Float16(__builtin_hypotf(__x, __y)); }
2629 {
return _Float16(__builtin_ilogbf(__x)); }
2632 lgamma(_Float16 __x)
2633 {
return _Float16(__builtin_lgammaf(__x)); }
2636 llrint(_Float16 __x)
2637 {
return _Float16(__builtin_llrintf(__x)); }
2640 llround(_Float16 __x)
2641 {
return _Float16(__builtin_llroundf(__x)); }
2645 {
return _Float16(__builtin_log1pf(__x)); }
2650 {
return _Float16(__builtin_log2f(__x)); }
2654 {
return _Float16(__builtin_logbf(__x)); }
2658 {
return _Float16(__builtin_lrintf(__x)); }
2661 lround(_Float16 __x)
2662 {
return _Float16(__builtin_lroundf(__x)); }
2665 nearbyint(_Float16 __x)
2666 {
return _Float16(__builtin_nearbyintf(__x)); }
2669 nextafter(_Float16 __x, _Float16 __y)
2671 if (std::__is_constant_evaluated())
2672 return __builtin_nextafterf16(__x, __y);
2673#ifdef __INT16_TYPE__
2674 using __float16_int_type = __INT16_TYPE__;
2676 using __float16_int_type =
short int;
2678 __float16_int_type __hx, __hy, __ix, __iy;
2679 __builtin_memcpy(&__hx, &__x,
sizeof(__x));
2680 __builtin_memcpy(&__hy, &__y,
sizeof(__x));
2681 __ix = __hx & 0x7fff;
2682 __iy = __hy & 0x7fff;
2683 if (__ix > 0x7c00 || __iy > 0x7c00)
2689 __hy = (__hy & 0x8000) | 1;
2690 __builtin_memcpy(&__x, &__hy,
sizeof(__x));
2691 __builtin_nextafterf(0.0f, 1.0f);
2703 if (__hy >= 0 || __hx > __hy)
2708 __hy = __hx & 0x7c00;
2710 __builtin_nextafterf(__FLT_MAX__, __builtin_inff());
2711 else if (__hy < 0x0400)
2712 __builtin_nextafterf(__FLT_MIN__, 0.0f);
2713 __builtin_memcpy(&__x, &__hx,
sizeof(__x));
2718 remainder(_Float16 __x, _Float16 __y)
2719 {
return _Float16(__builtin_remainderf(__x, __y)); }
2722 remquo(_Float16 __x, _Float16 __y,
int* __pquo)
2723 {
return _Float16(__builtin_remquof(__x, __y, __pquo)); }
2727 {
return _Float16(__builtin_rintf(__x)); }
2731 {
return _Float16(__builtin_roundf(__x)); }
2734 scalbln(_Float16 __x,
long __ex)
2735 {
return _Float16(__builtin_scalblnf(__x, __ex)); }
2738 scalbn(_Float16 __x,
int __ex)
2739 {
return _Float16(__builtin_scalbnf(__x, __ex)); }
2742 tgamma(_Float16 __x)
2743 {
return _Float16(__builtin_tgammaf(__x)); }
2747 {
return _Float16(__builtin_truncf(__x)); }
2750#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2753 {
return __builtin_acoshf(__x); }
2757 {
return __builtin_asinhf(__x); }
2761 {
return __builtin_atanhf(__x); }
2765 {
return __builtin_cbrtf(__x); }
2768 copysign(_Float32 __x, _Float32 __y)
2769 {
return __builtin_copysignf(__x, __y); }
2773 {
return __builtin_erff(__x); }
2777 {
return __builtin_erfcf(__x); }
2781 {
return __builtin_exp2f(__x); }
2785 {
return __builtin_expm1f(__x); }
2788 fdim(_Float32 __x, _Float32 __y)
2789 {
return __builtin_fdimf(__x, __y); }
2792 fma(_Float32 __x, _Float32 __y, _Float32 __z)
2793 {
return __builtin_fmaf(__x, __y, __z); }
2796 fmax(_Float32 __x, _Float32 __y)
2797 {
return __builtin_fmaxf(__x, __y); }
2800 fmin(_Float32 __x, _Float32 __y)
2801 {
return __builtin_fminf(__x, __y); }
2804 hypot(_Float32 __x, _Float32 __y)
2805 {
return __builtin_hypotf(__x, __y); }
2809 {
return __builtin_ilogbf(__x); }
2812 lgamma(_Float32 __x)
2813 {
return __builtin_lgammaf(__x); }
2816 llrint(_Float32 __x)
2817 {
return __builtin_llrintf(__x); }
2820 llround(_Float32 __x)
2821 {
return __builtin_llroundf(__x); }
2825 {
return __builtin_log1pf(__x); }
2830 {
return __builtin_log2f(__x); }
2834 {
return __builtin_logbf(__x); }
2838 {
return __builtin_lrintf(__x); }
2841 lround(_Float32 __x)
2842 {
return __builtin_lroundf(__x); }
2845 nearbyint(_Float32 __x)
2846 {
return __builtin_nearbyintf(__x); }
2849 nextafter(_Float32 __x, _Float32 __y)
2850 {
return __builtin_nextafterf(__x, __y); }
2853 remainder(_Float32 __x, _Float32 __y)
2854 {
return __builtin_remainderf(__x, __y); }
2857 remquo(_Float32 __x, _Float32 __y,
int* __pquo)
2858 {
return __builtin_remquof(__x, __y, __pquo); }
2862 {
return __builtin_rintf(__x); }
2866 {
return __builtin_roundf(__x); }
2869 scalbln(_Float32 __x,
long __ex)
2870 {
return __builtin_scalblnf(__x, __ex); }
2873 scalbn(_Float32 __x,
int __ex)
2874 {
return __builtin_scalbnf(__x, __ex); }
2877 tgamma(_Float32 __x)
2878 {
return __builtin_tgammaf(__x); }
2882 {
return __builtin_truncf(__x); }
2885#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
2888 {
return __builtin_acosh(__x); }
2892 {
return __builtin_asinh(__x); }
2896 {
return __builtin_atanh(__x); }
2900 {
return __builtin_cbrt(__x); }
2903 copysign(_Float64 __x, _Float64 __y)
2904 {
return __builtin_copysign(__x, __y); }
2908 {
return __builtin_erf(__x); }
2912 {
return __builtin_erfc(__x); }
2916 {
return __builtin_exp2(__x); }
2920 {
return __builtin_expm1(__x); }
2923 fdim(_Float64 __x, _Float64 __y)
2924 {
return __builtin_fdim(__x, __y); }
2927 fma(_Float64 __x, _Float64 __y, _Float64 __z)
2928 {
return __builtin_fma(__x, __y, __z); }
2931 fmax(_Float64 __x, _Float64 __y)
2932 {
return __builtin_fmax(__x, __y); }
2935 fmin(_Float64 __x, _Float64 __y)
2936 {
return __builtin_fmin(__x, __y); }
2939 hypot(_Float64 __x, _Float64 __y)
2940 {
return __builtin_hypot(__x, __y); }
2944 {
return __builtin_ilogb(__x); }
2947 lgamma(_Float64 __x)
2948 {
return __builtin_lgamma(__x); }
2951 llrint(_Float64 __x)
2952 {
return __builtin_llrint(__x); }
2955 llround(_Float64 __x)
2956 {
return __builtin_llround(__x); }
2960 {
return __builtin_log1p(__x); }
2965 {
return __builtin_log2(__x); }
2969 {
return __builtin_logb(__x); }
2973 {
return __builtin_lrint(__x); }
2976 lround(_Float64 __x)
2977 {
return __builtin_lround(__x); }
2980 nearbyint(_Float64 __x)
2981 {
return __builtin_nearbyint(__x); }
2984 nextafter(_Float64 __x, _Float64 __y)
2985 {
return __builtin_nextafter(__x, __y); }
2988 remainder(_Float64 __x, _Float64 __y)
2989 {
return __builtin_remainder(__x, __y); }
2992 remquo(_Float64 __x, _Float64 __y,
int* __pquo)
2993 {
return __builtin_remquo(__x, __y, __pquo); }
2997 {
return __builtin_rint(__x); }
3001 {
return __builtin_round(__x); }
3004 scalbln(_Float64 __x,
long __ex)
3005 {
return __builtin_scalbln(__x, __ex); }
3008 scalbn(_Float64 __x,
int __ex)
3009 {
return __builtin_scalbn(__x, __ex); }
3012 tgamma(_Float64 __x)
3013 {
return __builtin_tgamma(__x); }
3017 {
return __builtin_trunc(__x); }
3020#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
3022 acosh(_Float128 __x)
3023 {
return __builtin_acoshl(__x); }
3026 asinh(_Float128 __x)
3027 {
return __builtin_asinhl(__x); }
3030 atanh(_Float128 __x)
3031 {
return __builtin_atanhl(__x); }
3035 {
return __builtin_cbrtl(__x); }
3038 copysign(_Float128 __x, _Float128 __y)
3039 {
return __builtin_copysignl(__x, __y); }
3043 {
return __builtin_erfl(__x); }
3047 {
return __builtin_erfcl(__x); }
3051 {
return __builtin_exp2l(__x); }
3054 expm1(_Float128 __x)
3055 {
return __builtin_expm1l(__x); }
3058 fdim(_Float128 __x, _Float128 __y)
3059 {
return __builtin_fdiml(__x, __y); }
3062 fma(_Float128 __x, _Float128 __y, _Float128 __z)
3063 {
return __builtin_fmal(__x, __y, __z); }
3066 fmax(_Float128 __x, _Float128 __y)
3067 {
return __builtin_fmaxl(__x, __y); }
3070 fmin(_Float128 __x, _Float128 __y)
3071 {
return __builtin_fminl(__x, __y); }
3074 hypot(_Float128 __x, _Float128 __y)
3075 {
return __builtin_hypotl(__x, __y); }
3078 ilogb(_Float128 __x)
3079 {
return __builtin_ilogbl(__x); }
3082 lgamma(_Float128 __x)
3083 {
return __builtin_lgammal(__x); }
3086 llrint(_Float128 __x)
3087 {
return __builtin_llrintl(__x); }
3090 llround(_Float128 __x)
3091 {
return __builtin_llroundl(__x); }
3094 log1p(_Float128 __x)
3095 {
return __builtin_log1pl(__x); }
3100 {
return __builtin_log2l(__x); }
3104 {
return __builtin_logbl(__x); }
3107 lrint(_Float128 __x)
3108 {
return __builtin_lrintl(__x); }
3111 lround(_Float128 __x)
3112 {
return __builtin_lroundl(__x); }
3115 nearbyint(_Float128 __x)
3116 {
return __builtin_nearbyintl(__x); }
3119 nextafter(_Float128 __x, _Float128 __y)
3120 {
return __builtin_nextafterl(__x, __y); }
3123 remainder(_Float128 __x, _Float128 __y)
3124 {
return __builtin_remainderl(__x, __y); }
3127 remquo(_Float128 __x, _Float128 __y,
int* __pquo)
3128 {
return __builtin_remquol(__x, __y, __pquo); }
3132 {
return __builtin_rintl(__x); }
3135 round(_Float128 __x)
3136 {
return __builtin_roundl(__x); }
3139 scalbln(_Float128 __x,
long __ex)
3140 {
return __builtin_scalblnl(__x, __ex); }
3143 scalbn(_Float128 __x,
int __ex)
3144 {
return __builtin_scalbnl(__x, __ex); }
3147 tgamma(_Float128 __x)
3148 {
return __builtin_tgammal(__x); }
3151 trunc(_Float128 __x)
3152 {
return __builtin_truncl(__x); }
3153#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
3155 acosh(_Float128 __x)
3156 {
return __builtin_acoshf128(__x); }
3159 asinh(_Float128 __x)
3160 {
return __builtin_asinhf128(__x); }
3163 atanh(_Float128 __x)
3164 {
return __builtin_atanhf128(__x); }
3168 {
return __builtin_cbrtf128(__x); }
3171 copysign(_Float128 __x, _Float128 __y)
3172 {
return __builtin_copysignf128(__x, __y); }
3176 {
return __builtin_erff128(__x); }
3180 {
return __builtin_erfcf128(__x); }
3184 {
return __builtin_exp2f128(__x); }
3187 expm1(_Float128 __x)
3188 {
return __builtin_expm1f128(__x); }
3191 fdim(_Float128 __x, _Float128 __y)
3192 {
return __builtin_fdimf128(__x, __y); }
3195 fma(_Float128 __x, _Float128 __y, _Float128 __z)
3196 {
return __builtin_fmaf128(__x, __y, __z); }
3199 fmax(_Float128 __x, _Float128 __y)
3200 {
return __builtin_fmaxf128(__x, __y); }
3203 fmin(_Float128 __x, _Float128 __y)
3204 {
return __builtin_fminf128(__x, __y); }
3207 hypot(_Float128 __x, _Float128 __y)
3208 {
return __builtin_hypotf128(__x, __y); }
3211 ilogb(_Float128 __x)
3212 {
return __builtin_ilogbf128(__x); }
3215 lgamma(_Float128 __x)
3216 {
return __builtin_lgammaf128(__x); }
3219 llrint(_Float128 __x)
3220 {
return __builtin_llrintf128(__x); }
3223 llround(_Float128 __x)
3224 {
return __builtin_llroundf128(__x); }
3227 log1p(_Float128 __x)
3228 {
return __builtin_log1pf128(__x); }
3233 {
return __builtin_log2f128(__x); }
3237 {
return __builtin_logbf128(__x); }
3240 lrint(_Float128 __x)
3241 {
return __builtin_lrintf128(__x); }
3244 lround(_Float128 __x)
3245 {
return __builtin_lroundf128(__x); }
3248 nearbyint(_Float128 __x)
3249 {
return __builtin_nearbyintf128(__x); }
3252 nextafter(_Float128 __x, _Float128 __y)
3253 {
return __builtin_nextafterf128(__x, __y); }
3256 remainder(_Float128 __x, _Float128 __y)
3257 {
return __builtin_remainderf128(__x, __y); }
3260 remquo(_Float128 __x, _Float128 __y,
int* __pquo)
3261 {
return __builtin_remquof128(__x, __y, __pquo); }
3265 {
return __builtin_rintf128(__x); }
3268 round(_Float128 __x)
3269 {
return __builtin_roundf128(__x); }
3272 scalbln(_Float128 __x,
long __ex)
3273 {
return __builtin_scalblnf128(__x, __ex); }
3276 scalbn(_Float128 __x,
int __ex)
3277 {
return __builtin_scalbnf128(__x, __ex); }
3280 tgamma(_Float128 __x)
3281 {
return __builtin_tgammaf128(__x); }
3284 trunc(_Float128 __x)
3285 {
return __builtin_truncf128(__x); }
3288#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3289 constexpr __gnu_cxx::__bfloat16_t
3290 acosh(__gnu_cxx::__bfloat16_t __x)
3291 {
return __gnu_cxx::__bfloat16_t(__builtin_acoshf(__x)); }
3293 constexpr __gnu_cxx::__bfloat16_t
3294 asinh(__gnu_cxx::__bfloat16_t __x)
3295 {
return __gnu_cxx::__bfloat16_t(__builtin_asinhf(__x)); }
3297 constexpr __gnu_cxx::__bfloat16_t
3298 atanh(__gnu_cxx::__bfloat16_t __x)
3299 {
return __gnu_cxx::__bfloat16_t(__builtin_atanhf(__x)); }
3301 constexpr __gnu_cxx::__bfloat16_t
3302 cbrt(__gnu_cxx::__bfloat16_t __x)
3303 {
return __gnu_cxx::__bfloat16_t(__builtin_cbrtf(__x)); }
3305 constexpr __gnu_cxx::__bfloat16_t
3306 copysign(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3307 {
return __gnu_cxx::__bfloat16_t(__builtin_copysignf(__x, __y)); }
3309 constexpr __gnu_cxx::__bfloat16_t
3310 erf(__gnu_cxx::__bfloat16_t __x)
3311 {
return __gnu_cxx::__bfloat16_t(__builtin_erff(__x)); }
3313 constexpr __gnu_cxx::__bfloat16_t
3314 erfc(__gnu_cxx::__bfloat16_t __x)
3315 {
return __gnu_cxx::__bfloat16_t(__builtin_erfcf(__x)); }
3317 constexpr __gnu_cxx::__bfloat16_t
3318 exp2(__gnu_cxx::__bfloat16_t __x)
3319 {
return __gnu_cxx::__bfloat16_t(__builtin_exp2f(__x)); }
3321 constexpr __gnu_cxx::__bfloat16_t
3322 expm1(__gnu_cxx::__bfloat16_t __x)
3323 {
return __gnu_cxx::__bfloat16_t(__builtin_expm1f(__x)); }
3325 constexpr __gnu_cxx::__bfloat16_t
3326 fdim(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3327 {
return __gnu_cxx::__bfloat16_t(__builtin_fdimf(__x, __y)); }
3329 constexpr __gnu_cxx::__bfloat16_t
3330 fma(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z)
3331 {
return __gnu_cxx::__bfloat16_t(__builtin_fmaf(__x, __y, __z)); }
3333 constexpr __gnu_cxx::__bfloat16_t
3334 fmax(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3335 {
return __gnu_cxx::__bfloat16_t(__builtin_fmaxf(__x, __y)); }
3337 constexpr __gnu_cxx::__bfloat16_t
3338 fmin(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3339 {
return __gnu_cxx::__bfloat16_t(__builtin_fminf(__x, __y)); }
3341 constexpr __gnu_cxx::__bfloat16_t
3342 hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3343 {
return __gnu_cxx::__bfloat16_t(__builtin_hypotf(__x, __y)); }
3346 ilogb(__gnu_cxx::__bfloat16_t __x)
3347 {
return __gnu_cxx::__bfloat16_t(__builtin_ilogbf(__x)); }
3349 constexpr __gnu_cxx::__bfloat16_t
3350 lgamma(__gnu_cxx::__bfloat16_t __x)
3351 {
return __gnu_cxx::__bfloat16_t(__builtin_lgammaf(__x)); }
3354 llrint(__gnu_cxx::__bfloat16_t __x)
3355 {
return __gnu_cxx::__bfloat16_t(__builtin_llrintf(__x)); }
3358 llround(__gnu_cxx::__bfloat16_t __x)
3359 {
return __gnu_cxx::__bfloat16_t(__builtin_llroundf(__x)); }
3361 constexpr __gnu_cxx::__bfloat16_t
3362 log1p(__gnu_cxx::__bfloat16_t __x)
3363 {
return __gnu_cxx::__bfloat16_t(__builtin_log1pf(__x)); }
3366 constexpr __gnu_cxx::__bfloat16_t
3367 log2(__gnu_cxx::__bfloat16_t __x)
3368 {
return __gnu_cxx::__bfloat16_t(__builtin_log2f(__x)); }
3370 constexpr __gnu_cxx::__bfloat16_t
3371 logb(__gnu_cxx::__bfloat16_t __x)
3372 {
return __gnu_cxx::__bfloat16_t(__builtin_logbf(__x)); }
3375 lrint(__gnu_cxx::__bfloat16_t __x)
3376 {
return __gnu_cxx::__bfloat16_t(__builtin_lrintf(__x)); }
3379 lround(__gnu_cxx::__bfloat16_t __x)
3380 {
return __gnu_cxx::__bfloat16_t(__builtin_lroundf(__x)); }
3382 constexpr __gnu_cxx::__bfloat16_t
3383 nearbyint(__gnu_cxx::__bfloat16_t __x)
3384 {
return __gnu_cxx::__bfloat16_t(__builtin_nearbyintf(__x)); }
3386 constexpr __gnu_cxx::__bfloat16_t
3387 nextafter(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3389 if (std::__is_constant_evaluated())
3390 return __builtin_nextafterf16b(__x, __y);
3391#ifdef __INT16_TYPE__
3392 using __bfloat16_int_type = __INT16_TYPE__;
3394 using __bfloat16_int_type =
short int;
3396 __bfloat16_int_type __hx, __hy, __ix, __iy;
3397 __builtin_memcpy(&__hx, &__x,
sizeof(__x));
3398 __builtin_memcpy(&__hy, &__y,
sizeof(__x));
3399 __ix = __hx & 0x7fff;
3400 __iy = __hy & 0x7fff;
3401 if (__ix > 0x7f80 || __iy > 0x7f80)
3407 __hy = (__hy & 0x8000) | 1;
3408 __builtin_memcpy(&__x, &__hy,
sizeof(__x));
3409 __builtin_nextafterf(0.0f, 1.0f);
3421 if (__hy >= 0 || __hx > __hy)
3426 __hy = __hx & 0x7f80;
3428 __builtin_nextafterf(__FLT_MAX__, __builtin_inff());
3429 else if (__hy < 0x0080)
3430 __builtin_nextafterf(__FLT_MIN__, 0.0f);
3431 __builtin_memcpy(&__x, &__hx,
sizeof(__x));
3435 constexpr __gnu_cxx::__bfloat16_t
3436 remainder(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3437 {
return __gnu_cxx::__bfloat16_t(__builtin_remainderf(__x, __y)); }
3439 inline __gnu_cxx::__bfloat16_t
3440 remquo(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y,
int* __pquo)
3441 {
return __gnu_cxx::__bfloat16_t(__builtin_remquof(__x, __y, __pquo)); }
3443 constexpr __gnu_cxx::__bfloat16_t
3444 rint(__gnu_cxx::__bfloat16_t __x)
3445 {
return __gnu_cxx::__bfloat16_t(__builtin_rintf(__x)); }
3447 constexpr __gnu_cxx::__bfloat16_t
3448 round(__gnu_cxx::__bfloat16_t __x)
3449 {
return __gnu_cxx::__bfloat16_t(__builtin_roundf(__x)); }
3451 constexpr __gnu_cxx::__bfloat16_t
3452 scalbln(__gnu_cxx::__bfloat16_t __x,
long __ex)
3453 {
return __gnu_cxx::__bfloat16_t(__builtin_scalblnf(__x, __ex)); }
3455 constexpr __gnu_cxx::__bfloat16_t
3456 scalbn(__gnu_cxx::__bfloat16_t __x,
int __ex)
3457 {
return __gnu_cxx::__bfloat16_t(__builtin_scalbnf(__x, __ex)); }
3459 constexpr __gnu_cxx::__bfloat16_t
3460 tgamma(__gnu_cxx::__bfloat16_t __x)
3461 {
return __gnu_cxx::__bfloat16_t(__builtin_tgammaf(__x)); }
3463 constexpr __gnu_cxx::__bfloat16_t
3464 trunc(__gnu_cxx::__bfloat16_t __x)
3465 {
return __gnu_cxx::__bfloat16_t(__builtin_truncf(__x)); }
3468#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
3469 template<
typename _Tp,
typename _Up>
3470 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3471 copysign(_Tp __x, _Up __y)
3473 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3474 return copysign(__type(__x), __type(__y));
3477 template<
typename _Tp,
typename _Up>
3478 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3479 fdim(_Tp __x, _Up __y)
3481 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3482 return fdim(__type(__x), __type(__y));
3485 template<
typename _Tp,
typename _Up>
3486 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3487 fmax(_Tp __x, _Up __y)
3489 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3490 return fmax(__type(__x), __type(__y));
3493 template<
typename _Tp,
typename _Up>
3494 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3495 fmin(_Tp __x, _Up __y)
3497 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3498 return fmin(__type(__x), __type(__y));
3501 template<
typename _Tp,
typename _Up>
3502 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3503 hypot(_Tp __x, _Up __y)
3505 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3506 return hypot(__type(__x), __type(__y));
3509 template<
typename _Tp,
typename _Up>
3510 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3511 nextafter(_Tp __x, _Up __y)
3513 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3514 return nextafter(__type(__x), __type(__y));
3517 template<
typename _Tp,
typename _Up>
3518 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3519 remainder(_Tp __x, _Up __y)
3521 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3522 return remainder(__type(__x), __type(__y));
3525 template<
typename _Tp,
typename _Up>
3526 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3527 remquo(_Tp __x, _Up __y,
int* __pquo)
3529 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3530 return remquo(__type(__x), __type(__y), __pquo);
3533 template<
typename _Tp,
typename _Up,
typename _Vp>
3534 constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
3535 fma(_Tp __x, _Up __y, _Vp __z)
3537 typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
3538 return fma(__type(__x), __type(__y), __type(__z));
3545#if __cplusplus >= 201703L
3548#define __cpp_lib_hypot 201603L
3550 template<
typename _Tp>
3552 __hypot3(_Tp __x, _Tp __y, _Tp __z)
3557 if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
3558 return __a *
std::sqrt((__x / __a) * (__x / __a)
3559 + (__y / __a) * (__y / __a)
3560 + (__z / __a) * (__z / __a));
3566 hypot(
float __x,
float __y,
float __z)
3567 {
return std::__hypot3<float>(__x, __y, __z); }
3570 hypot(
double __x,
double __y,
double __z)
3571 {
return std::__hypot3<double>(__x, __y, __z); }
3574 hypot(
long double __x,
long double __y,
long double __z)
3575 {
return std::__hypot3<long double>(__x, __y, __z); }
3577 template<
typename _Tp,
typename _Up,
typename _Vp>
3578 __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
3579 hypot(_Tp __x, _Up __y, _Vp __z)
3581 using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
3582 return std::__hypot3<__type>(__x, __y, __z);
3585#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3587 hypot(_Float16 __x, _Float16 __y, _Float16 __z)
3588 {
return std::__hypot3<_Float16>(__x, __y, __z); }
3591#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3593 hypot(_Float32 __x, _Float32 __y, _Float32 __z)
3594 {
return std::__hypot3<_Float32>(__x, __y, __z); }
3597#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3599 hypot(_Float64 __x, _Float64 __y, _Float64 __z)
3600 {
return std::__hypot3<_Float64>(__x, __y, __z); }
3603#if defined(__STDCPP_FLOAT128_T__) \
3604 && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \
3605 || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
3607 hypot(_Float128 __x, _Float128 __y, _Float128 __z)
3608 {
return std::__hypot3<_Float128>(__x, __y, __z); }
3611#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3612 inline __gnu_cxx::__bfloat16_t
3613 hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z)
3614 {
return std::__hypot3<__gnu_cxx::__bfloat16_t>(__x, __y, __z); }
3619#if __cplusplus >= 202002L
3621# define __cpp_lib_interpolate 201902L
3623 template<
typename _Fp>
3625 __lerp(_Fp __a, _Fp __b, _Fp __t)
noexcept
3627 if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
3628 return __t * __b + (1 - __t) * __a;
3635 const _Fp __x = __a + __t * (__b - __a);
3636 return (__t > 1) == (__b > __a)
3637 ? (__b < __x ? __x : __b)
3638 : (__b > __x ? __x : __b);
3642 lerp(
float __a,
float __b,
float __t)
noexcept
3643 {
return std::__lerp(__a, __b, __t); }
3646 lerp(
double __a,
double __b,
double __t)
noexcept
3647 {
return std::__lerp(__a, __b, __t); }
3649 constexpr long double
3650 lerp(
long double __a,
long double __b,
long double __t)
noexcept
3651 {
return std::__lerp(__a, __b, __t); }
3653 template<
typename _Tp,
typename _Up,
typename _Vp>
3654 constexpr __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
3655 lerp(_Tp __x, _Up __y, _Vp __z)
noexcept
3657 using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
3658 return std::__lerp<__type>(__x, __y, __z);
3661#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3663 lerp(_Float16 __x, _Float16 __y, _Float16 __z)
noexcept
3664 {
return std::__lerp<_Float16>(__x, __y, __z); }
3667#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3669 lerp(_Float32 __x, _Float32 __y, _Float32 __z)
noexcept
3670 {
return std::__lerp<_Float32>(__x, __y, __z); }
3673#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3675 lerp(_Float64 __x, _Float64 __y, _Float64 __z)
noexcept
3676 {
return std::__lerp<_Float64>(__x, __y, __z); }
3679#if defined(__STDCPP_FLOAT128_T__) \
3680 && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \
3681 || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
3683 lerp(_Float128 __x, _Float128 __y, _Float128 __z)
noexcept
3684 {
return std::__lerp<_Float128>(__x, __y, __z); }
3687#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3688 inline __gnu_cxx::__bfloat16_t
3689 lerp(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z)
noexcept
3690 {
return std::__lerp<__gnu_cxx::__bfloat16_t>(__x, __y, __z); }
3695_GLIBCXX_END_NAMESPACE_VERSION
3698#if _GLIBCXX_USE_STD_SPEC_FUNCS
constexpr __enable_if_is_duration< _ToDur > floor(const duration< _Rep, _Period > &__d)
constexpr enable_if_t< __and_< __is_duration< _ToDur >, __not_< treat_as_floating_point< typename _ToDur::rep > > >::value, _ToDur > round(const duration< _Rep, _Period > &__d)
constexpr __enable_if_is_duration< _ToDur > ceil(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].