36#ifndef _GLIBCXX_COMPLEX
37#define _GLIBCXX_COMPLEX 1
40#pragma GCC system_header
43#pragma GCC diagnostic push
44#pragma GCC diagnostic ignored "-Wc++11-extensions"
56#pragma clang diagnostic push
57#pragma clang diagnostic ignored "-Wc99-extensions"
60#define __glibcxx_want_constexpr_complex
61#define __glibcxx_want_complex_udls
62#define __glibcxx_want_tuple_like
65#if __glibcxx_tuple_like >= 202311
70namespace std _GLIBCXX_VISIBILITY(default)
72_GLIBCXX_BEGIN_NAMESPACE_VERSION
83 template<
typename _Tp>
class complex;
84 template<>
class complex<float>;
85 template<>
class complex<double>;
86 template<>
class complex<long double>;
96 template<
typename _Tp>
132#if __glibcxx_tuple_like >= 202311L
133 template<
typename _Tp>
136 template<
typename _Tp>
138 {
using type = _Tp; };
139 template<
typename _Tp>
140 struct tuple_element<1, complex<_Tp>>
141 {
using type = _Tp; };
142 template<
typename _Tp>
143 inline constexpr bool __is_tuple_like_v<complex<_Tp>> =
true;
155 template<
typename _Tp>
164 _GLIBCXX_CONSTEXPR
complex(
const _Tp& __r = _Tp(),
const _Tp& __i = _Tp())
165 : _M_real(__r), _M_imag(__i) { }
168#if __cplusplus >= 201103L
173 template<
typename _Up>
174#if __cplusplus > 202002L
175 explicit(!
requires(_Up __u) { _Tp{__u}; })
178 : _M_real(_Tp(__z.real())), _M_imag(_Tp(__z.imag())) { }
180#if __cplusplus >= 201103L
183 _GLIBCXX_ABI_TAG_CXX11
185 real()
const {
return _M_real; }
187 _GLIBCXX_ABI_TAG_CXX11
189 imag()
const {
return _M_imag; }
193 real() {
return _M_real; }
197 real()
const {
return _M_real; }
201 imag() {
return _M_imag; }
205 imag()
const {
return _M_imag; }
210 _GLIBCXX20_CONSTEXPR
void
211 real(_Tp __val) { _M_real = __val; }
213 _GLIBCXX20_CONSTEXPR
void
214 imag(_Tp __val) { _M_imag = __val; }
243#if __cplusplus >= 201103L
248 template<
typename _Up>
251 template<
typename _Up>
254 template<
typename _Up>
257 template<
typename _Up>
260 template<
typename _Up>
263 _GLIBCXX_CONSTEXPR
complex __rep()
const
266#if __glibcxx_tuple_like >= 202311L
267 template<
typename _Cp>
268 [[__gnu__::__always_inline__]]
270 __get_part(
this _Cp& __z,
size_t __i)
noexcept
272 return __i == 0 ? __z._M_real : __z._M_imag;
281 template<
typename _Tp>
291 template<
typename _Tp>
301 template<
typename _Tp>
310 template<
typename _Tp>
311 template<
typename _Up>
315 _M_real = __z.real();
316 _M_imag = __z.imag();
321 template<
typename _Tp>
322 template<
typename _Up>
326 _M_real += __z.real();
327 _M_imag += __z.imag();
332 template<
typename _Tp>
333 template<
typename _Up>
337 _M_real -= __z.real();
338 _M_imag -= __z.imag();
344 template<
typename _Tp>
345 template<
typename _Up>
349 const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
350 _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
357 template<
typename _Tp>
358 template<
typename _Up>
362 const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
364 _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
372 template<
typename _Tp>
381 template<
typename _Tp>
382 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
390 template<
typename _Tp>
391 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
402 template<
typename _Tp>
403 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
411 template<
typename _Tp>
412 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
420 template<
typename _Tp>
421 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
432 template<
typename _Tp>
433 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
441 template<
typename _Tp>
442 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
450 template<
typename _Tp>
451 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
462 template<
typename _Tp>
463 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
471 template<
typename _Tp>
472 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
480 template<
typename _Tp>
481 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
491 template<
typename _Tp>
492 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
497 template<
typename _Tp>
498 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
504 template<
typename _Tp>
505 inline _GLIBCXX_CONSTEXPR
bool
507 {
return __x.real() == __y.real() && __x.imag() == __y.imag(); }
509 template<
typename _Tp>
510 inline _GLIBCXX_CONSTEXPR
bool
512 {
return __x.real() == __y && __x.imag() == _Tp(); }
514#if !(__cpp_impl_three_way_comparison >= 201907L)
515 template<
typename _Tp>
516 inline _GLIBCXX_CONSTEXPR
bool
517 operator==(
const _Tp& __x,
const complex<_Tp>& __y)
518 {
return __x == __y.real() && _Tp() == __y.imag(); }
523 template<
typename _Tp>
524 inline _GLIBCXX_CONSTEXPR
bool
526 {
return __x.real() != __y.real() || __x.imag() != __y.imag(); }
528 template<
typename _Tp>
529 inline _GLIBCXX_CONSTEXPR
bool
531 {
return __x.real() != __y || __x.imag() != _Tp(); }
533 template<
typename _Tp>
534 inline _GLIBCXX_CONSTEXPR
bool
536 {
return __x != __y.real() || _Tp() != __y.imag(); }
541 template<
typename _Tp,
typename _CharT,
class _Traits>
549 if (_Traits::eq(__ch, __is.
widen(
'(')))
552 if (__is >> __u >> __ch)
554 const _CharT __rparen = __is.
widen(
')');
555 if (_Traits::eq(__ch, __rparen))
560 else if (_Traits::eq(__ch, __is.
widen(
',')))
563 if (__is >> __v >> __ch)
565 if (_Traits::eq(__ch, __rparen))
595 template<
typename _Tp,
typename _CharT,
class _Traits>
596 basic_ostream<_CharT, _Traits>&
597 operator<<(basic_ostream<_CharT, _Traits>& __os,
const complex<_Tp>& __x)
599 basic_ostringstream<_CharT, _Traits> __s;
600 __s.
flags(__os.flags());
601 __s.imbue(__os.getloc());
602 __s.precision(__os.precision());
603 __s <<
'(' << __x.real() <<
',' << __x.imag() <<
')';
604 return __os << __s.str();
608#if __cplusplus >= 201103L
609 template<
typename _Tp>
612 {
return __z.real(); }
614 template<
typename _Tp>
617 {
return __z.imag(); }
619 template<
typename _Tp>
622 {
return __z.real(); }
624 template<
typename _Tp>
627 {
return __z.real(); }
629 template<
typename _Tp>
632 {
return __z.imag(); }
634 template<
typename _Tp>
637 {
return __z.imag(); }
640#if __glibcxx_tuple_like >= 202311L
641 template<
size_t _Int,
typename _Tp>
642 [[nodiscard,__gnu__::__always_inline__]]
646 static_assert(_Int < 2);
647 return __z.__get_part(_Int);
650 template<
size_t _Int,
typename _Tp>
651 [[nodiscard,__gnu__::__always_inline__]]
655 static_assert(_Int < 2);
659 template<
size_t _Int,
typename _Tp>
660 [[nodiscard,__gnu__::__always_inline__]]
664 static_assert(_Int < 2);
665 return __z.__get_part(_Int);
668 template<
size_t _Int,
typename _Tp>
669 [[nodiscard,__gnu__::__always_inline__]]
670 constexpr const _Tp&&
673 static_assert(_Int < 2);
678#if _GLIBCXX_USE_C99_COMPLEX
679#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
681 __complex_abs(__complex__ _Float16 __z)
682 {
return _Float16(__builtin_cabsf(__z)); }
685 __complex_arg(__complex__ _Float16 __z)
686 {
return _Float16(__builtin_cargf(__z)); }
688 inline __complex__ _Float16
689 __complex_cos(__complex__ _Float16 __z)
690 {
return static_cast<__complex__ _Float16
>(__builtin_ccosf(__z)); }
692 inline __complex__ _Float16
693 __complex_cosh(__complex__ _Float16 __z)
694 {
return static_cast<__complex__ _Float16
>(__builtin_ccoshf(__z)); }
696 inline __complex__ _Float16
697 __complex_exp(__complex__ _Float16 __z)
698 {
return static_cast<__complex__ _Float16
>(__builtin_cexpf(__z)); }
700 inline __complex__ _Float16
701 __complex_log(__complex__ _Float16 __z)
702 {
return static_cast<__complex__ _Float16
>(__builtin_clogf(__z)); }
704 inline __complex__ _Float16
705 __complex_sin(__complex__ _Float16 __z)
706 {
return static_cast<__complex__ _Float16
>(__builtin_csinf(__z)); }
708 inline __complex__ _Float16
709 __complex_sinh(__complex__ _Float16 __z)
710 {
return static_cast<__complex__ _Float16
>(__builtin_csinhf(__z)); }
712 inline __complex__ _Float16
713 __complex_sqrt(__complex__ _Float16 __z)
714 {
return static_cast<__complex__ _Float16
>(__builtin_csqrtf(__z)); }
716 inline __complex__ _Float16
717 __complex_tan(__complex__ _Float16 __z)
718 {
return static_cast<__complex__ _Float16
>(__builtin_ctanf(__z)); }
720 inline __complex__ _Float16
721 __complex_tanh(__complex__ _Float16 __z)
722 {
return static_cast<__complex__ _Float16
>(__builtin_ctanhf(__z)); }
724 inline __complex__ _Float16
725 __complex_pow(__complex__ _Float16 __x, __complex__ _Float16 __y)
726 {
return static_cast<__complex__ _Float16
>(__builtin_cpowf(__x, __y)); }
729#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
731 __complex_abs(__complex__ _Float32 __z) {
return __builtin_cabsf(__z); }
734 __complex_arg(__complex__ _Float32 __z) {
return __builtin_cargf(__z); }
736 inline __complex__ _Float32
737 __complex_cos(__complex__ _Float32 __z) {
return __builtin_ccosf(__z); }
739 inline __complex__ _Float32
740 __complex_cosh(__complex__ _Float32 __z) {
return __builtin_ccoshf(__z); }
742 inline __complex__ _Float32
743 __complex_exp(__complex__ _Float32 __z) {
return __builtin_cexpf(__z); }
745 inline __complex__ _Float32
746 __complex_log(__complex__ _Float32 __z) {
return __builtin_clogf(__z); }
748 inline __complex__ _Float32
749 __complex_sin(__complex__ _Float32 __z) {
return __builtin_csinf(__z); }
751 inline __complex__ _Float32
752 __complex_sinh(__complex__ _Float32 __z) {
return __builtin_csinhf(__z); }
754 inline __complex__ _Float32
755 __complex_sqrt(__complex__ _Float32 __z) {
return __builtin_csqrtf(__z); }
757 inline __complex__ _Float32
758 __complex_tan(__complex__ _Float32 __z) {
return __builtin_ctanf(__z); }
760 inline __complex__ _Float32
761 __complex_tanh(__complex__ _Float32 __z) {
return __builtin_ctanhf(__z); }
763 inline __complex__ _Float32
764 __complex_pow(__complex__ _Float32 __x, __complex__ _Float32 __y)
765 {
return __builtin_cpowf(__x, __y); }
768#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
770 __complex_abs(__complex__ _Float64 __z) {
return __builtin_cabs(__z); }
773 __complex_arg(__complex__ _Float64 __z) {
return __builtin_carg(__z); }
775 inline __complex__ _Float64
776 __complex_cos(__complex__ _Float64 __z) {
return __builtin_ccos(__z); }
778 inline __complex__ _Float64
779 __complex_cosh(__complex__ _Float64 __z) {
return __builtin_ccosh(__z); }
781 inline __complex__ _Float64
782 __complex_exp(__complex__ _Float64 __z) {
return __builtin_cexp(__z); }
784 inline __complex__ _Float64
785 __complex_log(__complex__ _Float64 __z) {
return __builtin_clog(__z); }
787 inline __complex__ _Float64
788 __complex_sin(__complex__ _Float64 __z) {
return __builtin_csin(__z); }
790 inline __complex__ _Float64
791 __complex_sinh(__complex__ _Float64 __z) {
return __builtin_csinh(__z); }
793 inline __complex__ _Float64
794 __complex_sqrt(__complex__ _Float64 __z) {
return __builtin_csqrt(__z); }
796 inline __complex__ _Float64
797 __complex_tan(__complex__ _Float64 __z) {
return __builtin_ctan(__z); }
799 inline __complex__ _Float64
800 __complex_tanh(__complex__ _Float64 __z) {
return __builtin_ctanh(__z); }
802 inline __complex__ _Float64
803 __complex_pow(__complex__ _Float64 __x, __complex__ _Float64 __y)
804 {
return __builtin_cpow(__x, __y); }
807#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
809 __complex_abs(__complex__ _Float128 __z) {
return __builtin_cabsl(__z); }
812 __complex_arg(__complex__ _Float128 __z) {
return __builtin_cargl(__z); }
814 inline __complex__ _Float128
815 __complex_cos(__complex__ _Float128 __z) {
return __builtin_ccosl(__z); }
817 inline __complex__ _Float128
818 __complex_cosh(__complex__ _Float128 __z) {
return __builtin_ccoshl(__z); }
820 inline __complex__ _Float128
821 __complex_exp(__complex__ _Float128 __z) {
return __builtin_cexpl(__z); }
823 inline __complex__ _Float128
824 __complex_log(__complex__ _Float128 __z) {
return __builtin_clogl(__z); }
826 inline __complex__ _Float128
827 __complex_sin(__complex__ _Float128 __z) {
return __builtin_csinl(__z); }
829 inline __complex__ _Float128
830 __complex_sinh(__complex__ _Float128 __z) {
return __builtin_csinhl(__z); }
832 inline __complex__ _Float128
833 __complex_sqrt(__complex__ _Float128 __z) {
return __builtin_csqrtl(__z); }
835 inline __complex__ _Float128
836 __complex_tan(__complex__ _Float128 __z) {
return __builtin_ctanl(__z); }
838 inline __complex__ _Float128
839 __complex_tanh(__complex__ _Float128 __z) {
return __builtin_ctanhl(__z); }
841 inline __complex__ _Float128
842 __complex_pow(__complex__ _Float128 __x, __complex__ _Float128 __y)
843 {
return __builtin_cpowl(__x, __y); }
844#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
846 __complex_abs(__complex__ _Float128 __z) {
return __builtin_cabsf128(__z); }
849 __complex_arg(__complex__ _Float128 __z) {
return __builtin_cargf128(__z); }
851 inline __complex__ _Float128
852 __complex_cos(__complex__ _Float128 __z) {
return __builtin_ccosf128(__z); }
854 inline __complex__ _Float128
855 __complex_cosh(__complex__ _Float128 __z) {
return __builtin_ccoshf128(__z); }
857 inline __complex__ _Float128
858 __complex_exp(__complex__ _Float128 __z) {
return __builtin_cexpf128(__z); }
860 inline __complex__ _Float128
861 __complex_log(__complex__ _Float128 __z) {
return __builtin_clogf128(__z); }
863 inline __complex__ _Float128
864 __complex_sin(__complex__ _Float128 __z) {
return __builtin_csinf128(__z); }
866 inline __complex__ _Float128
867 __complex_sinh(__complex__ _Float128 __z) {
return __builtin_csinhf128(__z); }
869 inline __complex__ _Float128
870 __complex_sqrt(__complex__ _Float128 __z) {
return __builtin_csqrtf128(__z); }
872 inline __complex__ _Float128
873 __complex_tan(__complex__ _Float128 __z) {
return __builtin_ctanf128(__z); }
875 inline __complex__ _Float128
876 __complex_tanh(__complex__ _Float128 __z) {
return __builtin_ctanhf128(__z); }
878 inline __complex__ _Float128
879 __complex_pow(__complex__ _Float128 __x, __complex__ _Float128 __y)
880 {
return __builtin_cpowf128(__x, __y); }
883#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
884 inline __gnu_cxx::__bfloat16_t
885 __complex_abs(__complex__
decltype(0.0bf16) __z)
886 {
return __gnu_cxx::__bfloat16_t(__builtin_cabsf(__z)); }
888 inline __gnu_cxx::__bfloat16_t
889 __complex_arg(__complex__
decltype(0.0bf16) __z)
890 {
return __gnu_cxx::__bfloat16_t(__builtin_cargf(__z)); }
892 inline __complex__
decltype(0.0bf16)
893 __complex_cos(__complex__
decltype(0.0bf16) __z)
894 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_ccosf(__z)); }
896 inline __complex__
decltype(0.0bf16)
897 __complex_cosh(__complex__
decltype(0.0bf16) __z)
898 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_ccoshf(__z)); }
900 inline __complex__
decltype(0.0bf16)
901 __complex_exp(__complex__
decltype(0.0bf16) __z)
902 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_cexpf(__z)); }
904 inline __complex__
decltype(0.0bf16)
905 __complex_log(__complex__
decltype(0.0bf16) __z)
906 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_clogf(__z)); }
908 inline __complex__
decltype(0.0bf16)
909 __complex_sin(__complex__
decltype(0.0bf16) __z)
910 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_csinf(__z)); }
912 inline __complex__
decltype(0.0bf16)
913 __complex_sinh(__complex__
decltype(0.0bf16) __z)
914 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_csinhf(__z)); }
916 inline __complex__
decltype(0.0bf16)
917 __complex_sqrt(__complex__
decltype(0.0bf16) __z)
918 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_csqrtf(__z)); }
920 inline __complex__
decltype(0.0bf16)
921 __complex_tan(__complex__
decltype(0.0bf16) __z)
922 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_ctanf(__z)); }
924 inline __complex__
decltype(0.0bf16)
925 __complex_tanh(__complex__
decltype(0.0bf16) __z)
926 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_ctanhf(__z)); }
928 inline __complex__
decltype(0.0bf16)
929 __complex_pow(__complex__
decltype(0.0bf16) __x,
930 __complex__
decltype(0.0bf16) __y)
931 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_cpowf(__x,
937 template<
typename _Tp>
941 _Tp __x = __z.real();
942 _Tp __y = __z.imag();
948 return __s *
sqrt(__x * __x + __y * __y);
951#if _GLIBCXX_USE_C99_COMPLEX
953 __complex_abs(__complex__
float __z) {
return __builtin_cabsf(__z); }
956 __complex_abs(__complex__
double __z) {
return __builtin_cabs(__z); }
959 __complex_abs(
const __complex__
long double& __z)
960 {
return __builtin_cabsl(__z); }
962 template<
typename _Tp>
966 template<
typename _Tp>
968 abs(
const complex<_Tp>& __z) {
return __complex_abs(__z); }
973 template<
typename _Tp>
976 {
return atan2(__z.imag(), __z.real()); }
978#if _GLIBCXX_USE_C99_COMPLEX
980 __complex_arg(__complex__
float __z) {
return __builtin_cargf(__z); }
983 __complex_arg(__complex__
double __z) {
return __builtin_carg(__z); }
986 __complex_arg(
const __complex__
long double& __z)
987 {
return __builtin_cargl(__z); }
989 template<
typename _Tp>
993 template<
typename _Tp>
995 arg(
const complex<_Tp>& __z) {
return __complex_arg(__z); }
1006 template<
typename _Tp>
1007 static inline _GLIBCXX20_CONSTEXPR _Tp _S_do_it(
const complex<_Tp>& __z)
1009 const _Tp __x = __z.real();
1010 const _Tp __y = __z.imag();
1011 return __x * __x + __y * __y;
1016 struct _Norm_helper<true>
1018 template<
typename _Tp>
1019 static inline _GLIBCXX20_CONSTEXPR _Tp _S_do_it(
const complex<_Tp>& __z)
1023 const _Tp __x = __z.real();
1024 const _Tp __y = __z.imag();
1025 return __x * __x + __y * __y;
1029 template<
typename _Tp>
1030 inline _GLIBCXX20_CONSTEXPR _Tp
1033 return _Norm_helper<__is_floating<_Tp>::__value
1034 && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
1037 template<
typename _Tp>
1039 polar(
const _Tp& __rho,
const _Tp& __theta)
1041 __glibcxx_assert( __rho >= 0 );
1045 template<
typename _Tp>
1046 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
1053 template<
typename _Tp>
1055 __complex_cos(
const complex<_Tp>& __z)
1057 const _Tp __x = __z.real();
1058 const _Tp __y = __z.imag();
1059 return complex<_Tp>(
cos(__x) *
cosh(__y), -
sin(__x) *
sinh(__y));
1062#if _GLIBCXX_USE_C99_COMPLEX
1063 inline __complex__
float
1064 __complex_cos(__complex__
float __z) {
return __builtin_ccosf(__z); }
1066 inline __complex__
double
1067 __complex_cos(__complex__
double __z) {
return __builtin_ccos(__z); }
1069 inline __complex__
long double
1070 __complex_cos(
const __complex__
long double& __z)
1071 {
return __builtin_ccosl(__z); }
1073 template<
typename _Tp>
1077 template<
typename _Tp>
1079 cos(
const complex<_Tp>& __z) {
return __complex_cos(__z); }
1083 template<
typename _Tp>
1087 const _Tp __x = __z.real();
1088 const _Tp __y = __z.imag();
1092#if _GLIBCXX_USE_C99_COMPLEX
1093 inline __complex__
float
1094 __complex_cosh(__complex__
float __z) {
return __builtin_ccoshf(__z); }
1096 inline __complex__
double
1097 __complex_cosh(__complex__
double __z) {
return __builtin_ccosh(__z); }
1099 inline __complex__
long double
1100 __complex_cosh(
const __complex__
long double& __z)
1101 {
return __builtin_ccoshl(__z); }
1103 template<
typename _Tp>
1107 template<
typename _Tp>
1109 cosh(
const complex<_Tp>& __z) {
return __complex_cosh(__z); }
1113 template<
typename _Tp>
1118#if _GLIBCXX_USE_C99_COMPLEX
1119 inline __complex__
float
1120 __complex_exp(__complex__
float __z) {
return __builtin_cexpf(__z); }
1122 inline __complex__
double
1123 __complex_exp(__complex__
double __z) {
return __builtin_cexp(__z); }
1125 inline __complex__
long double
1126 __complex_exp(
const __complex__
long double& __z)
1127 {
return __builtin_cexpl(__z); }
1129 template<
typename _Tp>
1133 template<
typename _Tp>
1135 exp(
const complex<_Tp>& __z) {
return __complex_exp(__z); }
1140 template<
typename _Tp>
1145#if _GLIBCXX_USE_C99_COMPLEX
1146 inline __complex__
float
1147 __complex_log(__complex__
float __z) {
return __builtin_clogf(__z); }
1149 inline __complex__
double
1150 __complex_log(__complex__
double __z) {
return __builtin_clog(__z); }
1152 inline __complex__
long double
1153 __complex_log(
const __complex__
long double& __z)
1154 {
return __builtin_clogl(__z); }
1156 template<
typename _Tp>
1160 template<
typename _Tp>
1162 log(
const complex<_Tp>& __z) {
return __complex_log(__z); }
1165 template<
typename _Tp>
1171 template<
typename _Tp>
1173 __complex_sin(
const complex<_Tp>& __z)
1175 const _Tp __x = __z.real();
1176 const _Tp __y = __z.imag();
1180#if _GLIBCXX_USE_C99_COMPLEX
1181 inline __complex__
float
1182 __complex_sin(__complex__
float __z) {
return __builtin_csinf(__z); }
1184 inline __complex__
double
1185 __complex_sin(__complex__
double __z) {
return __builtin_csin(__z); }
1187 inline __complex__
long double
1188 __complex_sin(
const __complex__
long double& __z)
1189 {
return __builtin_csinl(__z); }
1191 template<
typename _Tp>
1195 template<
typename _Tp>
1197 sin(
const complex<_Tp>& __z) {
return __complex_sin(__z); }
1201 template<
typename _Tp>
1205 const _Tp __x = __z.real();
1206 const _Tp __y = __z.imag();
1210#if _GLIBCXX_USE_C99_COMPLEX
1211 inline __complex__
float
1212 __complex_sinh(__complex__
float __z) {
return __builtin_csinhf(__z); }
1214 inline __complex__
double
1215 __complex_sinh(__complex__
double __z) {
return __builtin_csinh(__z); }
1217 inline __complex__
long double
1218 __complex_sinh(
const __complex__
long double& __z)
1219 {
return __builtin_csinhl(__z); }
1221 template<
typename _Tp>
1225 template<
typename _Tp>
1227 sinh(
const complex<_Tp>& __z) {
return __complex_sinh(__z); }
1232 template<
typename _Tp>
1236 _Tp __x = __z.real();
1237 _Tp __y = __z.imag();
1250 :
complex<_Tp>(
abs(__y) / __t, __y < _Tp() ? -__u : __u);
1254#if _GLIBCXX_USE_C99_COMPLEX
1255 inline __complex__
float
1256 __complex_sqrt(__complex__
float __z) {
return __builtin_csqrtf(__z); }
1258 inline __complex__
double
1259 __complex_sqrt(__complex__
double __z) {
return __builtin_csqrt(__z); }
1261 inline __complex__
long double
1262 __complex_sqrt(
const __complex__
long double& __z)
1263 {
return __builtin_csqrtl(__z); }
1265 template<
typename _Tp>
1269 template<
typename _Tp>
1271 sqrt(
const complex<_Tp>& __z) {
return __complex_sqrt(__z); }
1276 template<
typename _Tp>
1281#if _GLIBCXX_USE_C99_COMPLEX
1282 inline __complex__
float
1283 __complex_tan(__complex__
float __z) {
return __builtin_ctanf(__z); }
1285 inline __complex__
double
1286 __complex_tan(__complex__
double __z) {
return __builtin_ctan(__z); }
1288 inline __complex__
long double
1289 __complex_tan(
const __complex__
long double& __z)
1290 {
return __builtin_ctanl(__z); }
1292 template<
typename _Tp>
1296 template<
typename _Tp>
1298 tan(
const complex<_Tp>& __z) {
return __complex_tan(__z); }
1304 template<
typename _Tp>
1309#if _GLIBCXX_USE_C99_COMPLEX
1310 inline __complex__
float
1311 __complex_tanh(__complex__
float __z) {
return __builtin_ctanhf(__z); }
1313 inline __complex__
double
1314 __complex_tanh(__complex__
double __z) {
return __builtin_ctanh(__z); }
1316 inline __complex__
long double
1317 __complex_tanh(
const __complex__
long double& __z)
1318 {
return __builtin_ctanhl(__z); }
1320 template<
typename _Tp>
1324 template<
typename _Tp>
1326 tanh(
const complex<_Tp>& __z) {
return __complex_tanh(__z); }
1333 template<
typename _Tp>
1355 template<
typename _Tp>
1360 ?
complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -(
unsigned)__n)
1361 : std::__complex_pow_unsigned(__z, __n);
1364 template<
typename _Tp>
1368#if ! _GLIBCXX_USE_C99_COMPLEX
1372 if (__x.imag() == _Tp() && __x.real() > _Tp())
1373 return pow(__x.real(), __y);
1379 template<
typename _Tp>
1381 __complex_pow(
const complex<_Tp>& __x,
const complex<_Tp>& __y)
1382 {
return __x == _Tp() ? _Tp() :
std::exp(__y *
std::log(__x)); }
1384#if _GLIBCXX_USE_C99_COMPLEX
1385 inline __complex__
float
1386 __complex_pow(__complex__
float __x, __complex__
float __y)
1387 {
return __builtin_cpowf(__x, __y); }
1389 inline __complex__
double
1390 __complex_pow(__complex__
double __x, __complex__
double __y)
1391 {
return __builtin_cpow(__x, __y); }
1393 inline __complex__
long double
1394 __complex_pow(
const __complex__
long double& __x,
1395 const __complex__
long double& __y)
1396 {
return __builtin_cpowl(__x, __y); }
1398 template<
typename _Tp>
1401 {
return __complex_pow(__x.__rep(), __y.__rep()); }
1403 template<
typename _Tp>
1405 pow(
const complex<_Tp>& __x,
const complex<_Tp>& __y)
1406 {
return __complex_pow(__x, __y); }
1409 template<
typename _Tp>
1414 __y.imag() *
log(__x))
1418#if __glibcxx_tuple_like >= 202311L
1419#define _GLIBCXX26_DECLARE_COMPLEX_TUPLE_HELPER_ACCESSOR \
1420 template<typename _Cp> \
1421 [[__gnu__::__always_inline__]] \
1423 __get_part(this _Cp& __z, size_t __i) noexcept \
1425 return __i == 0 ? __real__ __z._M_value \
1426 : __imag__ __z._M_value; \
1429#define _GLIBCXX26_DECLARE_COMPLEX_TUPLE_HELPER_ACCESSOR
1435 class complex<float>
1438 typedef float value_type;
1439 typedef __complex__
float _ComplexT;
1441 _GLIBCXX_CONSTEXPR
complex(_ComplexT __z) : _M_value(__z) { }
1443 _GLIBCXX_CONSTEXPR
complex(
float __r = 0.0f,
float __i = 0.0f)
1444#if __cplusplus >= 201103L
1445 : _M_value{ __r, __i } { }
1448 __real__ _M_value = __r;
1449 __imag__ _M_value = __i;
1453#if __cplusplus >= 201103L
1454 _GLIBCXX14_CONSTEXPR
complex(
const complex&) =
default;
1457#if __cplusplus > 202002L
1458 template<
typename _Up>
1459 explicit(!
requires(_Up __u) { value_type{__u}; })
1460 constexpr complex(
const complex<_Up>& __z)
1463 explicit _GLIBCXX_CONSTEXPR
complex(
const complex<double>&);
1464 explicit _GLIBCXX_CONSTEXPR
complex(
const complex<long double>&);
1467#if __cplusplus >= 201103L
1470 __attribute ((__abi_tag__ (
"cxx11")))
1472 real()
const {
return __real__ _M_value; }
1474 __attribute ((__abi_tag__ (
"cxx11")))
1476 imag()
const {
return __imag__ _M_value; }
1479 real() {
return __real__ _M_value; }
1482 real()
const {
return __real__ _M_value; }
1485 imag() {
return __imag__ _M_value; }
1488 imag()
const {
return __imag__ _M_value; }
1493 _GLIBCXX20_CONSTEXPR
void
1494 real(
float __val) { __real__ _M_value = __val; }
1496 _GLIBCXX20_CONSTEXPR
void
1497 imag(
float __val) { __imag__ _M_value = __val; }
1499 _GLIBCXX20_CONSTEXPR complex&
1506 _GLIBCXX20_CONSTEXPR complex&
1513 _GLIBCXX20_CONSTEXPR complex&
1520 _GLIBCXX20_CONSTEXPR complex&
1527 _GLIBCXX20_CONSTEXPR complex&
1536#if __cplusplus >= 201103L
1537 _GLIBCXX14_CONSTEXPR complex&
operator=(
const complex&) =
default;
1540 template<
typename _Tp>
1541 _GLIBCXX20_CONSTEXPR complex&
1544 __real__ _M_value = __z.real();
1545 __imag__ _M_value = __z.imag();
1549 template<
typename _Tp>
1550 _GLIBCXX20_CONSTEXPR complex&
1553 _M_value += __z.__rep();
1558 _GLIBCXX20_CONSTEXPR complex&
1561 _M_value -= __z.__rep();
1566 _GLIBCXX20_CONSTEXPR complex&
1569 const _ComplexT __t = __z.__rep();
1575 _GLIBCXX20_CONSTEXPR complex&
1578 const _ComplexT __t = __z.__rep();
1583 _GLIBCXX_CONSTEXPR _ComplexT __rep()
const {
return _M_value; }
1585 _GLIBCXX26_DECLARE_COMPLEX_TUPLE_HELPER_ACCESSOR
1594 class complex<double>
1597 typedef double value_type;
1598 typedef __complex__
double _ComplexT;
1600 _GLIBCXX_CONSTEXPR
complex(_ComplexT __z) : _M_value(__z) { }
1602 _GLIBCXX_CONSTEXPR
complex(
double __r = 0.0,
double __i = 0.0)
1603#if __cplusplus >= 201103L
1604 : _M_value{ __r, __i } { }
1607 __real__ _M_value = __r;
1608 __imag__ _M_value = __i;
1612#if __cplusplus >= 201103L
1613 _GLIBCXX14_CONSTEXPR
complex(
const complex&) =
default;
1616#if __cplusplus > 202002L
1617 template<
typename _Up>
1618 explicit(!
requires(_Up __u) { value_type{__u}; })
1619 constexpr complex(
const complex<_Up>& __z)
1622 _GLIBCXX_CONSTEXPR
complex(
const complex<float>& __z)
1623 : _M_value(__z.__rep()) { }
1625 explicit _GLIBCXX_CONSTEXPR
complex(
const complex<long double>&);
1628#if __cplusplus >= 201103L
1631 __attribute ((__abi_tag__ (
"cxx11")))
1633 real()
const {
return __real__ _M_value; }
1635 __attribute ((__abi_tag__ (
"cxx11")))
1637 imag()
const {
return __imag__ _M_value; }
1640 real() {
return __real__ _M_value; }
1643 real()
const {
return __real__ _M_value; }
1646 imag() {
return __imag__ _M_value; }
1649 imag()
const {
return __imag__ _M_value; }
1654 _GLIBCXX20_CONSTEXPR
void
1655 real(
double __val) { __real__ _M_value = __val; }
1657 _GLIBCXX20_CONSTEXPR
void
1658 imag(
double __val) { __imag__ _M_value = __val; }
1660 _GLIBCXX20_CONSTEXPR complex&
1667 _GLIBCXX20_CONSTEXPR complex&
1674 _GLIBCXX20_CONSTEXPR complex&
1681 _GLIBCXX20_CONSTEXPR complex&
1688 _GLIBCXX20_CONSTEXPR complex&
1696#if __cplusplus >= 201103L
1697 _GLIBCXX14_CONSTEXPR complex&
operator=(
const complex&) =
default;
1700 template<
typename _Tp>
1701 _GLIBCXX20_CONSTEXPR complex&
1704 _M_value = __z.__rep();
1708 template<
typename _Tp>
1709 _GLIBCXX20_CONSTEXPR complex&
1712 _M_value += __z.__rep();
1716 template<
typename _Tp>
1717 _GLIBCXX20_CONSTEXPR complex&
1720 _M_value -= __z.__rep();
1724 template<
typename _Tp>
1725 _GLIBCXX20_CONSTEXPR complex&
1728 const _ComplexT __t = __z.__rep();
1733 template<
typename _Tp>
1734 _GLIBCXX20_CONSTEXPR complex&
1737 const _ComplexT __t = __z.__rep();
1742 _GLIBCXX_CONSTEXPR _ComplexT __rep()
const {
return _M_value; }
1744 _GLIBCXX26_DECLARE_COMPLEX_TUPLE_HELPER_ACCESSOR
1753 class complex<long double>
1756 typedef long double value_type;
1757 typedef __complex__
long double _ComplexT;
1759 _GLIBCXX_CONSTEXPR
complex(_ComplexT __z) : _M_value(__z) { }
1761 _GLIBCXX_CONSTEXPR
complex(
long double __r = 0.0L,
1762 long double __i = 0.0L)
1763#if __cplusplus >= 201103L
1764 : _M_value{ __r, __i } { }
1767 __real__ _M_value = __r;
1768 __imag__ _M_value = __i;
1772#if __cplusplus >= 201103L
1773 _GLIBCXX14_CONSTEXPR
complex(
const complex&) =
default;
1776#if __cplusplus > 202002L
1777 template<
typename _Up>
1778 explicit(!
requires(_Up __u) { value_type{__u}; })
1779 constexpr complex(
const complex<_Up>& __z)
1782 _GLIBCXX_CONSTEXPR
complex(
const complex<float>& __z)
1783 : _M_value(__z.__rep()) { }
1785 _GLIBCXX_CONSTEXPR
complex(
const complex<double>& __z)
1786 : _M_value(__z.__rep()) { }
1789#if __cplusplus >= 201103L
1792 __attribute ((__abi_tag__ (
"cxx11")))
1793 constexpr long double
1794 real()
const {
return __real__ _M_value; }
1796 __attribute ((__abi_tag__ (
"cxx11")))
1797 constexpr long double
1798 imag()
const {
return __imag__ _M_value; }
1801 real() {
return __real__ _M_value; }
1804 real()
const {
return __real__ _M_value; }
1807 imag() {
return __imag__ _M_value; }
1810 imag()
const {
return __imag__ _M_value; }
1815 _GLIBCXX20_CONSTEXPR
void
1816 real(
long double __val) { __real__ _M_value = __val; }
1818 _GLIBCXX20_CONSTEXPR
void
1819 imag(
long double __val) { __imag__ _M_value = __val; }
1821 _GLIBCXX20_CONSTEXPR complex&
1828 _GLIBCXX20_CONSTEXPR complex&
1835 _GLIBCXX20_CONSTEXPR complex&
1842 _GLIBCXX20_CONSTEXPR complex&
1849 _GLIBCXX20_CONSTEXPR complex&
1857#if __cplusplus >= 201103L
1858 _GLIBCXX14_CONSTEXPR complex&
operator=(
const complex&) =
default;
1861 template<
typename _Tp>
1862 _GLIBCXX20_CONSTEXPR complex&
1865 _M_value = __z.__rep();
1869 template<
typename _Tp>
1870 _GLIBCXX20_CONSTEXPR complex&
1873 _M_value += __z.__rep();
1877 template<
typename _Tp>
1878 _GLIBCXX20_CONSTEXPR complex&
1881 _M_value -= __z.__rep();
1885 template<
typename _Tp>
1886 _GLIBCXX20_CONSTEXPR complex&
1889 const _ComplexT __t = __z.__rep();
1894 template<
typename _Tp>
1895 _GLIBCXX20_CONSTEXPR complex&
1898 const _ComplexT __t = __z.__rep();
1903 _GLIBCXX_CONSTEXPR _ComplexT __rep()
const {
return _M_value; }
1905 _GLIBCXX26_DECLARE_COMPLEX_TUPLE_HELPER_ACCESSOR
1911#if __cplusplus > 202002L
1912 template<
typename _Tp>
1913 struct __complex_type
1916#ifdef __STDCPP_FLOAT16_T__
1918 struct __complex_type<_Float16>
1919 {
typedef __complex__ _Float16 type; };
1922#ifdef __STDCPP_FLOAT32_T__
1924 struct __complex_type<_Float32>
1925 {
typedef __complex__ _Float32 type; };
1928#ifdef __STDCPP_FLOAT64_T__
1930 struct __complex_type<_Float64>
1931 {
typedef __complex__ _Float64 type; };
1934#ifdef __STDCPP_FLOAT128_T__
1936 struct __complex_type<_Float128>
1937 {
typedef __complex__ _Float128 type; };
1940#ifdef __STDCPP_BFLOAT16_T__
1942 struct __complex_type<__gnu_cxx::__bfloat16_t>
1943 {
typedef __complex__
decltype(0.0bf16) type; };
1946 template<
typename _Tp>
1947 requires requires {
typename __complex_type<_Tp>::type; }
1952 typedef typename std::__complex_type<_Tp>::type _ComplexT;
1954 constexpr complex(_ComplexT __z) : _M_value(__z) { }
1956 constexpr complex(_Tp __r = _Tp(), _Tp __i = _Tp())
1957 : _M_value{ __r, __i } { }
1959 template<
typename _Up>
1960 explicit(!
requires(_Up __u) {
value_type{__u}; })
1965 real()
const {
return __real__ _M_value; }
1968 imag()
const {
return __imag__ _M_value; }
1971 real(_Tp __val) { __real__ _M_value = __val; }
1974 imag(_Tp __val) { __imag__ _M_value = __val; }
2016 template<
typename _Up>
2020 __real__ _M_value = __z.real();
2021 __imag__ _M_value = __z.imag();
2025 template<
typename _Up>
2029 _M_value += __z.__rep();
2037 _M_value -= __z.__rep();
2045 const _ComplexT __t = __z.__rep();
2054 const _ComplexT __t = __z.__rep();
2059 constexpr _ComplexT __rep()
const {
return _M_value; }
2061 _GLIBCXX26_DECLARE_COMPLEX_TUPLE_HELPER_ACCESSOR
2068#undef _GLIBCXX26_DECLARE_COMPLEX_TUPLE_HELPER_ACCESSOR
2070#if __cplusplus <= 202002L
2073 inline _GLIBCXX_CONSTEXPR
2075 : _M_value(__z.__rep()) { }
2077 inline _GLIBCXX_CONSTEXPR
2079 : _M_value(__z.__rep()) { }
2081 inline _GLIBCXX_CONSTEXPR
2083 : _M_value(__z.__rep()) { }
2089#if _GLIBCXX_EXTERN_TEMPLATE
2097#ifdef _GLIBCXX_USE_WCHAR_T
2109_GLIBCXX_END_NAMESPACE_VERSION
2112#if __cplusplus >= 201103L
2114namespace std _GLIBCXX_VISIBILITY(
default)
2116_GLIBCXX_BEGIN_NAMESPACE_VERSION
2129 template<
typename _Tp>
2134 const _Tp __pi_2 = (_Tp) 1.5707963267948966192313216916397514L;
2138#if _GLIBCXX_USE_C99_COMPLEX_ARC
2139#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2140 inline __complex__ _Float16
2141 __complex_acos(__complex__ _Float16 __z)
2142 {
return static_cast<__complex__ _Float16
>(__builtin_cacosf(__z)); }
2144 inline __complex__ _Float16
2145 __complex_asin(__complex__ _Float16 __z)
2146 {
return static_cast<__complex__ _Float16
>(__builtin_casinf(__z)); }
2148 inline __complex__ _Float16
2149 __complex_atan(__complex__ _Float16 __z)
2150 {
return static_cast<__complex__ _Float16
>(__builtin_catanf(__z)); }
2152 inline __complex__ _Float16
2153 __complex_acosh(__complex__ _Float16 __z)
2154 {
return static_cast<__complex__ _Float16
>(__builtin_cacoshf(__z)); }
2156 inline __complex__ _Float16
2157 __complex_asinh(__complex__ _Float16 __z)
2158 {
return static_cast<__complex__ _Float16
>(__builtin_casinhf(__z)); }
2160 inline __complex__ _Float16
2161 __complex_atanh(__complex__ _Float16 __z)
2162 {
return static_cast<__complex__ _Float16
>(__builtin_catanhf(__z)); }
2165#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2166 inline __complex__ _Float32
2167 __complex_acos(__complex__ _Float32 __z)
2168 {
return __builtin_cacosf(__z); }
2170 inline __complex__ _Float32
2171 __complex_asin(__complex__ _Float32 __z)
2172 {
return __builtin_casinf(__z); }
2174 inline __complex__ _Float32
2175 __complex_atan(__complex__ _Float32 __z)
2176 {
return __builtin_catanf(__z); }
2178 inline __complex__ _Float32
2179 __complex_acosh(__complex__ _Float32 __z)
2180 {
return __builtin_cacoshf(__z); }
2182 inline __complex__ _Float32
2183 __complex_asinh(__complex__ _Float32 __z)
2184 {
return __builtin_casinhf(__z); }
2186 inline __complex__ _Float32
2187 __complex_atanh(__complex__ _Float32 __z)
2188 {
return __builtin_catanhf(__z); }
2191#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
2192 inline __complex__ _Float64
2193 __complex_acos(__complex__ _Float64 __z)
2194 {
return __builtin_cacos(__z); }
2196 inline __complex__ _Float64
2197 __complex_asin(__complex__ _Float64 __z)
2198 {
return __builtin_casin(__z); }
2200 inline __complex__ _Float64
2201 __complex_atan(__complex__ _Float64 __z)
2202 {
return __builtin_catan(__z); }
2204 inline __complex__ _Float64
2205 __complex_acosh(__complex__ _Float64 __z)
2206 {
return __builtin_cacosh(__z); }
2208 inline __complex__ _Float64
2209 __complex_asinh(__complex__ _Float64 __z)
2210 {
return __builtin_casinh(__z); }
2212 inline __complex__ _Float64
2213 __complex_atanh(__complex__ _Float64 __z)
2214 {
return __builtin_catanh(__z); }
2217#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
2218 inline __complex__ _Float128
2219 __complex_acos(__complex__ _Float128 __z)
2220 {
return __builtin_cacosl(__z); }
2222 inline __complex__ _Float128
2223 __complex_asin(__complex__ _Float128 __z)
2224 {
return __builtin_casinl(__z); }
2226 inline __complex__ _Float128
2227 __complex_atan(__complex__ _Float128 __z)
2228 {
return __builtin_catanl(__z); }
2230 inline __complex__ _Float128
2231 __complex_acosh(__complex__ _Float128 __z)
2232 {
return __builtin_cacoshl(__z); }
2234 inline __complex__ _Float128
2235 __complex_asinh(__complex__ _Float128 __z)
2236 {
return __builtin_casinhl(__z); }
2238 inline __complex__ _Float128
2239 __complex_atanh(__complex__ _Float128 __z)
2240 {
return __builtin_catanhl(__z); }
2241#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
2242 inline __complex__ _Float128
2243 __complex_acos(__complex__ _Float128 __z)
2244 {
return __builtin_cacosf128(__z); }
2246 inline __complex__ _Float128
2247 __complex_asin(__complex__ _Float128 __z)
2248 {
return __builtin_casinf128(__z); }
2250 inline __complex__ _Float128
2251 __complex_atan(__complex__ _Float128 __z)
2252 {
return __builtin_catanf128(__z); }
2254 inline __complex__ _Float128
2255 __complex_acosh(__complex__ _Float128 __z)
2256 {
return __builtin_cacoshf128(__z); }
2258 inline __complex__ _Float128
2259 __complex_asinh(__complex__ _Float128 __z)
2260 {
return __builtin_casinhf128(__z); }
2262 inline __complex__ _Float128
2263 __complex_atanh(__complex__ _Float128 __z)
2264 {
return __builtin_catanhf128(__z); }
2267#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2268 inline __complex__
decltype(0.0bf16)
2269 __complex_acos(__complex__
decltype(0.0bf16) __z)
2270 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_cacosf(__z)); }
2272 inline __complex__
decltype(0.0bf16)
2273 __complex_asin(__complex__
decltype(0.0bf16) __z)
2274 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_casinf(__z)); }
2276 inline __complex__
decltype(0.0bf16)
2277 __complex_atan(__complex__
decltype(0.0bf16) __z)
2278 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_catanf(__z)); }
2280 inline __complex__
decltype(0.0bf16)
2281 __complex_acosh(__complex__
decltype(0.0bf16) __z)
2282 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_cacoshf(__z)); }
2284 inline __complex__
decltype(0.0bf16)
2285 __complex_asinh(__complex__
decltype(0.0bf16) __z)
2286 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_casinhf(__z)); }
2288 inline __complex__
decltype(0.0bf16)
2289 __complex_atanh(__complex__
decltype(0.0bf16) __z)
2290 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_catanhf(__z)); }
2294#if _GLIBCXX_USE_C99_COMPLEX_ARC
2295 inline __complex__
float
2296 __complex_acos(__complex__
float __z)
2297 {
return __builtin_cacosf(__z); }
2299 inline __complex__
double
2300 __complex_acos(__complex__
double __z)
2301 {
return __builtin_cacos(__z); }
2303 inline __complex__
long double
2304 __complex_acos(
const __complex__
long double& __z)
2305 {
return __builtin_cacosl(__z); }
2307 template<
typename _Tp>
2310 {
return __complex_acos(__z.__rep()); }
2315 template<
typename _Tp>
2318 {
return __complex_acos(__z); }
2321 template<
typename _Tp>
2326 __t = std::asinh(__t);
2330#if _GLIBCXX_USE_C99_COMPLEX_ARC
2331 inline __complex__
float
2332 __complex_asin(__complex__
float __z)
2333 {
return __builtin_casinf(__z); }
2335 inline __complex__
double
2336 __complex_asin(__complex__
double __z)
2337 {
return __builtin_casin(__z); }
2339 inline __complex__
long double
2340 __complex_asin(
const __complex__
long double& __z)
2341 {
return __builtin_casinl(__z); }
2343 template<
typename _Tp>
2346 {
return __complex_asin(__z.__rep()); }
2351 template<
typename _Tp>
2354 {
return __complex_asin(__z); }
2357 template<
typename _Tp>
2361 const _Tp __r2 = __z.real() * __z.real();
2362 const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
2364 _Tp __num = __z.imag() + _Tp(1.0);
2365 _Tp __den = __z.imag() - _Tp(1.0);
2367 __num = __r2 + __num * __num;
2368 __den = __r2 + __den * __den;
2371 _Tp(0.25) * log(__num / __den));
2374#if _GLIBCXX_USE_C99_COMPLEX_ARC
2375 inline __complex__
float
2376 __complex_atan(__complex__
float __z)
2377 {
return __builtin_catanf(__z); }
2379 inline __complex__
double
2380 __complex_atan(__complex__
double __z)
2381 {
return __builtin_catan(__z); }
2383 inline __complex__
long double
2384 __complex_atan(
const __complex__
long double& __z)
2385 {
return __builtin_catanl(__z); }
2387 template<
typename _Tp>
2390 {
return __complex_atan(__z.__rep()); }
2395 template<
typename _Tp>
2398 {
return __complex_atan(__z); }
2401 template<
typename _Tp>
2407 +
std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
2410#if _GLIBCXX_USE_C99_COMPLEX_ARC
2411 inline __complex__
float
2412 __complex_acosh(__complex__
float __z)
2413 {
return __builtin_cacoshf(__z); }
2415 inline __complex__
double
2416 __complex_acosh(__complex__
double __z)
2417 {
return __builtin_cacosh(__z); }
2419 inline __complex__
long double
2420 __complex_acosh(
const __complex__
long double& __z)
2421 {
return __builtin_cacoshl(__z); }
2423 template<
typename _Tp>
2426 {
return __complex_acosh(__z.__rep()); }
2431 template<
typename _Tp>
2434 {
return __complex_acosh(__z); }
2437 template<
typename _Tp>
2442 * (__z.real() + __z.imag()) + _Tp(1.0),
2443 _Tp(2.0) * __z.real() * __z.imag());
2449#if _GLIBCXX_USE_C99_COMPLEX_ARC
2450 inline __complex__
float
2451 __complex_asinh(__complex__
float __z)
2452 {
return __builtin_casinhf(__z); }
2454 inline __complex__
double
2455 __complex_asinh(__complex__
double __z)
2456 {
return __builtin_casinh(__z); }
2458 inline __complex__
long double
2459 __complex_asinh(
const __complex__
long double& __z)
2460 {
return __builtin_casinhl(__z); }
2462 template<
typename _Tp>
2465 {
return __complex_asinh(__z.__rep()); }
2470 template<
typename _Tp>
2473 {
return __complex_asinh(__z); }
2476 template<
typename _Tp>
2480 const _Tp __i2 = __z.imag() * __z.imag();
2481 const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
2483 _Tp __num = _Tp(1.0) + __z.real();
2484 _Tp __den = _Tp(1.0) - __z.real();
2486 __num = __i2 + __num * __num;
2487 __den = __i2 + __den * __den;
2490 _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
2493#if _GLIBCXX_USE_C99_COMPLEX_ARC
2494 inline __complex__
float
2495 __complex_atanh(__complex__
float __z)
2496 {
return __builtin_catanhf(__z); }
2498 inline __complex__
double
2499 __complex_atanh(__complex__
double __z)
2500 {
return __builtin_catanh(__z); }
2502 inline __complex__
long double
2503 __complex_atanh(
const __complex__
long double& __z)
2504 {
return __builtin_catanhl(__z); }
2506 template<
typename _Tp>
2509 {
return __complex_atanh(__z.__rep()); }
2514 template<
typename _Tp>
2517 {
return __complex_atanh(__z); }
2520 template<
typename _Tp>
2529 template<
typename _Tp>
2530 inline typename __gnu_cxx::__promote<_Tp>::__type
2533 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2534#if (_GLIBCXX11_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
2535 return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
2542 template<
typename _Tp>
2543 _GLIBCXX_CONSTEXPR
inline typename __gnu_cxx::__promote<_Tp>::__type
2547 template<
typename _Tp>
2548 _GLIBCXX20_CONSTEXPR
inline typename __gnu_cxx::__promote<_Tp>::__type
2551 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2552 return __type(__x) * __type(__x);
2555 template<
typename _Tp>
2556 _GLIBCXX_CONSTEXPR
inline typename __gnu_cxx::__promote<_Tp>::__type
2560 template<
typename _Tp,
typename _Up>
2564 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2568 template<
typename _Tp,
typename _Up>
2572 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2576 template<
typename _Tp,
typename _Up>
2580 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2587 template<
typename _Tp>
2591 template<
typename _Tp>
2596#if _GLIBCXX_USE_C99_COMPLEX
2597 inline complex<float>
2598 __complex_proj(
const complex<float>& __z)
2599 {
return __builtin_cprojf(__z.__rep()); }
2601 inline complex<double>
2602 __complex_proj(
const complex<double>& __z)
2603 {
return __builtin_cproj(__z.__rep()); }
2605 inline complex<long double>
2606 __complex_proj(
const complex<long double>& __z)
2607 {
return __builtin_cprojl(__z.__rep()); }
2609#if __cplusplus > 202002L
2610#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2611 inline __complex__ _Float16
2612 __complex_proj(__complex__ _Float16 __z)
2613 {
return static_cast<__complex__ _Float16
>(__builtin_cprojf(__z)); }
2616#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2617 inline __complex__ _Float32
2618 __complex_proj(__complex__ _Float32 __z)
2619 {
return __builtin_cprojf(__z); }
2622#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
2623 inline __complex__ _Float64
2624 __complex_proj(__complex__ _Float64 __z)
2625 {
return __builtin_cproj(__z); }
2628#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
2629 inline __complex__ _Float128
2630 __complex_proj(__complex__ _Float128 __z)
2631 {
return __builtin_cprojl(__z); }
2632#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
2633 inline __complex__ _Float128
2634 __complex_proj(__complex__ _Float128 __z)
2635 {
return __builtin_cprojf128(__z); }
2638#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2639 inline __complex__
decltype(0.0bf16)
2640 __complex_proj(__complex__
decltype(0.0bf16) __z)
2641 {
return static_cast<__complex__ decltype(0.0bf16)
>(__builtin_cprojf(__z)); }
2644 template<
typename _Tp>
2645 requires requires {
typename __complex_type<_Tp>::type; }
2647 __complex_proj(
const complex<_Tp>& __z)
2648 {
return __complex_proj(__z.__rep()); }
2651#elif defined _GLIBCXX_USE_C99_MATH_FUNCS
2652 inline complex<float>
2653 __complex_proj(
const complex<float>& __z)
2655 if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
2656 return complex<float>(__builtin_inff(),
2657 __builtin_copysignf(0.0f, __z.imag()));
2661 inline complex<double>
2662 __complex_proj(
const complex<double>& __z)
2664 if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
2665 return complex<double>(__builtin_inf(),
2666 __builtin_copysign(0.0, __z.imag()));
2670 inline complex<long double>
2671 __complex_proj(
const complex<long double>& __z)
2673 if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
2674 return complex<long double>(__builtin_infl(),
2675 __builtin_copysignl(0.0l, __z.imag()));
2680 template<
typename _Tp>
2683 {
return __complex_proj(__z); }
2686 template<
typename _Tp>
2690 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2694 template<
typename _Tp>
2695 inline _GLIBCXX20_CONSTEXPR
2699 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2703#ifdef __cpp_lib_complex_udls
2705inline namespace literals {
2706inline namespace complex_literals {
2707#pragma GCC diagnostic push
2708#pragma GCC diagnostic ignored "-Wliteral-suffix"
2710 constexpr std::complex<float>
2711 operator""if(
long double __num)
2712 {
return std::complex<float>{0.0F,
static_cast<float>(__num)}; }
2714 constexpr std::complex<float>
2715 operator""if(
unsigned long long __num)
2716 {
return std::complex<float>{0.0F,
static_cast<float>(__num)}; }
2718 constexpr std::complex<double>
2719 operator""i(
long double __num)
2720 {
return std::complex<double>{0.0,
static_cast<double>(__num)}; }
2722 constexpr std::complex<double>
2723 operator""i(
unsigned long long __num)
2724 {
return std::complex<double>{0.0,
static_cast<double>(__num)}; }
2726 constexpr std::complex<long double>
2727 operator""il(
long double __num)
2728 {
return std::complex<long double>{0.0L, __num}; }
2730 constexpr std::complex<long double>
2731 operator""il(
unsigned long long __num)
2732 {
return std::complex<long double>{0.0L,
static_cast<long double>(__num)}; }
2734#pragma GCC diagnostic pop
2740_GLIBCXX_END_NAMESPACE_VERSION
2745#ifdef _GLIBCXX_CLANG
2746#pragma clang diagnostic pop
2749#pragma GCC diagnostic pop
complex< _Tp > log10(const complex< _Tp > &)
Return complex base 10 logarithm of z.
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
complex< _Tp > sin(const complex< _Tp > &)
Return complex sine of z.
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
constexpr complex< _Tp > & operator*=(const _Tp &)
Multiply this complex number by a scalar.
complex< _Tp > log(const complex< _Tp > &)
Return complex natural logarithm of z.
complex< _Tp > tan(const complex< _Tp > &)
Return complex tangent of z.
complex< _Tp > polar(const _Tp &, const _Tp &=0)
Return complex with magnitude rho and angle theta.
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
_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.
_Tp arg(const complex< _Tp > &)
Return phase angle of z.
constexpr complex< _Tp > & operator=(const _Tp &)
Assign a scalar to this complex number.
complex< _Tp > tanh(const complex< _Tp > &)
Return complex hyperbolic tangent of z.
constexpr complex< _Tp > conj(const complex< _Tp > &)
Return complex conjugate of z.
complex< _Tp > pow(const complex< _Tp > &, int)
Return x to the y'th power.
constexpr complex< _Tp > operator/(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x divided by y.
complex< _Tp > sinh(const complex< _Tp > &)
Return complex hyperbolic sine of z.
_Tp constexpr norm(const complex< _Tp > &)
Return z magnitude squared.
constexpr complex< _Tp > & operator/=(const _Tp &)
Divide this complex number by a scalar.
complex< _Tp > cos(const complex< _Tp > &)
Return complex cosine of z.
complex< _Tp > sqrt(const complex< _Tp > &)
Return complex square root of z.
basic_ostream< char > ostream
Base class for char output streams.
basic_istream< char > istream
Base class for char input streams.
basic_ostream< wchar_t > wostream
Base class for wchar_t output streams.
basic_istream< wchar_t > wistream
Base class for wchar_t input streams.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
ISO C++ entities toplevel namespace is std.
_Tp fabs(const std::complex< _Tp > &)
fabs(__z) [8.1.8].
std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, bitset< _Nb > &__x)
Global I/O operators for bitsets.
std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const bitset< _Nb > &__x)
Global I/O operators for bitsets.
_Tp value_type
Value typedef.
constexpr complex(const _Tp &__r=_Tp(), const _Tp &__i=_Tp())
Default constructor. First parameter is x, second parameter is y. Unspecified parameters default to 0...
constexpr complex(const complex< _Up > &__z)
Converting constructor.
constexpr complex< _Tp > & operator-=(const _Tp &__t)
Subtract a scalar from this complex number.
constexpr complex< _Tp > & operator+=(const _Tp &__t)
Add a scalar to this complex number.
void setstate(iostate __state)
Sets additional flags in the error state.
char_type widen(char __c) const
Widens characters.
Template class basic_istream.
__istream_type & putback(char_type __c)
Unextracting a single character.
fmtflags flags() const
Access to format flags.
static const iostate failbit
Indicates that an input operation failed to read the expected characters, or that an output operation...
Finds the size of a given tuple type.
Gives the type of the ith element of a given tuple type.