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