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