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