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-2022 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  _GLIBCXX_CONSTEXPR complex(const complex<_Up>& __z)
146  : _M_real(__z.real()), _M_imag(__z.imag()) { }
147 
148 #if __cplusplus >= 201103L
149  // _GLIBCXX_RESOLVE_LIB_DEFECTS
150  // DR 387. std::complex over-encapsulated.
151  _GLIBCXX_ABI_TAG_CXX11
152  constexpr _Tp
153  real() const { return _M_real; }
154 
155  _GLIBCXX_ABI_TAG_CXX11
156  constexpr _Tp
157  imag() const { return _M_imag; }
158 #else
159  /// Return real part of complex number.
160  _Tp&
161  real() { return _M_real; }
162 
163  /// Return real part of complex number.
164  const _Tp&
165  real() const { return _M_real; }
166 
167  /// Return imaginary part of complex number.
168  _Tp&
169  imag() { return _M_imag; }
170 
171  /// Return imaginary part of complex number.
172  const _Tp&
173  imag() const { return _M_imag; }
174 #endif
175 
176  // _GLIBCXX_RESOLVE_LIB_DEFECTS
177  // DR 387. std::complex over-encapsulated.
178  _GLIBCXX20_CONSTEXPR void
179  real(_Tp __val) { _M_real = __val; }
180 
181  _GLIBCXX20_CONSTEXPR void
182  imag(_Tp __val) { _M_imag = __val; }
183 
184  /// Assign a scalar to this complex number.
185  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator=(const _Tp&);
186 
187  /// Add a scalar to this complex number.
188  // 26.2.5/1
189  _GLIBCXX20_CONSTEXPR complex<_Tp>&
190  operator+=(const _Tp& __t)
191  {
192  _M_real += __t;
193  return *this;
194  }
195 
196  /// Subtract a scalar from this complex number.
197  // 26.2.5/3
198  _GLIBCXX20_CONSTEXPR complex<_Tp>&
199  operator-=(const _Tp& __t)
200  {
201  _M_real -= __t;
202  return *this;
203  }
204 
205  /// Multiply this complex number by a scalar.
206  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator*=(const _Tp&);
207  /// Divide this complex number by a scalar.
208  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator/=(const _Tp&);
209 
210  // Let the compiler synthesize the copy assignment operator
211 #if __cplusplus >= 201103L
212  _GLIBCXX20_CONSTEXPR complex& operator=(const complex&) = default;
213 #endif
214 
215  /// Assign another complex number to this one.
216  template<typename _Up>
217  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator=(const complex<_Up>&);
218  /// Add another complex number to this one.
219  template<typename _Up>
220  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator+=(const complex<_Up>&);
221  /// Subtract another complex number from this one.
222  template<typename _Up>
223  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator-=(const complex<_Up>&);
224  /// Multiply this complex number by another.
225  template<typename _Up>
226  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator*=(const complex<_Up>&);
227  /// Divide this complex number by another.
228  template<typename _Up>
229  _GLIBCXX20_CONSTEXPR complex<_Tp>& operator/=(const complex<_Up>&);
230 
231  _GLIBCXX_CONSTEXPR complex __rep() const
232  { return *this; }
233 
234  private:
235  _Tp _M_real;
236  _Tp _M_imag;
237  };
238 
239  template<typename _Tp>
240  _GLIBCXX20_CONSTEXPR complex<_Tp>&
241  complex<_Tp>::operator=(const _Tp& __t)
242  {
243  _M_real = __t;
244  _M_imag = _Tp();
245  return *this;
246  }
247 
248  // 26.2.5/5
249  template<typename _Tp>
250  _GLIBCXX20_CONSTEXPR complex<_Tp>&
251  complex<_Tp>::operator*=(const _Tp& __t)
252  {
253  _M_real *= __t;
254  _M_imag *= __t;
255  return *this;
256  }
257 
258  // 26.2.5/7
259  template<typename _Tp>
260  _GLIBCXX20_CONSTEXPR complex<_Tp>&
261  complex<_Tp>::operator/=(const _Tp& __t)
262  {
263  _M_real /= __t;
264  _M_imag /= __t;
265  return *this;
266  }
267 
268  template<typename _Tp>
269  template<typename _Up>
270  _GLIBCXX20_CONSTEXPR complex<_Tp>&
271  complex<_Tp>::operator=(const complex<_Up>& __z)
272  {
273  _M_real = __z.real();
274  _M_imag = __z.imag();
275  return *this;
276  }
277 
278  // 26.2.5/9
279  template<typename _Tp>
280  template<typename _Up>
281  _GLIBCXX20_CONSTEXPR complex<_Tp>&
282  complex<_Tp>::operator+=(const complex<_Up>& __z)
283  {
284  _M_real += __z.real();
285  _M_imag += __z.imag();
286  return *this;
287  }
288 
289  // 26.2.5/11
290  template<typename _Tp>
291  template<typename _Up>
292  _GLIBCXX20_CONSTEXPR complex<_Tp>&
293  complex<_Tp>::operator-=(const complex<_Up>& __z)
294  {
295  _M_real -= __z.real();
296  _M_imag -= __z.imag();
297  return *this;
298  }
299 
300  // 26.2.5/13
301  // XXX: This is a grammar school implementation.
302  template<typename _Tp>
303  template<typename _Up>
304  _GLIBCXX20_CONSTEXPR complex<_Tp>&
305  complex<_Tp>::operator*=(const complex<_Up>& __z)
306  {
307  const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
308  _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
309  _M_real = __r;
310  return *this;
311  }
312 
313  // 26.2.5/15
314  // XXX: This is a grammar school implementation.
315  template<typename _Tp>
316  template<typename _Up>
317  _GLIBCXX20_CONSTEXPR complex<_Tp>&
318  complex<_Tp>::operator/=(const complex<_Up>& __z)
319  {
320  const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
321  const _Tp __n = std::norm(__z);
322  _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
323  _M_real = __r / __n;
324  return *this;
325  }
326 
327  // Operators:
328  ///@{
329  /// Return new complex value @a x plus @a y.
330  template<typename _Tp>
331  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
332  operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
333  {
334  complex<_Tp> __r = __x;
335  __r += __y;
336  return __r;
337  }
338 
339  template<typename _Tp>
340  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
341  operator+(const complex<_Tp>& __x, const _Tp& __y)
342  {
343  complex<_Tp> __r = __x;
344  __r += __y;
345  return __r;
346  }
347 
348  template<typename _Tp>
349  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
350  operator+(const _Tp& __x, const complex<_Tp>& __y)
351  {
352  complex<_Tp> __r = __y;
353  __r += __x;
354  return __r;
355  }
356  ///@}
357 
358  ///@{
359  /// Return new complex value @a x minus @a y.
360  template<typename _Tp>
361  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
362  operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
363  {
364  complex<_Tp> __r = __x;
365  __r -= __y;
366  return __r;
367  }
368 
369  template<typename _Tp>
370  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
371  operator-(const complex<_Tp>& __x, const _Tp& __y)
372  {
373  complex<_Tp> __r = __x;
374  __r -= __y;
375  return __r;
376  }
377 
378  template<typename _Tp>
379  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
380  operator-(const _Tp& __x, const complex<_Tp>& __y)
381  {
382  complex<_Tp> __r = -__y;
383  __r += __x;
384  return __r;
385  }
386  ///@}
387 
388  ///@{
389  /// Return new complex value @a x times @a y.
390  template<typename _Tp>
391  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
392  operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
393  {
394  complex<_Tp> __r = __x;
395  __r *= __y;
396  return __r;
397  }
398 
399  template<typename _Tp>
400  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
401  operator*(const complex<_Tp>& __x, const _Tp& __y)
402  {
403  complex<_Tp> __r = __x;
404  __r *= __y;
405  return __r;
406  }
407 
408  template<typename _Tp>
409  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
410  operator*(const _Tp& __x, const complex<_Tp>& __y)
411  {
412  complex<_Tp> __r = __y;
413  __r *= __x;
414  return __r;
415  }
416  ///@}
417 
418  ///@{
419  /// Return new complex value @a x divided by @a y.
420  template<typename _Tp>
421  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
422  operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
423  {
424  complex<_Tp> __r = __x;
425  __r /= __y;
426  return __r;
427  }
428 
429  template<typename _Tp>
430  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
431  operator/(const complex<_Tp>& __x, const _Tp& __y)
432  {
433  complex<_Tp> __r = __x;
434  __r /= __y;
435  return __r;
436  }
437 
438  template<typename _Tp>
439  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
440  operator/(const _Tp& __x, const complex<_Tp>& __y)
441  {
442  complex<_Tp> __r = __x;
443  __r /= __y;
444  return __r;
445  }
446  ///@}
447 
448  /// Return @a x.
449  template<typename _Tp>
450  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
451  operator+(const complex<_Tp>& __x)
452  { return __x; }
453 
454  /// Return complex negation of @a x.
455  template<typename _Tp>
456  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
457  operator-(const complex<_Tp>& __x)
458  { return complex<_Tp>(-__x.real(), -__x.imag()); }
459 
460  ///@{
461  /// Return true if @a x is equal to @a y.
462  template<typename _Tp>
463  inline _GLIBCXX_CONSTEXPR bool
464  operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
465  { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
466 
467  template<typename _Tp>
468  inline _GLIBCXX_CONSTEXPR bool
469  operator==(const complex<_Tp>& __x, const _Tp& __y)
470  { return __x.real() == __y && __x.imag() == _Tp(); }
471 
472 #if !(__cpp_impl_three_way_comparison >= 201907L)
473  template<typename _Tp>
474  inline _GLIBCXX_CONSTEXPR bool
475  operator==(const _Tp& __x, const complex<_Tp>& __y)
476  { return __x == __y.real() && _Tp() == __y.imag(); }
477  ///@}
478 
479  ///@{
480  /// Return false if @a x is equal to @a y.
481  template<typename _Tp>
482  inline _GLIBCXX_CONSTEXPR bool
483  operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
484  { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
485 
486  template<typename _Tp>
487  inline _GLIBCXX_CONSTEXPR bool
488  operator!=(const complex<_Tp>& __x, const _Tp& __y)
489  { return __x.real() != __y || __x.imag() != _Tp(); }
490 
491  template<typename _Tp>
492  inline _GLIBCXX_CONSTEXPR bool
493  operator!=(const _Tp& __x, const complex<_Tp>& __y)
494  { return __x != __y.real() || _Tp() != __y.imag(); }
495 #endif
496  ///@}
497 
498  /// Extraction operator for complex values.
499  template<typename _Tp, typename _CharT, class _Traits>
500  basic_istream<_CharT, _Traits>&
501  operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
502  {
503  bool __fail = true;
504  _CharT __ch;
505  if (__is >> __ch)
506  {
507  if (_Traits::eq(__ch, __is.widen('(')))
508  {
509  _Tp __u;
510  if (__is >> __u >> __ch)
511  {
512  const _CharT __rparen = __is.widen(')');
513  if (_Traits::eq(__ch, __rparen))
514  {
515  __x = __u;
516  __fail = false;
517  }
518  else if (_Traits::eq(__ch, __is.widen(',')))
519  {
520  _Tp __v;
521  if (__is >> __v >> __ch)
522  {
523  if (_Traits::eq(__ch, __rparen))
524  {
525  __x = complex<_Tp>(__u, __v);
526  __fail = false;
527  }
528  else
529  __is.putback(__ch);
530  }
531  }
532  else
533  __is.putback(__ch);
534  }
535  }
536  else
537  {
538  __is.putback(__ch);
539  _Tp __u;
540  if (__is >> __u)
541  {
542  __x = __u;
543  __fail = false;
544  }
545  }
546  }
547  if (__fail)
548  __is.setstate(ios_base::failbit);
549  return __is;
550  }
551 
552  /// Insertion operator for complex values.
553  template<typename _Tp, typename _CharT, class _Traits>
554  basic_ostream<_CharT, _Traits>&
555  operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
556  {
557  basic_ostringstream<_CharT, _Traits> __s;
558  __s.flags(__os.flags());
559  __s.imbue(__os.getloc());
560  __s.precision(__os.precision());
561  __s << '(' << __x.real() << ',' << __x.imag() << ')';
562  return __os << __s.str();
563  }
564 
565  // Values
566 #if __cplusplus >= 201103L
567  template<typename _Tp>
568  constexpr _Tp
569  real(const complex<_Tp>& __z)
570  { return __z.real(); }
571 
572  template<typename _Tp>
573  constexpr _Tp
574  imag(const complex<_Tp>& __z)
575  { return __z.imag(); }
576 #else
577  template<typename _Tp>
578  inline _Tp&
579  real(complex<_Tp>& __z)
580  { return __z.real(); }
581 
582  template<typename _Tp>
583  inline const _Tp&
584  real(const complex<_Tp>& __z)
585  { return __z.real(); }
586 
587  template<typename _Tp>
588  inline _Tp&
589  imag(complex<_Tp>& __z)
590  { return __z.imag(); }
591 
592  template<typename _Tp>
593  inline const _Tp&
594  imag(const complex<_Tp>& __z)
595  { return __z.imag(); }
596 #endif
597 
598  // 26.2.7/3 abs(__z): Returns the magnitude of __z.
599  template<typename _Tp>
600  inline _Tp
601  __complex_abs(const complex<_Tp>& __z)
602  {
603  _Tp __x = __z.real();
604  _Tp __y = __z.imag();
605  const _Tp __s = std::max(abs(__x), abs(__y));
606  if (__s == _Tp()) // well ...
607  return __s;
608  __x /= __s;
609  __y /= __s;
610  return __s * sqrt(__x * __x + __y * __y);
611  }
612 
613 #if _GLIBCXX_USE_C99_COMPLEX
614  inline float
615  __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
616 
617  inline double
618  __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
619 
620  inline long double
621  __complex_abs(const __complex__ long double& __z)
622  { return __builtin_cabsl(__z); }
623 
624  template<typename _Tp>
625  inline _Tp
626  abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
627 #else
628  template<typename _Tp>
629  inline _Tp
630  abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
631 #endif
632 
633 
634  // 26.2.7/4: arg(__z): Returns the phase angle of __z.
635  template<typename _Tp>
636  inline _Tp
637  __complex_arg(const complex<_Tp>& __z)
638  { return atan2(__z.imag(), __z.real()); }
639 
640 #if _GLIBCXX_USE_C99_COMPLEX
641  inline float
642  __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
643 
644  inline double
645  __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
646 
647  inline long double
648  __complex_arg(const __complex__ long double& __z)
649  { return __builtin_cargl(__z); }
650 
651  template<typename _Tp>
652  inline _Tp
653  arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
654 #else
655  template<typename _Tp>
656  inline _Tp
657  arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
658 #endif
659 
660  // 26.2.7/5: norm(__z) returns the squared magnitude of __z.
661  // As defined, norm() is -not- a norm is the common mathematical
662  // sense used in numerics. The helper class _Norm_helper<> tries to
663  // distinguish between builtin floating point and the rest, so as
664  // to deliver an answer as close as possible to the real value.
665  template<bool>
666  struct _Norm_helper
667  {
668  template<typename _Tp>
669  static inline _GLIBCXX20_CONSTEXPR _Tp _S_do_it(const complex<_Tp>& __z)
670  {
671  const _Tp __x = __z.real();
672  const _Tp __y = __z.imag();
673  return __x * __x + __y * __y;
674  }
675  };
676 
677  template<>
678  struct _Norm_helper<true>
679  {
680  template<typename _Tp>
681  static inline _GLIBCXX20_CONSTEXPR _Tp _S_do_it(const complex<_Tp>& __z)
682  {
683  //_Tp __res = std::abs(__z);
684  //return __res * __res;
685  const _Tp __x = __z.real();
686  const _Tp __y = __z.imag();
687  return __x * __x + __y * __y;
688  }
689  };
690 
691  template<typename _Tp>
692  inline _GLIBCXX20_CONSTEXPR _Tp
693  norm(const complex<_Tp>& __z)
694  {
695  return _Norm_helper<__is_floating<_Tp>::__value
696  && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
697  }
698 
699  template<typename _Tp>
700  inline complex<_Tp>
701  polar(const _Tp& __rho, const _Tp& __theta)
702  {
703  __glibcxx_assert( __rho >= 0 );
704  return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta));
705  }
706 
707  template<typename _Tp>
708  inline _GLIBCXX20_CONSTEXPR complex<_Tp>
709  conj(const complex<_Tp>& __z)
710  { return complex<_Tp>(__z.real(), -__z.imag()); }
711 
712  // Transcendentals
713 
714  // 26.2.8/1 cos(__z): Returns the cosine of __z.
715  template<typename _Tp>
716  inline complex<_Tp>
717  __complex_cos(const complex<_Tp>& __z)
718  {
719  const _Tp __x = __z.real();
720  const _Tp __y = __z.imag();
721  return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
722  }
723 
724 #if _GLIBCXX_USE_C99_COMPLEX
725  inline __complex__ float
726  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
727 
728  inline __complex__ double
729  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
730 
731  inline __complex__ long double
732  __complex_cos(const __complex__ long double& __z)
733  { return __builtin_ccosl(__z); }
734 
735  template<typename _Tp>
736  inline complex<_Tp>
737  cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
738 #else
739  template<typename _Tp>
740  inline complex<_Tp>
741  cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
742 #endif
743 
744  // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
745  template<typename _Tp>
746  inline complex<_Tp>
747  __complex_cosh(const complex<_Tp>& __z)
748  {
749  const _Tp __x = __z.real();
750  const _Tp __y = __z.imag();
751  return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
752  }
753 
754 #if _GLIBCXX_USE_C99_COMPLEX
755  inline __complex__ float
756  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
757 
758  inline __complex__ double
759  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
760 
761  inline __complex__ long double
762  __complex_cosh(const __complex__ long double& __z)
763  { return __builtin_ccoshl(__z); }
764 
765  template<typename _Tp>
766  inline complex<_Tp>
767  cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
768 #else
769  template<typename _Tp>
770  inline complex<_Tp>
771  cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
772 #endif
773 
774  // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
775  template<typename _Tp>
776  inline complex<_Tp>
777  __complex_exp(const complex<_Tp>& __z)
778  { return std::polar<_Tp>(exp(__z.real()), __z.imag()); }
779 
780 #if _GLIBCXX_USE_C99_COMPLEX
781  inline __complex__ float
782  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
783 
784  inline __complex__ double
785  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
786 
787  inline __complex__ long double
788  __complex_exp(const __complex__ long double& __z)
789  { return __builtin_cexpl(__z); }
790 
791  template<typename _Tp>
792  inline complex<_Tp>
793  exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
794 #else
795  template<typename _Tp>
796  inline complex<_Tp>
797  exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
798 #endif
799 
800  // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z.
801  // The branch cut is along the negative axis.
802  template<typename _Tp>
803  inline complex<_Tp>
804  __complex_log(const complex<_Tp>& __z)
805  { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
806 
807 #if _GLIBCXX_USE_C99_COMPLEX
808  inline __complex__ float
809  __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
810 
811  inline __complex__ double
812  __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
813 
814  inline __complex__ long double
815  __complex_log(const __complex__ long double& __z)
816  { return __builtin_clogl(__z); }
817 
818  template<typename _Tp>
819  inline complex<_Tp>
820  log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
821 #else
822  template<typename _Tp>
823  inline complex<_Tp>
824  log(const complex<_Tp>& __z) { return __complex_log(__z); }
825 #endif
826 
827  template<typename _Tp>
828  inline complex<_Tp>
829  log10(const complex<_Tp>& __z)
830  { return std::log(__z) / log(_Tp(10.0)); }
831 
832  // 26.2.8/10 sin(__z): Returns the sine of __z.
833  template<typename _Tp>
834  inline complex<_Tp>
835  __complex_sin(const complex<_Tp>& __z)
836  {
837  const _Tp __x = __z.real();
838  const _Tp __y = __z.imag();
839  return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
840  }
841 
842 #if _GLIBCXX_USE_C99_COMPLEX
843  inline __complex__ float
844  __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
845 
846  inline __complex__ double
847  __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
848 
849  inline __complex__ long double
850  __complex_sin(const __complex__ long double& __z)
851  { return __builtin_csinl(__z); }
852 
853  template<typename _Tp>
854  inline complex<_Tp>
855  sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
856 #else
857  template<typename _Tp>
858  inline complex<_Tp>
859  sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
860 #endif
861 
862  // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
863  template<typename _Tp>
864  inline complex<_Tp>
865  __complex_sinh(const complex<_Tp>& __z)
866  {
867  const _Tp __x = __z.real();
868  const _Tp __y = __z.imag();
869  return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
870  }
871 
872 #if _GLIBCXX_USE_C99_COMPLEX
873  inline __complex__ float
874  __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
875 
876  inline __complex__ double
877  __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
878 
879  inline __complex__ long double
880  __complex_sinh(const __complex__ long double& __z)
881  { return __builtin_csinhl(__z); }
882 
883  template<typename _Tp>
884  inline complex<_Tp>
885  sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
886 #else
887  template<typename _Tp>
888  inline complex<_Tp>
889  sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
890 #endif
891 
892  // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
893  // The branch cut is on the negative axis.
894  template<typename _Tp>
895  complex<_Tp>
896  __complex_sqrt(const complex<_Tp>& __z)
897  {
898  _Tp __x = __z.real();
899  _Tp __y = __z.imag();
900 
901  if (__x == _Tp())
902  {
903  _Tp __t = sqrt(abs(__y) / 2);
904  return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
905  }
906  else
907  {
908  _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
909  _Tp __u = __t / 2;
910  return __x > _Tp()
911  ? complex<_Tp>(__u, __y / __t)
912  : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
913  }
914  }
915 
916 #if _GLIBCXX_USE_C99_COMPLEX
917  inline __complex__ float
918  __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
919 
920  inline __complex__ double
921  __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
922 
923  inline __complex__ long double
924  __complex_sqrt(const __complex__ long double& __z)
925  { return __builtin_csqrtl(__z); }
926 
927  template<typename _Tp>
928  inline complex<_Tp>
929  sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
930 #else
931  template<typename _Tp>
932  inline complex<_Tp>
933  sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
934 #endif
935 
936  // 26.2.8/14 tan(__z): Return the complex tangent of __z.
937 
938  template<typename _Tp>
939  inline complex<_Tp>
940  __complex_tan(const complex<_Tp>& __z)
941  { return std::sin(__z) / std::cos(__z); }
942 
943 #if _GLIBCXX_USE_C99_COMPLEX
944  inline __complex__ float
945  __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
946 
947  inline __complex__ double
948  __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
949 
950  inline __complex__ long double
951  __complex_tan(const __complex__ long double& __z)
952  { return __builtin_ctanl(__z); }
953 
954  template<typename _Tp>
955  inline complex<_Tp>
956  tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
957 #else
958  template<typename _Tp>
959  inline complex<_Tp>
960  tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
961 #endif
962 
963 
964  // 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z.
965 
966  template<typename _Tp>
967  inline complex<_Tp>
968  __complex_tanh(const complex<_Tp>& __z)
969  { return std::sinh(__z) / std::cosh(__z); }
970 
971 #if _GLIBCXX_USE_C99_COMPLEX
972  inline __complex__ float
973  __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
974 
975  inline __complex__ double
976  __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
977 
978  inline __complex__ long double
979  __complex_tanh(const __complex__ long double& __z)
980  { return __builtin_ctanhl(__z); }
981 
982  template<typename _Tp>
983  inline complex<_Tp>
984  tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
985 #else
986  template<typename _Tp>
987  inline complex<_Tp>
988  tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
989 #endif
990 
991 
992  // 26.2.8/9 pow(__x, __y): Returns the complex power base of __x
993  // raised to the __y-th power. The branch
994  // cut is on the negative axis.
995  template<typename _Tp>
996  complex<_Tp>
997  __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
998  {
999  complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
1000 
1001  while (__n >>= 1)
1002  {
1003  __x *= __x;
1004  if (__n % 2)
1005  __y *= __x;
1006  }
1007 
1008  return __y;
1009  }
1010 
1011  // In C++11 mode we used to implement the resolution of
1012  // DR 844. complex pow return type is ambiguous.
1013  // thus the following overload was disabled in that mode. However, doing
1014  // that causes all sorts of issues, see, for example:
1015  // http://gcc.gnu.org/ml/libstdc++/2013-01/msg00058.html
1016  // and also PR57974.
1017  template<typename _Tp>
1018  inline complex<_Tp>
1019  pow(const complex<_Tp>& __z, int __n)
1020  {
1021  return __n < 0
1022  ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -(unsigned)__n)
1023  : std::__complex_pow_unsigned(__z, __n);
1024  }
1025 
1026  template<typename _Tp>
1027  complex<_Tp>
1028  pow(const complex<_Tp>& __x, const _Tp& __y)
1029  {
1030 #if ! _GLIBCXX_USE_C99_COMPLEX
1031  if (__x == _Tp())
1032  return _Tp();
1033 #endif
1034  if (__x.imag() == _Tp() && __x.real() > _Tp())
1035  return pow(__x.real(), __y);
1036 
1037  complex<_Tp> __t = std::log(__x);
1038  return std::polar<_Tp>(exp(__y * __t.real()), __y * __t.imag());
1039  }
1040 
1041  template<typename _Tp>
1042  inline complex<_Tp>
1043  __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1044  { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
1045 
1046 #if _GLIBCXX_USE_C99_COMPLEX
1047  inline __complex__ float
1048  __complex_pow(__complex__ float __x, __complex__ float __y)
1049  { return __builtin_cpowf(__x, __y); }
1050 
1051  inline __complex__ double
1052  __complex_pow(__complex__ double __x, __complex__ double __y)
1053  { return __builtin_cpow(__x, __y); }
1054 
1055  inline __complex__ long double
1056  __complex_pow(const __complex__ long double& __x,
1057  const __complex__ long double& __y)
1058  { return __builtin_cpowl(__x, __y); }
1059 
1060  template<typename _Tp>
1061  inline complex<_Tp>
1062  pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1063  { return __complex_pow(__x.__rep(), __y.__rep()); }
1064 #else
1065  template<typename _Tp>
1066  inline complex<_Tp>
1067  pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1068  { return __complex_pow(__x, __y); }
1069 #endif
1070 
1071  template<typename _Tp>
1072  inline complex<_Tp>
1073  pow(const _Tp& __x, const complex<_Tp>& __y)
1074  {
1075  return __x > _Tp() ? std::polar<_Tp>(pow(__x, __y.real()),
1076  __y.imag() * log(__x))
1077  : std::pow(complex<_Tp>(__x), __y);
1078  }
1079 
1080  /// 26.2.3 complex specializations
1081  /// complex<float> specialization
1082  template<>
1083  class complex<float>
1084  {
1085  public:
1086  typedef float value_type;
1087  typedef __complex__ float _ComplexT;
1088 
1089  _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1090 
1091  _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f)
1092 #if __cplusplus >= 201103L
1093  : _M_value{ __r, __i } { }
1094 #else
1095  {
1096  __real__ _M_value = __r;
1097  __imag__ _M_value = __i;
1098  }
1099 #endif
1100 
1101  explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&);
1102  explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1103 
1104 #if __cplusplus >= 201103L
1105  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1106  // DR 387. std::complex over-encapsulated.
1107  __attribute ((__abi_tag__ ("cxx11")))
1108  constexpr float
1109  real() const { return __real__ _M_value; }
1110 
1111  __attribute ((__abi_tag__ ("cxx11")))
1112  constexpr float
1113  imag() const { return __imag__ _M_value; }
1114 #else
1115  float&
1116  real() { return __real__ _M_value; }
1117 
1118  const float&
1119  real() const { return __real__ _M_value; }
1120 
1121  float&
1122  imag() { return __imag__ _M_value; }
1123 
1124  const float&
1125  imag() const { return __imag__ _M_value; }
1126 #endif
1127 
1128  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1129  // DR 387. std::complex over-encapsulated.
1130  _GLIBCXX20_CONSTEXPR void
1131  real(float __val) { __real__ _M_value = __val; }
1132 
1133  _GLIBCXX20_CONSTEXPR void
1134  imag(float __val) { __imag__ _M_value = __val; }
1135 
1136  _GLIBCXX20_CONSTEXPR complex&
1137  operator=(float __f)
1138  {
1139  _M_value = __f;
1140  return *this;
1141  }
1142 
1143  _GLIBCXX20_CONSTEXPR complex&
1144  operator+=(float __f)
1145  {
1146  _M_value += __f;
1147  return *this;
1148  }
1149 
1150  _GLIBCXX20_CONSTEXPR complex&
1151  operator-=(float __f)
1152  {
1153  _M_value -= __f;
1154  return *this;
1155  }
1156 
1157  _GLIBCXX20_CONSTEXPR complex&
1158  operator*=(float __f)
1159  {
1160  _M_value *= __f;
1161  return *this;
1162  }
1163 
1164  _GLIBCXX20_CONSTEXPR complex&
1165  operator/=(float __f)
1166  {
1167  _M_value /= __f;
1168  return *this;
1169  }
1170 
1171  // Let the compiler synthesize the copy and assignment
1172  // operator. It always does a pretty good job.
1173 #if __cplusplus >= 201103L
1174  _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1175 #endif
1176 
1177  template<typename _Tp>
1178  _GLIBCXX20_CONSTEXPR complex&
1179  operator=(const complex<_Tp>& __z)
1180  {
1181  __real__ _M_value = __z.real();
1182  __imag__ _M_value = __z.imag();
1183  return *this;
1184  }
1185 
1186  template<typename _Tp>
1187  _GLIBCXX20_CONSTEXPR complex&
1188  operator+=(const complex<_Tp>& __z)
1189  {
1190  _M_value += __z.__rep();
1191  return *this;
1192  }
1193 
1194  template<class _Tp>
1195  _GLIBCXX20_CONSTEXPR complex&
1196  operator-=(const complex<_Tp>& __z)
1197  {
1198  _M_value -= __z.__rep();
1199  return *this;
1200  }
1201 
1202  template<class _Tp>
1203  _GLIBCXX20_CONSTEXPR complex&
1204  operator*=(const complex<_Tp>& __z)
1205  {
1206  const _ComplexT __t = __z.__rep();
1207  _M_value *= __t;
1208  return *this;
1209  }
1210 
1211  template<class _Tp>
1212  _GLIBCXX20_CONSTEXPR complex&
1213  operator/=(const complex<_Tp>& __z)
1214  {
1215  const _ComplexT __t = __z.__rep();
1216  _M_value /= __t;
1217  return *this;
1218  }
1219 
1220  _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1221 
1222  private:
1223  _ComplexT _M_value;
1224  };
1225 
1226  /// 26.2.3 complex specializations
1227  /// complex<double> specialization
1228  template<>
1229  class complex<double>
1230  {
1231  public:
1232  typedef double value_type;
1233  typedef __complex__ double _ComplexT;
1234 
1235  _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1236 
1237  _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0)
1238 #if __cplusplus >= 201103L
1239  : _M_value{ __r, __i } { }
1240 #else
1241  {
1242  __real__ _M_value = __r;
1243  __imag__ _M_value = __i;
1244  }
1245 #endif
1246 
1247  _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1248  : _M_value(__z.__rep()) { }
1249 
1250  explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1251 
1252 #if __cplusplus >= 201103L
1253  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1254  // DR 387. std::complex over-encapsulated.
1255  __attribute ((__abi_tag__ ("cxx11")))
1256  constexpr double
1257  real() const { return __real__ _M_value; }
1258 
1259  __attribute ((__abi_tag__ ("cxx11")))
1260  constexpr double
1261  imag() const { return __imag__ _M_value; }
1262 #else
1263  double&
1264  real() { return __real__ _M_value; }
1265 
1266  const double&
1267  real() const { return __real__ _M_value; }
1268 
1269  double&
1270  imag() { return __imag__ _M_value; }
1271 
1272  const double&
1273  imag() const { return __imag__ _M_value; }
1274 #endif
1275 
1276  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1277  // DR 387. std::complex over-encapsulated.
1278  _GLIBCXX20_CONSTEXPR void
1279  real(double __val) { __real__ _M_value = __val; }
1280 
1281  _GLIBCXX20_CONSTEXPR void
1282  imag(double __val) { __imag__ _M_value = __val; }
1283 
1284  _GLIBCXX20_CONSTEXPR complex&
1285  operator=(double __d)
1286  {
1287  _M_value = __d;
1288  return *this;
1289  }
1290 
1291  _GLIBCXX20_CONSTEXPR complex&
1292  operator+=(double __d)
1293  {
1294  _M_value += __d;
1295  return *this;
1296  }
1297 
1298  _GLIBCXX20_CONSTEXPR complex&
1299  operator-=(double __d)
1300  {
1301  _M_value -= __d;
1302  return *this;
1303  }
1304 
1305  _GLIBCXX20_CONSTEXPR complex&
1306  operator*=(double __d)
1307  {
1308  _M_value *= __d;
1309  return *this;
1310  }
1311 
1312  _GLIBCXX20_CONSTEXPR complex&
1313  operator/=(double __d)
1314  {
1315  _M_value /= __d;
1316  return *this;
1317  }
1318 
1319  // The compiler will synthesize this, efficiently.
1320 #if __cplusplus >= 201103L
1321  _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1322 #endif
1323 
1324  template<typename _Tp>
1325  _GLIBCXX20_CONSTEXPR complex&
1326  operator=(const complex<_Tp>& __z)
1327  {
1328  _M_value = __z.__rep();
1329  return *this;
1330  }
1331 
1332  template<typename _Tp>
1333  _GLIBCXX20_CONSTEXPR complex&
1334  operator+=(const complex<_Tp>& __z)
1335  {
1336  _M_value += __z.__rep();
1337  return *this;
1338  }
1339 
1340  template<typename _Tp>
1341  _GLIBCXX20_CONSTEXPR complex&
1342  operator-=(const complex<_Tp>& __z)
1343  {
1344  _M_value -= __z.__rep();
1345  return *this;
1346  }
1347 
1348  template<typename _Tp>
1349  _GLIBCXX20_CONSTEXPR complex&
1350  operator*=(const complex<_Tp>& __z)
1351  {
1352  const _ComplexT __t = __z.__rep();
1353  _M_value *= __t;
1354  return *this;
1355  }
1356 
1357  template<typename _Tp>
1358  _GLIBCXX20_CONSTEXPR complex&
1359  operator/=(const complex<_Tp>& __z)
1360  {
1361  const _ComplexT __t = __z.__rep();
1362  _M_value /= __t;
1363  return *this;
1364  }
1365 
1366  _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1367 
1368  private:
1369  _ComplexT _M_value;
1370  };
1371 
1372  /// 26.2.3 complex specializations
1373  /// complex<long double> specialization
1374  template<>
1375  class complex<long double>
1376  {
1377  public:
1378  typedef long double value_type;
1379  typedef __complex__ long double _ComplexT;
1380 
1381  _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1382 
1383  _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L,
1384  long double __i = 0.0L)
1385 #if __cplusplus >= 201103L
1386  : _M_value{ __r, __i } { }
1387 #else
1388  {
1389  __real__ _M_value = __r;
1390  __imag__ _M_value = __i;
1391  }
1392 #endif
1393 
1394  _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1395  : _M_value(__z.__rep()) { }
1396 
1397  _GLIBCXX_CONSTEXPR complex(const complex<double>& __z)
1398  : _M_value(__z.__rep()) { }
1399 
1400 #if __cplusplus >= 201103L
1401  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1402  // DR 387. std::complex over-encapsulated.
1403  __attribute ((__abi_tag__ ("cxx11")))
1404  constexpr long double
1405  real() const { return __real__ _M_value; }
1406 
1407  __attribute ((__abi_tag__ ("cxx11")))
1408  constexpr long double
1409  imag() const { return __imag__ _M_value; }
1410 #else
1411  long double&
1412  real() { return __real__ _M_value; }
1413 
1414  const long double&
1415  real() const { return __real__ _M_value; }
1416 
1417  long double&
1418  imag() { return __imag__ _M_value; }
1419 
1420  const long double&
1421  imag() const { return __imag__ _M_value; }
1422 #endif
1423 
1424  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1425  // DR 387. std::complex over-encapsulated.
1426  _GLIBCXX20_CONSTEXPR void
1427  real(long double __val) { __real__ _M_value = __val; }
1428 
1429  _GLIBCXX20_CONSTEXPR void
1430  imag(long double __val) { __imag__ _M_value = __val; }
1431 
1432  _GLIBCXX20_CONSTEXPR complex&
1433  operator=(long double __r)
1434  {
1435  _M_value = __r;
1436  return *this;
1437  }
1438 
1439  _GLIBCXX20_CONSTEXPR complex&
1440  operator+=(long double __r)
1441  {
1442  _M_value += __r;
1443  return *this;
1444  }
1445 
1446  _GLIBCXX20_CONSTEXPR complex&
1447  operator-=(long double __r)
1448  {
1449  _M_value -= __r;
1450  return *this;
1451  }
1452 
1453  _GLIBCXX20_CONSTEXPR complex&
1454  operator*=(long double __r)
1455  {
1456  _M_value *= __r;
1457  return *this;
1458  }
1459 
1460  _GLIBCXX20_CONSTEXPR complex&
1461  operator/=(long double __r)
1462  {
1463  _M_value /= __r;
1464  return *this;
1465  }
1466 
1467  // The compiler knows how to do this efficiently
1468 #if __cplusplus >= 201103L
1469  _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1470 #endif
1471 
1472  template<typename _Tp>
1473  _GLIBCXX20_CONSTEXPR complex&
1474  operator=(const complex<_Tp>& __z)
1475  {
1476  _M_value = __z.__rep();
1477  return *this;
1478  }
1479 
1480  template<typename _Tp>
1481  _GLIBCXX20_CONSTEXPR complex&
1482  operator+=(const complex<_Tp>& __z)
1483  {
1484  _M_value += __z.__rep();
1485  return *this;
1486  }
1487 
1488  template<typename _Tp>
1489  _GLIBCXX20_CONSTEXPR complex&
1490  operator-=(const complex<_Tp>& __z)
1491  {
1492  _M_value -= __z.__rep();
1493  return *this;
1494  }
1495 
1496  template<typename _Tp>
1497  _GLIBCXX20_CONSTEXPR complex&
1498  operator*=(const complex<_Tp>& __z)
1499  {
1500  const _ComplexT __t = __z.__rep();
1501  _M_value *= __t;
1502  return *this;
1503  }
1504 
1505  template<typename _Tp>
1506  _GLIBCXX20_CONSTEXPR complex&
1507  operator/=(const complex<_Tp>& __z)
1508  {
1509  const _ComplexT __t = __z.__rep();
1510  _M_value /= __t;
1511  return *this;
1512  }
1513 
1514  _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1515 
1516  private:
1517  _ComplexT _M_value;
1518  };
1519 
1520  // These bits have to be at the end of this file, so that the
1521  // specializations have all been defined.
1522  inline _GLIBCXX_CONSTEXPR
1523  complex<float>::complex(const complex<double>& __z)
1524  : _M_value(__z.__rep()) { }
1525 
1526  inline _GLIBCXX_CONSTEXPR
1527  complex<float>::complex(const complex<long double>& __z)
1528  : _M_value(__z.__rep()) { }
1529 
1530  inline _GLIBCXX_CONSTEXPR
1531  complex<double>::complex(const complex<long double>& __z)
1532  : _M_value(__z.__rep()) { }
1533 
1534  // Inhibit implicit instantiations for required instantiations,
1535  // which are defined via explicit instantiations elsewhere.
1536  // NB: This syntax is a GNU extension.
1537 #if _GLIBCXX_EXTERN_TEMPLATE
1538  extern template istream& operator>>(istream&, complex<float>&);
1539  extern template ostream& operator<<(ostream&, const complex<float>&);
1540  extern template istream& operator>>(istream&, complex<double>&);
1541  extern template ostream& operator<<(ostream&, const complex<double>&);
1542  extern template istream& operator>>(istream&, complex<long double>&);
1543  extern template ostream& operator<<(ostream&, const complex<long double>&);
1544 
1545 #ifdef _GLIBCXX_USE_WCHAR_T
1546  extern template wistream& operator>>(wistream&, complex<float>&);
1547  extern template wostream& operator<<(wostream&, const complex<float>&);
1548  extern template wistream& operator>>(wistream&, complex<double>&);
1549  extern template wostream& operator<<(wostream&, const complex<double>&);
1550  extern template wistream& operator>>(wistream&, complex<long double>&);
1551  extern template wostream& operator<<(wostream&, const complex<long double>&);
1552 #endif
1553 #endif
1554 
1555  /// @} group complex_numbers
1556 
1557 _GLIBCXX_END_NAMESPACE_VERSION
1558 } // namespace
1559 
1560 #if __cplusplus >= 201103L
1561 
1562 namespace std _GLIBCXX_VISIBILITY(default)
1563 {
1564 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1565 
1566  // Forward declarations.
1567  template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
1568  template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
1569  template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
1570 
1571  template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
1572  template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
1573  template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
1574  // DR 595.
1575  template<typename _Tp> _Tp fabs(const std::complex<_Tp>&);
1576 
1577  template<typename _Tp>
1578  inline std::complex<_Tp>
1579  __complex_acos(const std::complex<_Tp>& __z)
1580  {
1581  const std::complex<_Tp> __t = std::asin(__z);
1582  const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
1583  return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
1584  }
1585 
1586 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1587  inline __complex__ float
1588  __complex_acos(__complex__ float __z)
1589  { return __builtin_cacosf(__z); }
1590 
1591  inline __complex__ double
1592  __complex_acos(__complex__ double __z)
1593  { return __builtin_cacos(__z); }
1594 
1595  inline __complex__ long double
1596  __complex_acos(const __complex__ long double& __z)
1597  { return __builtin_cacosl(__z); }
1598 
1599  template<typename _Tp>
1600  inline std::complex<_Tp>
1601  acos(const std::complex<_Tp>& __z)
1602  { return __complex_acos(__z.__rep()); }
1603 #else
1604  /// acos(__z) [8.1.2].
1605  // Effects: Behaves the same as C99 function cacos, defined
1606  // in subclause 7.3.5.1.
1607  template<typename _Tp>
1608  inline std::complex<_Tp>
1609  acos(const std::complex<_Tp>& __z)
1610  { return __complex_acos(__z); }
1611 #endif
1612 
1613  template<typename _Tp>
1614  inline std::complex<_Tp>
1615  __complex_asin(const std::complex<_Tp>& __z)
1616  {
1617  std::complex<_Tp> __t(-__z.imag(), __z.real());
1618  __t = std::asinh(__t);
1619  return std::complex<_Tp>(__t.imag(), -__t.real());
1620  }
1621 
1622 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1623  inline __complex__ float
1624  __complex_asin(__complex__ float __z)
1625  { return __builtin_casinf(__z); }
1626 
1627  inline __complex__ double
1628  __complex_asin(__complex__ double __z)
1629  { return __builtin_casin(__z); }
1630 
1631  inline __complex__ long double
1632  __complex_asin(const __complex__ long double& __z)
1633  { return __builtin_casinl(__z); }
1634 
1635  template<typename _Tp>
1636  inline std::complex<_Tp>
1637  asin(const std::complex<_Tp>& __z)
1638  { return __complex_asin(__z.__rep()); }
1639 #else
1640  /// asin(__z) [8.1.3].
1641  // Effects: Behaves the same as C99 function casin, defined
1642  // in subclause 7.3.5.2.
1643  template<typename _Tp>
1644  inline std::complex<_Tp>
1645  asin(const std::complex<_Tp>& __z)
1646  { return __complex_asin(__z); }
1647 #endif
1648 
1649  template<typename _Tp>
1650  std::complex<_Tp>
1651  __complex_atan(const std::complex<_Tp>& __z)
1652  {
1653  const _Tp __r2 = __z.real() * __z.real();
1654  const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
1655 
1656  _Tp __num = __z.imag() + _Tp(1.0);
1657  _Tp __den = __z.imag() - _Tp(1.0);
1658 
1659  __num = __r2 + __num * __num;
1660  __den = __r2 + __den * __den;
1661 
1662  return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
1663  _Tp(0.25) * log(__num / __den));
1664  }
1665 
1666 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1667  inline __complex__ float
1668  __complex_atan(__complex__ float __z)
1669  { return __builtin_catanf(__z); }
1670 
1671  inline __complex__ double
1672  __complex_atan(__complex__ double __z)
1673  { return __builtin_catan(__z); }
1674 
1675  inline __complex__ long double
1676  __complex_atan(const __complex__ long double& __z)
1677  { return __builtin_catanl(__z); }
1678 
1679  template<typename _Tp>
1680  inline std::complex<_Tp>
1681  atan(const std::complex<_Tp>& __z)
1682  { return __complex_atan(__z.__rep()); }
1683 #else
1684  /// atan(__z) [8.1.4].
1685  // Effects: Behaves the same as C99 function catan, defined
1686  // in subclause 7.3.5.3.
1687  template<typename _Tp>
1688  inline std::complex<_Tp>
1689  atan(const std::complex<_Tp>& __z)
1690  { return __complex_atan(__z); }
1691 #endif
1692 
1693  template<typename _Tp>
1694  std::complex<_Tp>
1695  __complex_acosh(const std::complex<_Tp>& __z)
1696  {
1697  // Kahan's formula.
1698  return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
1699  + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
1700  }
1701 
1702 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1703  inline __complex__ float
1704  __complex_acosh(__complex__ float __z)
1705  { return __builtin_cacoshf(__z); }
1706 
1707  inline __complex__ double
1708  __complex_acosh(__complex__ double __z)
1709  { return __builtin_cacosh(__z); }
1710 
1711  inline __complex__ long double
1712  __complex_acosh(const __complex__ long double& __z)
1713  { return __builtin_cacoshl(__z); }
1714 
1715  template<typename _Tp>
1716  inline std::complex<_Tp>
1717  acosh(const std::complex<_Tp>& __z)
1718  { return __complex_acosh(__z.__rep()); }
1719 #else
1720  /// acosh(__z) [8.1.5].
1721  // Effects: Behaves the same as C99 function cacosh, defined
1722  // in subclause 7.3.6.1.
1723  template<typename _Tp>
1724  inline std::complex<_Tp>
1725  acosh(const std::complex<_Tp>& __z)
1726  { return __complex_acosh(__z); }
1727 #endif
1728 
1729  template<typename _Tp>
1730  std::complex<_Tp>
1731  __complex_asinh(const std::complex<_Tp>& __z)
1732  {
1733  std::complex<_Tp> __t((__z.real() - __z.imag())
1734  * (__z.real() + __z.imag()) + _Tp(1.0),
1735  _Tp(2.0) * __z.real() * __z.imag());
1736  __t = std::sqrt(__t);
1737 
1738  return std::log(__t + __z);
1739  }
1740 
1741 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1742  inline __complex__ float
1743  __complex_asinh(__complex__ float __z)
1744  { return __builtin_casinhf(__z); }
1745 
1746  inline __complex__ double
1747  __complex_asinh(__complex__ double __z)
1748  { return __builtin_casinh(__z); }
1749 
1750  inline __complex__ long double
1751  __complex_asinh(const __complex__ long double& __z)
1752  { return __builtin_casinhl(__z); }
1753 
1754  template<typename _Tp>
1755  inline std::complex<_Tp>
1756  asinh(const std::complex<_Tp>& __z)
1757  { return __complex_asinh(__z.__rep()); }
1758 #else
1759  /// asinh(__z) [8.1.6].
1760  // Effects: Behaves the same as C99 function casin, defined
1761  // in subclause 7.3.6.2.
1762  template<typename _Tp>
1763  inline std::complex<_Tp>
1764  asinh(const std::complex<_Tp>& __z)
1765  { return __complex_asinh(__z); }
1766 #endif
1767 
1768  template<typename _Tp>
1769  std::complex<_Tp>
1770  __complex_atanh(const std::complex<_Tp>& __z)
1771  {
1772  const _Tp __i2 = __z.imag() * __z.imag();
1773  const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
1774 
1775  _Tp __num = _Tp(1.0) + __z.real();
1776  _Tp __den = _Tp(1.0) - __z.real();
1777 
1778  __num = __i2 + __num * __num;
1779  __den = __i2 + __den * __den;
1780 
1781  return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
1782  _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
1783  }
1784 
1785 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1786  inline __complex__ float
1787  __complex_atanh(__complex__ float __z)
1788  { return __builtin_catanhf(__z); }
1789 
1790  inline __complex__ double
1791  __complex_atanh(__complex__ double __z)
1792  { return __builtin_catanh(__z); }
1793 
1794  inline __complex__ long double
1795  __complex_atanh(const __complex__ long double& __z)
1796  { return __builtin_catanhl(__z); }
1797 
1798  template<typename _Tp>
1799  inline std::complex<_Tp>
1800  atanh(const std::complex<_Tp>& __z)
1801  { return __complex_atanh(__z.__rep()); }
1802 #else
1803  /// atanh(__z) [8.1.7].
1804  // Effects: Behaves the same as C99 function catanh, defined
1805  // in subclause 7.3.6.3.
1806  template<typename _Tp>
1807  inline std::complex<_Tp>
1808  atanh(const std::complex<_Tp>& __z)
1809  { return __complex_atanh(__z); }
1810 #endif
1811 
1812  template<typename _Tp>
1813  inline _Tp
1814  /// fabs(__z) [8.1.8].
1815  // Effects: Behaves the same as C99 function cabs, defined
1816  // in subclause 7.3.8.1.
1817  fabs(const std::complex<_Tp>& __z)
1818  { return std::abs(__z); }
1819 
1820  /// Additional overloads [8.1.9].
1821  template<typename _Tp>
1822  inline typename __gnu_cxx::__promote<_Tp>::__type
1823  arg(_Tp __x)
1824  {
1825  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1826 #if (_GLIBCXX11_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
1827  return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
1828  : __type();
1829 #else
1830  return std::arg(std::complex<__type>(__x));
1831 #endif
1832  }
1833 
1834  template<typename _Tp>
1835  _GLIBCXX_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
1836  imag(_Tp)
1837  { return _Tp(); }
1838 
1839  template<typename _Tp>
1840  _GLIBCXX20_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
1841  norm(_Tp __x)
1842  {
1843  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1844  return __type(__x) * __type(__x);
1845  }
1846 
1847  template<typename _Tp>
1848  _GLIBCXX_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
1849  real(_Tp __x)
1850  { return __x; }
1851 
1852  template<typename _Tp, typename _Up>
1853  inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1854  pow(const std::complex<_Tp>& __x, const _Up& __y)
1855  {
1856  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1857  return std::pow(std::complex<__type>(__x), __type(__y));
1858  }
1859 
1860  template<typename _Tp, typename _Up>
1861  inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1862  pow(const _Tp& __x, const std::complex<_Up>& __y)
1863  {
1864  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1865  return std::pow(__type(__x), std::complex<__type>(__y));
1866  }
1867 
1868  template<typename _Tp, typename _Up>
1869  inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1870  pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
1871  {
1872  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1873  return std::pow(std::complex<__type>(__x),
1874  std::complex<__type>(__y));
1875  }
1876 
1877  // Forward declarations.
1878  // DR 781.
1879  template<typename _Tp>
1880  std::complex<_Tp> proj(const std::complex<_Tp>&);
1881 
1882  // Generic implementation of std::proj, does not work for infinities.
1883  template<typename _Tp>
1884  inline std::complex<_Tp>
1885  __complex_proj(const std::complex<_Tp>& __z)
1886  { return __z; }
1887 
1888 #if _GLIBCXX_USE_C99_COMPLEX
1889  inline complex<float>
1890  __complex_proj(const complex<float>& __z)
1891  { return __builtin_cprojf(__z.__rep()); }
1892 
1893  inline complex<double>
1894  __complex_proj(const complex<double>& __z)
1895  { return __builtin_cproj(__z.__rep()); }
1896 
1897  inline complex<long double>
1898  __complex_proj(const complex<long double>& __z)
1899  { return __builtin_cprojl(__z.__rep()); }
1900 #elif defined _GLIBCXX_USE_C99_MATH_TR1
1901  inline complex<float>
1902  __complex_proj(const complex<float>& __z)
1903  {
1904  if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
1905  return complex<float>(__builtin_inff(),
1906  __builtin_copysignf(0.0f, __z.imag()));
1907  return __z;
1908  }
1909 
1910  inline complex<double>
1911  __complex_proj(const complex<double>& __z)
1912  {
1913  if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
1914  return complex<double>(__builtin_inf(),
1915  __builtin_copysign(0.0, __z.imag()));
1916  return __z;
1917  }
1918 
1919  inline complex<long double>
1920  __complex_proj(const complex<long double>& __z)
1921  {
1922  if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
1923  return complex<long double>(__builtin_infl(),
1924  __builtin_copysignl(0.0l, __z.imag()));
1925  return __z;
1926  }
1927 #endif
1928 
1929  template<typename _Tp>
1930  inline std::complex<_Tp>
1931  proj(const std::complex<_Tp>& __z)
1932  { return __complex_proj(__z); }
1933 
1934  // Overload for scalars
1935  template<typename _Tp>
1936  inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
1937  proj(_Tp __x)
1938  {
1939  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1940  return std::proj(std::complex<__type>(__x));
1941  }
1942 
1943  template<typename _Tp>
1944  inline _GLIBCXX20_CONSTEXPR
1945  std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
1946  conj(_Tp __x)
1947  {
1948  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1949  return std::complex<__type>(__x, -__type());
1950  }
1951 
1952 #if __cplusplus > 201103L
1953 
1954 inline namespace literals {
1955 inline namespace complex_literals {
1956 #pragma GCC diagnostic push
1957 #pragma GCC diagnostic ignored "-Wliteral-suffix"
1958 #define __cpp_lib_complex_udls 201309L
1959 
1960  constexpr std::complex<float>
1961  operator""if(long double __num)
1962  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
1963 
1964  constexpr std::complex<float>
1965  operator""if(unsigned long long __num)
1966  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
1967 
1968  constexpr std::complex<double>
1969  operator""i(long double __num)
1970  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
1971 
1972  constexpr std::complex<double>
1973  operator""i(unsigned long long __num)
1974  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
1975 
1976  constexpr std::complex<long double>
1977  operator""il(long double __num)
1978  { return std::complex<long double>{0.0L, __num}; }
1979 
1980  constexpr std::complex<long double>
1981  operator""il(unsigned long long __num)
1982  { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }
1983 
1984 #pragma GCC diagnostic pop
1985 } // inline namespace complex_literals
1986 } // inline namespace literals
1987 
1988 #endif // C++14
1989 
1990 _GLIBCXX_END_NAMESPACE_VERSION
1991 } // namespace
1992 
1993 #endif // C++11
1994 
1995 #endif /* _GLIBCXX_COMPLEX */