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-2015 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  _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
507  __is.setstate(ios_base::failbit);
508  }
509  else if (__ch == ')')
510  __x = __re_x;
511  else
512  __is.setstate(ios_base::failbit);
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>
525  basic_ostream<_CharT, _Traits>&
526  operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
527  {
528  basic_ostringstream<_CharT, _Traits> __s;
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  { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
671 
672  template<typename _Tp>
673  inline complex<_Tp>
674  conj(const complex<_Tp>& __z)
675  { return complex<_Tp>(__z.real(), -__z.imag()); }
676 
677  // Transcendentals
678 
679  // 26.2.8/1 cos(__z): Returns the cosine of __z.
680  template<typename _Tp>
681  inline complex<_Tp>
682  __complex_cos(const complex<_Tp>& __z)
683  {
684  const _Tp __x = __z.real();
685  const _Tp __y = __z.imag();
686  return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
687  }
688 
689 #if _GLIBCXX_USE_C99_COMPLEX
690  inline __complex__ float
691  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
692 
693  inline __complex__ double
694  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
695 
696  inline __complex__ long double
697  __complex_cos(const __complex__ long double& __z)
698  { return __builtin_ccosl(__z); }
699 
700  template<typename _Tp>
701  inline complex<_Tp>
702  cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
703 #else
704  template<typename _Tp>
705  inline complex<_Tp>
706  cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
707 #endif
708 
709  // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
710  template<typename _Tp>
711  inline complex<_Tp>
712  __complex_cosh(const complex<_Tp>& __z)
713  {
714  const _Tp __x = __z.real();
715  const _Tp __y = __z.imag();
716  return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
717  }
718 
719 #if _GLIBCXX_USE_C99_COMPLEX
720  inline __complex__ float
721  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
722 
723  inline __complex__ double
724  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
725 
726  inline __complex__ long double
727  __complex_cosh(const __complex__ long double& __z)
728  { return __builtin_ccoshl(__z); }
729 
730  template<typename _Tp>
731  inline complex<_Tp>
732  cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
733 #else
734  template<typename _Tp>
735  inline complex<_Tp>
736  cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
737 #endif
738 
739  // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
740  template<typename _Tp>
741  inline complex<_Tp>
742  __complex_exp(const complex<_Tp>& __z)
743  { return std::polar<_Tp>(exp(__z.real()), __z.imag()); }
744 
745 #if _GLIBCXX_USE_C99_COMPLEX
746  inline __complex__ float
747  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
748 
749  inline __complex__ double
750  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
751 
752  inline __complex__ long double
753  __complex_exp(const __complex__ long double& __z)
754  { return __builtin_cexpl(__z); }
755 
756  template<typename _Tp>
757  inline complex<_Tp>
758  exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
759 #else
760  template<typename _Tp>
761  inline complex<_Tp>
762  exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
763 #endif
764 
765  // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z.
766  // The branch cut is along the negative axis.
767  template<typename _Tp>
768  inline complex<_Tp>
769  __complex_log(const complex<_Tp>& __z)
770  { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
771 
772 #if _GLIBCXX_USE_C99_COMPLEX
773  inline __complex__ float
774  __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
775 
776  inline __complex__ double
777  __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
778 
779  inline __complex__ long double
780  __complex_log(const __complex__ long double& __z)
781  { return __builtin_clogl(__z); }
782 
783  template<typename _Tp>
784  inline complex<_Tp>
785  log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
786 #else
787  template<typename _Tp>
788  inline complex<_Tp>
789  log(const complex<_Tp>& __z) { return __complex_log(__z); }
790 #endif
791 
792  template<typename _Tp>
793  inline complex<_Tp>
794  log10(const complex<_Tp>& __z)
795  { return std::log(__z) / log(_Tp(10.0)); }
796 
797  // 26.2.8/10 sin(__z): Returns the sine of __z.
798  template<typename _Tp>
799  inline complex<_Tp>
800  __complex_sin(const complex<_Tp>& __z)
801  {
802  const _Tp __x = __z.real();
803  const _Tp __y = __z.imag();
804  return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
805  }
806 
807 #if _GLIBCXX_USE_C99_COMPLEX
808  inline __complex__ float
809  __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
810 
811  inline __complex__ double
812  __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
813 
814  inline __complex__ long double
815  __complex_sin(const __complex__ long double& __z)
816  { return __builtin_csinl(__z); }
817 
818  template<typename _Tp>
819  inline complex<_Tp>
820  sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
821 #else
822  template<typename _Tp>
823  inline complex<_Tp>
824  sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
825 #endif
826 
827  // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
828  template<typename _Tp>
829  inline complex<_Tp>
830  __complex_sinh(const complex<_Tp>& __z)
831  {
832  const _Tp __x = __z.real();
833  const _Tp __y = __z.imag();
834  return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
835  }
836 
837 #if _GLIBCXX_USE_C99_COMPLEX
838  inline __complex__ float
839  __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
840 
841  inline __complex__ double
842  __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
843 
844  inline __complex__ long double
845  __complex_sinh(const __complex__ long double& __z)
846  { return __builtin_csinhl(__z); }
847 
848  template<typename _Tp>
849  inline complex<_Tp>
850  sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
851 #else
852  template<typename _Tp>
853  inline complex<_Tp>
854  sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
855 #endif
856 
857  // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
858  // The branch cut is on the negative axis.
859  template<typename _Tp>
860  complex<_Tp>
861  __complex_sqrt(const complex<_Tp>& __z)
862  {
863  _Tp __x = __z.real();
864  _Tp __y = __z.imag();
865 
866  if (__x == _Tp())
867  {
868  _Tp __t = sqrt(abs(__y) / 2);
869  return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
870  }
871  else
872  {
873  _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
874  _Tp __u = __t / 2;
875  return __x > _Tp()
876  ? complex<_Tp>(__u, __y / __t)
877  : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
878  }
879  }
880 
881 #if _GLIBCXX_USE_C99_COMPLEX
882  inline __complex__ float
883  __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
884 
885  inline __complex__ double
886  __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
887 
888  inline __complex__ long double
889  __complex_sqrt(const __complex__ long double& __z)
890  { return __builtin_csqrtl(__z); }
891 
892  template<typename _Tp>
893  inline complex<_Tp>
894  sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
895 #else
896  template<typename _Tp>
897  inline complex<_Tp>
898  sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
899 #endif
900 
901  // 26.2.8/14 tan(__z): Return the complex tangent of __z.
902 
903  template<typename _Tp>
904  inline complex<_Tp>
905  __complex_tan(const complex<_Tp>& __z)
906  { return std::sin(__z) / std::cos(__z); }
907 
908 #if _GLIBCXX_USE_C99_COMPLEX
909  inline __complex__ float
910  __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
911 
912  inline __complex__ double
913  __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
914 
915  inline __complex__ long double
916  __complex_tan(const __complex__ long double& __z)
917  { return __builtin_ctanl(__z); }
918 
919  template<typename _Tp>
920  inline complex<_Tp>
921  tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
922 #else
923  template<typename _Tp>
924  inline complex<_Tp>
925  tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
926 #endif
927 
928 
929  // 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z.
930 
931  template<typename _Tp>
932  inline complex<_Tp>
933  __complex_tanh(const complex<_Tp>& __z)
934  { return std::sinh(__z) / std::cosh(__z); }
935 
936 #if _GLIBCXX_USE_C99_COMPLEX
937  inline __complex__ float
938  __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
939 
940  inline __complex__ double
941  __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
942 
943  inline __complex__ long double
944  __complex_tanh(const __complex__ long double& __z)
945  { return __builtin_ctanhl(__z); }
946 
947  template<typename _Tp>
948  inline complex<_Tp>
949  tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
950 #else
951  template<typename _Tp>
952  inline complex<_Tp>
953  tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
954 #endif
955 
956 
957  // 26.2.8/9 pow(__x, __y): Returns the complex power base of __x
958  // raised to the __y-th power. The branch
959  // cut is on the negative axis.
960  template<typename _Tp>
961  complex<_Tp>
962  __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
963  {
964  complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
965 
966  while (__n >>= 1)
967  {
968  __x *= __x;
969  if (__n % 2)
970  __y *= __x;
971  }
972 
973  return __y;
974  }
975 
976  // In C++11 mode we used to implement the resolution of
977  // DR 844. complex pow return type is ambiguous.
978  // thus the following overload was disabled in that mode. However, doing
979  // that causes all sorts of issues, see, for example:
980  // http://gcc.gnu.org/ml/libstdc++/2013-01/msg00058.html
981  // and also PR57974.
982  template<typename _Tp>
983  inline complex<_Tp>
984  pow(const complex<_Tp>& __z, int __n)
985  {
986  return __n < 0
987  ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -(unsigned)__n)
988  : std::__complex_pow_unsigned(__z, __n);
989  }
990 
991  template<typename _Tp>
992  complex<_Tp>
993  pow(const complex<_Tp>& __x, const _Tp& __y)
994  {
995 #ifndef _GLIBCXX_USE_C99_COMPLEX
996  if (__x == _Tp())
997  return _Tp();
998 #endif
999  if (__x.imag() == _Tp() && __x.real() > _Tp())
1000  return pow(__x.real(), __y);
1001 
1002  complex<_Tp> __t = std::log(__x);
1003  return std::polar<_Tp>(exp(__y * __t.real()), __y * __t.imag());
1004  }
1005 
1006  template<typename _Tp>
1007  inline complex<_Tp>
1008  __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1009  { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
1010 
1011 #if _GLIBCXX_USE_C99_COMPLEX
1012  inline __complex__ float
1013  __complex_pow(__complex__ float __x, __complex__ float __y)
1014  { return __builtin_cpowf(__x, __y); }
1015 
1016  inline __complex__ double
1017  __complex_pow(__complex__ double __x, __complex__ double __y)
1018  { return __builtin_cpow(__x, __y); }
1019 
1020  inline __complex__ long double
1021  __complex_pow(const __complex__ long double& __x,
1022  const __complex__ long double& __y)
1023  { return __builtin_cpowl(__x, __y); }
1024 
1025  template<typename _Tp>
1026  inline complex<_Tp>
1027  pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1028  { return __complex_pow(__x.__rep(), __y.__rep()); }
1029 #else
1030  template<typename _Tp>
1031  inline complex<_Tp>
1032  pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1033  { return __complex_pow(__x, __y); }
1034 #endif
1035 
1036  template<typename _Tp>
1037  inline complex<_Tp>
1038  pow(const _Tp& __x, const complex<_Tp>& __y)
1039  {
1040  return __x > _Tp() ? std::polar<_Tp>(pow(__x, __y.real()),
1041  __y.imag() * log(__x))
1042  : std::pow(complex<_Tp>(__x), __y);
1043  }
1044 
1045  /// 26.2.3 complex specializations
1046  /// complex<float> specialization
1047  template<>
1048  struct complex<float>
1049  {
1050  typedef float value_type;
1051  typedef __complex__ float _ComplexT;
1052 
1053  _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1054 
1055  _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f)
1056 #if __cplusplus >= 201103L
1057  : _M_value{ __r, __i } { }
1058 #else
1059  {
1060  __real__ _M_value = __r;
1061  __imag__ _M_value = __i;
1062  }
1063 #endif
1064 
1065  explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&);
1066  explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1067 
1068 #if __cplusplus >= 201103L
1069  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1070  // DR 387. std::complex over-encapsulated.
1071  __attribute ((__abi_tag__ ("cxx11")))
1072  constexpr float
1073  real() const { return __real__ _M_value; }
1074 
1075  __attribute ((__abi_tag__ ("cxx11")))
1076  constexpr float
1077  imag() const { return __imag__ _M_value; }
1078 #else
1079  float&
1080  real() { return __real__ _M_value; }
1081 
1082  const float&
1083  real() const { return __real__ _M_value; }
1084 
1085  float&
1086  imag() { return __imag__ _M_value; }
1087 
1088  const float&
1089  imag() const { return __imag__ _M_value; }
1090 #endif
1091 
1092  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1093  // DR 387. std::complex over-encapsulated.
1094  void
1095  real(float __val) { __real__ _M_value = __val; }
1096 
1097  void
1098  imag(float __val) { __imag__ _M_value = __val; }
1099 
1100  complex&
1101  operator=(float __f)
1102  {
1103  _M_value = __f;
1104  return *this;
1105  }
1106 
1107  complex&
1108  operator+=(float __f)
1109  {
1110  _M_value += __f;
1111  return *this;
1112  }
1113 
1114  complex&
1115  operator-=(float __f)
1116  {
1117  _M_value -= __f;
1118  return *this;
1119  }
1120 
1121  complex&
1122  operator*=(float __f)
1123  {
1124  _M_value *= __f;
1125  return *this;
1126  }
1127 
1128  complex&
1129  operator/=(float __f)
1130  {
1131  _M_value /= __f;
1132  return *this;
1133  }
1134 
1135  // Let the compiler synthesize the copy and assignment
1136  // operator. It always does a pretty good job.
1137  // complex& operator=(const complex&);
1138 
1139  template<typename _Tp>
1140  complex&
1141  operator=(const complex<_Tp>& __z)
1142  {
1143  __real__ _M_value = __z.real();
1144  __imag__ _M_value = __z.imag();
1145  return *this;
1146  }
1147 
1148  template<typename _Tp>
1149  complex&
1150  operator+=(const complex<_Tp>& __z)
1151  {
1152  __real__ _M_value += __z.real();
1153  __imag__ _M_value += __z.imag();
1154  return *this;
1155  }
1156 
1157  template<class _Tp>
1158  complex&
1159  operator-=(const complex<_Tp>& __z)
1160  {
1161  __real__ _M_value -= __z.real();
1162  __imag__ _M_value -= __z.imag();
1163  return *this;
1164  }
1165 
1166  template<class _Tp>
1167  complex&
1168  operator*=(const complex<_Tp>& __z)
1169  {
1170  _ComplexT __t;
1171  __real__ __t = __z.real();
1172  __imag__ __t = __z.imag();
1173  _M_value *= __t;
1174  return *this;
1175  }
1176 
1177  template<class _Tp>
1178  complex&
1179  operator/=(const complex<_Tp>& __z)
1180  {
1181  _ComplexT __t;
1182  __real__ __t = __z.real();
1183  __imag__ __t = __z.imag();
1184  _M_value /= __t;
1185  return *this;
1186  }
1187 
1188  _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1189 
1190  private:
1191  _ComplexT _M_value;
1192  };
1193 
1194  /// 26.2.3 complex specializations
1195  /// complex<double> specialization
1196  template<>
1197  struct complex<double>
1198  {
1199  typedef double value_type;
1200  typedef __complex__ double _ComplexT;
1201 
1202  _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1203 
1204  _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0)
1205 #if __cplusplus >= 201103L
1206  : _M_value{ __r, __i } { }
1207 #else
1208  {
1209  __real__ _M_value = __r;
1210  __imag__ _M_value = __i;
1211  }
1212 #endif
1213 
1214  _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1215  : _M_value(__z.__rep()) { }
1216 
1217  explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1218 
1219 #if __cplusplus >= 201103L
1220  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1221  // DR 387. std::complex over-encapsulated.
1222  __attribute ((__abi_tag__ ("cxx11")))
1223  constexpr double
1224  real() const { return __real__ _M_value; }
1225 
1226  __attribute ((__abi_tag__ ("cxx11")))
1227  constexpr double
1228  imag() const { return __imag__ _M_value; }
1229 #else
1230  double&
1231  real() { return __real__ _M_value; }
1232 
1233  const double&
1234  real() const { return __real__ _M_value; }
1235 
1236  double&
1237  imag() { return __imag__ _M_value; }
1238 
1239  const double&
1240  imag() const { return __imag__ _M_value; }
1241 #endif
1242 
1243  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1244  // DR 387. std::complex over-encapsulated.
1245  void
1246  real(double __val) { __real__ _M_value = __val; }
1247 
1248  void
1249  imag(double __val) { __imag__ _M_value = __val; }
1250 
1251  complex&
1252  operator=(double __d)
1253  {
1254  _M_value = __d;
1255  return *this;
1256  }
1257 
1258  complex&
1259  operator+=(double __d)
1260  {
1261  _M_value += __d;
1262  return *this;
1263  }
1264 
1265  complex&
1266  operator-=(double __d)
1267  {
1268  _M_value -= __d;
1269  return *this;
1270  }
1271 
1272  complex&
1273  operator*=(double __d)
1274  {
1275  _M_value *= __d;
1276  return *this;
1277  }
1278 
1279  complex&
1280  operator/=(double __d)
1281  {
1282  _M_value /= __d;
1283  return *this;
1284  }
1285 
1286  // The compiler will synthesize this, efficiently.
1287  // complex& operator=(const complex&);
1288 
1289  template<typename _Tp>
1290  complex&
1291  operator=(const complex<_Tp>& __z)
1292  {
1293  __real__ _M_value = __z.real();
1294  __imag__ _M_value = __z.imag();
1295  return *this;
1296  }
1297 
1298  template<typename _Tp>
1299  complex&
1300  operator+=(const complex<_Tp>& __z)
1301  {
1302  __real__ _M_value += __z.real();
1303  __imag__ _M_value += __z.imag();
1304  return *this;
1305  }
1306 
1307  template<typename _Tp>
1308  complex&
1309  operator-=(const complex<_Tp>& __z)
1310  {
1311  __real__ _M_value -= __z.real();
1312  __imag__ _M_value -= __z.imag();
1313  return *this;
1314  }
1315 
1316  template<typename _Tp>
1317  complex&
1318  operator*=(const complex<_Tp>& __z)
1319  {
1320  _ComplexT __t;
1321  __real__ __t = __z.real();
1322  __imag__ __t = __z.imag();
1323  _M_value *= __t;
1324  return *this;
1325  }
1326 
1327  template<typename _Tp>
1328  complex&
1329  operator/=(const complex<_Tp>& __z)
1330  {
1331  _ComplexT __t;
1332  __real__ __t = __z.real();
1333  __imag__ __t = __z.imag();
1334  _M_value /= __t;
1335  return *this;
1336  }
1337 
1338  _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1339 
1340  private:
1341  _ComplexT _M_value;
1342  };
1343 
1344  /// 26.2.3 complex specializations
1345  /// complex<long double> specialization
1346  template<>
1347  struct complex<long double>
1348  {
1349  typedef long double value_type;
1350  typedef __complex__ long double _ComplexT;
1351 
1352  _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1353 
1354  _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L,
1355  long double __i = 0.0L)
1356 #if __cplusplus >= 201103L
1357  : _M_value{ __r, __i } { }
1358 #else
1359  {
1360  __real__ _M_value = __r;
1361  __imag__ _M_value = __i;
1362  }
1363 #endif
1364 
1365  _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1366  : _M_value(__z.__rep()) { }
1367 
1368  _GLIBCXX_CONSTEXPR complex(const complex<double>& __z)
1369  : _M_value(__z.__rep()) { }
1370 
1371 #if __cplusplus >= 201103L
1372  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1373  // DR 387. std::complex over-encapsulated.
1374  __attribute ((__abi_tag__ ("cxx11")))
1375  constexpr long double
1376  real() const { return __real__ _M_value; }
1377 
1378  __attribute ((__abi_tag__ ("cxx11")))
1379  constexpr long double
1380  imag() const { return __imag__ _M_value; }
1381 #else
1382  long double&
1383  real() { return __real__ _M_value; }
1384 
1385  const long double&
1386  real() const { return __real__ _M_value; }
1387 
1388  long double&
1389  imag() { return __imag__ _M_value; }
1390 
1391  const long double&
1392  imag() const { return __imag__ _M_value; }
1393 #endif
1394 
1395  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1396  // DR 387. std::complex over-encapsulated.
1397  void
1398  real(long double __val) { __real__ _M_value = __val; }
1399 
1400  void
1401  imag(long double __val) { __imag__ _M_value = __val; }
1402 
1403  complex&
1404  operator=(long double __r)
1405  {
1406  _M_value = __r;
1407  return *this;
1408  }
1409 
1410  complex&
1411  operator+=(long double __r)
1412  {
1413  _M_value += __r;
1414  return *this;
1415  }
1416 
1417  complex&
1418  operator-=(long double __r)
1419  {
1420  _M_value -= __r;
1421  return *this;
1422  }
1423 
1424  complex&
1425  operator*=(long double __r)
1426  {
1427  _M_value *= __r;
1428  return *this;
1429  }
1430 
1431  complex&
1432  operator/=(long double __r)
1433  {
1434  _M_value /= __r;
1435  return *this;
1436  }
1437 
1438  // The compiler knows how to do this efficiently
1439  // complex& operator=(const complex&);
1440 
1441  template<typename _Tp>
1442  complex&
1443  operator=(const complex<_Tp>& __z)
1444  {
1445  __real__ _M_value = __z.real();
1446  __imag__ _M_value = __z.imag();
1447  return *this;
1448  }
1449 
1450  template<typename _Tp>
1451  complex&
1452  operator+=(const complex<_Tp>& __z)
1453  {
1454  __real__ _M_value += __z.real();
1455  __imag__ _M_value += __z.imag();
1456  return *this;
1457  }
1458 
1459  template<typename _Tp>
1460  complex&
1461  operator-=(const complex<_Tp>& __z)
1462  {
1463  __real__ _M_value -= __z.real();
1464  __imag__ _M_value -= __z.imag();
1465  return *this;
1466  }
1467 
1468  template<typename _Tp>
1469  complex&
1470  operator*=(const complex<_Tp>& __z)
1471  {
1472  _ComplexT __t;
1473  __real__ __t = __z.real();
1474  __imag__ __t = __z.imag();
1475  _M_value *= __t;
1476  return *this;
1477  }
1478 
1479  template<typename _Tp>
1480  complex&
1481  operator/=(const complex<_Tp>& __z)
1482  {
1483  _ComplexT __t;
1484  __real__ __t = __z.real();
1485  __imag__ __t = __z.imag();
1486  _M_value /= __t;
1487  return *this;
1488  }
1489 
1490  _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1491 
1492  private:
1493  _ComplexT _M_value;
1494  };
1495 
1496  // These bits have to be at the end of this file, so that the
1497  // specializations have all been defined.
1498  inline _GLIBCXX_CONSTEXPR
1499  complex<float>::complex(const complex<double>& __z)
1500  : _M_value(__z.__rep()) { }
1501 
1502  inline _GLIBCXX_CONSTEXPR
1503  complex<float>::complex(const complex<long double>& __z)
1504  : _M_value(__z.__rep()) { }
1505 
1506  inline _GLIBCXX_CONSTEXPR
1507  complex<double>::complex(const complex<long double>& __z)
1508  : _M_value(__z.__rep()) { }
1509 
1510  // Inhibit implicit instantiations for required instantiations,
1511  // which are defined via explicit instantiations elsewhere.
1512  // NB: This syntax is a GNU extension.
1513 #if _GLIBCXX_EXTERN_TEMPLATE
1514  extern template istream& operator>>(istream&, complex<float>&);
1515  extern template ostream& operator<<(ostream&, const complex<float>&);
1516  extern template istream& operator>>(istream&, complex<double>&);
1517  extern template ostream& operator<<(ostream&, const complex<double>&);
1518  extern template istream& operator>>(istream&, complex<long double>&);
1519  extern template ostream& operator<<(ostream&, const complex<long double>&);
1520 
1521 #ifdef _GLIBCXX_USE_WCHAR_T
1522  extern template wistream& operator>>(wistream&, complex<float>&);
1523  extern template wostream& operator<<(wostream&, const complex<float>&);
1524  extern template wistream& operator>>(wistream&, complex<double>&);
1525  extern template wostream& operator<<(wostream&, const complex<double>&);
1526  extern template wistream& operator>>(wistream&, complex<long double>&);
1527  extern template wostream& operator<<(wostream&, const complex<long double>&);
1528 #endif
1529 #endif
1530 
1531  // @} group complex_numbers
1532 
1533 _GLIBCXX_END_NAMESPACE_VERSION
1534 } // namespace
1535 
1536 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
1537 {
1538 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1539 
1540  // See ext/type_traits.h for the primary template.
1541  template<typename _Tp, typename _Up>
1542  struct __promote_2<std::complex<_Tp>, _Up>
1543  {
1544  public:
1545  typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1546  };
1547 
1548  template<typename _Tp, typename _Up>
1549  struct __promote_2<_Tp, std::complex<_Up> >
1550  {
1551  public:
1552  typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1553  };
1554 
1555  template<typename _Tp, typename _Up>
1556  struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
1557  {
1558  public:
1559  typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1560  };
1561 
1562 _GLIBCXX_END_NAMESPACE_VERSION
1563 } // namespace
1564 
1565 #if __cplusplus >= 201103L
1566 
1567 namespace std _GLIBCXX_VISIBILITY(default)
1568 {
1569 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1570 
1571  // Forward declarations.
1572  template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
1573  template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
1574  template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
1575 
1576  template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
1577  template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
1578  template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
1579  // DR 595.
1580  template<typename _Tp> _Tp fabs(const std::complex<_Tp>&);
1581 
1582  template<typename _Tp>
1583  inline std::complex<_Tp>
1584  __complex_acos(const std::complex<_Tp>& __z)
1585  {
1586  const std::complex<_Tp> __t = std::asin(__z);
1587  const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
1588  return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
1589  }
1590 
1591 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1592  inline __complex__ float
1593  __complex_acos(__complex__ float __z)
1594  { return __builtin_cacosf(__z); }
1595 
1596  inline __complex__ double
1597  __complex_acos(__complex__ double __z)
1598  { return __builtin_cacos(__z); }
1599 
1600  inline __complex__ long double
1601  __complex_acos(const __complex__ long double& __z)
1602  { return __builtin_cacosl(__z); }
1603 
1604  template<typename _Tp>
1605  inline std::complex<_Tp>
1606  acos(const std::complex<_Tp>& __z)
1607  { return __complex_acos(__z.__rep()); }
1608 #else
1609  /// acos(__z) [8.1.2].
1610  // Effects: Behaves the same as C99 function cacos, defined
1611  // in subclause 7.3.5.1.
1612  template<typename _Tp>
1613  inline std::complex<_Tp>
1614  acos(const std::complex<_Tp>& __z)
1615  { return __complex_acos(__z); }
1616 #endif
1617 
1618  template<typename _Tp>
1619  inline std::complex<_Tp>
1620  __complex_asin(const std::complex<_Tp>& __z)
1621  {
1622  std::complex<_Tp> __t(-__z.imag(), __z.real());
1623  __t = std::asinh(__t);
1624  return std::complex<_Tp>(__t.imag(), -__t.real());
1625  }
1626 
1627 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1628  inline __complex__ float
1629  __complex_asin(__complex__ float __z)
1630  { return __builtin_casinf(__z); }
1631 
1632  inline __complex__ double
1633  __complex_asin(__complex__ double __z)
1634  { return __builtin_casin(__z); }
1635 
1636  inline __complex__ long double
1637  __complex_asin(const __complex__ long double& __z)
1638  { return __builtin_casinl(__z); }
1639 
1640  template<typename _Tp>
1641  inline std::complex<_Tp>
1642  asin(const std::complex<_Tp>& __z)
1643  { return __complex_asin(__z.__rep()); }
1644 #else
1645  /// asin(__z) [8.1.3].
1646  // Effects: Behaves the same as C99 function casin, defined
1647  // in subclause 7.3.5.2.
1648  template<typename _Tp>
1649  inline std::complex<_Tp>
1650  asin(const std::complex<_Tp>& __z)
1651  { return __complex_asin(__z); }
1652 #endif
1653 
1654  template<typename _Tp>
1655  std::complex<_Tp>
1656  __complex_atan(const std::complex<_Tp>& __z)
1657  {
1658  const _Tp __r2 = __z.real() * __z.real();
1659  const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
1660 
1661  _Tp __num = __z.imag() + _Tp(1.0);
1662  _Tp __den = __z.imag() - _Tp(1.0);
1663 
1664  __num = __r2 + __num * __num;
1665  __den = __r2 + __den * __den;
1666 
1667  return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
1668  _Tp(0.25) * log(__num / __den));
1669  }
1670 
1671 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1672  inline __complex__ float
1673  __complex_atan(__complex__ float __z)
1674  { return __builtin_catanf(__z); }
1675 
1676  inline __complex__ double
1677  __complex_atan(__complex__ double __z)
1678  { return __builtin_catan(__z); }
1679 
1680  inline __complex__ long double
1681  __complex_atan(const __complex__ long double& __z)
1682  { return __builtin_catanl(__z); }
1683 
1684  template<typename _Tp>
1685  inline std::complex<_Tp>
1686  atan(const std::complex<_Tp>& __z)
1687  { return __complex_atan(__z.__rep()); }
1688 #else
1689  /// atan(__z) [8.1.4].
1690  // Effects: Behaves the same as C99 function catan, defined
1691  // in subclause 7.3.5.3.
1692  template<typename _Tp>
1693  inline std::complex<_Tp>
1694  atan(const std::complex<_Tp>& __z)
1695  { return __complex_atan(__z); }
1696 #endif
1697 
1698  template<typename _Tp>
1699  std::complex<_Tp>
1700  __complex_acosh(const std::complex<_Tp>& __z)
1701  {
1702  // Kahan's formula.
1703  return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
1704  + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
1705  }
1706 
1707 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1708  inline __complex__ float
1709  __complex_acosh(__complex__ float __z)
1710  { return __builtin_cacoshf(__z); }
1711 
1712  inline __complex__ double
1713  __complex_acosh(__complex__ double __z)
1714  { return __builtin_cacosh(__z); }
1715 
1716  inline __complex__ long double
1717  __complex_acosh(const __complex__ long double& __z)
1718  { return __builtin_cacoshl(__z); }
1719 
1720  template<typename _Tp>
1721  inline std::complex<_Tp>
1722  acosh(const std::complex<_Tp>& __z)
1723  { return __complex_acosh(__z.__rep()); }
1724 #else
1725  /// acosh(__z) [8.1.5].
1726  // Effects: Behaves the same as C99 function cacosh, defined
1727  // in subclause 7.3.6.1.
1728  template<typename _Tp>
1729  inline std::complex<_Tp>
1730  acosh(const std::complex<_Tp>& __z)
1731  { return __complex_acosh(__z); }
1732 #endif
1733 
1734  template<typename _Tp>
1735  std::complex<_Tp>
1736  __complex_asinh(const std::complex<_Tp>& __z)
1737  {
1738  std::complex<_Tp> __t((__z.real() - __z.imag())
1739  * (__z.real() + __z.imag()) + _Tp(1.0),
1740  _Tp(2.0) * __z.real() * __z.imag());
1741  __t = std::sqrt(__t);
1742 
1743  return std::log(__t + __z);
1744  }
1745 
1746 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1747  inline __complex__ float
1748  __complex_asinh(__complex__ float __z)
1749  { return __builtin_casinhf(__z); }
1750 
1751  inline __complex__ double
1752  __complex_asinh(__complex__ double __z)
1753  { return __builtin_casinh(__z); }
1754 
1755  inline __complex__ long double
1756  __complex_asinh(const __complex__ long double& __z)
1757  { return __builtin_casinhl(__z); }
1758 
1759  template<typename _Tp>
1760  inline std::complex<_Tp>
1761  asinh(const std::complex<_Tp>& __z)
1762  { return __complex_asinh(__z.__rep()); }
1763 #else
1764  /// asinh(__z) [8.1.6].
1765  // Effects: Behaves the same as C99 function casin, defined
1766  // in subclause 7.3.6.2.
1767  template<typename _Tp>
1768  inline std::complex<_Tp>
1769  asinh(const std::complex<_Tp>& __z)
1770  { return __complex_asinh(__z); }
1771 #endif
1772 
1773  template<typename _Tp>
1774  std::complex<_Tp>
1775  __complex_atanh(const std::complex<_Tp>& __z)
1776  {
1777  const _Tp __i2 = __z.imag() * __z.imag();
1778  const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
1779 
1780  _Tp __num = _Tp(1.0) + __z.real();
1781  _Tp __den = _Tp(1.0) - __z.real();
1782 
1783  __num = __i2 + __num * __num;
1784  __den = __i2 + __den * __den;
1785 
1786  return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
1787  _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
1788  }
1789 
1790 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1791  inline __complex__ float
1792  __complex_atanh(__complex__ float __z)
1793  { return __builtin_catanhf(__z); }
1794 
1795  inline __complex__ double
1796  __complex_atanh(__complex__ double __z)
1797  { return __builtin_catanh(__z); }
1798 
1799  inline __complex__ long double
1800  __complex_atanh(const __complex__ long double& __z)
1801  { return __builtin_catanhl(__z); }
1802 
1803  template<typename _Tp>
1804  inline std::complex<_Tp>
1805  atanh(const std::complex<_Tp>& __z)
1806  { return __complex_atanh(__z.__rep()); }
1807 #else
1808  /// atanh(__z) [8.1.7].
1809  // Effects: Behaves the same as C99 function catanh, defined
1810  // in subclause 7.3.6.3.
1811  template<typename _Tp>
1812  inline std::complex<_Tp>
1813  atanh(const std::complex<_Tp>& __z)
1814  { return __complex_atanh(__z); }
1815 #endif
1816 
1817  template<typename _Tp>
1818  inline _Tp
1819  /// fabs(__z) [8.1.8].
1820  // Effects: Behaves the same as C99 function cabs, defined
1821  // in subclause 7.3.8.1.
1822  fabs(const std::complex<_Tp>& __z)
1823  { return std::abs(__z); }
1824 
1825  /// Additional overloads [8.1.9].
1826  template<typename _Tp>
1827  inline typename __gnu_cxx::__promote<_Tp>::__type
1828  arg(_Tp __x)
1829  {
1830  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1831 #if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
1832  return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
1833  : __type();
1834 #else
1835  return std::arg(std::complex<__type>(__x));
1836 #endif
1837  }
1838 
1839  template<typename _Tp>
1840  inline typename __gnu_cxx::__promote<_Tp>::__type
1841  imag(_Tp)
1842  { return _Tp(); }
1843 
1844  template<typename _Tp>
1845  inline typename __gnu_cxx::__promote<_Tp>::__type
1846  norm(_Tp __x)
1847  {
1848  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1849  return __type(__x) * __type(__x);
1850  }
1851 
1852  template<typename _Tp>
1853  inline typename __gnu_cxx::__promote<_Tp>::__type
1854  real(_Tp __x)
1855  { return __x; }
1856 
1857  template<typename _Tp, typename _Up>
1858  inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1859  pow(const std::complex<_Tp>& __x, const _Up& __y)
1860  {
1861  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1862  return std::pow(std::complex<__type>(__x), __type(__y));
1863  }
1864 
1865  template<typename _Tp, typename _Up>
1866  inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1867  pow(const _Tp& __x, const std::complex<_Up>& __y)
1868  {
1869  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1870  return std::pow(__type(__x), std::complex<__type>(__y));
1871  }
1872 
1873  template<typename _Tp, typename _Up>
1874  inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1875  pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
1876  {
1877  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1878  return std::pow(std::complex<__type>(__x),
1879  std::complex<__type>(__y));
1880  }
1881 
1882  // Forward declarations.
1883  // DR 781.
1884  template<typename _Tp> std::complex<_Tp> proj(const std::complex<_Tp>&);
1885 
1886  template<typename _Tp>
1887  std::complex<_Tp>
1888  __complex_proj(const std::complex<_Tp>& __z)
1889  {
1890  const _Tp __den = (__z.real() * __z.real()
1891  + __z.imag() * __z.imag() + _Tp(1.0));
1892 
1893  return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den,
1894  (_Tp(2.0) * __z.imag()) / __den);
1895  }
1896 
1897 #if _GLIBCXX_USE_C99_COMPLEX
1898  inline __complex__ float
1899  __complex_proj(__complex__ float __z)
1900  { return __builtin_cprojf(__z); }
1901 
1902  inline __complex__ double
1903  __complex_proj(__complex__ double __z)
1904  { return __builtin_cproj(__z); }
1905 
1906  inline __complex__ long double
1907  __complex_proj(const __complex__ long double& __z)
1908  { return __builtin_cprojl(__z); }
1909 
1910  template<typename _Tp>
1911  inline std::complex<_Tp>
1912  proj(const std::complex<_Tp>& __z)
1913  { return __complex_proj(__z.__rep()); }
1914 #else
1915  template<typename _Tp>
1916  inline std::complex<_Tp>
1917  proj(const std::complex<_Tp>& __z)
1918  { return __complex_proj(__z); }
1919 #endif
1920 
1921  // DR 1137.
1922  template<typename _Tp>
1923  inline typename __gnu_cxx::__promote<_Tp>::__type
1924  proj(_Tp __x)
1925  { return __x; }
1926 
1927  template<typename _Tp>
1928  inline typename __gnu_cxx::__promote<_Tp>::__type
1929  conj(_Tp __x)
1930  { return __x; }
1931 
1932 #if __cplusplus > 201103L
1933 
1934 inline namespace literals {
1935 inline namespace complex_literals {
1936 
1937 #define __cpp_lib_complex_udls 201309
1938 
1939  constexpr std::complex<float>
1940  operator""if(long double __num)
1941  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
1942 
1943  constexpr std::complex<float>
1944  operator""if(unsigned long long __num)
1945  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
1946 
1947  constexpr std::complex<double>
1948  operator""i(long double __num)
1949  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
1950 
1951  constexpr std::complex<double>
1952  operator""i(unsigned long long __num)
1953  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
1954 
1955  constexpr std::complex<long double>
1956  operator""il(long double __num)
1957  { return std::complex<long double>{0.0L, __num}; }
1958 
1959  constexpr std::complex<long double>
1960  operator""il(unsigned long long __num)
1961  { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }
1962 
1963 } // inline namespace complex_literals
1964 } // inline namespace literals
1965 
1966 #endif // C++14
1967 
1968 _GLIBCXX_END_NAMESPACE_VERSION
1969 } // namespace
1970 
1971 #endif // C++11
1972 
1973 #endif /* _GLIBCXX_COMPLEX */