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-2018 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 <[email protected]>
33 // Improved by Gabriel Dos Reis <[email protected]>
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>
211  complex<_Tp>& operator=(const complex<_Up>&);
212  /// Add another complex number to this one.
213  template<typename _Up>
214  complex<_Tp>& operator+=(const complex<_Up>&);
215  /// Subtract another complex number from this one.
216  template<typename _Up>
217  complex<_Tp>& operator-=(const complex<_Up>&);
218  /// Multiply this complex number by another.
219  template<typename _Up>
220  complex<_Tp>& operator*=(const complex<_Up>&);
221  /// Divide this complex number by another.
222  template<typename _Up>
223  complex<_Tp>& operator/=(const complex<_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>&
265  complex<_Tp>::operator=(const complex<_Up>& __z)
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>&
276  complex<_Tp>::operator+=(const complex<_Up>& __z)
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>&
287  complex<_Tp>::operator-=(const complex<_Up>& __z)
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>&
299  complex<_Tp>::operator*=(const complex<_Up>& __z)
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>&
312  complex<_Tp>::operator/=(const complex<_Up>& __z)
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>
445  operator+(const complex<_Tp>& __x)
446  { return __x; }
447 
448  /// Return complex negation of @a x.
449  template<typename _Tp>
450  inline complex<_Tp>
451  operator-(const complex<_Tp>& __x)
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>
492  basic_istream<_CharT, _Traits>&
493  operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
494  {
495  bool __fail = true;
496  _CharT __ch;
497  if (__is >> __ch)
498  {
499  if (_Traits::eq(__ch, __is.widen('(')))
500  {
501  _Tp __u;
502  if (__is >> __u >> __ch)
503  {
504  const _CharT __rparen = __is.widen(')');
505  if (_Traits::eq(__ch, __rparen))
506  {
507  __x = __u;
508  __fail = false;
509  }
510  else if (_Traits::eq(__ch, __is.widen(',')))
511  {
512  _Tp __v;
513  if (__is >> __v >> __ch)
514  {
515  if (_Traits::eq(__ch, __rparen))
516  {
517  __x = complex<_Tp>(__u, __v);
518  __fail = false;
519  }
520  else
521  __is.putback(__ch);
522  }
523  }
524  else
525  __is.putback(__ch);
526  }
527  }
528  else
529  {
530  __is.putback(__ch);
531  _Tp __u;
532  if (__is >> __u)
533  {
534  __x = __u;
535  __fail = false;
536  }
537  }
538  }
539  if (__fail)
540  __is.setstate(ios_base::failbit);
541  return __is;
542  }
543 
544  /// Insertion operator for complex values.
545  template<typename _Tp, typename _CharT, class _Traits>
546  basic_ostream<_CharT, _Traits>&
547  operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
548  {
549  basic_ostringstream<_CharT, _Traits> __s;
550  __s.flags(__os.flags());
551  __s.imbue(__os.getloc());
552  __s.precision(__os.precision());
553  __s << '(' << __x.real() << ',' << __x.imag() << ')';
554  return __os << __s.str();
555  }
556 
557  // Values
558 #if __cplusplus >= 201103L
559  template<typename _Tp>
560  constexpr _Tp
561  real(const complex<_Tp>& __z)
562  { return __z.real(); }
563 
564  template<typename _Tp>
565  constexpr _Tp
566  imag(const complex<_Tp>& __z)
567  { return __z.imag(); }
568 #else
569  template<typename _Tp>
570  inline _Tp&
571  real(complex<_Tp>& __z)
572  { return __z.real(); }
573 
574  template<typename _Tp>
575  inline const _Tp&
576  real(const complex<_Tp>& __z)
577  { return __z.real(); }
578 
579  template<typename _Tp>
580  inline _Tp&
581  imag(complex<_Tp>& __z)
582  { return __z.imag(); }
583 
584  template<typename _Tp>
585  inline const _Tp&
586  imag(const complex<_Tp>& __z)
587  { return __z.imag(); }
588 #endif
589 
590  // 26.2.7/3 abs(__z): Returns the magnitude of __z.
591  template<typename _Tp>
592  inline _Tp
593  __complex_abs(const complex<_Tp>& __z)
594  {
595  _Tp __x = __z.real();
596  _Tp __y = __z.imag();
597  const _Tp __s = std::max(abs(__x), abs(__y));
598  if (__s == _Tp()) // well ...
599  return __s;
600  __x /= __s;
601  __y /= __s;
602  return __s * sqrt(__x * __x + __y * __y);
603  }
604 
605 #if _GLIBCXX_USE_C99_COMPLEX
606  inline float
607  __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
608 
609  inline double
610  __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
611 
612  inline long double
613  __complex_abs(const __complex__ long double& __z)
614  { return __builtin_cabsl(__z); }
615 
616  template<typename _Tp>
617  inline _Tp
618  abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
619 #else
620  template<typename _Tp>
621  inline _Tp
622  abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
623 #endif
624 
625 
626  // 26.2.7/4: arg(__z): Returns the phase angle of __z.
627  template<typename _Tp>
628  inline _Tp
629  __complex_arg(const complex<_Tp>& __z)
630  { return atan2(__z.imag(), __z.real()); }
631 
632 #if _GLIBCXX_USE_C99_COMPLEX
633  inline float
634  __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
635 
636  inline double
637  __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
638 
639  inline long double
640  __complex_arg(const __complex__ long double& __z)
641  { return __builtin_cargl(__z); }
642 
643  template<typename _Tp>
644  inline _Tp
645  arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
646 #else
647  template<typename _Tp>
648  inline _Tp
649  arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
650 #endif
651 
652  // 26.2.7/5: norm(__z) returns the squared magnitude of __z.
653  // As defined, norm() is -not- a norm is the common mathematical
654  // sense used in numerics. The helper class _Norm_helper<> tries to
655  // distinguish between builtin floating point and the rest, so as
656  // to deliver an answer as close as possible to the real value.
657  template<bool>
658  struct _Norm_helper
659  {
660  template<typename _Tp>
661  static inline _Tp _S_do_it(const complex<_Tp>& __z)
662  {
663  const _Tp __x = __z.real();
664  const _Tp __y = __z.imag();
665  return __x * __x + __y * __y;
666  }
667  };
668 
669  template<>
670  struct _Norm_helper<true>
671  {
672  template<typename _Tp>
673  static inline _Tp _S_do_it(const complex<_Tp>& __z)
674  {
675  _Tp __res = std::abs(__z);
676  return __res * __res;
677  }
678  };
679 
680  template<typename _Tp>
681  inline _Tp
682  norm(const complex<_Tp>& __z)
683  {
684  return _Norm_helper<__is_floating<_Tp>::__value
685  && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
686  }
687 
688  template<typename _Tp>
689  inline complex<_Tp>
690  polar(const _Tp& __rho, const _Tp& __theta)
691  {
692  __glibcxx_assert( __rho >= 0 );
693  return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta));
694  }
695 
696  template<typename _Tp>
697  inline complex<_Tp>
698  conj(const complex<_Tp>& __z)
699  { return complex<_Tp>(__z.real(), -__z.imag()); }
700 
701  // Transcendentals
702 
703  // 26.2.8/1 cos(__z): Returns the cosine of __z.
704  template<typename _Tp>
705  inline complex<_Tp>
706  __complex_cos(const complex<_Tp>& __z)
707  {
708  const _Tp __x = __z.real();
709  const _Tp __y = __z.imag();
710  return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
711  }
712 
713 #if _GLIBCXX_USE_C99_COMPLEX
714  inline __complex__ float
715  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
716 
717  inline __complex__ double
718  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
719 
720  inline __complex__ long double
721  __complex_cos(const __complex__ long double& __z)
722  { return __builtin_ccosl(__z); }
723 
724  template<typename _Tp>
725  inline complex<_Tp>
726  cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
727 #else
728  template<typename _Tp>
729  inline complex<_Tp>
730  cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
731 #endif
732 
733  // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
734  template<typename _Tp>
735  inline complex<_Tp>
736  __complex_cosh(const complex<_Tp>& __z)
737  {
738  const _Tp __x = __z.real();
739  const _Tp __y = __z.imag();
740  return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
741  }
742 
743 #if _GLIBCXX_USE_C99_COMPLEX
744  inline __complex__ float
745  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
746 
747  inline __complex__ double
748  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
749 
750  inline __complex__ long double
751  __complex_cosh(const __complex__ long double& __z)
752  { return __builtin_ccoshl(__z); }
753 
754  template<typename _Tp>
755  inline complex<_Tp>
756  cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
757 #else
758  template<typename _Tp>
759  inline complex<_Tp>
760  cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
761 #endif
762 
763  // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
764  template<typename _Tp>
765  inline complex<_Tp>
766  __complex_exp(const complex<_Tp>& __z)
767  { return std::polar<_Tp>(exp(__z.real()), __z.imag()); }
768 
769 #if _GLIBCXX_USE_C99_COMPLEX
770  inline __complex__ float
771  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
772 
773  inline __complex__ double
774  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
775 
776  inline __complex__ long double
777  __complex_exp(const __complex__ long double& __z)
778  { return __builtin_cexpl(__z); }
779 
780  template<typename _Tp>
781  inline complex<_Tp>
782  exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
783 #else
784  template<typename _Tp>
785  inline complex<_Tp>
786  exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
787 #endif
788 
789  // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z.
790  // The branch cut is along the negative axis.
791  template<typename _Tp>
792  inline complex<_Tp>
793  __complex_log(const complex<_Tp>& __z)
794  { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
795 
796 #if _GLIBCXX_USE_C99_COMPLEX
797  inline __complex__ float
798  __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
799 
800  inline __complex__ double
801  __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
802 
803  inline __complex__ long double
804  __complex_log(const __complex__ long double& __z)
805  { return __builtin_clogl(__z); }
806 
807  template<typename _Tp>
808  inline complex<_Tp>
809  log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
810 #else
811  template<typename _Tp>
812  inline complex<_Tp>
813  log(const complex<_Tp>& __z) { return __complex_log(__z); }
814 #endif
815 
816  template<typename _Tp>
817  inline complex<_Tp>
818  log10(const complex<_Tp>& __z)
819  { return std::log(__z) / log(_Tp(10.0)); }
820 
821  // 26.2.8/10 sin(__z): Returns the sine of __z.
822  template<typename _Tp>
823  inline complex<_Tp>
824  __complex_sin(const complex<_Tp>& __z)
825  {
826  const _Tp __x = __z.real();
827  const _Tp __y = __z.imag();
828  return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
829  }
830 
831 #if _GLIBCXX_USE_C99_COMPLEX
832  inline __complex__ float
833  __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
834 
835  inline __complex__ double
836  __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
837 
838  inline __complex__ long double
839  __complex_sin(const __complex__ long double& __z)
840  { return __builtin_csinl(__z); }
841 
842  template<typename _Tp>
843  inline complex<_Tp>
844  sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
845 #else
846  template<typename _Tp>
847  inline complex<_Tp>
848  sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
849 #endif
850 
851  // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
852  template<typename _Tp>
853  inline complex<_Tp>
854  __complex_sinh(const complex<_Tp>& __z)
855  {
856  const _Tp __x = __z.real();
857  const _Tp __y = __z.imag();
858  return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
859  }
860 
861 #if _GLIBCXX_USE_C99_COMPLEX
862  inline __complex__ float
863  __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
864 
865  inline __complex__ double
866  __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
867 
868  inline __complex__ long double
869  __complex_sinh(const __complex__ long double& __z)
870  { return __builtin_csinhl(__z); }
871 
872  template<typename _Tp>
873  inline complex<_Tp>
874  sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
875 #else
876  template<typename _Tp>
877  inline complex<_Tp>
878  sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
879 #endif
880 
881  // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
882  // The branch cut is on the negative axis.
883  template<typename _Tp>
884  complex<_Tp>
885  __complex_sqrt(const complex<_Tp>& __z)
886  {
887  _Tp __x = __z.real();
888  _Tp __y = __z.imag();
889 
890  if (__x == _Tp())
891  {
892  _Tp __t = sqrt(abs(__y) / 2);
893  return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
894  }
895  else
896  {
897  _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
898  _Tp __u = __t / 2;
899  return __x > _Tp()
900  ? complex<_Tp>(__u, __y / __t)
901  : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
902  }
903  }
904 
905 #if _GLIBCXX_USE_C99_COMPLEX
906  inline __complex__ float
907  __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
908 
909  inline __complex__ double
910  __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
911 
912  inline __complex__ long double
913  __complex_sqrt(const __complex__ long double& __z)
914  { return __builtin_csqrtl(__z); }
915 
916  template<typename _Tp>
917  inline complex<_Tp>
918  sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
919 #else
920  template<typename _Tp>
921  inline complex<_Tp>
922  sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
923 #endif
924 
925  // 26.2.8/14 tan(__z): Return the complex tangent of __z.
926 
927  template<typename _Tp>
928  inline complex<_Tp>
929  __complex_tan(const complex<_Tp>& __z)
930  { return std::sin(__z) / std::cos(__z); }
931 
932 #if _GLIBCXX_USE_C99_COMPLEX
933  inline __complex__ float
934  __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
935 
936  inline __complex__ double
937  __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
938 
939  inline __complex__ long double
940  __complex_tan(const __complex__ long double& __z)
941  { return __builtin_ctanl(__z); }
942 
943  template<typename _Tp>
944  inline complex<_Tp>
945  tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
946 #else
947  template<typename _Tp>
948  inline complex<_Tp>
949  tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
950 #endif
951 
952 
953  // 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z.
954 
955  template<typename _Tp>
956  inline complex<_Tp>
957  __complex_tanh(const complex<_Tp>& __z)
958  { return std::sinh(__z) / std::cosh(__z); }
959 
960 #if _GLIBCXX_USE_C99_COMPLEX
961  inline __complex__ float
962  __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
963 
964  inline __complex__ double
965  __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
966 
967  inline __complex__ long double
968  __complex_tanh(const __complex__ long double& __z)
969  { return __builtin_ctanhl(__z); }
970 
971  template<typename _Tp>
972  inline complex<_Tp>
973  tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
974 #else
975  template<typename _Tp>
976  inline complex<_Tp>
977  tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
978 #endif
979 
980 
981  // 26.2.8/9 pow(__x, __y): Returns the complex power base of __x
982  // raised to the __y-th power. The branch
983  // cut is on the negative axis.
984  template<typename _Tp>
985  complex<_Tp>
986  __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
987  {
988  complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
989 
990  while (__n >>= 1)
991  {
992  __x *= __x;
993  if (__n % 2)
994  __y *= __x;
995  }
996 
997  return __y;
998  }
999 
1000  // In C++11 mode we used to implement the resolution of
1001  // DR 844. complex pow return type is ambiguous.
1002  // thus the following overload was disabled in that mode. However, doing
1003  // that causes all sorts of issues, see, for example:
1004  // http://gcc.gnu.org/ml/libstdc++/2013-01/msg00058.html
1005  // and also PR57974.
1006  template<typename _Tp>
1007  inline complex<_Tp>
1008  pow(const complex<_Tp>& __z, int __n)
1009  {
1010  return __n < 0
1011  ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -(unsigned)__n)
1012  : std::__complex_pow_unsigned(__z, __n);
1013  }
1014 
1015  template<typename _Tp>
1016  complex<_Tp>
1017  pow(const complex<_Tp>& __x, const _Tp& __y)
1018  {
1019 #if ! _GLIBCXX_USE_C99_COMPLEX
1020  if (__x == _Tp())
1021  return _Tp();
1022 #endif
1023  if (__x.imag() == _Tp() && __x.real() > _Tp())
1024  return pow(__x.real(), __y);
1025 
1026  complex<_Tp> __t = std::log(__x);
1027  return std::polar<_Tp>(exp(__y * __t.real()), __y * __t.imag());
1028  }
1029 
1030  template<typename _Tp>
1031  inline complex<_Tp>
1032  __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1033  { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
1034 
1035 #if _GLIBCXX_USE_C99_COMPLEX
1036  inline __complex__ float
1037  __complex_pow(__complex__ float __x, __complex__ float __y)
1038  { return __builtin_cpowf(__x, __y); }
1039 
1040  inline __complex__ double
1041  __complex_pow(__complex__ double __x, __complex__ double __y)
1042  { return __builtin_cpow(__x, __y); }
1043 
1044  inline __complex__ long double
1045  __complex_pow(const __complex__ long double& __x,
1046  const __complex__ long double& __y)
1047  { return __builtin_cpowl(__x, __y); }
1048 
1049  template<typename _Tp>
1050  inline complex<_Tp>
1051  pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1052  { return __complex_pow(__x.__rep(), __y.__rep()); }
1053 #else
1054  template<typename _Tp>
1055  inline complex<_Tp>
1056  pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1057  { return __complex_pow(__x, __y); }
1058 #endif
1059 
1060  template<typename _Tp>
1061  inline complex<_Tp>
1062  pow(const _Tp& __x, const complex<_Tp>& __y)
1063  {
1064  return __x > _Tp() ? std::polar<_Tp>(pow(__x, __y.real()),
1065  __y.imag() * log(__x))
1066  : std::pow(complex<_Tp>(__x), __y);
1067  }
1068 
1069  /// 26.2.3 complex specializations
1070  /// complex<float> specialization
1071  template<>
1072  struct complex<float>
1073  {
1074  typedef float value_type;
1075  typedef __complex__ float _ComplexT;
1076 
1077  _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1078 
1079  _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f)
1080 #if __cplusplus >= 201103L
1081  : _M_value{ __r, __i } { }
1082 #else
1083  {
1084  __real__ _M_value = __r;
1085  __imag__ _M_value = __i;
1086  }
1087 #endif
1088 
1089  explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&);
1090  explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1091 
1092 #if __cplusplus >= 201103L
1093  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1094  // DR 387. std::complex over-encapsulated.
1095  __attribute ((__abi_tag__ ("cxx11")))
1096  constexpr float
1097  real() const { return __real__ _M_value; }
1098 
1099  __attribute ((__abi_tag__ ("cxx11")))
1100  constexpr float
1101  imag() const { return __imag__ _M_value; }
1102 #else
1103  float&
1104  real() { return __real__ _M_value; }
1105 
1106  const float&
1107  real() const { return __real__ _M_value; }
1108 
1109  float&
1110  imag() { return __imag__ _M_value; }
1111 
1112  const float&
1113  imag() const { return __imag__ _M_value; }
1114 #endif
1115 
1116  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1117  // DR 387. std::complex over-encapsulated.
1118  void
1119  real(float __val) { __real__ _M_value = __val; }
1120 
1121  void
1122  imag(float __val) { __imag__ _M_value = __val; }
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  complex&
1139  operator-=(float __f)
1140  {
1141  _M_value -= __f;
1142  return *this;
1143  }
1144 
1145  complex&
1146  operator*=(float __f)
1147  {
1148  _M_value *= __f;
1149  return *this;
1150  }
1151 
1152  complex&
1153  operator/=(float __f)
1154  {
1155  _M_value /= __f;
1156  return *this;
1157  }
1158 
1159  // Let the compiler synthesize the copy and assignment
1160  // operator. It always does a pretty good job.
1161  // complex& operator=(const complex&);
1162 
1163  template<typename _Tp>
1164  complex&
1165  operator=(const complex<_Tp>& __z)
1166  {
1167  __real__ _M_value = __z.real();
1168  __imag__ _M_value = __z.imag();
1169  return *this;
1170  }
1171 
1172  template<typename _Tp>
1173  complex&
1174  operator+=(const complex<_Tp>& __z)
1175  {
1176  __real__ _M_value += __z.real();
1177  __imag__ _M_value += __z.imag();
1178  return *this;
1179  }
1180 
1181  template<class _Tp>
1182  complex&
1183  operator-=(const complex<_Tp>& __z)
1184  {
1185  __real__ _M_value -= __z.real();
1186  __imag__ _M_value -= __z.imag();
1187  return *this;
1188  }
1189 
1190  template<class _Tp>
1191  complex&
1192  operator*=(const complex<_Tp>& __z)
1193  {
1194  _ComplexT __t;
1195  __real__ __t = __z.real();
1196  __imag__ __t = __z.imag();
1197  _M_value *= __t;
1198  return *this;
1199  }
1200 
1201  template<class _Tp>
1202  complex&
1203  operator/=(const complex<_Tp>& __z)
1204  {
1205  _ComplexT __t;
1206  __real__ __t = __z.real();
1207  __imag__ __t = __z.imag();
1208  _M_value /= __t;
1209  return *this;
1210  }
1211 
1212  _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1213 
1214  private:
1215  _ComplexT _M_value;
1216  };
1217 
1218  /// 26.2.3 complex specializations
1219  /// complex<double> specialization
1220  template<>
1221  struct complex<double>
1222  {
1223  typedef double value_type;
1224  typedef __complex__ double _ComplexT;
1225 
1226  _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1227 
1228  _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0)
1229 #if __cplusplus >= 201103L
1230  : _M_value{ __r, __i } { }
1231 #else
1232  {
1233  __real__ _M_value = __r;
1234  __imag__ _M_value = __i;
1235  }
1236 #endif
1237 
1238  _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1239  : _M_value(__z.__rep()) { }
1240 
1241  explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1242 
1243 #if __cplusplus >= 201103L
1244  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1245  // DR 387. std::complex over-encapsulated.
1246  __attribute ((__abi_tag__ ("cxx11")))
1247  constexpr double
1248  real() const { return __real__ _M_value; }
1249 
1250  __attribute ((__abi_tag__ ("cxx11")))
1251  constexpr double
1252  imag() const { return __imag__ _M_value; }
1253 #else
1254  double&
1255  real() { return __real__ _M_value; }
1256 
1257  const double&
1258  real() const { return __real__ _M_value; }
1259 
1260  double&
1261  imag() { return __imag__ _M_value; }
1262 
1263  const double&
1264  imag() const { return __imag__ _M_value; }
1265 #endif
1266 
1267  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1268  // DR 387. std::complex over-encapsulated.
1269  void
1270  real(double __val) { __real__ _M_value = __val; }
1271 
1272  void
1273  imag(double __val) { __imag__ _M_value = __val; }
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  complex&
1290  operator-=(double __d)
1291  {
1292  _M_value -= __d;
1293  return *this;
1294  }
1295 
1296  complex&
1297  operator*=(double __d)
1298  {
1299  _M_value *= __d;
1300  return *this;
1301  }
1302 
1303  complex&
1304  operator/=(double __d)
1305  {
1306  _M_value /= __d;
1307  return *this;
1308  }
1309 
1310  // The compiler will synthesize this, efficiently.
1311  // complex& operator=(const complex&);
1312 
1313  template<typename _Tp>
1314  complex&
1315  operator=(const complex<_Tp>& __z)
1316  {
1317  __real__ _M_value = __z.real();
1318  __imag__ _M_value = __z.imag();
1319  return *this;
1320  }
1321 
1322  template<typename _Tp>
1323  complex&
1324  operator+=(const complex<_Tp>& __z)
1325  {
1326  __real__ _M_value += __z.real();
1327  __imag__ _M_value += __z.imag();
1328  return *this;
1329  }
1330 
1331  template<typename _Tp>
1332  complex&
1333  operator-=(const complex<_Tp>& __z)
1334  {
1335  __real__ _M_value -= __z.real();
1336  __imag__ _M_value -= __z.imag();
1337  return *this;
1338  }
1339 
1340  template<typename _Tp>
1341  complex&
1342  operator*=(const complex<_Tp>& __z)
1343  {
1344  _ComplexT __t;
1345  __real__ __t = __z.real();
1346  __imag__ __t = __z.imag();
1347  _M_value *= __t;
1348  return *this;
1349  }
1350 
1351  template<typename _Tp>
1352  complex&
1353  operator/=(const complex<_Tp>& __z)
1354  {
1355  _ComplexT __t;
1356  __real__ __t = __z.real();
1357  __imag__ __t = __z.imag();
1358  _M_value /= __t;
1359  return *this;
1360  }
1361 
1362  _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1363 
1364  private:
1365  _ComplexT _M_value;
1366  };
1367 
1368  /// 26.2.3 complex specializations
1369  /// complex<long double> specialization
1370  template<>
1371  struct complex<long double>
1372  {
1373  typedef long double value_type;
1374  typedef __complex__ long double _ComplexT;
1375 
1376  _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1377 
1378  _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L,
1379  long double __i = 0.0L)
1380 #if __cplusplus >= 201103L
1381  : _M_value{ __r, __i } { }
1382 #else
1383  {
1384  __real__ _M_value = __r;
1385  __imag__ _M_value = __i;
1386  }
1387 #endif
1388 
1389  _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1390  : _M_value(__z.__rep()) { }
1391 
1392  _GLIBCXX_CONSTEXPR complex(const complex<double>& __z)
1393  : _M_value(__z.__rep()) { }
1394 
1395 #if __cplusplus >= 201103L
1396  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1397  // DR 387. std::complex over-encapsulated.
1398  __attribute ((__abi_tag__ ("cxx11")))
1399  constexpr long double
1400  real() const { return __real__ _M_value; }
1401 
1402  __attribute ((__abi_tag__ ("cxx11")))
1403  constexpr long double
1404  imag() const { return __imag__ _M_value; }
1405 #else
1406  long double&
1407  real() { return __real__ _M_value; }
1408 
1409  const long double&
1410  real() const { return __real__ _M_value; }
1411 
1412  long double&
1413  imag() { return __imag__ _M_value; }
1414 
1415  const long double&
1416  imag() const { return __imag__ _M_value; }
1417 #endif
1418 
1419  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1420  // DR 387. std::complex over-encapsulated.
1421  void
1422  real(long double __val) { __real__ _M_value = __val; }
1423 
1424  void
1425  imag(long double __val) { __imag__ _M_value = __val; }
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  complex&
1442  operator-=(long double __r)
1443  {
1444  _M_value -= __r;
1445  return *this;
1446  }
1447 
1448  complex&
1449  operator*=(long double __r)
1450  {
1451  _M_value *= __r;
1452  return *this;
1453  }
1454 
1455  complex&
1456  operator/=(long double __r)
1457  {
1458  _M_value /= __r;
1459  return *this;
1460  }
1461 
1462  // The compiler knows how to do this efficiently
1463  // complex& operator=(const complex&);
1464 
1465  template<typename _Tp>
1466  complex&
1467  operator=(const complex<_Tp>& __z)
1468  {
1469  __real__ _M_value = __z.real();
1470  __imag__ _M_value = __z.imag();
1471  return *this;
1472  }
1473 
1474  template<typename _Tp>
1475  complex&
1476  operator+=(const complex<_Tp>& __z)
1477  {
1478  __real__ _M_value += __z.real();
1479  __imag__ _M_value += __z.imag();
1480  return *this;
1481  }
1482 
1483  template<typename _Tp>
1484  complex&
1485  operator-=(const complex<_Tp>& __z)
1486  {
1487  __real__ _M_value -= __z.real();
1488  __imag__ _M_value -= __z.imag();
1489  return *this;
1490  }
1491 
1492  template<typename _Tp>
1493  complex&
1494  operator*=(const complex<_Tp>& __z)
1495  {
1496  _ComplexT __t;
1497  __real__ __t = __z.real();
1498  __imag__ __t = __z.imag();
1499  _M_value *= __t;
1500  return *this;
1501  }
1502 
1503  template<typename _Tp>
1504  complex&
1505  operator/=(const complex<_Tp>& __z)
1506  {
1507  _ComplexT __t;
1508  __real__ __t = __z.real();
1509  __imag__ __t = __z.imag();
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 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
1561 {
1562 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1563 
1564  // See ext/type_traits.h for the primary template.
1565  template<typename _Tp, typename _Up>
1566  struct __promote_2<std::complex<_Tp>, _Up>
1567  {
1568  public:
1569  typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1570  };
1571 
1572  template<typename _Tp, typename _Up>
1573  struct __promote_2<_Tp, std::complex<_Up> >
1574  {
1575  public:
1576  typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1577  };
1578 
1579  template<typename _Tp, typename _Up>
1580  struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
1581  {
1582  public:
1583  typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1584  };
1585 
1586 _GLIBCXX_END_NAMESPACE_VERSION
1587 } // namespace
1588 
1589 #if __cplusplus >= 201103L
1590 
1591 namespace std _GLIBCXX_VISIBILITY(default)
1592 {
1593 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1594 
1595  // Forward declarations.
1596  template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
1597  template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
1598  template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
1599 
1600  template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
1601  template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
1602  template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
1603  // DR 595.
1604  template<typename _Tp> _Tp fabs(const std::complex<_Tp>&);
1605 
1606  template<typename _Tp>
1607  inline std::complex<_Tp>
1608  __complex_acos(const std::complex<_Tp>& __z)
1609  {
1610  const std::complex<_Tp> __t = std::asin(__z);
1611  const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
1612  return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
1613  }
1614 
1615 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1616  inline __complex__ float
1617  __complex_acos(__complex__ float __z)
1618  { return __builtin_cacosf(__z); }
1619 
1620  inline __complex__ double
1621  __complex_acos(__complex__ double __z)
1622  { return __builtin_cacos(__z); }
1623 
1624  inline __complex__ long double
1625  __complex_acos(const __complex__ long double& __z)
1626  { return __builtin_cacosl(__z); }
1627 
1628  template<typename _Tp>
1629  inline std::complex<_Tp>
1630  acos(const std::complex<_Tp>& __z)
1631  { return __complex_acos(__z.__rep()); }
1632 #else
1633  /// acos(__z) [8.1.2].
1634  // Effects: Behaves the same as C99 function cacos, defined
1635  // in subclause 7.3.5.1.
1636  template<typename _Tp>
1637  inline std::complex<_Tp>
1638  acos(const std::complex<_Tp>& __z)
1639  { return __complex_acos(__z); }
1640 #endif
1641 
1642  template<typename _Tp>
1643  inline std::complex<_Tp>
1644  __complex_asin(const std::complex<_Tp>& __z)
1645  {
1646  std::complex<_Tp> __t(-__z.imag(), __z.real());
1647  __t = std::asinh(__t);
1648  return std::complex<_Tp>(__t.imag(), -__t.real());
1649  }
1650 
1651 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1652  inline __complex__ float
1653  __complex_asin(__complex__ float __z)
1654  { return __builtin_casinf(__z); }
1655 
1656  inline __complex__ double
1657  __complex_asin(__complex__ double __z)
1658  { return __builtin_casin(__z); }
1659 
1660  inline __complex__ long double
1661  __complex_asin(const __complex__ long double& __z)
1662  { return __builtin_casinl(__z); }
1663 
1664  template<typename _Tp>
1665  inline std::complex<_Tp>
1666  asin(const std::complex<_Tp>& __z)
1667  { return __complex_asin(__z.__rep()); }
1668 #else
1669  /// asin(__z) [8.1.3].
1670  // Effects: Behaves the same as C99 function casin, defined
1671  // in subclause 7.3.5.2.
1672  template<typename _Tp>
1673  inline std::complex<_Tp>
1674  asin(const std::complex<_Tp>& __z)
1675  { return __complex_asin(__z); }
1676 #endif
1677 
1678  template<typename _Tp>
1679  std::complex<_Tp>
1680  __complex_atan(const std::complex<_Tp>& __z)
1681  {
1682  const _Tp __r2 = __z.real() * __z.real();
1683  const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
1684 
1685  _Tp __num = __z.imag() + _Tp(1.0);
1686  _Tp __den = __z.imag() - _Tp(1.0);
1687 
1688  __num = __r2 + __num * __num;
1689  __den = __r2 + __den * __den;
1690 
1691  return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
1692  _Tp(0.25) * log(__num / __den));
1693  }
1694 
1695 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1696  inline __complex__ float
1697  __complex_atan(__complex__ float __z)
1698  { return __builtin_catanf(__z); }
1699 
1700  inline __complex__ double
1701  __complex_atan(__complex__ double __z)
1702  { return __builtin_catan(__z); }
1703 
1704  inline __complex__ long double
1705  __complex_atan(const __complex__ long double& __z)
1706  { return __builtin_catanl(__z); }
1707 
1708  template<typename _Tp>
1709  inline std::complex<_Tp>
1710  atan(const std::complex<_Tp>& __z)
1711  { return __complex_atan(__z.__rep()); }
1712 #else
1713  /// atan(__z) [8.1.4].
1714  // Effects: Behaves the same as C99 function catan, defined
1715  // in subclause 7.3.5.3.
1716  template<typename _Tp>
1717  inline std::complex<_Tp>
1718  atan(const std::complex<_Tp>& __z)
1719  { return __complex_atan(__z); }
1720 #endif
1721 
1722  template<typename _Tp>
1723  std::complex<_Tp>
1724  __complex_acosh(const std::complex<_Tp>& __z)
1725  {
1726  // Kahan's formula.
1727  return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
1728  + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
1729  }
1730 
1731 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1732  inline __complex__ float
1733  __complex_acosh(__complex__ float __z)
1734  { return __builtin_cacoshf(__z); }
1735 
1736  inline __complex__ double
1737  __complex_acosh(__complex__ double __z)
1738  { return __builtin_cacosh(__z); }
1739 
1740  inline __complex__ long double
1741  __complex_acosh(const __complex__ long double& __z)
1742  { return __builtin_cacoshl(__z); }
1743 
1744  template<typename _Tp>
1745  inline std::complex<_Tp>
1746  acosh(const std::complex<_Tp>& __z)
1747  { return __complex_acosh(__z.__rep()); }
1748 #else
1749  /// acosh(__z) [8.1.5].
1750  // Effects: Behaves the same as C99 function cacosh, defined
1751  // in subclause 7.3.6.1.
1752  template<typename _Tp>
1753  inline std::complex<_Tp>
1754  acosh(const std::complex<_Tp>& __z)
1755  { return __complex_acosh(__z); }
1756 #endif
1757 
1758  template<typename _Tp>
1759  std::complex<_Tp>
1760  __complex_asinh(const std::complex<_Tp>& __z)
1761  {
1762  std::complex<_Tp> __t((__z.real() - __z.imag())
1763  * (__z.real() + __z.imag()) + _Tp(1.0),
1764  _Tp(2.0) * __z.real() * __z.imag());
1765  __t = std::sqrt(__t);
1766 
1767  return std::log(__t + __z);
1768  }
1769 
1770 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1771  inline __complex__ float
1772  __complex_asinh(__complex__ float __z)
1773  { return __builtin_casinhf(__z); }
1774 
1775  inline __complex__ double
1776  __complex_asinh(__complex__ double __z)
1777  { return __builtin_casinh(__z); }
1778 
1779  inline __complex__ long double
1780  __complex_asinh(const __complex__ long double& __z)
1781  { return __builtin_casinhl(__z); }
1782 
1783  template<typename _Tp>
1784  inline std::complex<_Tp>
1785  asinh(const std::complex<_Tp>& __z)
1786  { return __complex_asinh(__z.__rep()); }
1787 #else
1788  /// asinh(__z) [8.1.6].
1789  // Effects: Behaves the same as C99 function casin, defined
1790  // in subclause 7.3.6.2.
1791  template<typename _Tp>
1792  inline std::complex<_Tp>
1793  asinh(const std::complex<_Tp>& __z)
1794  { return __complex_asinh(__z); }
1795 #endif
1796 
1797  template<typename _Tp>
1798  std::complex<_Tp>
1799  __complex_atanh(const std::complex<_Tp>& __z)
1800  {
1801  const _Tp __i2 = __z.imag() * __z.imag();
1802  const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
1803 
1804  _Tp __num = _Tp(1.0) + __z.real();
1805  _Tp __den = _Tp(1.0) - __z.real();
1806 
1807  __num = __i2 + __num * __num;
1808  __den = __i2 + __den * __den;
1809 
1810  return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
1811  _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
1812  }
1813 
1814 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1815  inline __complex__ float
1816  __complex_atanh(__complex__ float __z)
1817  { return __builtin_catanhf(__z); }
1818 
1819  inline __complex__ double
1820  __complex_atanh(__complex__ double __z)
1821  { return __builtin_catanh(__z); }
1822 
1823  inline __complex__ long double
1824  __complex_atanh(const __complex__ long double& __z)
1825  { return __builtin_catanhl(__z); }
1826 
1827  template<typename _Tp>
1828  inline std::complex<_Tp>
1829  atanh(const std::complex<_Tp>& __z)
1830  { return __complex_atanh(__z.__rep()); }
1831 #else
1832  /// atanh(__z) [8.1.7].
1833  // Effects: Behaves the same as C99 function catanh, defined
1834  // in subclause 7.3.6.3.
1835  template<typename _Tp>
1836  inline std::complex<_Tp>
1837  atanh(const std::complex<_Tp>& __z)
1838  { return __complex_atanh(__z); }
1839 #endif
1840 
1841  template<typename _Tp>
1842  inline _Tp
1843  /// fabs(__z) [8.1.8].
1844  // Effects: Behaves the same as C99 function cabs, defined
1845  // in subclause 7.3.8.1.
1846  fabs(const std::complex<_Tp>& __z)
1847  { return std::abs(__z); }
1848 
1849  /// Additional overloads [8.1.9].
1850  template<typename _Tp>
1851  inline typename __gnu_cxx::__promote<_Tp>::__type
1852  arg(_Tp __x)
1853  {
1854  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1855 #if (_GLIBCXX11_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
1856  return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
1857  : __type();
1858 #else
1859  return std::arg(std::complex<__type>(__x));
1860 #endif
1861  }
1862 
1863  template<typename _Tp>
1864  _GLIBCXX_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
1865  imag(_Tp)
1866  { return _Tp(); }
1867 
1868  template<typename _Tp>
1869  inline typename __gnu_cxx::__promote<_Tp>::__type
1870  norm(_Tp __x)
1871  {
1872  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1873  return __type(__x) * __type(__x);
1874  }
1875 
1876  template<typename _Tp>
1877  _GLIBCXX_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
1878  real(_Tp __x)
1879  { return __x; }
1880 
1881  template<typename _Tp, typename _Up>
1882  inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1883  pow(const std::complex<_Tp>& __x, const _Up& __y)
1884  {
1885  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1886  return std::pow(std::complex<__type>(__x), __type(__y));
1887  }
1888 
1889  template<typename _Tp, typename _Up>
1890  inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1891  pow(const _Tp& __x, const std::complex<_Up>& __y)
1892  {
1893  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1894  return std::pow(__type(__x), std::complex<__type>(__y));
1895  }
1896 
1897  template<typename _Tp, typename _Up>
1898  inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1899  pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
1900  {
1901  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1902  return std::pow(std::complex<__type>(__x),
1903  std::complex<__type>(__y));
1904  }
1905 
1906  // Forward declarations.
1907  // DR 781.
1908  template<typename _Tp> std::complex<_Tp> proj(const std::complex<_Tp>&);
1909 
1910  template<typename _Tp>
1911  std::complex<_Tp>
1912  __complex_proj(const std::complex<_Tp>& __z)
1913  {
1914  const _Tp __den = (__z.real() * __z.real()
1915  + __z.imag() * __z.imag() + _Tp(1.0));
1916 
1917  return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den,
1918  (_Tp(2.0) * __z.imag()) / __den);
1919  }
1920 
1921 #if _GLIBCXX_USE_C99_COMPLEX
1922  inline __complex__ float
1923  __complex_proj(__complex__ float __z)
1924  { return __builtin_cprojf(__z); }
1925 
1926  inline __complex__ double
1927  __complex_proj(__complex__ double __z)
1928  { return __builtin_cproj(__z); }
1929 
1930  inline __complex__ long double
1931  __complex_proj(const __complex__ long double& __z)
1932  { return __builtin_cprojl(__z); }
1933 
1934  template<typename _Tp>
1935  inline std::complex<_Tp>
1936  proj(const std::complex<_Tp>& __z)
1937  { return __complex_proj(__z.__rep()); }
1938 #else
1939  template<typename _Tp>
1940  inline std::complex<_Tp>
1941  proj(const std::complex<_Tp>& __z)
1942  { return __complex_proj(__z); }
1943 #endif
1944 
1945  template<typename _Tp>
1946  inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
1947  proj(_Tp __x)
1948  {
1949  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1950  return std::proj(std::complex<__type>(__x));
1951  }
1952 
1953  template<typename _Tp>
1954  inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
1955  conj(_Tp __x)
1956  {
1957  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1958  return std::complex<__type>(__x, -__type());
1959  }
1960 
1961 #if __cplusplus > 201103L
1962 
1963 inline namespace literals {
1964 inline namespace complex_literals {
1965 #pragma GCC diagnostic push
1966 #pragma GCC diagnostic ignored "-Wliteral-suffix"
1967 #define __cpp_lib_complex_udls 201309
1968 
1969  constexpr std::complex<float>
1970  operator""if(long double __num)
1971  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
1972 
1973  constexpr std::complex<float>
1974  operator""if(unsigned long long __num)
1975  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
1976 
1977  constexpr std::complex<double>
1978  operator""i(long double __num)
1979  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
1980 
1981  constexpr std::complex<double>
1982  operator""i(unsigned long long __num)
1983  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
1984 
1985  constexpr std::complex<long double>
1986  operator""il(long double __num)
1987  { return std::complex<long double>{0.0L, __num}; }
1988 
1989  constexpr std::complex<long double>
1990  operator""il(unsigned long long __num)
1991  { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }
1992 
1993 #pragma GCC diagnostic pop
1994 } // inline namespace complex_literals
1995 } // inline namespace literals
1996 
1997 #endif // C++14
1998 
1999 _GLIBCXX_END_NAMESPACE_VERSION
2000 } // namespace
2001 
2002 #endif // C++11
2003 
2004 #endif /* _GLIBCXX_COMPLEX */