libstdc++
complex
Go to the documentation of this file.
1 // The template and inlines for the -*- C++ -*- complex number classes.
2 
3 // Copyright (C) 1997-2025 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file include/complex
26  * This is a Standard C++ Library header.
27  */
28 
29 //
30 // ISO C++ 14882: 26.2 Complex Numbers
31 // Note: this is not a conforming implementation.
32 // Initially implemented by Ulrich Drepper <drepper@cygnus.com>
33 // Improved by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
34 //
35 
36 #ifndef _GLIBCXX_COMPLEX
37 #define _GLIBCXX_COMPLEX 1
38 
39 #ifdef _GLIBCXX_SYSHDR
40 #pragma GCC system_header
41 #endif
42 
43 #pragma GCC diagnostic push
44 #pragma GCC diagnostic ignored "-Wc++11-extensions" // extern template
45 
46 #include <bits/c++config.h>
47 #include <bits/cpp_type_traits.h>
48 #include <ext/type_traits.h>
49 #include <cmath>
50 #include <sstream>
51 
52 // Get rid of a macro possibly defined in <complex.h>
53 #undef complex
54 
55 #ifdef _GLIBCXX_CLANG
56 #pragma clang diagnostic push
57 #pragma clang diagnostic ignored "-Wc99-extensions"
58 #endif
59 
60 #define __glibcxx_want_constexpr_complex
61 #define __glibcxx_want_complex_udls
62 #define __glibcxx_want_tuple_like
63 #include <bits/version.h>
64 
65 #if __glibcxx_tuple_like >= 202311 // >= C++26
66 # include <bits/utility.h> // for tuple_element_t
67 # include <bits/stl_pair.h> // for __is_tuple_like_v
68 #endif
69 
70 namespace std _GLIBCXX_VISIBILITY(default)
71 {
72 _GLIBCXX_BEGIN_NAMESPACE_VERSION
73 
74  /**
75  * @defgroup complex_numbers Complex Numbers
76  * @ingroup numerics
77  *
78  * Classes and functions for complex numbers.
79  * @{
80  */
81 
82  // Forward declarations.
83  template<typename _Tp> class complex;
84  template<> class complex<float>;
85  template<> class complex<double>;
86  template<> class complex<long double>;
87 
88  /// Return magnitude of @a z.
89  template<typename _Tp> _Tp abs(const complex<_Tp>&);
90  /// Return phase angle of @a z.
91  template<typename _Tp> _Tp arg(const complex<_Tp>&);
92  /// Return @a z magnitude squared.
93  template<typename _Tp> _Tp _GLIBCXX20_CONSTEXPR norm(const complex<_Tp>&);
94 
95  /// Return complex conjugate of @a z.
96  template<typename _Tp>
97  _GLIBCXX20_CONSTEXPR complex<_Tp> conj(const complex<_Tp>&);
98  /// Return complex with magnitude @a rho and angle @a theta.
99  template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
100 
101  // Transcendentals:
102  /// Return complex cosine of @a z.
103  template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
104  /// Return complex hyperbolic cosine of @a z.
105  template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
106  /// Return complex base e exponential of @a z.
107  template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
108  /// Return complex natural logarithm of @a z.
109  template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
110  /// Return complex base 10 logarithm of @a z.
111  template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
112  /// Return @a x to the @a y'th power.
113  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
114  /// Return @a x to the @a y'th power.
115  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
116  /// Return @a x to the @a y'th power.
117  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
118  const complex<_Tp>&);
119  /// Return @a x to the @a y'th power.
120  template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
121  /// Return complex sine of @a z.
122  template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
123  /// Return complex hyperbolic sine of @a z.
124  template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
125  /// Return complex square root of @a z.
126  template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
127  /// Return complex tangent of @a z.
128  template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
129  /// Return complex hyperbolic tangent of @a z.
130  template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
131 
132 #if __glibcxx_tuple_like >= 202311L // >= C++26
133  template<typename _Tp>
134  struct tuple_size<complex<_Tp>>
135  : public integral_constant<size_t, 2> { };
136  template<typename _Tp>
137  struct tuple_element<0, complex<_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;
144 #endif // __glibcxx_tuple_like >= 202311
145 
146  // 26.2.2 Primary template class complex
147  /**
148  * Template to represent complex numbers.
149  *
150  * Specializations for float, double, and long double are part of the
151  * library. Results with any other type are not guaranteed.
152  *
153  * @param Tp Type of real and imaginary values.
154  */
155  template<typename _Tp>
156  class complex
157  {
158  public:
159  /// Value typedef.
160  typedef _Tp value_type;
161 
162  /// Default constructor. First parameter is x, second parameter is y.
163  /// Unspecified parameters default to 0.
164  _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
165  : _M_real(__r), _M_imag(__i) { }
166 
167  // Let the compiler synthesize the copy constructor
168 #if __cplusplus >= 201103L
169  constexpr complex(const complex&) = default;
170 #endif
171 
172  /// Converting constructor.
173  template<typename _Up>
174 #if __cplusplus > 202002L
175  explicit(!requires(_Up __u) { _Tp{__u}; })
176 #endif
177  _GLIBCXX_CONSTEXPR complex(const complex<_Up>& __z)
178  : _M_real(_Tp(__z.real())), _M_imag(_Tp(__z.imag())) { }
179 
180 #if __cplusplus >= 201103L
181  // _GLIBCXX_RESOLVE_LIB_DEFECTS
182  // DR 387. std::complex over-encapsulated.
183  _GLIBCXX_ABI_TAG_CXX11
184  constexpr _Tp
185  real() const { return _M_real; }
186 
187  _GLIBCXX_ABI_TAG_CXX11
188  constexpr _Tp
189  imag() const { return _M_imag; }
190 #else
191  /// Return real part of complex number.
192  _Tp&
193  real() { return _M_real; }
194 
195  /// Return real part of complex number.
196  const _Tp&
197  real() const { return _M_real; }
198 
199  /// Return imaginary part of complex number.
200  _Tp&
201  imag() { return _M_imag; }
202 
203  /// Return imaginary part of complex number.
204  const _Tp&
205  imag() const { return _M_imag; }
206 #endif
207 
208  // _GLIBCXX_RESOLVE_LIB_DEFECTS
209  // DR 387. std::complex over-encapsulated.
210  _GLIBCXX20_CONSTEXPR void
211  real(_Tp __val) { _M_real = __val; }
212 
213  _GLIBCXX20_CONSTEXPR void
214  imag(_Tp __val) { _M_imag = __val; }
215 
216  /// Assign a scalar to this complex number.
217  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator=(const _Tp&);
218 
219  /// Add a scalar to this complex number.
220  // 26.2.5/1
221  _GLIBCXX20_CONSTEXPR complex<_Tp>&
222  operator+=(const _Tp& __t)
223  {
224  _M_real += __t;
225  return *this;
226  }
227 
228  /// Subtract a scalar from this complex number.
229  // 26.2.5/3
230  _GLIBCXX20_CONSTEXPR complex<_Tp>&
231  operator-=(const _Tp& __t)
232  {
233  _M_real -= __t;
234  return *this;
235  }
236 
237  /// Multiply this complex number by a scalar.
238  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator*=(const _Tp&);
239  /// Divide this complex number by a scalar.
240  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator/=(const _Tp&);
241 
242  // Let the compiler synthesize the copy assignment operator
243 #if __cplusplus >= 201103L
244  _GLIBCXX20_CONSTEXPR complex& operator=(const complex&) = default;
245 #endif
246 
247  /// Assign another complex number to this one.
248  template<typename _Up>
249  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator=(const complex<_Up>&);
250  /// Add another complex number to this one.
251  template<typename _Up>
252  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator+=(const complex<_Up>&);
253  /// Subtract another complex number from this one.
254  template<typename _Up>
255  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator-=(const complex<_Up>&);
256  /// Multiply this complex number by another.
257  template<typename _Up>
258  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator*=(const complex<_Up>&);
259  /// Divide this complex number by another.
260  template<typename _Up>
261  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator/=(const complex<_Up>&);
262 
263  _GLIBCXX_CONSTEXPR complex __rep() const
264  { return *this; }
265 
266 #if __glibcxx_tuple_like >= 202311L // >= C++26
267  template<typename _Cp>
268  [[__gnu__::__always_inline__]]
269  constexpr auto&
270  __get_part(this _Cp& __z, size_t __i) noexcept
271  {
272  return __i == 0 ? __z._M_real : __z._M_imag;
273  }
274 #endif
275 
276  private:
277  _Tp _M_real;
278  _Tp _M_imag;
279  };
280 
281  template<typename _Tp>
282  _GLIBCXX20_CONSTEXPR complex<_Tp>&
283  complex<_Tp>::operator=(const _Tp& __t)
284  {
285  _M_real = __t;
286  _M_imag = _Tp();
287  return *this;
288  }
289 
290  // 26.2.5/5
291  template<typename _Tp>
292  _GLIBCXX20_CONSTEXPR complex<_Tp>&
293  complex<_Tp>::operator*=(const _Tp& __t)
294  {
295  _M_real *= __t;
296  _M_imag *= __t;
297  return *this;
298  }
299 
300  // 26.2.5/7
301  template<typename _Tp>
302  _GLIBCXX20_CONSTEXPR complex<_Tp>&
303  complex<_Tp>::operator/=(const _Tp& __t)
304  {
305  _M_real /= __t;
306  _M_imag /= __t;
307  return *this;
308  }
309 
310  template<typename _Tp>
311  template<typename _Up>
312  _GLIBCXX20_CONSTEXPR complex<_Tp>&
313  complex<_Tp>::operator=(const complex<_Up>& __z)
314  {
315  _M_real = __z.real();
316  _M_imag = __z.imag();
317  return *this;
318  }
319 
320  // 26.2.5/9
321  template<typename _Tp>
322  template<typename _Up>
323  _GLIBCXX20_CONSTEXPR complex<_Tp>&
324  complex<_Tp>::operator+=(const complex<_Up>& __z)
325  {
326  _M_real += __z.real();
327  _M_imag += __z.imag();
328  return *this;
329  }
330 
331  // 26.2.5/11
332  template<typename _Tp>
333  template<typename _Up>
334  _GLIBCXX20_CONSTEXPR complex<_Tp>&
335  complex<_Tp>::operator-=(const complex<_Up>& __z)
336  {
337  _M_real -= __z.real();
338  _M_imag -= __z.imag();
339  return *this;
340  }
341 
342  // 26.2.5/13
343  // XXX: This is a grammar school implementation.
344  template<typename _Tp>
345  template<typename _Up>
346  _GLIBCXX20_CONSTEXPR complex<_Tp>&
347  complex<_Tp>::operator*=(const complex<_Up>& __z)
348  {
349  const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
350  _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
351  _M_real = __r;
352  return *this;
353  }
354 
355  // 26.2.5/15
356  // XXX: This is a grammar school implementation.
357  template<typename _Tp>
358  template<typename _Up>
359  _GLIBCXX20_CONSTEXPR complex<_Tp>&
360  complex<_Tp>::operator/=(const complex<_Up>& __z)
361  {
362  const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
363  const _Tp __n = std::norm(__z);
364  _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
365  _M_real = __r / __n;
366  return *this;
367  }
368 
369  // Operators:
370  ///@{
371  /// Return new complex value @a x plus @a y.
372  template<typename _Tp>
373  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
374  operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
375  {
376  complex<_Tp> __r = __x;
377  __r += __y;
378  return __r;
379  }
380 
381  template<typename _Tp>
382  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
383  operator+(const complex<_Tp>& __x, const _Tp& __y)
384  {
385  complex<_Tp> __r = __x;
386  __r += __y;
387  return __r;
388  }
389 
390  template<typename _Tp>
391  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
392  operator+(const _Tp& __x, const complex<_Tp>& __y)
393  {
394  complex<_Tp> __r = __y;
395  __r += __x;
396  return __r;
397  }
398  ///@}
399 
400  ///@{
401  /// Return new complex value @a x minus @a y.
402  template<typename _Tp>
403  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
404  operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
405  {
406  complex<_Tp> __r = __x;
407  __r -= __y;
408  return __r;
409  }
410 
411  template<typename _Tp>
412  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
413  operator-(const complex<_Tp>& __x, const _Tp& __y)
414  {
415  complex<_Tp> __r = __x;
416  __r -= __y;
417  return __r;
418  }
419 
420  template<typename _Tp>
421  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
422  operator-(const _Tp& __x, const complex<_Tp>& __y)
423  {
424  complex<_Tp> __r = -__y;
425  __r += __x;
426  return __r;
427  }
428  ///@}
429 
430  ///@{
431  /// Return new complex value @a x times @a y.
432  template<typename _Tp>
433  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
434  operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
435  {
436  complex<_Tp> __r = __x;
437  __r *= __y;
438  return __r;
439  }
440 
441  template<typename _Tp>
442  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
443  operator*(const complex<_Tp>& __x, const _Tp& __y)
444  {
445  complex<_Tp> __r = __x;
446  __r *= __y;
447  return __r;
448  }
449 
450  template<typename _Tp>
451  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
452  operator*(const _Tp& __x, const complex<_Tp>& __y)
453  {
454  complex<_Tp> __r = __y;
455  __r *= __x;
456  return __r;
457  }
458  ///@}
459 
460  ///@{
461  /// Return new complex value @a x divided by @a y.
462  template<typename _Tp>
463  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
464  operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
465  {
466  complex<_Tp> __r = __x;
467  __r /= __y;
468  return __r;
469  }
470 
471  template<typename _Tp>
472  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
473  operator/(const complex<_Tp>& __x, const _Tp& __y)
474  {
475  complex<_Tp> __r = __x;
476  __r /= __y;
477  return __r;
478  }
479 
480  template<typename _Tp>
481  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
482  operator/(const _Tp& __x, const complex<_Tp>& __y)
483  {
484  complex<_Tp> __r = __x;
485  __r /= __y;
486  return __r;
487  }
488  ///@}
489 
490  /// Return @a x.
491  template<typename _Tp>
492  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
493  operator+(const complex<_Tp>& __x)
494  { return __x; }
495 
496  /// Return complex negation of @a x.
497  template<typename _Tp>
498  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
499  operator-(const complex<_Tp>& __x)
500  { return complex<_Tp>(-__x.real(), -__x.imag()); }
501 
502  ///@{
503  /// Return true if @a x is equal to @a y.
504  template<typename _Tp>
505  inline _GLIBCXX_CONSTEXPR bool
506  operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
507  { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
508 
509  template<typename _Tp>
510  inline _GLIBCXX_CONSTEXPR bool
511  operator==(const complex<_Tp>& __x, const _Tp& __y)
512  { return __x.real() == __y && __x.imag() == _Tp(); }
513 
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(); }
519  ///@}
520 
521  ///@{
522  /// Return false if @a x is equal to @a y.
523  template<typename _Tp>
524  inline _GLIBCXX_CONSTEXPR bool
525  operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
526  { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
527 
528  template<typename _Tp>
529  inline _GLIBCXX_CONSTEXPR bool
530  operator!=(const complex<_Tp>& __x, const _Tp& __y)
531  { return __x.real() != __y || __x.imag() != _Tp(); }
532 
533  template<typename _Tp>
534  inline _GLIBCXX_CONSTEXPR bool
535  operator!=(const _Tp& __x, const complex<_Tp>& __y)
536  { return __x != __y.real() || _Tp() != __y.imag(); }
537 #endif
538  ///@}
539 
540  /// Extraction operator for complex values.
541  template<typename _Tp, typename _CharT, class _Traits>
542  basic_istream<_CharT, _Traits>&
543  operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
544  {
545  bool __fail = true;
546  _CharT __ch;
547  if (__is >> __ch)
548  {
549  if (_Traits::eq(__ch, __is.widen('(')))
550  {
551  _Tp __u;
552  if (__is >> __u >> __ch)
553  {
554  const _CharT __rparen = __is.widen(')');
555  if (_Traits::eq(__ch, __rparen))
556  {
557  __x = __u;
558  __fail = false;
559  }
560  else if (_Traits::eq(__ch, __is.widen(',')))
561  {
562  _Tp __v;
563  if (__is >> __v >> __ch)
564  {
565  if (_Traits::eq(__ch, __rparen))
566  {
567  __x = complex<_Tp>(__u, __v);
568  __fail = false;
569  }
570  else
571  __is.putback(__ch);
572  }
573  }
574  else
575  __is.putback(__ch);
576  }
577  }
578  else
579  {
580  __is.putback(__ch);
581  _Tp __u;
582  if (__is >> __u)
583  {
584  __x = __u;
585  __fail = false;
586  }
587  }
588  }
589  if (__fail)
590  __is.setstate(ios_base::failbit);
591  return __is;
592  }
593 
594  /// Insertion operator for complex values.
595  template<typename _Tp, typename _CharT, class _Traits>
596  basic_ostream<_CharT, _Traits>&
597  operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
598  {
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();
605  }
606 
607  // Values
608 #if __cplusplus >= 201103L
609  template<typename _Tp>
610  constexpr _Tp
611  real(const complex<_Tp>& __z)
612  { return __z.real(); }
613 
614  template<typename _Tp>
615  constexpr _Tp
616  imag(const complex<_Tp>& __z)
617  { return __z.imag(); }
618 #else
619  template<typename _Tp>
620  inline _Tp&
621  real(complex<_Tp>& __z)
622  { return __z.real(); }
623 
624  template<typename _Tp>
625  inline const _Tp&
626  real(const complex<_Tp>& __z)
627  { return __z.real(); }
628 
629  template<typename _Tp>
630  inline _Tp&
631  imag(complex<_Tp>& __z)
632  { return __z.imag(); }
633 
634  template<typename _Tp>
635  inline const _Tp&
636  imag(const complex<_Tp>& __z)
637  { return __z.imag(); }
638 #endif
639 
640 #if __glibcxx_tuple_like >= 202311L // >= C++26
641  template<size_t _Int, typename _Tp>
642  [[nodiscard,__gnu__::__always_inline__]]
643  constexpr _Tp&
644  get(complex<_Tp>& __z) noexcept
645  {
646  static_assert(_Int < 2);
647  return __z.__get_part(_Int);
648  }
649 
650  template<size_t _Int, typename _Tp>
651  [[nodiscard,__gnu__::__always_inline__]]
652  constexpr _Tp&&
653  get(complex<_Tp>&& __z) noexcept
654  {
655  static_assert(_Int < 2);
656  return std::move(__z.__get_part(_Int));
657  }
658 
659  template<size_t _Int, typename _Tp>
660  [[nodiscard,__gnu__::__always_inline__]]
661  constexpr const _Tp&
662  get(const complex<_Tp>& __z) noexcept
663  {
664  static_assert(_Int < 2);
665  return __z.__get_part(_Int);
666  }
667 
668  template<size_t _Int, typename _Tp>
669  [[nodiscard,__gnu__::__always_inline__]]
670  constexpr const _Tp&&
671  get(const complex<_Tp>&& __z) noexcept
672  {
673  static_assert(_Int < 2);
674  return std::move(__z.__get_part(_Int));
675  }
676 #endif // __glibcxx_tuple_like >= 202311
677 
678 #if _GLIBCXX_USE_C99_COMPLEX
679 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
680  inline _Float16
681  __complex_abs(__complex__ _Float16 __z)
682  { return _Float16(__builtin_cabsf(__z)); }
683 
684  inline _Float16
685  __complex_arg(__complex__ _Float16 __z)
686  { return _Float16(__builtin_cargf(__z)); }
687 
688  inline __complex__ _Float16
689  __complex_cos(__complex__ _Float16 __z)
690  { return static_cast<__complex__ _Float16>(__builtin_ccosf(__z)); }
691 
692  inline __complex__ _Float16
693  __complex_cosh(__complex__ _Float16 __z)
694  { return static_cast<__complex__ _Float16>(__builtin_ccoshf(__z)); }
695 
696  inline __complex__ _Float16
697  __complex_exp(__complex__ _Float16 __z)
698  { return static_cast<__complex__ _Float16>(__builtin_cexpf(__z)); }
699 
700  inline __complex__ _Float16
701  __complex_log(__complex__ _Float16 __z)
702  { return static_cast<__complex__ _Float16>(__builtin_clogf(__z)); }
703 
704  inline __complex__ _Float16
705  __complex_sin(__complex__ _Float16 __z)
706  { return static_cast<__complex__ _Float16>(__builtin_csinf(__z)); }
707 
708  inline __complex__ _Float16
709  __complex_sinh(__complex__ _Float16 __z)
710  { return static_cast<__complex__ _Float16>(__builtin_csinhf(__z)); }
711 
712  inline __complex__ _Float16
713  __complex_sqrt(__complex__ _Float16 __z)
714  { return static_cast<__complex__ _Float16>(__builtin_csqrtf(__z)); }
715 
716  inline __complex__ _Float16
717  __complex_tan(__complex__ _Float16 __z)
718  { return static_cast<__complex__ _Float16>(__builtin_ctanf(__z)); }
719 
720  inline __complex__ _Float16
721  __complex_tanh(__complex__ _Float16 __z)
722  { return static_cast<__complex__ _Float16>(__builtin_ctanhf(__z)); }
723 
724  inline __complex__ _Float16
725  __complex_pow(__complex__ _Float16 __x, __complex__ _Float16 __y)
726  { return static_cast<__complex__ _Float16>(__builtin_cpowf(__x, __y)); }
727 #endif
728 
729 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
730  inline _Float32
731  __complex_abs(__complex__ _Float32 __z) { return __builtin_cabsf(__z); }
732 
733  inline _Float32
734  __complex_arg(__complex__ _Float32 __z) { return __builtin_cargf(__z); }
735 
736  inline __complex__ _Float32
737  __complex_cos(__complex__ _Float32 __z) { return __builtin_ccosf(__z); }
738 
739  inline __complex__ _Float32
740  __complex_cosh(__complex__ _Float32 __z) { return __builtin_ccoshf(__z); }
741 
742  inline __complex__ _Float32
743  __complex_exp(__complex__ _Float32 __z) { return __builtin_cexpf(__z); }
744 
745  inline __complex__ _Float32
746  __complex_log(__complex__ _Float32 __z) { return __builtin_clogf(__z); }
747 
748  inline __complex__ _Float32
749  __complex_sin(__complex__ _Float32 __z) { return __builtin_csinf(__z); }
750 
751  inline __complex__ _Float32
752  __complex_sinh(__complex__ _Float32 __z) { return __builtin_csinhf(__z); }
753 
754  inline __complex__ _Float32
755  __complex_sqrt(__complex__ _Float32 __z) { return __builtin_csqrtf(__z); }
756 
757  inline __complex__ _Float32
758  __complex_tan(__complex__ _Float32 __z) { return __builtin_ctanf(__z); }
759 
760  inline __complex__ _Float32
761  __complex_tanh(__complex__ _Float32 __z) { return __builtin_ctanhf(__z); }
762 
763  inline __complex__ _Float32
764  __complex_pow(__complex__ _Float32 __x, __complex__ _Float32 __y)
765  { return __builtin_cpowf(__x, __y); }
766 #endif
767 
768 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
769  inline _Float64
770  __complex_abs(__complex__ _Float64 __z) { return __builtin_cabs(__z); }
771 
772  inline _Float64
773  __complex_arg(__complex__ _Float64 __z) { return __builtin_carg(__z); }
774 
775  inline __complex__ _Float64
776  __complex_cos(__complex__ _Float64 __z) { return __builtin_ccos(__z); }
777 
778  inline __complex__ _Float64
779  __complex_cosh(__complex__ _Float64 __z) { return __builtin_ccosh(__z); }
780 
781  inline __complex__ _Float64
782  __complex_exp(__complex__ _Float64 __z) { return __builtin_cexp(__z); }
783 
784  inline __complex__ _Float64
785  __complex_log(__complex__ _Float64 __z) { return __builtin_clog(__z); }
786 
787  inline __complex__ _Float64
788  __complex_sin(__complex__ _Float64 __z) { return __builtin_csin(__z); }
789 
790  inline __complex__ _Float64
791  __complex_sinh(__complex__ _Float64 __z) { return __builtin_csinh(__z); }
792 
793  inline __complex__ _Float64
794  __complex_sqrt(__complex__ _Float64 __z) { return __builtin_csqrt(__z); }
795 
796  inline __complex__ _Float64
797  __complex_tan(__complex__ _Float64 __z) { return __builtin_ctan(__z); }
798 
799  inline __complex__ _Float64
800  __complex_tanh(__complex__ _Float64 __z) { return __builtin_ctanh(__z); }
801 
802  inline __complex__ _Float64
803  __complex_pow(__complex__ _Float64 __x, __complex__ _Float64 __y)
804  { return __builtin_cpow(__x, __y); }
805 #endif
806 
807 #if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
808  inline _Float128
809  __complex_abs(__complex__ _Float128 __z) { return __builtin_cabsl(__z); }
810 
811  inline _Float128
812  __complex_arg(__complex__ _Float128 __z) { return __builtin_cargl(__z); }
813 
814  inline __complex__ _Float128
815  __complex_cos(__complex__ _Float128 __z) { return __builtin_ccosl(__z); }
816 
817  inline __complex__ _Float128
818  __complex_cosh(__complex__ _Float128 __z) { return __builtin_ccoshl(__z); }
819 
820  inline __complex__ _Float128
821  __complex_exp(__complex__ _Float128 __z) { return __builtin_cexpl(__z); }
822 
823  inline __complex__ _Float128
824  __complex_log(__complex__ _Float128 __z) { return __builtin_clogl(__z); }
825 
826  inline __complex__ _Float128
827  __complex_sin(__complex__ _Float128 __z) { return __builtin_csinl(__z); }
828 
829  inline __complex__ _Float128
830  __complex_sinh(__complex__ _Float128 __z) { return __builtin_csinhl(__z); }
831 
832  inline __complex__ _Float128
833  __complex_sqrt(__complex__ _Float128 __z) { return __builtin_csqrtl(__z); }
834 
835  inline __complex__ _Float128
836  __complex_tan(__complex__ _Float128 __z) { return __builtin_ctanl(__z); }
837 
838  inline __complex__ _Float128
839  __complex_tanh(__complex__ _Float128 __z) { return __builtin_ctanhl(__z); }
840 
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)
845  inline _Float128
846  __complex_abs(__complex__ _Float128 __z) { return __builtin_cabsf128(__z); }
847 
848  inline _Float128
849  __complex_arg(__complex__ _Float128 __z) { return __builtin_cargf128(__z); }
850 
851  inline __complex__ _Float128
852  __complex_cos(__complex__ _Float128 __z) { return __builtin_ccosf128(__z); }
853 
854  inline __complex__ _Float128
855  __complex_cosh(__complex__ _Float128 __z) { return __builtin_ccoshf128(__z); }
856 
857  inline __complex__ _Float128
858  __complex_exp(__complex__ _Float128 __z) { return __builtin_cexpf128(__z); }
859 
860  inline __complex__ _Float128
861  __complex_log(__complex__ _Float128 __z) { return __builtin_clogf128(__z); }
862 
863  inline __complex__ _Float128
864  __complex_sin(__complex__ _Float128 __z) { return __builtin_csinf128(__z); }
865 
866  inline __complex__ _Float128
867  __complex_sinh(__complex__ _Float128 __z) { return __builtin_csinhf128(__z); }
868 
869  inline __complex__ _Float128
870  __complex_sqrt(__complex__ _Float128 __z) { return __builtin_csqrtf128(__z); }
871 
872  inline __complex__ _Float128
873  __complex_tan(__complex__ _Float128 __z) { return __builtin_ctanf128(__z); }
874 
875  inline __complex__ _Float128
876  __complex_tanh(__complex__ _Float128 __z) { return __builtin_ctanhf128(__z); }
877 
878  inline __complex__ _Float128
879  __complex_pow(__complex__ _Float128 __x, __complex__ _Float128 __y)
880  { return __builtin_cpowf128(__x, __y); }
881 #endif
882 
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)); }
887 
888  inline __gnu_cxx::__bfloat16_t
889  __complex_arg(__complex__ decltype(0.0bf16) __z)
890  { return __gnu_cxx::__bfloat16_t(__builtin_cargf(__z)); }
891 
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)); }
895 
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)); }
899 
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)); }
903 
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)); }
907 
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)); }
911 
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)); }
915 
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)); }
919 
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)); }
923 
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)); }
927 
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,
932  __y)); }
933 #endif
934 #endif
935 
936  // 26.2.7/3 abs(__z): Returns the magnitude of __z.
937  template<typename _Tp>
938  inline _Tp
939  __complex_abs(const complex<_Tp>& __z)
940  {
941  _Tp __x = __z.real();
942  _Tp __y = __z.imag();
943  const _Tp __s = std::max(abs(__x), abs(__y));
944  if (__s == _Tp()) // well ...
945  return __s;
946  __x /= __s;
947  __y /= __s;
948  return __s * sqrt(__x * __x + __y * __y);
949  }
950 
951 #if _GLIBCXX_USE_C99_COMPLEX
952  inline float
953  __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
954 
955  inline double
956  __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
957 
958  inline long double
959  __complex_abs(const __complex__ long double& __z)
960  { return __builtin_cabsl(__z); }
961 
962  template<typename _Tp>
963  inline _Tp
964  abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
965 #else
966  template<typename _Tp>
967  inline _Tp
968  abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
969 #endif
970 
971 
972  // 26.2.7/4: arg(__z): Returns the phase angle of __z.
973  template<typename _Tp>
974  inline _Tp
975  __complex_arg(const complex<_Tp>& __z)
976  { return atan2(__z.imag(), __z.real()); }
977 
978 #if _GLIBCXX_USE_C99_COMPLEX
979  inline float
980  __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
981 
982  inline double
983  __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
984 
985  inline long double
986  __complex_arg(const __complex__ long double& __z)
987  { return __builtin_cargl(__z); }
988 
989  template<typename _Tp>
990  inline _Tp
991  arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
992 #else
993  template<typename _Tp>
994  inline _Tp
995  arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
996 #endif
997 
998  // 26.2.7/5: norm(__z) returns the squared magnitude of __z.
999  // As defined, norm() is -not- a norm is the common mathematical
1000  // sense used in numerics. The helper class _Norm_helper<> tries to
1001  // distinguish between builtin floating point and the rest, so as
1002  // to deliver an answer as close as possible to the real value.
1003  template<bool>
1004  struct _Norm_helper
1005  {
1006  template<typename _Tp>
1007  static inline _GLIBCXX20_CONSTEXPR _Tp _S_do_it(const complex<_Tp>& __z)
1008  {
1009  const _Tp __x = __z.real();
1010  const _Tp __y = __z.imag();
1011  return __x * __x + __y * __y;
1012  }
1013  };
1014 
1015  template<>
1016  struct _Norm_helper<true>
1017  {
1018  template<typename _Tp>
1019  static inline _GLIBCXX20_CONSTEXPR _Tp _S_do_it(const complex<_Tp>& __z)
1020  {
1021  //_Tp __res = std::abs(__z);
1022  //return __res * __res;
1023  const _Tp __x = __z.real();
1024  const _Tp __y = __z.imag();
1025  return __x * __x + __y * __y;
1026  }
1027  };
1028 
1029  template<typename _Tp>
1030  inline _GLIBCXX20_CONSTEXPR _Tp
1031  norm(const complex<_Tp>& __z)
1032  {
1033  return _Norm_helper<__is_floating<_Tp>::__value
1034  && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
1035  }
1036 
1037  template<typename _Tp>
1038  inline complex<_Tp>
1039  polar(const _Tp& __rho, const _Tp& __theta)
1040  {
1041  __glibcxx_assert( __rho >= 0 );
1042  return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta));
1043  }
1044 
1045  template<typename _Tp>
1046  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
1047  conj(const complex<_Tp>& __z)
1048  { return complex<_Tp>(__z.real(), -__z.imag()); }
1049 
1050  // Transcendentals
1051 
1052  // 26.2.8/1 cos(__z): Returns the cosine of __z.
1053  template<typename _Tp>
1054  inline complex<_Tp>
1055  __complex_cos(const complex<_Tp>& __z)
1056  {
1057  const _Tp __x = __z.real();
1058  const _Tp __y = __z.imag();
1059  return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
1060  }
1061 
1062 #if _GLIBCXX_USE_C99_COMPLEX
1063  inline __complex__ float
1064  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
1065 
1066  inline __complex__ double
1067  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
1068 
1069  inline __complex__ long double
1070  __complex_cos(const __complex__ long double& __z)
1071  { return __builtin_ccosl(__z); }
1072 
1073  template<typename _Tp>
1074  inline complex<_Tp>
1075  cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
1076 #else
1077  template<typename _Tp>
1078  inline complex<_Tp>
1079  cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
1080 #endif
1081 
1082  // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
1083  template<typename _Tp>
1084  inline complex<_Tp>
1085  __complex_cosh(const complex<_Tp>& __z)
1086  {
1087  const _Tp __x = __z.real();
1088  const _Tp __y = __z.imag();
1089  return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
1090  }
1091 
1092 #if _GLIBCXX_USE_C99_COMPLEX
1093  inline __complex__ float
1094  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
1095 
1096  inline __complex__ double
1097  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
1098 
1099  inline __complex__ long double
1100  __complex_cosh(const __complex__ long double& __z)
1101  { return __builtin_ccoshl(__z); }
1102 
1103  template<typename _Tp>
1104  inline complex<_Tp>
1105  cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
1106 #else
1107  template<typename _Tp>
1108  inline complex<_Tp>
1109  cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
1110 #endif
1111 
1112  // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
1113  template<typename _Tp>
1114  inline complex<_Tp>
1115  __complex_exp(const complex<_Tp>& __z)
1116  { return std::polar<_Tp>(exp(__z.real()), __z.imag()); }
1117 
1118 #if _GLIBCXX_USE_C99_COMPLEX
1119  inline __complex__ float
1120  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
1121 
1122  inline __complex__ double
1123  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
1124 
1125  inline __complex__ long double
1126  __complex_exp(const __complex__ long double& __z)
1127  { return __builtin_cexpl(__z); }
1128 
1129  template<typename _Tp>
1130  inline complex<_Tp>
1131  exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
1132 #else
1133  template<typename _Tp>
1134  inline complex<_Tp>
1135  exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
1136 #endif
1137 
1138  // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z.
1139  // The branch cut is along the negative axis.
1140  template<typename _Tp>
1141  inline complex<_Tp>
1142  __complex_log(const complex<_Tp>& __z)
1143  { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
1144 
1145 #if _GLIBCXX_USE_C99_COMPLEX
1146  inline __complex__ float
1147  __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
1148 
1149  inline __complex__ double
1150  __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
1151 
1152  inline __complex__ long double
1153  __complex_log(const __complex__ long double& __z)
1154  { return __builtin_clogl(__z); }
1155 
1156  template<typename _Tp>
1157  inline complex<_Tp>
1158  log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
1159 #else
1160  template<typename _Tp>
1161  inline complex<_Tp>
1162  log(const complex<_Tp>& __z) { return __complex_log(__z); }
1163 #endif
1164 
1165  template<typename _Tp>
1166  inline complex<_Tp>
1167  log10(const complex<_Tp>& __z)
1168  { return std::log(__z) / log(_Tp(10.0)); }
1169 
1170  // 26.2.8/10 sin(__z): Returns the sine of __z.
1171  template<typename _Tp>
1172  inline complex<_Tp>
1173  __complex_sin(const complex<_Tp>& __z)
1174  {
1175  const _Tp __x = __z.real();
1176  const _Tp __y = __z.imag();
1177  return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
1178  }
1179 
1180 #if _GLIBCXX_USE_C99_COMPLEX
1181  inline __complex__ float
1182  __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
1183 
1184  inline __complex__ double
1185  __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
1186 
1187  inline __complex__ long double
1188  __complex_sin(const __complex__ long double& __z)
1189  { return __builtin_csinl(__z); }
1190 
1191  template<typename _Tp>
1192  inline complex<_Tp>
1193  sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
1194 #else
1195  template<typename _Tp>
1196  inline complex<_Tp>
1197  sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
1198 #endif
1199 
1200  // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
1201  template<typename _Tp>
1202  inline complex<_Tp>
1203  __complex_sinh(const complex<_Tp>& __z)
1204  {
1205  const _Tp __x = __z.real();
1206  const _Tp __y = __z.imag();
1207  return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
1208  }
1209 
1210 #if _GLIBCXX_USE_C99_COMPLEX
1211  inline __complex__ float
1212  __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
1213 
1214  inline __complex__ double
1215  __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
1216 
1217  inline __complex__ long double
1218  __complex_sinh(const __complex__ long double& __z)
1219  { return __builtin_csinhl(__z); }
1220 
1221  template<typename _Tp>
1222  inline complex<_Tp>
1223  sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
1224 #else
1225  template<typename _Tp>
1226  inline complex<_Tp>
1227  sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
1228 #endif
1229 
1230  // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
1231  // The branch cut is on the negative axis.
1232  template<typename _Tp>
1233  complex<_Tp>
1234  __complex_sqrt(const complex<_Tp>& __z)
1235  {
1236  _Tp __x = __z.real();
1237  _Tp __y = __z.imag();
1238 
1239  if (__x == _Tp())
1240  {
1241  _Tp __t = sqrt(abs(__y) / 2);
1242  return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
1243  }
1244  else
1245  {
1246  _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
1247  _Tp __u = __t / 2;
1248  return __x > _Tp()
1249  ? complex<_Tp>(__u, __y / __t)
1250  : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
1251  }
1252  }
1253 
1254 #if _GLIBCXX_USE_C99_COMPLEX
1255  inline __complex__ float
1256  __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
1257 
1258  inline __complex__ double
1259  __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
1260 
1261  inline __complex__ long double
1262  __complex_sqrt(const __complex__ long double& __z)
1263  { return __builtin_csqrtl(__z); }
1264 
1265  template<typename _Tp>
1266  inline complex<_Tp>
1267  sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
1268 #else
1269  template<typename _Tp>
1270  inline complex<_Tp>
1271  sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
1272 #endif
1273 
1274  // 26.2.8/14 tan(__z): Return the complex tangent of __z.
1275 
1276  template<typename _Tp>
1277  inline complex<_Tp>
1278  __complex_tan(const complex<_Tp>& __z)
1279  { return std::sin(__z) / std::cos(__z); }
1280 
1281 #if _GLIBCXX_USE_C99_COMPLEX
1282  inline __complex__ float
1283  __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
1284 
1285  inline __complex__ double
1286  __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
1287 
1288  inline __complex__ long double
1289  __complex_tan(const __complex__ long double& __z)
1290  { return __builtin_ctanl(__z); }
1291 
1292  template<typename _Tp>
1293  inline complex<_Tp>
1294  tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
1295 #else
1296  template<typename _Tp>
1297  inline complex<_Tp>
1298  tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
1299 #endif
1300 
1301 
1302  // 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z.
1303 
1304  template<typename _Tp>
1305  inline complex<_Tp>
1306  __complex_tanh(const complex<_Tp>& __z)
1307  { return std::sinh(__z) / std::cosh(__z); }
1308 
1309 #if _GLIBCXX_USE_C99_COMPLEX
1310  inline __complex__ float
1311  __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
1312 
1313  inline __complex__ double
1314  __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
1315 
1316  inline __complex__ long double
1317  __complex_tanh(const __complex__ long double& __z)
1318  { return __builtin_ctanhl(__z); }
1319 
1320  template<typename _Tp>
1321  inline complex<_Tp>
1322  tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
1323 #else
1324  template<typename _Tp>
1325  inline complex<_Tp>
1326  tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
1327 #endif
1328 
1329 
1330  // 26.2.8/9 pow(__x, __y): Returns the complex power base of __x
1331  // raised to the __y-th power. The branch
1332  // cut is on the negative axis.
1333  template<typename _Tp>
1334  complex<_Tp>
1335  __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
1336  {
1337  complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
1338 
1339  while (__n >>= 1)
1340  {
1341  __x *= __x;
1342  if (__n % 2)
1343  __y *= __x;
1344  }
1345 
1346  return __y;
1347  }
1348 
1349  // In C++11 mode we used to implement the resolution of
1350  // DR 844. complex pow return type is ambiguous.
1351  // thus the following overload was disabled in that mode. However, doing
1352  // that causes all sorts of issues, see, for example:
1353  // http://gcc.gnu.org/ml/libstdc++/2013-01/msg00058.html
1354  // and also PR57974.
1355  template<typename _Tp>
1356  inline complex<_Tp>
1357  pow(const complex<_Tp>& __z, int __n)
1358  {
1359  return __n < 0
1360  ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -(unsigned)__n)
1361  : std::__complex_pow_unsigned(__z, __n);
1362  }
1363 
1364  template<typename _Tp>
1365  complex<_Tp>
1366  pow(const complex<_Tp>& __x, const _Tp& __y)
1367  {
1368 #if ! _GLIBCXX_USE_C99_COMPLEX
1369  if (__x == _Tp())
1370  return _Tp();
1371 #endif
1372  if (__x.imag() == _Tp() && __x.real() > _Tp())
1373  return pow(__x.real(), __y);
1374 
1375  complex<_Tp> __t = std::log(__x);
1376  return std::polar<_Tp>(exp(__y * __t.real()), __y * __t.imag());
1377  }
1378 
1379  template<typename _Tp>
1380  inline complex<_Tp>
1381  __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1382  { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
1383 
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); }
1388 
1389  inline __complex__ double
1390  __complex_pow(__complex__ double __x, __complex__ double __y)
1391  { return __builtin_cpow(__x, __y); }
1392 
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); }
1397 
1398  template<typename _Tp>
1399  inline complex<_Tp>
1400  pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1401  { return __complex_pow(__x.__rep(), __y.__rep()); }
1402 #else
1403  template<typename _Tp>
1404  inline complex<_Tp>
1405  pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1406  { return __complex_pow(__x, __y); }
1407 #endif
1408 
1409  template<typename _Tp>
1410  inline complex<_Tp>
1411  pow(const _Tp& __x, const complex<_Tp>& __y)
1412  {
1413  return __x > _Tp() ? std::polar<_Tp>(pow(__x, __y.real()),
1414  __y.imag() * log(__x))
1415  : std::pow(complex<_Tp>(__x), __y);
1416  }
1417 
1418 #if __glibcxx_tuple_like >= 202311L // >= C++26
1419 #define _GLIBCXX26_DECLARE_COMPLEX_TUPLE_HELPER_ACCESSOR \
1420  template<typename _Cp> \
1421  [[__gnu__::__always_inline__]] \
1422  constexpr auto& \
1423  __get_part(this _Cp& __z, size_t __i) noexcept \
1424  { \
1425  return __i == 0 ? __real__ __z._M_value \
1426  : __imag__ __z._M_value; \
1427  }
1428 #else
1429 #define _GLIBCXX26_DECLARE_COMPLEX_TUPLE_HELPER_ACCESSOR
1430 #endif
1431 
1432  /// 26.2.3 complex specializations
1433  /// complex<float> specialization
1434  template<>
1435  class complex<float>
1436  {
1437  public:
1438  typedef float value_type;
1439  typedef __complex__ float _ComplexT;
1440 
1441  _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1442 
1443  _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f)
1444 #if __cplusplus >= 201103L
1445  : _M_value{ __r, __i } { }
1446 #else
1447  {
1448  __real__ _M_value = __r;
1449  __imag__ _M_value = __i;
1450  }
1451 #endif
1452 
1453 #if __cplusplus >= 201103L
1454  _GLIBCXX14_CONSTEXPR complex(const complex&) = default;
1455 #endif
1456 
1457 #if __cplusplus > 202002L
1458  template<typename _Up>
1459  explicit(!requires(_Up __u) { value_type{__u}; })
1460  constexpr complex(const complex<_Up>& __z)
1461  : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
1462 #else
1463  explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&);
1464  explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1465 #endif
1466 
1467 #if __cplusplus >= 201103L
1468  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1469  // DR 387. std::complex over-encapsulated.
1470  __attribute ((__abi_tag__ ("cxx11")))
1471  constexpr float
1472  real() const { return __real__ _M_value; }
1473 
1474  __attribute ((__abi_tag__ ("cxx11")))
1475  constexpr float
1476  imag() const { return __imag__ _M_value; }
1477 #else
1478  float&
1479  real() { return __real__ _M_value; }
1480 
1481  const float&
1482  real() const { return __real__ _M_value; }
1483 
1484  float&
1485  imag() { return __imag__ _M_value; }
1486 
1487  const float&
1488  imag() const { return __imag__ _M_value; }
1489 #endif
1490 
1491  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1492  // DR 387. std::complex over-encapsulated.
1493  _GLIBCXX20_CONSTEXPR void
1494  real(float __val) { __real__ _M_value = __val; }
1495 
1496  _GLIBCXX20_CONSTEXPR void
1497  imag(float __val) { __imag__ _M_value = __val; }
1498 
1499  _GLIBCXX20_CONSTEXPR complex&
1500  operator=(float __f)
1501  {
1502  _M_value = __f;
1503  return *this;
1504  }
1505 
1506  _GLIBCXX20_CONSTEXPR complex&
1507  operator+=(float __f)
1508  {
1509  _M_value += __f;
1510  return *this;
1511  }
1512 
1513  _GLIBCXX20_CONSTEXPR complex&
1514  operator-=(float __f)
1515  {
1516  _M_value -= __f;
1517  return *this;
1518  }
1519 
1520  _GLIBCXX20_CONSTEXPR complex&
1521  operator*=(float __f)
1522  {
1523  _M_value *= __f;
1524  return *this;
1525  }
1526 
1527  _GLIBCXX20_CONSTEXPR complex&
1528  operator/=(float __f)
1529  {
1530  _M_value /= __f;
1531  return *this;
1532  }
1533 
1534  // Let the compiler synthesize the copy and assignment
1535  // operator. It always does a pretty good job.
1536 #if __cplusplus >= 201103L
1537  _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1538 #endif
1539 
1540  template<typename _Tp>
1541  _GLIBCXX20_CONSTEXPR complex&
1542  operator=(const complex<_Tp>& __z)
1543  {
1544  __real__ _M_value = __z.real();
1545  __imag__ _M_value = __z.imag();
1546  return *this;
1547  }
1548 
1549  template<typename _Tp>
1550  _GLIBCXX20_CONSTEXPR complex&
1551  operator+=(const complex<_Tp>& __z)
1552  {
1553  _M_value += __z.__rep();
1554  return *this;
1555  }
1556 
1557  template<class _Tp>
1558  _GLIBCXX20_CONSTEXPR complex&
1559  operator-=(const complex<_Tp>& __z)
1560  {
1561  _M_value -= __z.__rep();
1562  return *this;
1563  }
1564 
1565  template<class _Tp>
1566  _GLIBCXX20_CONSTEXPR complex&
1567  operator*=(const complex<_Tp>& __z)
1568  {
1569  const _ComplexT __t = __z.__rep();
1570  _M_value *= __t;
1571  return *this;
1572  }
1573 
1574  template<class _Tp>
1575  _GLIBCXX20_CONSTEXPR complex&
1576  operator/=(const complex<_Tp>& __z)
1577  {
1578  const _ComplexT __t = __z.__rep();
1579  _M_value /= __t;
1580  return *this;
1581  }
1582 
1583  _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1584 
1585  _GLIBCXX26_DECLARE_COMPLEX_TUPLE_HELPER_ACCESSOR
1586 
1587  private:
1588  _ComplexT _M_value;
1589  };
1590 
1591  /// 26.2.3 complex specializations
1592  /// complex<double> specialization
1593  template<>
1594  class complex<double>
1595  {
1596  public:
1597  typedef double value_type;
1598  typedef __complex__ double _ComplexT;
1599 
1600  _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1601 
1602  _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0)
1603 #if __cplusplus >= 201103L
1604  : _M_value{ __r, __i } { }
1605 #else
1606  {
1607  __real__ _M_value = __r;
1608  __imag__ _M_value = __i;
1609  }
1610 #endif
1611 
1612 #if __cplusplus >= 201103L
1613  _GLIBCXX14_CONSTEXPR complex(const complex&) = default;
1614 #endif
1615 
1616 #if __cplusplus > 202002L
1617  template<typename _Up>
1618  explicit(!requires(_Up __u) { value_type{__u}; })
1619  constexpr complex(const complex<_Up>& __z)
1620  : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
1621 #else
1622  _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1623  : _M_value(__z.__rep()) { }
1624 
1625  explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1626 #endif
1627 
1628 #if __cplusplus >= 201103L
1629  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1630  // DR 387. std::complex over-encapsulated.
1631  __attribute ((__abi_tag__ ("cxx11")))
1632  constexpr double
1633  real() const { return __real__ _M_value; }
1634 
1635  __attribute ((__abi_tag__ ("cxx11")))
1636  constexpr double
1637  imag() const { return __imag__ _M_value; }
1638 #else
1639  double&
1640  real() { return __real__ _M_value; }
1641 
1642  const double&
1643  real() const { return __real__ _M_value; }
1644 
1645  double&
1646  imag() { return __imag__ _M_value; }
1647 
1648  const double&
1649  imag() const { return __imag__ _M_value; }
1650 #endif
1651 
1652  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1653  // DR 387. std::complex over-encapsulated.
1654  _GLIBCXX20_CONSTEXPR void
1655  real(double __val) { __real__ _M_value = __val; }
1656 
1657  _GLIBCXX20_CONSTEXPR void
1658  imag(double __val) { __imag__ _M_value = __val; }
1659 
1660  _GLIBCXX20_CONSTEXPR complex&
1661  operator=(double __d)
1662  {
1663  _M_value = __d;
1664  return *this;
1665  }
1666 
1667  _GLIBCXX20_CONSTEXPR complex&
1668  operator+=(double __d)
1669  {
1670  _M_value += __d;
1671  return *this;
1672  }
1673 
1674  _GLIBCXX20_CONSTEXPR complex&
1675  operator-=(double __d)
1676  {
1677  _M_value -= __d;
1678  return *this;
1679  }
1680 
1681  _GLIBCXX20_CONSTEXPR complex&
1682  operator*=(double __d)
1683  {
1684  _M_value *= __d;
1685  return *this;
1686  }
1687 
1688  _GLIBCXX20_CONSTEXPR complex&
1689  operator/=(double __d)
1690  {
1691  _M_value /= __d;
1692  return *this;
1693  }
1694 
1695  // The compiler will synthesize this, efficiently.
1696 #if __cplusplus >= 201103L
1697  _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1698 #endif
1699 
1700  template<typename _Tp>
1701  _GLIBCXX20_CONSTEXPR complex&
1702  operator=(const complex<_Tp>& __z)
1703  {
1704  _M_value = __z.__rep();
1705  return *this;
1706  }
1707 
1708  template<typename _Tp>
1709  _GLIBCXX20_CONSTEXPR complex&
1710  operator+=(const complex<_Tp>& __z)
1711  {
1712  _M_value += __z.__rep();
1713  return *this;
1714  }
1715 
1716  template<typename _Tp>
1717  _GLIBCXX20_CONSTEXPR complex&
1718  operator-=(const complex<_Tp>& __z)
1719  {
1720  _M_value -= __z.__rep();
1721  return *this;
1722  }
1723 
1724  template<typename _Tp>
1725  _GLIBCXX20_CONSTEXPR complex&
1726  operator*=(const complex<_Tp>& __z)
1727  {
1728  const _ComplexT __t = __z.__rep();
1729  _M_value *= __t;
1730  return *this;
1731  }
1732 
1733  template<typename _Tp>
1734  _GLIBCXX20_CONSTEXPR complex&
1735  operator/=(const complex<_Tp>& __z)
1736  {
1737  const _ComplexT __t = __z.__rep();
1738  _M_value /= __t;
1739  return *this;
1740  }
1741 
1742  _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1743 
1744  _GLIBCXX26_DECLARE_COMPLEX_TUPLE_HELPER_ACCESSOR
1745 
1746  private:
1747  _ComplexT _M_value;
1748  };
1749 
1750  /// 26.2.3 complex specializations
1751  /// complex<long double> specialization
1752  template<>
1753  class complex<long double>
1754  {
1755  public:
1756  typedef long double value_type;
1757  typedef __complex__ long double _ComplexT;
1758 
1759  _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1760 
1761  _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L,
1762  long double __i = 0.0L)
1763 #if __cplusplus >= 201103L
1764  : _M_value{ __r, __i } { }
1765 #else
1766  {
1767  __real__ _M_value = __r;
1768  __imag__ _M_value = __i;
1769  }
1770 #endif
1771 
1772 #if __cplusplus >= 201103L
1773  _GLIBCXX14_CONSTEXPR complex(const complex&) = default;
1774 #endif
1775 
1776 #if __cplusplus > 202002L
1777  template<typename _Up>
1778  explicit(!requires(_Up __u) { value_type{__u}; })
1779  constexpr complex(const complex<_Up>& __z)
1780  : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
1781 #else
1782  _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1783  : _M_value(__z.__rep()) { }
1784 
1785  _GLIBCXX_CONSTEXPR complex(const complex<double>& __z)
1786  : _M_value(__z.__rep()) { }
1787 #endif
1788 
1789 #if __cplusplus >= 201103L
1790  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1791  // DR 387. std::complex over-encapsulated.
1792  __attribute ((__abi_tag__ ("cxx11")))
1793  constexpr long double
1794  real() const { return __real__ _M_value; }
1795 
1796  __attribute ((__abi_tag__ ("cxx11")))
1797  constexpr long double
1798  imag() const { return __imag__ _M_value; }
1799 #else
1800  long double&
1801  real() { return __real__ _M_value; }
1802 
1803  const long double&
1804  real() const { return __real__ _M_value; }
1805 
1806  long double&
1807  imag() { return __imag__ _M_value; }
1808 
1809  const long double&
1810  imag() const { return __imag__ _M_value; }
1811 #endif
1812 
1813  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1814  // DR 387. std::complex over-encapsulated.
1815  _GLIBCXX20_CONSTEXPR void
1816  real(long double __val) { __real__ _M_value = __val; }
1817 
1818  _GLIBCXX20_CONSTEXPR void
1819  imag(long double __val) { __imag__ _M_value = __val; }
1820 
1821  _GLIBCXX20_CONSTEXPR complex&
1822  operator=(long double __r)
1823  {
1824  _M_value = __r;
1825  return *this;
1826  }
1827 
1828  _GLIBCXX20_CONSTEXPR complex&
1829  operator+=(long double __r)
1830  {
1831  _M_value += __r;
1832  return *this;
1833  }
1834 
1835  _GLIBCXX20_CONSTEXPR complex&
1836  operator-=(long double __r)
1837  {
1838  _M_value -= __r;
1839  return *this;
1840  }
1841 
1842  _GLIBCXX20_CONSTEXPR complex&
1843  operator*=(long double __r)
1844  {
1845  _M_value *= __r;
1846  return *this;
1847  }
1848 
1849  _GLIBCXX20_CONSTEXPR complex&
1850  operator/=(long double __r)
1851  {
1852  _M_value /= __r;
1853  return *this;
1854  }
1855 
1856  // The compiler knows how to do this efficiently
1857 #if __cplusplus >= 201103L
1858  _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1859 #endif
1860 
1861  template<typename _Tp>
1862  _GLIBCXX20_CONSTEXPR complex&
1863  operator=(const complex<_Tp>& __z)
1864  {
1865  _M_value = __z.__rep();
1866  return *this;
1867  }
1868 
1869  template<typename _Tp>
1870  _GLIBCXX20_CONSTEXPR complex&
1871  operator+=(const complex<_Tp>& __z)
1872  {
1873  _M_value += __z.__rep();
1874  return *this;
1875  }
1876 
1877  template<typename _Tp>
1878  _GLIBCXX20_CONSTEXPR complex&
1879  operator-=(const complex<_Tp>& __z)
1880  {
1881  _M_value -= __z.__rep();
1882  return *this;
1883  }
1884 
1885  template<typename _Tp>
1886  _GLIBCXX20_CONSTEXPR complex&
1887  operator*=(const complex<_Tp>& __z)
1888  {
1889  const _ComplexT __t = __z.__rep();
1890  _M_value *= __t;
1891  return *this;
1892  }
1893 
1894  template<typename _Tp>
1895  _GLIBCXX20_CONSTEXPR complex&
1896  operator/=(const complex<_Tp>& __z)
1897  {
1898  const _ComplexT __t = __z.__rep();
1899  _M_value /= __t;
1900  return *this;
1901  }
1902 
1903  _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1904 
1905  _GLIBCXX26_DECLARE_COMPLEX_TUPLE_HELPER_ACCESSOR
1906 
1907  private:
1908  _ComplexT _M_value;
1909  };
1910 
1911 #if __cplusplus > 202002L
1912  template<typename _Tp>
1913  struct __complex_type
1914  { };
1915 
1916 #ifdef __STDCPP_FLOAT16_T__
1917  template<>
1918  struct __complex_type<_Float16>
1919  { typedef __complex__ _Float16 type; };
1920 #endif
1921 
1922 #ifdef __STDCPP_FLOAT32_T__
1923  template<>
1924  struct __complex_type<_Float32>
1925  { typedef __complex__ _Float32 type; };
1926 #endif
1927 
1928 #ifdef __STDCPP_FLOAT64_T__
1929  template<>
1930  struct __complex_type<_Float64>
1931  { typedef __complex__ _Float64 type; };
1932 #endif
1933 
1934 #ifdef __STDCPP_FLOAT128_T__
1935  template<>
1936  struct __complex_type<_Float128>
1937  { typedef __complex__ _Float128 type; };
1938 #endif
1939 
1940 #ifdef __STDCPP_BFLOAT16_T__
1941  template<>
1942  struct __complex_type<__gnu_cxx::__bfloat16_t>
1943  { typedef __complex__ decltype(0.0bf16) type; };
1944 #endif
1945 
1946  template<typename _Tp>
1947  requires requires { typename __complex_type<_Tp>::type; }
1948  class complex<_Tp>
1949  {
1950  public:
1951  typedef _Tp value_type;
1952  typedef typename std::__complex_type<_Tp>::type _ComplexT;
1953 
1954  constexpr complex(_ComplexT __z) : _M_value(__z) { }
1955 
1956  constexpr complex(_Tp __r = _Tp(), _Tp __i = _Tp())
1957  : _M_value{ __r, __i } { }
1958 
1959  template<typename _Up>
1960  explicit(!requires(_Up __u) { value_type{__u}; })
1961  constexpr complex(const complex<_Up>& __z)
1962  : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
1963 
1964  constexpr _Tp
1965  real() const { return __real__ _M_value; }
1966 
1967  constexpr _Tp
1968  imag() const { return __imag__ _M_value; }
1969 
1970  constexpr void
1971  real(_Tp __val) { __real__ _M_value = __val; }
1972 
1973  constexpr void
1974  imag(_Tp __val) { __imag__ _M_value = __val; }
1975 
1976  constexpr complex&
1977  operator=(_Tp __f)
1978  {
1979  _M_value = __f;
1980  return *this;
1981  }
1982 
1983  constexpr complex&
1984  operator+=(_Tp __f)
1985  {
1986  _M_value += __f;
1987  return *this;
1988  }
1989 
1990  constexpr complex&
1991  operator-=(_Tp __f)
1992  {
1993  _M_value -= __f;
1994  return *this;
1995  }
1996 
1997  constexpr complex&
1998  operator*=(_Tp __f)
1999  {
2000  _M_value *= __f;
2001  return *this;
2002  }
2003 
2004  constexpr complex&
2005  operator/=(_Tp __f)
2006  {
2007  _M_value /= __f;
2008  return *this;
2009  }
2010 
2011  // Let the compiler synthesize the copy and assignment
2012  // operator. It always does a pretty good job.
2013  constexpr complex(const complex&) = default;
2014  constexpr complex& operator=(const complex&) = default;
2015 
2016  template<typename _Up>
2017  constexpr complex&
2018  operator=(const complex<_Up>& __z)
2019  {
2020  __real__ _M_value = __z.real();
2021  __imag__ _M_value = __z.imag();
2022  return *this;
2023  }
2024 
2025  template<typename _Up>
2026  constexpr complex&
2027  operator+=(const complex<_Up>& __z)
2028  {
2029  _M_value += __z.__rep();
2030  return *this;
2031  }
2032 
2033  template<class _Up>
2034  constexpr complex&
2035  operator-=(const complex<_Up>& __z)
2036  {
2037  _M_value -= __z.__rep();
2038  return *this;
2039  }
2040 
2041  template<class _Up>
2042  constexpr complex&
2043  operator*=(const complex<_Up>& __z)
2044  {
2045  const _ComplexT __t = __z.__rep();
2046  _M_value *= __t;
2047  return *this;
2048  }
2049 
2050  template<class _Up>
2051  constexpr complex&
2052  operator/=(const complex<_Up>& __z)
2053  {
2054  const _ComplexT __t = __z.__rep();
2055  _M_value /= __t;
2056  return *this;
2057  }
2058 
2059  constexpr _ComplexT __rep() const { return _M_value; }
2060 
2061  _GLIBCXX26_DECLARE_COMPLEX_TUPLE_HELPER_ACCESSOR
2062 
2063  private:
2064  _ComplexT _M_value;
2065  };
2066 #endif
2067 
2068 #undef _GLIBCXX26_DECLARE_COMPLEX_TUPLE_HELPER_ACCESSOR
2069 
2070 #if __cplusplus <= 202002L
2071  // These bits have to be at the end of this file, so that the
2072  // specializations have all been defined.
2073  inline _GLIBCXX_CONSTEXPR
2074  complex<float>::complex(const complex<double>& __z)
2075  : _M_value(__z.__rep()) { }
2076 
2077  inline _GLIBCXX_CONSTEXPR
2078  complex<float>::complex(const complex<long double>& __z)
2079  : _M_value(__z.__rep()) { }
2080 
2081  inline _GLIBCXX_CONSTEXPR
2082  complex<double>::complex(const complex<long double>& __z)
2083  : _M_value(__z.__rep()) { }
2084 #endif
2085 
2086  // Inhibit implicit instantiations for required instantiations,
2087  // which are defined via explicit instantiations elsewhere.
2088  // NB: This syntax is a GNU extension.
2089 #if _GLIBCXX_EXTERN_TEMPLATE
2090  extern template istream& operator>>(istream&, complex<float>&);
2091  extern template ostream& operator<<(ostream&, const complex<float>&);
2092  extern template istream& operator>>(istream&, complex<double>&);
2093  extern template ostream& operator<<(ostream&, const complex<double>&);
2094  extern template istream& operator>>(istream&, complex<long double>&);
2095  extern template ostream& operator<<(ostream&, const complex<long double>&);
2096 
2097 #ifdef _GLIBCXX_USE_WCHAR_T
2098  extern template wistream& operator>>(wistream&, complex<float>&);
2099  extern template wostream& operator<<(wostream&, const complex<float>&);
2100  extern template wistream& operator>>(wistream&, complex<double>&);
2101  extern template wostream& operator<<(wostream&, const complex<double>&);
2102  extern template wistream& operator>>(wistream&, complex<long double>&);
2103  extern template wostream& operator<<(wostream&, const complex<long double>&);
2104 #endif
2105 #endif
2106 
2107  /// @} group complex_numbers
2108 
2109 _GLIBCXX_END_NAMESPACE_VERSION
2110 } // namespace
2111 
2112 #if __cplusplus >= 201103L
2113 
2114 namespace std _GLIBCXX_VISIBILITY(default)
2115 {
2116 _GLIBCXX_BEGIN_NAMESPACE_VERSION
2117 
2118  // Forward declarations.
2119  template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
2120  template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
2121  template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
2122 
2123  template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
2124  template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
2125  template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
2126  // DR 595.
2127  template<typename _Tp> _Tp fabs(const std::complex<_Tp>&);
2128 
2129  template<typename _Tp>
2130  inline std::complex<_Tp>
2131  __complex_acos(const std::complex<_Tp>& __z)
2132  {
2133  const std::complex<_Tp> __t = std::asin(__z);
2134  const _Tp __pi_2 = (_Tp) 1.5707963267948966192313216916397514L;
2135  return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
2136  }
2137 
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)); }
2143 
2144  inline __complex__ _Float16
2145  __complex_asin(__complex__ _Float16 __z)
2146  { return static_cast<__complex__ _Float16>(__builtin_casinf(__z)); }
2147 
2148  inline __complex__ _Float16
2149  __complex_atan(__complex__ _Float16 __z)
2150  { return static_cast<__complex__ _Float16>(__builtin_catanf(__z)); }
2151 
2152  inline __complex__ _Float16
2153  __complex_acosh(__complex__ _Float16 __z)
2154  { return static_cast<__complex__ _Float16>(__builtin_cacoshf(__z)); }
2155 
2156  inline __complex__ _Float16
2157  __complex_asinh(__complex__ _Float16 __z)
2158  { return static_cast<__complex__ _Float16>(__builtin_casinhf(__z)); }
2159 
2160  inline __complex__ _Float16
2161  __complex_atanh(__complex__ _Float16 __z)
2162  { return static_cast<__complex__ _Float16>(__builtin_catanhf(__z)); }
2163 #endif
2164 
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); }
2169 
2170  inline __complex__ _Float32
2171  __complex_asin(__complex__ _Float32 __z)
2172  { return __builtin_casinf(__z); }
2173 
2174  inline __complex__ _Float32
2175  __complex_atan(__complex__ _Float32 __z)
2176  { return __builtin_catanf(__z); }
2177 
2178  inline __complex__ _Float32
2179  __complex_acosh(__complex__ _Float32 __z)
2180  { return __builtin_cacoshf(__z); }
2181 
2182  inline __complex__ _Float32
2183  __complex_asinh(__complex__ _Float32 __z)
2184  { return __builtin_casinhf(__z); }
2185 
2186  inline __complex__ _Float32
2187  __complex_atanh(__complex__ _Float32 __z)
2188  { return __builtin_catanhf(__z); }
2189 #endif
2190 
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); }
2195 
2196  inline __complex__ _Float64
2197  __complex_asin(__complex__ _Float64 __z)
2198  { return __builtin_casin(__z); }
2199 
2200  inline __complex__ _Float64
2201  __complex_atan(__complex__ _Float64 __z)
2202  { return __builtin_catan(__z); }
2203 
2204  inline __complex__ _Float64
2205  __complex_acosh(__complex__ _Float64 __z)
2206  { return __builtin_cacosh(__z); }
2207 
2208  inline __complex__ _Float64
2209  __complex_asinh(__complex__ _Float64 __z)
2210  { return __builtin_casinh(__z); }
2211 
2212  inline __complex__ _Float64
2213  __complex_atanh(__complex__ _Float64 __z)
2214  { return __builtin_catanh(__z); }
2215 #endif
2216 
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); }
2221 
2222  inline __complex__ _Float128
2223  __complex_asin(__complex__ _Float128 __z)
2224  { return __builtin_casinl(__z); }
2225 
2226  inline __complex__ _Float128
2227  __complex_atan(__complex__ _Float128 __z)
2228  { return __builtin_catanl(__z); }
2229 
2230  inline __complex__ _Float128
2231  __complex_acosh(__complex__ _Float128 __z)
2232  { return __builtin_cacoshl(__z); }
2233 
2234  inline __complex__ _Float128
2235  __complex_asinh(__complex__ _Float128 __z)
2236  { return __builtin_casinhl(__z); }
2237 
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); }
2245 
2246  inline __complex__ _Float128
2247  __complex_asin(__complex__ _Float128 __z)
2248  { return __builtin_casinf128(__z); }
2249 
2250  inline __complex__ _Float128
2251  __complex_atan(__complex__ _Float128 __z)
2252  { return __builtin_catanf128(__z); }
2253 
2254  inline __complex__ _Float128
2255  __complex_acosh(__complex__ _Float128 __z)
2256  { return __builtin_cacoshf128(__z); }
2257 
2258  inline __complex__ _Float128
2259  __complex_asinh(__complex__ _Float128 __z)
2260  { return __builtin_casinhf128(__z); }
2261 
2262  inline __complex__ _Float128
2263  __complex_atanh(__complex__ _Float128 __z)
2264  { return __builtin_catanhf128(__z); }
2265 #endif
2266 
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)); }
2271 
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)); }
2275 
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)); }
2279 
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)); }
2283 
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)); }
2287 
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)); }
2291 #endif
2292 #endif
2293 
2294 #if _GLIBCXX_USE_C99_COMPLEX_ARC
2295  inline __complex__ float
2296  __complex_acos(__complex__ float __z)
2297  { return __builtin_cacosf(__z); }
2298 
2299  inline __complex__ double
2300  __complex_acos(__complex__ double __z)
2301  { return __builtin_cacos(__z); }
2302 
2303  inline __complex__ long double
2304  __complex_acos(const __complex__ long double& __z)
2305  { return __builtin_cacosl(__z); }
2306 
2307  template<typename _Tp>
2308  inline std::complex<_Tp>
2309  acos(const std::complex<_Tp>& __z)
2310  { return __complex_acos(__z.__rep()); }
2311 #else
2312  /// acos(__z) [8.1.2].
2313  // Effects: Behaves the same as C99 function cacos, defined
2314  // in subclause 7.3.5.1.
2315  template<typename _Tp>
2316  inline std::complex<_Tp>
2317  acos(const std::complex<_Tp>& __z)
2318  { return __complex_acos(__z); }
2319 #endif
2320 
2321  template<typename _Tp>
2322  inline std::complex<_Tp>
2323  __complex_asin(const std::complex<_Tp>& __z)
2324  {
2325  std::complex<_Tp> __t(-__z.imag(), __z.real());
2326  __t = std::asinh(__t);
2327  return std::complex<_Tp>(__t.imag(), -__t.real());
2328  }
2329 
2330 #if _GLIBCXX_USE_C99_COMPLEX_ARC
2331  inline __complex__ float
2332  __complex_asin(__complex__ float __z)
2333  { return __builtin_casinf(__z); }
2334 
2335  inline __complex__ double
2336  __complex_asin(__complex__ double __z)
2337  { return __builtin_casin(__z); }
2338 
2339  inline __complex__ long double
2340  __complex_asin(const __complex__ long double& __z)
2341  { return __builtin_casinl(__z); }
2342 
2343  template<typename _Tp>
2344  inline std::complex<_Tp>
2345  asin(const std::complex<_Tp>& __z)
2346  { return __complex_asin(__z.__rep()); }
2347 #else
2348  /// asin(__z) [8.1.3].
2349  // Effects: Behaves the same as C99 function casin, defined
2350  // in subclause 7.3.5.2.
2351  template<typename _Tp>
2352  inline std::complex<_Tp>
2353  asin(const std::complex<_Tp>& __z)
2354  { return __complex_asin(__z); }
2355 #endif
2356 
2357  template<typename _Tp>
2358  std::complex<_Tp>
2359  __complex_atan(const std::complex<_Tp>& __z)
2360  {
2361  const _Tp __r2 = __z.real() * __z.real();
2362  const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
2363 
2364  _Tp __num = __z.imag() + _Tp(1.0);
2365  _Tp __den = __z.imag() - _Tp(1.0);
2366 
2367  __num = __r2 + __num * __num;
2368  __den = __r2 + __den * __den;
2369 
2370  return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
2371  _Tp(0.25) * log(__num / __den));
2372  }
2373 
2374 #if _GLIBCXX_USE_C99_COMPLEX_ARC
2375  inline __complex__ float
2376  __complex_atan(__complex__ float __z)
2377  { return __builtin_catanf(__z); }
2378 
2379  inline __complex__ double
2380  __complex_atan(__complex__ double __z)
2381  { return __builtin_catan(__z); }
2382 
2383  inline __complex__ long double
2384  __complex_atan(const __complex__ long double& __z)
2385  { return __builtin_catanl(__z); }
2386 
2387  template<typename _Tp>
2388  inline std::complex<_Tp>
2389  atan(const std::complex<_Tp>& __z)
2390  { return __complex_atan(__z.__rep()); }
2391 #else
2392  /// atan(__z) [8.1.4].
2393  // Effects: Behaves the same as C99 function catan, defined
2394  // in subclause 7.3.5.3.
2395  template<typename _Tp>
2396  inline std::complex<_Tp>
2397  atan(const std::complex<_Tp>& __z)
2398  { return __complex_atan(__z); }
2399 #endif
2400 
2401  template<typename _Tp>
2402  std::complex<_Tp>
2403  __complex_acosh(const std::complex<_Tp>& __z)
2404  {
2405  // Kahan's formula.
2406  return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
2407  + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
2408  }
2409 
2410 #if _GLIBCXX_USE_C99_COMPLEX_ARC
2411  inline __complex__ float
2412  __complex_acosh(__complex__ float __z)
2413  { return __builtin_cacoshf(__z); }
2414 
2415  inline __complex__ double
2416  __complex_acosh(__complex__ double __z)
2417  { return __builtin_cacosh(__z); }
2418 
2419  inline __complex__ long double
2420  __complex_acosh(const __complex__ long double& __z)
2421  { return __builtin_cacoshl(__z); }
2422 
2423  template<typename _Tp>
2424  inline std::complex<_Tp>
2425  acosh(const std::complex<_Tp>& __z)
2426  { return __complex_acosh(__z.__rep()); }
2427 #else
2428  /// acosh(__z) [8.1.5].
2429  // Effects: Behaves the same as C99 function cacosh, defined
2430  // in subclause 7.3.6.1.
2431  template<typename _Tp>
2432  inline std::complex<_Tp>
2433  acosh(const std::complex<_Tp>& __z)
2434  { return __complex_acosh(__z); }
2435 #endif
2436 
2437  template<typename _Tp>
2438  std::complex<_Tp>
2439  __complex_asinh(const std::complex<_Tp>& __z)
2440  {
2441  std::complex<_Tp> __t((__z.real() - __z.imag())
2442  * (__z.real() + __z.imag()) + _Tp(1.0),
2443  _Tp(2.0) * __z.real() * __z.imag());
2444  __t = std::sqrt(__t);
2445 
2446  return std::log(__t + __z);
2447  }
2448 
2449 #if _GLIBCXX_USE_C99_COMPLEX_ARC
2450  inline __complex__ float
2451  __complex_asinh(__complex__ float __z)
2452  { return __builtin_casinhf(__z); }
2453 
2454  inline __complex__ double
2455  __complex_asinh(__complex__ double __z)
2456  { return __builtin_casinh(__z); }
2457 
2458  inline __complex__ long double
2459  __complex_asinh(const __complex__ long double& __z)
2460  { return __builtin_casinhl(__z); }
2461 
2462  template<typename _Tp>
2463  inline std::complex<_Tp>
2464  asinh(const std::complex<_Tp>& __z)
2465  { return __complex_asinh(__z.__rep()); }
2466 #else
2467  /// asinh(__z) [8.1.6].
2468  // Effects: Behaves the same as C99 function casin, defined
2469  // in subclause 7.3.6.2.
2470  template<typename _Tp>
2471  inline std::complex<_Tp>
2472  asinh(const std::complex<_Tp>& __z)
2473  { return __complex_asinh(__z); }
2474 #endif
2475 
2476  template<typename _Tp>
2477  std::complex<_Tp>
2478  __complex_atanh(const std::complex<_Tp>& __z)
2479  {
2480  const _Tp __i2 = __z.imag() * __z.imag();
2481  const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
2482 
2483  _Tp __num = _Tp(1.0) + __z.real();
2484  _Tp __den = _Tp(1.0) - __z.real();
2485 
2486  __num = __i2 + __num * __num;
2487  __den = __i2 + __den * __den;
2488 
2489  return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
2490  _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
2491  }
2492 
2493 #if _GLIBCXX_USE_C99_COMPLEX_ARC
2494  inline __complex__ float
2495  __complex_atanh(__complex__ float __z)
2496  { return __builtin_catanhf(__z); }
2497 
2498  inline __complex__ double
2499  __complex_atanh(__complex__ double __z)
2500  { return __builtin_catanh(__z); }
2501 
2502  inline __complex__ long double
2503  __complex_atanh(const __complex__ long double& __z)
2504  { return __builtin_catanhl(__z); }
2505 
2506  template<typename _Tp>
2507  inline std::complex<_Tp>
2508  atanh(const std::complex<_Tp>& __z)
2509  { return __complex_atanh(__z.__rep()); }
2510 #else
2511  /// atanh(__z) [8.1.7].
2512  // Effects: Behaves the same as C99 function catanh, defined
2513  // in subclause 7.3.6.3.
2514  template<typename _Tp>
2515  inline std::complex<_Tp>
2516  atanh(const std::complex<_Tp>& __z)
2517  { return __complex_atanh(__z); }
2518 #endif
2519 
2520  template<typename _Tp>
2521  inline _Tp
2522  /// fabs(__z) [8.1.8].
2523  // Effects: Behaves the same as C99 function cabs, defined
2524  // in subclause 7.3.8.1.
2525  fabs(const std::complex<_Tp>& __z)
2526  { return std::abs(__z); }
2527 
2528  /// Additional overloads [8.1.9].
2529  template<typename _Tp>
2530  inline typename __gnu_cxx::__promote<_Tp>::__type
2531  arg(_Tp __x)
2532  {
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)
2536  : __type();
2537 #else
2538  return std::arg(std::complex<__type>(__x));
2539 #endif
2540  }
2541 
2542  template<typename _Tp>
2543  _GLIBCXX_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
2544  imag(_Tp)
2545  { return _Tp(); }
2546 
2547  template<typename _Tp>
2548  _GLIBCXX20_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
2549  norm(_Tp __x)
2550  {
2551  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2552  return __type(__x) * __type(__x);
2553  }
2554 
2555  template<typename _Tp>
2556  _GLIBCXX_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
2557  real(_Tp __x)
2558  { return __x; }
2559 
2560  template<typename _Tp, typename _Up>
2561  inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
2562  pow(const std::complex<_Tp>& __x, const _Up& __y)
2563  {
2564  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2565  return std::pow(std::complex<__type>(__x), __type(__y));
2566  }
2567 
2568  template<typename _Tp, typename _Up>
2569  inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
2570  pow(const _Tp& __x, const std::complex<_Up>& __y)
2571  {
2572  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2573  return std::pow(__type(__x), std::complex<__type>(__y));
2574  }
2575 
2576  template<typename _Tp, typename _Up>
2577  inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
2578  pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
2579  {
2580  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2581  return std::pow(std::complex<__type>(__x),
2582  std::complex<__type>(__y));
2583  }
2584 
2585  // Forward declarations.
2586  // DR 781.
2587  template<typename _Tp>
2588  std::complex<_Tp> proj(const std::complex<_Tp>&);
2589 
2590  // Generic implementation of std::proj, does not work for infinities.
2591  template<typename _Tp>
2592  inline std::complex<_Tp>
2593  __complex_proj(const std::complex<_Tp>& __z)
2594  { return __z; }
2595 
2596 #if _GLIBCXX_USE_C99_COMPLEX
2597  inline complex<float>
2598  __complex_proj(const complex<float>& __z)
2599  { return __builtin_cprojf(__z.__rep()); }
2600 
2601  inline complex<double>
2602  __complex_proj(const complex<double>& __z)
2603  { return __builtin_cproj(__z.__rep()); }
2604 
2605  inline complex<long double>
2606  __complex_proj(const complex<long double>& __z)
2607  { return __builtin_cprojl(__z.__rep()); }
2608 
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)); }
2614 #endif
2615 
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); }
2620 #endif
2621 
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); }
2626 #endif
2627 
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); }
2636 #endif
2637 
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)); }
2642 #endif
2643 
2644  template<typename _Tp>
2645  requires requires { typename __complex_type<_Tp>::type; }
2646  inline complex<_Tp>
2647  __complex_proj(const complex<_Tp>& __z)
2648  { return __complex_proj(__z.__rep()); }
2649 #endif
2650 
2651 #elif defined _GLIBCXX_USE_C99_MATH_FUNCS
2652  inline complex<float>
2653  __complex_proj(const complex<float>& __z)
2654  {
2655  if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
2656  return complex<float>(__builtin_inff(),
2657  __builtin_copysignf(0.0f, __z.imag()));
2658  return __z;
2659  }
2660 
2661  inline complex<double>
2662  __complex_proj(const complex<double>& __z)
2663  {
2664  if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
2665  return complex<double>(__builtin_inf(),
2666  __builtin_copysign(0.0, __z.imag()));
2667  return __z;
2668  }
2669 
2670  inline complex<long double>
2671  __complex_proj(const complex<long double>& __z)
2672  {
2673  if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
2674  return complex<long double>(__builtin_infl(),
2675  __builtin_copysignl(0.0l, __z.imag()));
2676  return __z;
2677  }
2678 #endif
2679 
2680  template<typename _Tp>
2681  inline std::complex<_Tp>
2682  proj(const std::complex<_Tp>& __z)
2683  { return __complex_proj(__z); }
2684 
2685  // Overload for scalars
2686  template<typename _Tp>
2687  inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
2688  proj(_Tp __x)
2689  {
2690  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2691  return std::proj(std::complex<__type>(__x));
2692  }
2693 
2694  template<typename _Tp>
2695  inline _GLIBCXX20_CONSTEXPR
2696  std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
2697  conj(_Tp __x)
2698  {
2699  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2700  return std::complex<__type>(__x, -__type());
2701  }
2702 
2703 #ifdef __cpp_lib_complex_udls // C++ >= 14
2704 
2705 inline namespace literals {
2706 inline namespace complex_literals {
2707 #pragma GCC diagnostic push
2708 #pragma GCC diagnostic ignored "-Wliteral-suffix"
2709 
2710  constexpr std::complex<float>
2711  operator""if(long double __num)
2712  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
2713 
2714  constexpr std::complex<float>
2715  operator""if(unsigned long long __num)
2716  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
2717 
2718  constexpr std::complex<double>
2719  operator""i(long double __num)
2720  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
2721 
2722  constexpr std::complex<double>
2723  operator""i(unsigned long long __num)
2724  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
2725 
2726  constexpr std::complex<long double>
2727  operator""il(long double __num)
2728  { return std::complex<long double>{0.0L, __num}; }
2729 
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)}; }
2733 
2734 #pragma GCC diagnostic pop
2735 } // inline namespace complex_literals
2736 } // inline namespace literals
2737 
2738 #endif // __cpp_lib_complex_udls
2739 
2740 _GLIBCXX_END_NAMESPACE_VERSION
2741 } // namespace
2742 
2743 #endif // C++11
2744 
2745 #ifdef _GLIBCXX_CLANG
2746 #pragma clang diagnostic pop
2747 #endif
2748 
2749 #pragma GCC diagnostic pop
2750 #endif /* _GLIBCXX_COMPLEX */