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