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, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 // 2006, 2007, 2008, 2009, 2010, 2011
5 // Free Software Foundation, Inc.
6 //
7 // This file is part of the GNU ISO C++ Library. This library is free
8 // software; you can redistribute it and/or modify it under the
9 // terms of the GNU General Public License as published by the
10 // Free Software Foundation; either version 3, or (at your option)
11 // any later version.
12 
13 // This library is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
17 
18 // Under Section 7 of GPL version 3, you are granted additional
19 // permissions described in the GCC Runtime Library Exception, version
20 // 3.1, as published by the Free Software Foundation.
21 
22 // You should have received a copy of the GNU General Public License and
23 // a copy of the GCC Runtime Library Exception along with this program;
24 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
25 // <http://www.gnu.org/licenses/>.
26 
27 /** @file include/complex
28  * This is a Standard C++ Library header.
29  */
30 
31 //
32 // ISO C++ 14882: 26.2 Complex Numbers
33 // Note: this is not a conforming implementation.
34 // Initially implemented by Ulrich Drepper <drepper@cygnus.com>
35 // Improved by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
36 //
37 
38 #ifndef _GLIBCXX_COMPLEX
39 #define _GLIBCXX_COMPLEX 1
40 
41 #pragma GCC system_header
42 
43 #include <bits/c++config.h>
44 #include <bits/cpp_type_traits.h>
45 #include <ext/type_traits.h>
46 #include <cmath>
47 #include <sstream>
48 
49 namespace std _GLIBCXX_VISIBILITY(default)
50 {
51 _GLIBCXX_BEGIN_NAMESPACE_VERSION
52 
53  /**
54  * @defgroup complex_numbers Complex Numbers
55  * @ingroup numerics
56  *
57  * Classes and functions for complex numbers.
58  * @{
59  */
60 
61  // Forward declarations.
62  template<typename _Tp> class complex;
63  template<> class complex<float>;
64  template<> class complex<double>;
65  template<> class complex<long double>;
66 
67  /// Return magnitude of @a z.
68  template<typename _Tp> _Tp abs(const complex<_Tp>&);
69  /// Return phase angle of @a z.
70  template<typename _Tp> _Tp arg(const complex<_Tp>&);
71  /// Return @a z magnitude squared.
72  template<typename _Tp> _Tp norm(const complex<_Tp>&);
73 
74  /// Return complex conjugate of @a z.
75  template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
76  /// Return complex with magnitude @a rho and angle @a theta.
77  template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
78 
79  // Transcendentals:
80  /// Return complex cosine of @a z.
81  template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
82  /// Return complex hyperbolic cosine of @a z.
83  template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
84  /// Return complex base e exponential of @a z.
85  template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
86  /// Return complex natural logarithm of @a z.
87  template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
88  /// Return complex base 10 logarithm of @a z.
89  template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
90 #ifndef __GXX_EXPERIMENTAL_CXX0X__
91  // DR 844.
92  /// Return @a x to the @a y'th power.
93  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
94 #endif
95  /// Return @a x to the @a y'th power.
96  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
97  /// Return @a x to the @a y'th power.
98  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
99  const complex<_Tp>&);
100  /// Return @a x to the @a y'th power.
101  template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
102  /// Return complex sine of @a z.
103  template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
104  /// Return complex hyperbolic sine of @a z.
105  template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
106  /// Return complex square root of @a z.
107  template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
108  /// Return complex tangent of @a z.
109  template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
110  /// Return complex hyperbolic tangent of @a z.
111  template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
112 
113 
114  // 26.2.2 Primary template class complex
115  /**
116  * Template to represent complex numbers.
117  *
118  * Specializations for float, double, and long double are part of the
119  * library. Results with any other type are not guaranteed.
120  *
121  * @param Tp Type of real and imaginary values.
122  */
123  template<typename _Tp>
124  struct complex
125  {
126  /// Value typedef.
127  typedef _Tp value_type;
128 
129  /// Default constructor. First parameter is x, second parameter is y.
130  /// Unspecified parameters default to 0.
131  _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
132  : _M_real(__r), _M_imag(__i) { }
133 
134  // Lets the compiler synthesize the copy constructor
135  // complex (const complex<_Tp>&);
136  /// Copy constructor.
137  template<typename _Up>
138  _GLIBCXX_CONSTEXPR complex(const complex<_Up>& __z)
139  : _M_real(__z.real()), _M_imag(__z.imag()) { }
140 
141 #ifdef __GXX_EXPERIMENTAL_CXX0X__
142  // _GLIBCXX_RESOLVE_LIB_DEFECTS
143  // DR 387. std::complex over-encapsulated.
144  constexpr _Tp
145  real() const { return _M_real; }
146 
147  constexpr _Tp
148  imag() const { 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>
207  /// Add @a z to this complex number.
208  template<typename _Up>
210  /// Subtract @a z from this complex number.
211  template<typename _Up>
213  /// Multiply this complex number by @a z.
214  template<typename _Up>
216  /// Divide this complex number by @a z.
217  template<typename _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>&
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>&
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>&
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>&
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>&
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>
441  { return __x; }
442 
443  /// Return complex negation of @a x.
444  template<typename _Tp>
445  inline complex<_Tp>
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>&
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
503  }
504  else if (__ch == ')')
505  __x = __re_x;
506  else
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  {
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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
533  template<typename _Tp>
534  inline constexpr _Tp
535  real(const complex<_Tp>& __z)
536  { return __z.real(); }
537 
538  template<typename _Tp>
539  inline 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 #ifndef __GXX_EXPERIMENTAL_CXX0X__
956  template<typename _Tp>
957  complex<_Tp>
958  __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
959  {
960  complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
961 
962  while (__n >>= 1)
963  {
964  __x *= __x;
965  if (__n % 2)
966  __y *= __x;
967  }
968 
969  return __y;
970  }
971 
972  // _GLIBCXX_RESOLVE_LIB_DEFECTS
973  // DR 844. complex pow return type is ambiguous.
974  template<typename _Tp>
975  inline complex<_Tp>
976  pow(const complex<_Tp>& __z, int __n)
977  {
978  return __n < 0
979  ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -__n)
980  : std::__complex_pow_unsigned(__z, __n);
981  }
982 #endif
983 
984  template<typename _Tp>
985  complex<_Tp>
986  pow(const complex<_Tp>& __x, const _Tp& __y)
987  {
988 #ifndef _GLIBCXX_USE_C99_COMPLEX
989  if (__x == _Tp())
990  return _Tp();
991 #endif
992  if (__x.imag() == _Tp() && __x.real() > _Tp())
993  return pow(__x.real(), __y);
994 
995  complex<_Tp> __t = std::log(__x);
996  return std::polar(exp(__y * __t.real()), __y * __t.imag());
997  }
998 
999  template<typename _Tp>
1000  inline complex<_Tp>
1001  __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1002  { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
1003 
1004 #if _GLIBCXX_USE_C99_COMPLEX
1005  inline __complex__ float
1006  __complex_pow(__complex__ float __x, __complex__ float __y)
1007  { return __builtin_cpowf(__x, __y); }
1008 
1009  inline __complex__ double
1010  __complex_pow(__complex__ double __x, __complex__ double __y)
1011  { return __builtin_cpow(__x, __y); }
1012 
1013  inline __complex__ long double
1014  __complex_pow(const __complex__ long double& __x,
1015  const __complex__ long double& __y)
1016  { return __builtin_cpowl(__x, __y); }
1017 
1018  template<typename _Tp>
1019  inline complex<_Tp>
1020  pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1021  { return __complex_pow(__x.__rep(), __y.__rep()); }
1022 #else
1023  template<typename _Tp>
1024  inline complex<_Tp>
1025  pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1026  { return __complex_pow(__x, __y); }
1027 #endif
1028 
1029  template<typename _Tp>
1030  inline complex<_Tp>
1031  pow(const _Tp& __x, const complex<_Tp>& __y)
1032  {
1033  return __x > _Tp() ? std::polar(pow(__x, __y.real()),
1034  __y.imag() * log(__x))
1035  : std::pow(complex<_Tp>(__x), __y);
1036  }
1037 
1038  // 26.2.3 complex specializations
1039  // complex<float> specialization
1040  template<>
1041  struct complex<float>
1042  {
1043  typedef float value_type;
1044  typedef __complex__ float _ComplexT;
1045 
1046  _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1047 
1048  _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f)
1049 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1050  // The list-initialization extension to __complex__ types is
1051  // not available in GCC 4.6. Thus libstdc++/48760 cannot be
1052  // fixed in C++0x mode, unfortunately.
1053  : _M_value(__r + __i * 1.0fi) { }
1054 #else
1055  {
1056  __real__ _M_value = __r;
1057  __imag__ _M_value = __i;
1058  }
1059 #endif
1060 
1061  explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&);
1062  explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1063 
1064 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1065  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1066  // DR 387. std::complex over-encapsulated.
1067  constexpr float
1068  real() const { return __real__ _M_value; }
1069 
1070  constexpr float
1071  imag() const { return __imag__ _M_value; }
1072 #else
1073  float&
1074  real() { return __real__ _M_value; }
1075 
1076  const float&
1077  real() const { return __real__ _M_value; }
1078 
1079  float&
1080  imag() { return __imag__ _M_value; }
1081 
1082  const float&
1083  imag() const { return __imag__ _M_value; }
1084 #endif
1085 
1086  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1087  // DR 387. std::complex over-encapsulated.
1088  void
1089  real(float __val) { __real__ _M_value = __val; }
1090 
1091  void
1092  imag(float __val) { __imag__ _M_value = __val; }
1093 
1094  complex&
1095  operator=(float __f)
1096  {
1097  _M_value = __f;
1098  return *this;
1099  }
1100 
1101  complex&
1102  operator+=(float __f)
1103  {
1104  _M_value += __f;
1105  return *this;
1106  }
1107 
1108  complex&
1109  operator-=(float __f)
1110  {
1111  _M_value -= __f;
1112  return *this;
1113  }
1114 
1115  complex&
1116  operator*=(float __f)
1117  {
1118  _M_value *= __f;
1119  return *this;
1120  }
1121 
1122  complex&
1123  operator/=(float __f)
1124  {
1125  _M_value /= __f;
1126  return *this;
1127  }
1128 
1129  // Let the compiler synthesize the copy and assignment
1130  // operator. It always does a pretty good job.
1131  // complex& operator=(const complex&);
1132 
1133  template<typename _Tp>
1134  complex&
1135  operator=(const complex<_Tp>& __z)
1136  {
1137  __real__ _M_value = __z.real();
1138  __imag__ _M_value = __z.imag();
1139  return *this;
1140  }
1141 
1142  template<typename _Tp>
1143  complex&
1144  operator+=(const complex<_Tp>& __z)
1145  {
1146  __real__ _M_value += __z.real();
1147  __imag__ _M_value += __z.imag();
1148  return *this;
1149  }
1150 
1151  template<class _Tp>
1152  complex&
1153  operator-=(const complex<_Tp>& __z)
1154  {
1155  __real__ _M_value -= __z.real();
1156  __imag__ _M_value -= __z.imag();
1157  return *this;
1158  }
1159 
1160  template<class _Tp>
1161  complex&
1162  operator*=(const complex<_Tp>& __z)
1163  {
1164  _ComplexT __t;
1165  __real__ __t = __z.real();
1166  __imag__ __t = __z.imag();
1167  _M_value *= __t;
1168  return *this;
1169  }
1170 
1171  template<class _Tp>
1172  complex&
1173  operator/=(const complex<_Tp>& __z)
1174  {
1175  _ComplexT __t;
1176  __real__ __t = __z.real();
1177  __imag__ __t = __z.imag();
1178  _M_value /= __t;
1179  return *this;
1180  }
1181 
1182  _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1183 
1184  private:
1185  _ComplexT _M_value;
1186  };
1187 
1188  // 26.2.3 complex specializations
1189  // complex<double> specialization
1190  template<>
1191  struct complex<double>
1192  {
1193  typedef double value_type;
1194  typedef __complex__ double _ComplexT;
1195 
1196  _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1197 
1198  _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0)
1199 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1200  // The list-initialization extension to __complex__ types is
1201  // not available in GCC 4.6. Thus libstdc++/48760 cannot be
1202  // fixed in C++0x mode, unfortunately.
1203  : _M_value(__r + __i * 1.0i) { }
1204 #else
1205  {
1206  __real__ _M_value = __r;
1207  __imag__ _M_value = __i;
1208  }
1209 #endif
1210 
1211  _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1212  : _M_value(__z.__rep()) { }
1213 
1214  explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1215 
1216 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1217  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1218  // DR 387. std::complex over-encapsulated.
1219  constexpr double
1220  real() const { return __real__ _M_value; }
1221 
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 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1352  // The list-initialization extension to __complex__ types is
1353  // not available in GCC 4.6. Thus libstdc++/48760 cannot be
1354  // fixed in C++0x mode, unfortunately.
1355  : _M_value(__r + __i * 1.0Li) { }
1356 #else
1357  {
1358  __real__ _M_value = __r;
1359  __imag__ _M_value = __i;
1360  }
1361 #endif
1362 
1363  _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1364  : _M_value(__z.__rep()) { }
1365 
1366  _GLIBCXX_CONSTEXPR complex(const complex<double>& __z)
1367  : _M_value(__z.__rep()) { }
1368 
1369 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1370  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1371  // DR 387. std::complex over-encapsulated.
1372  constexpr long double
1373  real() const { return __real__ _M_value; }
1374 
1375  constexpr long double
1376  imag() const { return __imag__ _M_value; }
1377 #else
1378  long double&
1379  real() { return __real__ _M_value; }
1380 
1381  const long double&
1382  real() const { return __real__ _M_value; }
1383 
1384  long double&
1385  imag() { return __imag__ _M_value; }
1386 
1387  const long double&
1388  imag() const { return __imag__ _M_value; }
1389 #endif
1390 
1391  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1392  // DR 387. std::complex over-encapsulated.
1393  void
1394  real(long double __val) { __real__ _M_value = __val; }
1395 
1396  void
1397  imag(long double __val) { __imag__ _M_value = __val; }
1398 
1399  complex&
1400  operator=(long double __r)
1401  {
1402  _M_value = __r;
1403  return *this;
1404  }
1405 
1406  complex&
1407  operator+=(long double __r)
1408  {
1409  _M_value += __r;
1410  return *this;
1411  }
1412 
1413  complex&
1414  operator-=(long double __r)
1415  {
1416  _M_value -= __r;
1417  return *this;
1418  }
1419 
1420  complex&
1421  operator*=(long double __r)
1422  {
1423  _M_value *= __r;
1424  return *this;
1425  }
1426 
1427  complex&
1428  operator/=(long double __r)
1429  {
1430  _M_value /= __r;
1431  return *this;
1432  }
1433 
1434  // The compiler knows how to do this efficiently
1435  // complex& operator=(const complex&);
1436 
1437  template<typename _Tp>
1438  complex&
1439  operator=(const complex<_Tp>& __z)
1440  {
1441  __real__ _M_value = __z.real();
1442  __imag__ _M_value = __z.imag();
1443  return *this;
1444  }
1445 
1446  template<typename _Tp>
1447  complex&
1448  operator+=(const complex<_Tp>& __z)
1449  {
1450  __real__ _M_value += __z.real();
1451  __imag__ _M_value += __z.imag();
1452  return *this;
1453  }
1454 
1455  template<typename _Tp>
1456  complex&
1457  operator-=(const complex<_Tp>& __z)
1458  {
1459  __real__ _M_value -= __z.real();
1460  __imag__ _M_value -= __z.imag();
1461  return *this;
1462  }
1463 
1464  template<typename _Tp>
1465  complex&
1466  operator*=(const complex<_Tp>& __z)
1467  {
1468  _ComplexT __t;
1469  __real__ __t = __z.real();
1470  __imag__ __t = __z.imag();
1471  _M_value *= __t;
1472  return *this;
1473  }
1474 
1475  template<typename _Tp>
1476  complex&
1477  operator/=(const complex<_Tp>& __z)
1478  {
1479  _ComplexT __t;
1480  __real__ __t = __z.real();
1481  __imag__ __t = __z.imag();
1482  _M_value /= __t;
1483  return *this;
1484  }
1485 
1486  _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1487 
1488  private:
1489  _ComplexT _M_value;
1490  };
1491 
1492  // These bits have to be at the end of this file, so that the
1493  // specializations have all been defined.
1494  inline _GLIBCXX_CONSTEXPR
1495  complex<float>::complex(const complex<double>& __z)
1496  : _M_value(__z.__rep()) { }
1497 
1498  inline _GLIBCXX_CONSTEXPR
1499  complex<float>::complex(const complex<long double>& __z)
1500  : _M_value(__z.__rep()) { }
1501 
1502  inline _GLIBCXX_CONSTEXPR
1503  complex<double>::complex(const complex<long double>& __z)
1504  : _M_value(__z.__rep()) { }
1505 
1506  // Inhibit implicit instantiations for required instantiations,
1507  // which are defined via explicit instantiations elsewhere.
1508  // NB: This syntax is a GNU extension.
1509 #if _GLIBCXX_EXTERN_TEMPLATE
1510  extern template istream& operator>>(istream&, complex<float>&);
1511  extern template ostream& operator<<(ostream&, const complex<float>&);
1512  extern template istream& operator>>(istream&, complex<double>&);
1513  extern template ostream& operator<<(ostream&, const complex<double>&);
1514  extern template istream& operator>>(istream&, complex<long double>&);
1515  extern template ostream& operator<<(ostream&, const complex<long double>&);
1516 
1517 #ifdef _GLIBCXX_USE_WCHAR_T
1518  extern template wistream& operator>>(wistream&, complex<float>&);
1519  extern template wostream& operator<<(wostream&, const complex<float>&);
1520  extern template wistream& operator>>(wistream&, complex<double>&);
1521  extern template wostream& operator<<(wostream&, const complex<double>&);
1522  extern template wistream& operator>>(wistream&, complex<long double>&);
1523  extern template wostream& operator<<(wostream&, const complex<long double>&);
1524 #endif
1525 #endif
1526 
1527  // @} group complex_numbers
1528 
1529 _GLIBCXX_END_NAMESPACE_VERSION
1530 } // namespace
1531 
1532 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
1533 {
1534 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1535 
1536  // See ext/type_traits.h for the primary template.
1537  template<typename _Tp, typename _Up>
1538  struct __promote_2<std::complex<_Tp>, _Up>
1539  {
1540  public:
1542  };
1543 
1544  template<typename _Tp, typename _Up>
1545  struct __promote_2<_Tp, std::complex<_Up> >
1546  {
1547  public:
1549  };
1550 
1551  template<typename _Tp, typename _Up>
1552  struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
1553  {
1554  public:
1556  };
1557 
1558 _GLIBCXX_END_NAMESPACE_VERSION
1559 } // namespace
1560 
1561 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1562 
1563 namespace std _GLIBCXX_VISIBILITY(default)
1564 {
1565 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1566 
1567  // Forward declarations.
1568  template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
1569  template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
1570  template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
1571 
1572  template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
1573  template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
1574  template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
1575  // DR 595.
1576  template<typename _Tp> _Tp fabs(const std::complex<_Tp>&);
1577 
1578  template<typename _Tp>
1579  inline std::complex<_Tp>
1580  __complex_acos(const std::complex<_Tp>& __z)
1581  {
1582  const std::complex<_Tp> __t = std::asin(__z);
1583  const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
1584  return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
1585  }
1586 
1587 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1588  inline __complex__ float
1589  __complex_acos(__complex__ float __z)
1590  { return __builtin_cacosf(__z); }
1591 
1592  inline __complex__ double
1593  __complex_acos(__complex__ double __z)
1594  { return __builtin_cacos(__z); }
1595 
1596  inline __complex__ long double
1597  __complex_acos(const __complex__ long double& __z)
1598  { return __builtin_cacosl(__z); }
1599 
1600  template<typename _Tp>
1601  inline std::complex<_Tp>
1602  acos(const std::complex<_Tp>& __z)
1603  { return __complex_acos(__z.__rep()); }
1604 #else
1605  /// acos(__z) [8.1.2].
1606  // Effects: Behaves the same as C99 function cacos, defined
1607  // in subclause 7.3.5.1.
1608  template<typename _Tp>
1609  inline std::complex<_Tp>
1611  { return __complex_acos(__z); }
1612 #endif
1613 
1614  template<typename _Tp>
1615  inline std::complex<_Tp>
1616  __complex_asin(const std::complex<_Tp>& __z)
1617  {
1618  std::complex<_Tp> __t(-__z.imag(), __z.real());
1619  __t = std::asinh(__t);
1620  return std::complex<_Tp>(__t.imag(), -__t.real());
1621  }
1622 
1623 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1624  inline __complex__ float
1625  __complex_asin(__complex__ float __z)
1626  { return __builtin_casinf(__z); }
1627 
1628  inline __complex__ double
1629  __complex_asin(__complex__ double __z)
1630  { return __builtin_casin(__z); }
1631 
1632  inline __complex__ long double
1633  __complex_asin(const __complex__ long double& __z)
1634  { return __builtin_casinl(__z); }
1635 
1636  template<typename _Tp>
1637  inline std::complex<_Tp>
1638  asin(const std::complex<_Tp>& __z)
1639  { return __complex_asin(__z.__rep()); }
1640 #else
1641  /// asin(__z) [8.1.3].
1642  // Effects: Behaves the same as C99 function casin, defined
1643  // in subclause 7.3.5.2.
1644  template<typename _Tp>
1645  inline std::complex<_Tp>
1647  { return __complex_asin(__z); }
1648 #endif
1649 
1650  template<typename _Tp>
1652  __complex_atan(const std::complex<_Tp>& __z)
1653  {
1654  const _Tp __r2 = __z.real() * __z.real();
1655  const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
1656 
1657  _Tp __num = __z.imag() + _Tp(1.0);
1658  _Tp __den = __z.imag() - _Tp(1.0);
1659 
1660  __num = __r2 + __num * __num;
1661  __den = __r2 + __den * __den;
1662 
1663  return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
1664  _Tp(0.25) * log(__num / __den));
1665  }
1666 
1667 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1668  inline __complex__ float
1669  __complex_atan(__complex__ float __z)
1670  { return __builtin_catanf(__z); }
1671 
1672  inline __complex__ double
1673  __complex_atan(__complex__ double __z)
1674  { return __builtin_catan(__z); }
1675 
1676  inline __complex__ long double
1677  __complex_atan(const __complex__ long double& __z)
1678  { return __builtin_catanl(__z); }
1679 
1680  template<typename _Tp>
1681  inline std::complex<_Tp>
1682  atan(const std::complex<_Tp>& __z)
1683  { return __complex_atan(__z.__rep()); }
1684 #else
1685  /// atan(__z) [8.1.4].
1686  // Effects: Behaves the same as C99 function catan, defined
1687  // in subclause 7.3.5.3.
1688  template<typename _Tp>
1689  inline std::complex<_Tp>
1691  { return __complex_atan(__z); }
1692 #endif
1693 
1694  template<typename _Tp>
1696  __complex_acosh(const std::complex<_Tp>& __z)
1697  {
1698  // Kahan's formula.
1699  return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
1700  + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
1701  }
1702 
1703 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1704  inline __complex__ float
1705  __complex_acosh(__complex__ float __z)
1706  { return __builtin_cacoshf(__z); }
1707 
1708  inline __complex__ double
1709  __complex_acosh(__complex__ double __z)
1710  { return __builtin_cacosh(__z); }
1711 
1712  inline __complex__ long double
1713  __complex_acosh(const __complex__ long double& __z)
1714  { return __builtin_cacoshl(__z); }
1715 
1716  template<typename _Tp>
1717  inline std::complex<_Tp>
1718  acosh(const std::complex<_Tp>& __z)
1719  { return __complex_acosh(__z.__rep()); }
1720 #else
1721  /// acosh(__z) [8.1.5].
1722  // Effects: Behaves the same as C99 function cacosh, defined
1723  // in subclause 7.3.6.1.
1724  template<typename _Tp>
1725  inline std::complex<_Tp>
1727  { return __complex_acosh(__z); }
1728 #endif
1729 
1730  template<typename _Tp>
1732  __complex_asinh(const std::complex<_Tp>& __z)
1733  {
1734  std::complex<_Tp> __t((__z.real() - __z.imag())
1735  * (__z.real() + __z.imag()) + _Tp(1.0),
1736  _Tp(2.0) * __z.real() * __z.imag());
1737  __t = std::sqrt(__t);
1738 
1739  return std::log(__t + __z);
1740  }
1741 
1742 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1743  inline __complex__ float
1744  __complex_asinh(__complex__ float __z)
1745  { return __builtin_casinhf(__z); }
1746 
1747  inline __complex__ double
1748  __complex_asinh(__complex__ double __z)
1749  { return __builtin_casinh(__z); }
1750 
1751  inline __complex__ long double
1752  __complex_asinh(const __complex__ long double& __z)
1753  { return __builtin_casinhl(__z); }
1754 
1755  template<typename _Tp>
1756  inline std::complex<_Tp>
1757  asinh(const std::complex<_Tp>& __z)
1758  { return __complex_asinh(__z.__rep()); }
1759 #else
1760  /// asinh(__z) [8.1.6].
1761  // Effects: Behaves the same as C99 function casin, defined
1762  // in subclause 7.3.6.2.
1763  template<typename _Tp>
1764  inline std::complex<_Tp>
1766  { return __complex_asinh(__z); }
1767 #endif
1768 
1769  template<typename _Tp>
1771  __complex_atanh(const std::complex<_Tp>& __z)
1772  {
1773  const _Tp __i2 = __z.imag() * __z.imag();
1774  const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
1775 
1776  _Tp __num = _Tp(1.0) + __z.real();
1777  _Tp __den = _Tp(1.0) - __z.real();
1778 
1779  __num = __i2 + __num * __num;
1780  __den = __i2 + __den * __den;
1781 
1782  return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
1783  _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
1784  }
1785 
1786 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1787  inline __complex__ float
1788  __complex_atanh(__complex__ float __z)
1789  { return __builtin_catanhf(__z); }
1790 
1791  inline __complex__ double
1792  __complex_atanh(__complex__ double __z)
1793  { return __builtin_catanh(__z); }
1794 
1795  inline __complex__ long double
1796  __complex_atanh(const __complex__ long double& __z)
1797  { return __builtin_catanhl(__z); }
1798 
1799  template<typename _Tp>
1800  inline std::complex<_Tp>
1801  atanh(const std::complex<_Tp>& __z)
1802  { return __complex_atanh(__z.__rep()); }
1803 #else
1804  /// atanh(__z) [8.1.7].
1805  // Effects: Behaves the same as C99 function catanh, defined
1806  // in subclause 7.3.6.3.
1807  template<typename _Tp>
1808  inline std::complex<_Tp>
1810  { return __complex_atanh(__z); }
1811 #endif
1812 
1813  template<typename _Tp>
1814  inline _Tp
1815  /// fabs(__z) [8.1.8].
1816  // Effects: Behaves the same as C99 function cabs, defined
1817  // in subclause 7.3.8.1.
1819  { return std::abs(__z); }
1820 
1821  /// Additional overloads [8.1.9].
1822  template<typename _Tp>
1823  inline typename __gnu_cxx::__promote<_Tp>::__type
1824  arg(_Tp __x)
1825  {
1826  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1827 #if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
1828  return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
1829  : __type();
1830 #else
1831  return std::arg(std::complex<__type>(__x));
1832 #endif
1833  }
1834 
1835  template<typename _Tp>
1836  inline typename __gnu_cxx::__promote<_Tp>::__type
1837  imag(_Tp)
1838  { return _Tp(); }
1839 
1840  template<typename _Tp>
1841  inline typename __gnu_cxx::__promote<_Tp>::__type
1842  norm(_Tp __x)
1843  {
1844  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1845  return __type(__x) * __type(__x);
1846  }
1847 
1848  template<typename _Tp>
1849  inline typename __gnu_cxx::__promote<_Tp>::__type
1850  real(_Tp __x)
1851  { return __x; }
1852 
1853  template<typename _Tp, typename _Up>
1855  pow(const std::complex<_Tp>& __x, const _Up& __y)
1856  {
1857  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1858  return std::pow(std::complex<__type>(__x), __type(__y));
1859  }
1860 
1861  template<typename _Tp, typename _Up>
1863  pow(const _Tp& __x, const std::complex<_Up>& __y)
1864  {
1865  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1866  return std::pow(__type(__x), std::complex<__type>(__y));
1867  }
1868 
1869  template<typename _Tp, typename _Up>
1871  pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
1872  {
1873  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1874  return std::pow(std::complex<__type>(__x),
1875  std::complex<__type>(__y));
1876  }
1877 
1878  // Forward declarations.
1879  // DR 781.
1880  template<typename _Tp> std::complex<_Tp> proj(const std::complex<_Tp>&);
1881 
1882  template<typename _Tp>
1884  __complex_proj(const std::complex<_Tp>& __z)
1885  {
1886  const _Tp __den = (__z.real() * __z.real()
1887  + __z.imag() * __z.imag() + _Tp(1.0));
1888 
1889  return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den,
1890  (_Tp(2.0) * __z.imag()) / __den);
1891  }
1892 
1893 #if _GLIBCXX_USE_C99_COMPLEX
1894  inline __complex__ float
1895  __complex_proj(__complex__ float __z)
1896  { return __builtin_cprojf(__z); }
1897 
1898  inline __complex__ double
1899  __complex_proj(__complex__ double __z)
1900  { return __builtin_cproj(__z); }
1901 
1902  inline __complex__ long double
1903  __complex_proj(const __complex__ long double& __z)
1904  { return __builtin_cprojl(__z); }
1905 
1906  template<typename _Tp>
1907  inline std::complex<_Tp>
1908  proj(const std::complex<_Tp>& __z)
1909  { return __complex_proj(__z.__rep()); }
1910 #else
1911  template<typename _Tp>
1912  inline std::complex<_Tp>
1913  proj(const std::complex<_Tp>& __z)
1914  { return __complex_proj(__z); }
1915 #endif
1916 
1917  // DR 1137.
1918  template<typename _Tp>
1919  inline typename __gnu_cxx::__promote<_Tp>::__type
1920  proj(_Tp __x)
1921  { return __x; }
1922 
1923  template<typename _Tp>
1924  inline typename __gnu_cxx::__promote<_Tp>::__type
1925  conj(_Tp __x)
1926  { return __x; }
1927 
1928 _GLIBCXX_END_NAMESPACE_VERSION
1929 } // namespace
1930 
1931 #endif // __GXX_EXPERIMENTAL_CXX0X__
1932 
1933 #endif /* _GLIBCXX_COMPLEX */