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
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 _GLIBCXX_BEGIN_NAMESPACE(std)
50 
51  /**
52  * @defgroup complex_numbers Complex Numbers
53  * @ingroup numerics
54  *
55  * Classes and functions for complex numbers.
56  * @{
57  */
58 
59  // Forward declarations.
60  template<typename _Tp> class complex;
61  template<> class complex<float>;
62  template<> class complex<double>;
63  template<> class complex<long double>;
64 
65  /// Return magnitude of @a z.
66  template<typename _Tp> _Tp abs(const complex<_Tp>&);
67  /// Return phase angle of @a z.
68  template<typename _Tp> _Tp arg(const complex<_Tp>&);
69  /// Return @a z magnitude squared.
70  template<typename _Tp> _Tp norm(const complex<_Tp>&);
71 
72  /// Return complex conjugate of @a z.
73  template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
74  /// Return complex with magnitude @a rho and angle @a theta.
75  template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
76 
77  // Transcendentals:
78  /// Return complex cosine of @a z.
79  template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
80  /// Return complex hyperbolic cosine of @a z.
81  template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
82  /// Return complex base e exponential of @a z.
83  template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
84  /// Return complex natural logarithm of @a z.
85  template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
86  /// Return complex base 10 logarithm of @a z.
87  template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
88 #ifndef __GXX_EXPERIMENTAL_CXX0X__
89  // DR 844.
90  /// Return @a x to the @a y'th power.
91  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
92 #endif
93  /// Return @a x to the @a y'th power.
94  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
95  /// Return @a x to the @a y'th power.
96  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
97  const complex<_Tp>&);
98  /// Return @a x to the @a y'th power.
99  template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
100  /// Return complex sine of @a z.
101  template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
102  /// Return complex hyperbolic sine of @a z.
103  template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
104  /// Return complex square root of @a z.
105  template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
106  /// Return complex tangent of @a z.
107  template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
108  /// Return complex hyperbolic tangent of @a z.
109  template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
110 
111 
112  // 26.2.2 Primary template class complex
113  /**
114  * Template to represent complex numbers.
115  *
116  * Specializations for float, double, and long double are part of the
117  * library. Results with any other type are not guaranteed.
118  *
119  * @param Tp Type of real and imaginary values.
120  */
121  template<typename _Tp>
122  struct complex
123  {
124  /// Value typedef.
125  typedef _Tp value_type;
126 
127  /// Default constructor. First parameter is x, second parameter is y.
128  /// Unspecified parameters default to 0.
129  complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
130  : _M_real(__r), _M_imag(__i) { }
131 
132  // Lets the compiler synthesize the copy constructor
133  // complex (const complex<_Tp>&);
134  /// Copy constructor.
135  template<typename _Up>
136  complex(const complex<_Up>& __z)
137  : _M_real(__z.real()), _M_imag(__z.imag()) { }
138 
139 #ifdef __GXX_EXPERIMENTAL_CXX0X__
140  // _GLIBCXX_RESOLVE_LIB_DEFECTS
141  // DR 387. std::complex over-encapsulated.
142  _Tp real() const
143  { return _M_real; }
144 
145  _Tp imag() const
146  { return _M_imag; }
147 #else
148  /// Return real part of complex number.
149  _Tp& real()
150  { return _M_real; }
151 
152  /// Return real part of complex number.
153  const _Tp& real() const
154  { return _M_real; }
155 
156  /// Return imaginary part of complex number.
157  _Tp& imag()
158  { return _M_imag; }
159 
160  /// Return imaginary part of complex number.
161  const _Tp& imag() const
162  { return _M_imag; }
163 #endif
164 
165  // _GLIBCXX_RESOLVE_LIB_DEFECTS
166  // DR 387. std::complex over-encapsulated.
167  void real(_Tp __val)
168  { _M_real = __val; }
169 
170  void imag(_Tp __val)
171  { _M_imag = __val; }
172 
173  /// Assign this complex number to scalar @a t.
174  complex<_Tp>& operator=(const _Tp&);
175 
176  /// Add @a t to this complex number.
177  // 26.2.5/1
178  complex<_Tp>&
179  operator+=(const _Tp& __t)
180  {
181  _M_real += __t;
182  return *this;
183  }
184 
185  /// Subtract @a t from this complex number.
186  // 26.2.5/3
187  complex<_Tp>&
188  operator-=(const _Tp& __t)
189  {
190  _M_real -= __t;
191  return *this;
192  }
193 
194  /// Multiply this complex number by @a t.
195  complex<_Tp>& operator*=(const _Tp&);
196  /// Divide this complex number by @a t.
197  complex<_Tp>& operator/=(const _Tp&);
198 
199  // Lets the compiler synthesize the
200  // copy and assignment operator
201  // complex<_Tp>& operator= (const complex<_Tp>&);
202  /// Assign this complex number to complex @a z.
203  template<typename _Up>
204  complex<_Tp>& operator=(const complex<_Up>&);
205  /// Add @a z to this complex number.
206  template<typename _Up>
207  complex<_Tp>& operator+=(const complex<_Up>&);
208  /// Subtract @a z from this complex number.
209  template<typename _Up>
210  complex<_Tp>& operator-=(const complex<_Up>&);
211  /// Multiply this complex number by @a z.
212  template<typename _Up>
213  complex<_Tp>& operator*=(const complex<_Up>&);
214  /// Divide this complex number by @a z.
215  template<typename _Up>
216  complex<_Tp>& operator/=(const complex<_Up>&);
217 
218  const complex& __rep() const
219  { return *this; }
220 
221  private:
222  _Tp _M_real;
223  _Tp _M_imag;
224  };
225 
226  template<typename _Tp>
227  complex<_Tp>&
228  complex<_Tp>::operator=(const _Tp& __t)
229  {
230  _M_real = __t;
231  _M_imag = _Tp();
232  return *this;
233  }
234 
235  // 26.2.5/5
236  template<typename _Tp>
237  complex<_Tp>&
238  complex<_Tp>::operator*=(const _Tp& __t)
239  {
240  _M_real *= __t;
241  _M_imag *= __t;
242  return *this;
243  }
244 
245  // 26.2.5/7
246  template<typename _Tp>
247  complex<_Tp>&
248  complex<_Tp>::operator/=(const _Tp& __t)
249  {
250  _M_real /= __t;
251  _M_imag /= __t;
252  return *this;
253  }
254 
255  template<typename _Tp>
256  template<typename _Up>
257  complex<_Tp>&
259  {
260  _M_real = __z.real();
261  _M_imag = __z.imag();
262  return *this;
263  }
264 
265  // 26.2.5/9
266  template<typename _Tp>
267  template<typename _Up>
268  complex<_Tp>&
270  {
271  _M_real += __z.real();
272  _M_imag += __z.imag();
273  return *this;
274  }
275 
276  // 26.2.5/11
277  template<typename _Tp>
278  template<typename _Up>
279  complex<_Tp>&
281  {
282  _M_real -= __z.real();
283  _M_imag -= __z.imag();
284  return *this;
285  }
286 
287  // 26.2.5/13
288  // XXX: This is a grammar school implementation.
289  template<typename _Tp>
290  template<typename _Up>
291  complex<_Tp>&
293  {
294  const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
295  _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
296  _M_real = __r;
297  return *this;
298  }
299 
300  // 26.2.5/15
301  // XXX: This is a grammar school implementation.
302  template<typename _Tp>
303  template<typename _Up>
304  complex<_Tp>&
306  {
307  const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
308  const _Tp __n = std::norm(__z);
309  _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
310  _M_real = __r / __n;
311  return *this;
312  }
313 
314  // Operators:
315  //@{
316  /// Return new complex value @a x plus @a y.
317  template<typename _Tp>
318  inline complex<_Tp>
319  operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
320  {
321  complex<_Tp> __r = __x;
322  __r += __y;
323  return __r;
324  }
325 
326  template<typename _Tp>
327  inline complex<_Tp>
328  operator+(const complex<_Tp>& __x, const _Tp& __y)
329  {
330  complex<_Tp> __r = __x;
331  __r += __y;
332  return __r;
333  }
334 
335  template<typename _Tp>
336  inline complex<_Tp>
337  operator+(const _Tp& __x, const complex<_Tp>& __y)
338  {
339  complex<_Tp> __r = __y;
340  __r += __x;
341  return __r;
342  }
343  //@}
344 
345  //@{
346  /// Return new complex value @a x minus @a y.
347  template<typename _Tp>
348  inline complex<_Tp>
349  operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
350  {
351  complex<_Tp> __r = __x;
352  __r -= __y;
353  return __r;
354  }
355 
356  template<typename _Tp>
357  inline complex<_Tp>
358  operator-(const complex<_Tp>& __x, const _Tp& __y)
359  {
360  complex<_Tp> __r = __x;
361  __r -= __y;
362  return __r;
363  }
364 
365  template<typename _Tp>
366  inline complex<_Tp>
367  operator-(const _Tp& __x, const complex<_Tp>& __y)
368  {
369  complex<_Tp> __r(__x, -__y.imag());
370  __r -= __y.real();
371  return __r;
372  }
373  //@}
374 
375  //@{
376  /// Return new complex value @a x times @a y.
377  template<typename _Tp>
378  inline complex<_Tp>
379  operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
380  {
381  complex<_Tp> __r = __x;
382  __r *= __y;
383  return __r;
384  }
385 
386  template<typename _Tp>
387  inline complex<_Tp>
388  operator*(const complex<_Tp>& __x, const _Tp& __y)
389  {
390  complex<_Tp> __r = __x;
391  __r *= __y;
392  return __r;
393  }
394 
395  template<typename _Tp>
396  inline complex<_Tp>
397  operator*(const _Tp& __x, const complex<_Tp>& __y)
398  {
399  complex<_Tp> __r = __y;
400  __r *= __x;
401  return __r;
402  }
403  //@}
404 
405  //@{
406  /// Return new complex value @a x divided by @a y.
407  template<typename _Tp>
408  inline complex<_Tp>
409  operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
410  {
411  complex<_Tp> __r = __x;
412  __r /= __y;
413  return __r;
414  }
415 
416  template<typename _Tp>
417  inline complex<_Tp>
418  operator/(const complex<_Tp>& __x, const _Tp& __y)
419  {
420  complex<_Tp> __r = __x;
421  __r /= __y;
422  return __r;
423  }
424 
425  template<typename _Tp>
426  inline complex<_Tp>
427  operator/(const _Tp& __x, const complex<_Tp>& __y)
428  {
429  complex<_Tp> __r = __x;
430  __r /= __y;
431  return __r;
432  }
433  //@}
434 
435  /// Return @a x.
436  template<typename _Tp>
437  inline complex<_Tp>
439  { return __x; }
440 
441  /// Return complex negation of @a x.
442  template<typename _Tp>
443  inline complex<_Tp>
445  { return complex<_Tp>(-__x.real(), -__x.imag()); }
446 
447  //@{
448  /// Return true if @a x is equal to @a y.
449  template<typename _Tp>
450  inline bool
451  operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
452  { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
453 
454  template<typename _Tp>
455  inline bool
456  operator==(const complex<_Tp>& __x, const _Tp& __y)
457  { return __x.real() == __y && __x.imag() == _Tp(); }
458 
459  template<typename _Tp>
460  inline bool
461  operator==(const _Tp& __x, const complex<_Tp>& __y)
462  { return __x == __y.real() && _Tp() == __y.imag(); }
463  //@}
464 
465  //@{
466  /// Return false if @a x is equal to @a y.
467  template<typename _Tp>
468  inline bool
469  operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
470  { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
471 
472  template<typename _Tp>
473  inline bool
474  operator!=(const complex<_Tp>& __x, const _Tp& __y)
475  { return __x.real() != __y || __x.imag() != _Tp(); }
476 
477  template<typename _Tp>
478  inline bool
479  operator!=(const _Tp& __x, const complex<_Tp>& __y)
480  { return __x != __y.real() || _Tp() != __y.imag(); }
481  //@}
482 
483  /// Extraction operator for complex values.
484  template<typename _Tp, typename _CharT, class _Traits>
485  basic_istream<_CharT, _Traits>&
487  {
488  _Tp __re_x, __im_x;
489  _CharT __ch;
490  __is >> __ch;
491  if (__ch == '(')
492  {
493  __is >> __re_x >> __ch;
494  if (__ch == ',')
495  {
496  __is >> __im_x >> __ch;
497  if (__ch == ')')
498  __x = complex<_Tp>(__re_x, __im_x);
499  else
500  __is.setstate(ios_base::failbit);
501  }
502  else if (__ch == ')')
503  __x = __re_x;
504  else
505  __is.setstate(ios_base::failbit);
506  }
507  else
508  {
509  __is.putback(__ch);
510  __is >> __re_x;
511  __x = __re_x;
512  }
513  return __is;
514  }
515 
516  /// Insertion operator for complex values.
517  template<typename _Tp, typename _CharT, class _Traits>
518  basic_ostream<_CharT, _Traits>&
519  operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
520  {
522  __s.flags(__os.flags());
523  __s.imbue(__os.getloc());
524  __s.precision(__os.precision());
525  __s << '(' << __x.real() << ',' << __x.imag() << ')';
526  return __os << __s.str();
527  }
528 
529  // Values
530 #ifdef __GXX_EXPERIMENTAL_CXX0X__
531  template<typename _Tp>
532  inline _Tp
533  real(const complex<_Tp>& __z)
534  { return __z.real(); }
535 
536  template<typename _Tp>
537  inline _Tp
538  imag(const complex<_Tp>& __z)
539  { return __z.imag(); }
540 #else
541  template<typename _Tp>
542  inline _Tp&
543  real(complex<_Tp>& __z)
544  { return __z.real(); }
545 
546  template<typename _Tp>
547  inline const _Tp&
548  real(const complex<_Tp>& __z)
549  { return __z.real(); }
550 
551  template<typename _Tp>
552  inline _Tp&
553  imag(complex<_Tp>& __z)
554  { return __z.imag(); }
555 
556  template<typename _Tp>
557  inline const _Tp&
558  imag(const complex<_Tp>& __z)
559  { return __z.imag(); }
560 #endif
561 
562  // 26.2.7/3 abs(__z): Returns the magnitude of __z.
563  template<typename _Tp>
564  inline _Tp
565  __complex_abs(const complex<_Tp>& __z)
566  {
567  _Tp __x = __z.real();
568  _Tp __y = __z.imag();
569  const _Tp __s = std::max(abs(__x), abs(__y));
570  if (__s == _Tp()) // well ...
571  return __s;
572  __x /= __s;
573  __y /= __s;
574  return __s * sqrt(__x * __x + __y * __y);
575  }
576 
577 #if _GLIBCXX_USE_C99_COMPLEX
578  inline float
579  __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
580 
581  inline double
582  __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
583 
584  inline long double
585  __complex_abs(const __complex__ long double& __z)
586  { return __builtin_cabsl(__z); }
587 
588  template<typename _Tp>
589  inline _Tp
590  abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
591 #else
592  template<typename _Tp>
593  inline _Tp
594  abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
595 #endif
596 
597 
598  // 26.2.7/4: arg(__z): Returns the phase angle of __z.
599  template<typename _Tp>
600  inline _Tp
601  __complex_arg(const complex<_Tp>& __z)
602  { return atan2(__z.imag(), __z.real()); }
603 
604 #if _GLIBCXX_USE_C99_COMPLEX
605  inline float
606  __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
607 
608  inline double
609  __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
610 
611  inline long double
612  __complex_arg(const __complex__ long double& __z)
613  { return __builtin_cargl(__z); }
614 
615  template<typename _Tp>
616  inline _Tp
617  arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
618 #else
619  template<typename _Tp>
620  inline _Tp
621  arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
622 #endif
623 
624  // 26.2.7/5: norm(__z) returns the squared magnitude of __z.
625  // As defined, norm() is -not- a norm is the common mathematical
626  // sens used in numerics. The helper class _Norm_helper<> tries to
627  // distinguish between builtin floating point and the rest, so as
628  // to deliver an answer as close as possible to the real value.
629  template<bool>
630  struct _Norm_helper
631  {
632  template<typename _Tp>
633  static inline _Tp _S_do_it(const complex<_Tp>& __z)
634  {
635  const _Tp __x = __z.real();
636  const _Tp __y = __z.imag();
637  return __x * __x + __y * __y;
638  }
639  };
640 
641  template<>
642  struct _Norm_helper<true>
643  {
644  template<typename _Tp>
645  static inline _Tp _S_do_it(const complex<_Tp>& __z)
646  {
647  _Tp __res = std::abs(__z);
648  return __res * __res;
649  }
650  };
651 
652  template<typename _Tp>
653  inline _Tp
654  norm(const complex<_Tp>& __z)
655  {
656  return _Norm_helper<__is_floating<_Tp>::__value
657  && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
658  }
659 
660  template<typename _Tp>
661  inline complex<_Tp>
662  polar(const _Tp& __rho, const _Tp& __theta)
663  { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
664 
665  template<typename _Tp>
666  inline complex<_Tp>
667  conj(const complex<_Tp>& __z)
668  { return complex<_Tp>(__z.real(), -__z.imag()); }
669 
670  // Transcendentals
671 
672  // 26.2.8/1 cos(__z): Returns the cosine of __z.
673  template<typename _Tp>
674  inline complex<_Tp>
675  __complex_cos(const complex<_Tp>& __z)
676  {
677  const _Tp __x = __z.real();
678  const _Tp __y = __z.imag();
679  return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
680  }
681 
682 #if _GLIBCXX_USE_C99_COMPLEX
683  inline __complex__ float
684  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
685 
686  inline __complex__ double
687  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
688 
689  inline __complex__ long double
690  __complex_cos(const __complex__ long double& __z)
691  { return __builtin_ccosl(__z); }
692 
693  template<typename _Tp>
694  inline complex<_Tp>
695  cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
696 #else
697  template<typename _Tp>
698  inline complex<_Tp>
699  cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
700 #endif
701 
702  // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
703  template<typename _Tp>
704  inline complex<_Tp>
705  __complex_cosh(const complex<_Tp>& __z)
706  {
707  const _Tp __x = __z.real();
708  const _Tp __y = __z.imag();
709  return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
710  }
711 
712 #if _GLIBCXX_USE_C99_COMPLEX
713  inline __complex__ float
714  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
715 
716  inline __complex__ double
717  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
718 
719  inline __complex__ long double
720  __complex_cosh(const __complex__ long double& __z)
721  { return __builtin_ccoshl(__z); }
722 
723  template<typename _Tp>
724  inline complex<_Tp>
725  cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
726 #else
727  template<typename _Tp>
728  inline complex<_Tp>
729  cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
730 #endif
731 
732  // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
733  template<typename _Tp>
734  inline complex<_Tp>
735  __complex_exp(const complex<_Tp>& __z)
736  { return std::polar(exp(__z.real()), __z.imag()); }
737 
738 #if _GLIBCXX_USE_C99_COMPLEX
739  inline __complex__ float
740  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
741 
742  inline __complex__ double
743  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
744 
745  inline __complex__ long double
746  __complex_exp(const __complex__ long double& __z)
747  { return __builtin_cexpl(__z); }
748 
749  template<typename _Tp>
750  inline complex<_Tp>
751  exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
752 #else
753  template<typename _Tp>
754  inline complex<_Tp>
755  exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
756 #endif
757 
758  // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z.
759  // The branch cut is along the negative axis.
760  template<typename _Tp>
761  inline complex<_Tp>
762  __complex_log(const complex<_Tp>& __z)
763  { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
764 
765 #if _GLIBCXX_USE_C99_COMPLEX
766  inline __complex__ float
767  __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
768 
769  inline __complex__ double
770  __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
771 
772  inline __complex__ long double
773  __complex_log(const __complex__ long double& __z)
774  { return __builtin_clogl(__z); }
775 
776  template<typename _Tp>
777  inline complex<_Tp>
778  log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
779 #else
780  template<typename _Tp>
781  inline complex<_Tp>
782  log(const complex<_Tp>& __z) { return __complex_log(__z); }
783 #endif
784 
785  template<typename _Tp>
786  inline complex<_Tp>
787  log10(const complex<_Tp>& __z)
788  { return std::log(__z) / log(_Tp(10.0)); }
789 
790  // 26.2.8/10 sin(__z): Returns the sine of __z.
791  template<typename _Tp>
792  inline complex<_Tp>
793  __complex_sin(const complex<_Tp>& __z)
794  {
795  const _Tp __x = __z.real();
796  const _Tp __y = __z.imag();
797  return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
798  }
799 
800 #if _GLIBCXX_USE_C99_COMPLEX
801  inline __complex__ float
802  __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
803 
804  inline __complex__ double
805  __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
806 
807  inline __complex__ long double
808  __complex_sin(const __complex__ long double& __z)
809  { return __builtin_csinl(__z); }
810 
811  template<typename _Tp>
812  inline complex<_Tp>
813  sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
814 #else
815  template<typename _Tp>
816  inline complex<_Tp>
817  sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
818 #endif
819 
820  // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
821  template<typename _Tp>
822  inline complex<_Tp>
823  __complex_sinh(const complex<_Tp>& __z)
824  {
825  const _Tp __x = __z.real();
826  const _Tp __y = __z.imag();
827  return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
828  }
829 
830 #if _GLIBCXX_USE_C99_COMPLEX
831  inline __complex__ float
832  __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
833 
834  inline __complex__ double
835  __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
836 
837  inline __complex__ long double
838  __complex_sinh(const __complex__ long double& __z)
839  { return __builtin_csinhl(__z); }
840 
841  template<typename _Tp>
842  inline complex<_Tp>
843  sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
844 #else
845  template<typename _Tp>
846  inline complex<_Tp>
847  sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
848 #endif
849 
850  // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
851  // The branch cut is on the negative axis.
852  template<typename _Tp>
853  complex<_Tp>
854  __complex_sqrt(const complex<_Tp>& __z)
855  {
856  _Tp __x = __z.real();
857  _Tp __y = __z.imag();
858 
859  if (__x == _Tp())
860  {
861  _Tp __t = sqrt(abs(__y) / 2);
862  return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
863  }
864  else
865  {
866  _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
867  _Tp __u = __t / 2;
868  return __x > _Tp()
869  ? complex<_Tp>(__u, __y / __t)
870  : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
871  }
872  }
873 
874 #if _GLIBCXX_USE_C99_COMPLEX
875  inline __complex__ float
876  __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
877 
878  inline __complex__ double
879  __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
880 
881  inline __complex__ long double
882  __complex_sqrt(const __complex__ long double& __z)
883  { return __builtin_csqrtl(__z); }
884 
885  template<typename _Tp>
886  inline complex<_Tp>
887  sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
888 #else
889  template<typename _Tp>
890  inline complex<_Tp>
891  sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
892 #endif
893 
894  // 26.2.8/14 tan(__z): Return the complex tangent of __z.
895 
896  template<typename _Tp>
897  inline complex<_Tp>
898  __complex_tan(const complex<_Tp>& __z)
899  { return std::sin(__z) / std::cos(__z); }
900 
901 #if _GLIBCXX_USE_C99_COMPLEX
902  inline __complex__ float
903  __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
904 
905  inline __complex__ double
906  __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
907 
908  inline __complex__ long double
909  __complex_tan(const __complex__ long double& __z)
910  { return __builtin_ctanl(__z); }
911 
912  template<typename _Tp>
913  inline complex<_Tp>
914  tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
915 #else
916  template<typename _Tp>
917  inline complex<_Tp>
918  tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
919 #endif
920 
921 
922  // 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z.
923 
924  template<typename _Tp>
925  inline complex<_Tp>
926  __complex_tanh(const complex<_Tp>& __z)
927  { return std::sinh(__z) / std::cosh(__z); }
928 
929 #if _GLIBCXX_USE_C99_COMPLEX
930  inline __complex__ float
931  __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
932 
933  inline __complex__ double
934  __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
935 
936  inline __complex__ long double
937  __complex_tanh(const __complex__ long double& __z)
938  { return __builtin_ctanhl(__z); }
939 
940  template<typename _Tp>
941  inline complex<_Tp>
942  tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
943 #else
944  template<typename _Tp>
945  inline complex<_Tp>
946  tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
947 #endif
948 
949 
950  // 26.2.8/9 pow(__x, __y): Returns the complex power base of __x
951  // raised to the __y-th power. The branch
952  // cut is on the negative axis.
953 #ifndef __GXX_EXPERIMENTAL_CXX0X__
954  // _GLIBCXX_RESOLVE_LIB_DEFECTS
955  // DR 844. complex pow return type is ambiguous.
956  template<typename _Tp>
957  inline complex<_Tp>
958  pow(const complex<_Tp>& __z, int __n)
959  { return std::__pow_helper(__z, __n); }
960 #endif
961 
962  template<typename _Tp>
963  complex<_Tp>
964  pow(const complex<_Tp>& __x, const _Tp& __y)
965  {
966 #ifndef _GLIBCXX_USE_C99_COMPLEX
967  if (__x == _Tp())
968  return _Tp();
969 #endif
970  if (__x.imag() == _Tp() && __x.real() > _Tp())
971  return pow(__x.real(), __y);
972 
973  complex<_Tp> __t = std::log(__x);
974  return std::polar(exp(__y * __t.real()), __y * __t.imag());
975  }
976 
977  template<typename _Tp>
978  inline complex<_Tp>
979  __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
980  { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
981 
982 #if _GLIBCXX_USE_C99_COMPLEX
983  inline __complex__ float
984  __complex_pow(__complex__ float __x, __complex__ float __y)
985  { return __builtin_cpowf(__x, __y); }
986 
987  inline __complex__ double
988  __complex_pow(__complex__ double __x, __complex__ double __y)
989  { return __builtin_cpow(__x, __y); }
990 
991  inline __complex__ long double
992  __complex_pow(const __complex__ long double& __x,
993  const __complex__ long double& __y)
994  { return __builtin_cpowl(__x, __y); }
995 
996  template<typename _Tp>
997  inline complex<_Tp>
998  pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
999  { return __complex_pow(__x.__rep(), __y.__rep()); }
1000 #else
1001  template<typename _Tp>
1002  inline complex<_Tp>
1003  pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1004  { return __complex_pow(__x, __y); }
1005 #endif
1006 
1007  template<typename _Tp>
1008  inline complex<_Tp>
1009  pow(const _Tp& __x, const complex<_Tp>& __y)
1010  {
1011  return __x > _Tp() ? std::polar(pow(__x, __y.real()),
1012  __y.imag() * log(__x))
1013  : std::pow(complex<_Tp>(__x), __y);
1014  }
1015 
1016  // 26.2.3 complex specializations
1017  // complex<float> specialization
1018  template<>
1019  struct complex<float>
1020  {
1021  typedef float value_type;
1022  typedef __complex__ float _ComplexT;
1023 
1024  complex(_ComplexT __z) : _M_value(__z) { }
1025 
1026  complex(float __r = 0.0f, float __i = 0.0f)
1027  {
1028  __real__ _M_value = __r;
1029  __imag__ _M_value = __i;
1030  }
1031 
1032  explicit complex(const complex<double>&);
1033  explicit complex(const complex<long double>&);
1034 
1035 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1036  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1037  // DR 387. std::complex over-encapsulated.
1038  float real() const
1039  { return __real__ _M_value; }
1040 
1041  float imag() const
1042  { return __imag__ _M_value; }
1043 #else
1044  float& real()
1045  { return __real__ _M_value; }
1046 
1047  const float& real() const
1048  { return __real__ _M_value; }
1049 
1050  float& imag()
1051  { return __imag__ _M_value; }
1052 
1053  const float& imag() const
1054  { return __imag__ _M_value; }
1055 #endif
1056 
1057  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1058  // DR 387. std::complex over-encapsulated.
1059  void real(float __val)
1060  { __real__ _M_value = __val; }
1061 
1062  void imag(float __val)
1063  { __imag__ _M_value = __val; }
1064 
1065  complex<float>&
1066  operator=(float __f)
1067  {
1068  __real__ _M_value = __f;
1069  __imag__ _M_value = 0.0f;
1070  return *this;
1071  }
1072 
1073  complex<float>&
1074  operator+=(float __f)
1075  {
1076  __real__ _M_value += __f;
1077  return *this;
1078  }
1079 
1080  complex<float>&
1081  operator-=(float __f)
1082  {
1083  __real__ _M_value -= __f;
1084  return *this;
1085  }
1086 
1087  complex<float>&
1088  operator*=(float __f)
1089  {
1090  _M_value *= __f;
1091  return *this;
1092  }
1093 
1094  complex<float>&
1095  operator/=(float __f)
1096  {
1097  _M_value /= __f;
1098  return *this;
1099  }
1100 
1101  // Let the compiler synthesize the copy and assignment
1102  // operator. It always does a pretty good job.
1103  // complex& operator=(const complex&);
1104 
1105  template<typename _Tp>
1106  complex<float>&
1107  operator=(const complex<_Tp>& __z)
1108  {
1109  __real__ _M_value = __z.real();
1110  __imag__ _M_value = __z.imag();
1111  return *this;
1112  }
1113 
1114  template<typename _Tp>
1115  complex<float>&
1116  operator+=(const complex<_Tp>& __z)
1117  {
1118  __real__ _M_value += __z.real();
1119  __imag__ _M_value += __z.imag();
1120  return *this;
1121  }
1122 
1123  template<class _Tp>
1124  complex<float>&
1125  operator-=(const complex<_Tp>& __z)
1126  {
1127  __real__ _M_value -= __z.real();
1128  __imag__ _M_value -= __z.imag();
1129  return *this;
1130  }
1131 
1132  template<class _Tp>
1133  complex<float>&
1134  operator*=(const complex<_Tp>& __z)
1135  {
1136  _ComplexT __t;
1137  __real__ __t = __z.real();
1138  __imag__ __t = __z.imag();
1139  _M_value *= __t;
1140  return *this;
1141  }
1142 
1143  template<class _Tp>
1144  complex<float>&
1145  operator/=(const complex<_Tp>& __z)
1146  {
1147  _ComplexT __t;
1148  __real__ __t = __z.real();
1149  __imag__ __t = __z.imag();
1150  _M_value /= __t;
1151  return *this;
1152  }
1153 
1154  const _ComplexT& __rep() const { return _M_value; }
1155 
1156  private:
1157  _ComplexT _M_value;
1158  };
1159 
1160  // 26.2.3 complex specializations
1161  // complex<double> specialization
1162  template<>
1163  struct complex<double>
1164  {
1165  typedef double value_type;
1166  typedef __complex__ double _ComplexT;
1167 
1168  complex(_ComplexT __z) : _M_value(__z) { }
1169 
1170  complex(double __r = 0.0, double __i = 0.0)
1171  {
1172  __real__ _M_value = __r;
1173  __imag__ _M_value = __i;
1174  }
1175 
1176  complex(const complex<float>& __z)
1177  : _M_value(__z.__rep()) { }
1178 
1179  explicit complex(const complex<long double>&);
1180 
1181 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1182  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1183  // DR 387. std::complex over-encapsulated.
1184  double real() const
1185  { return __real__ _M_value; }
1186 
1187  double imag() const
1188  { return __imag__ _M_value; }
1189 #else
1190  double& real()
1191  { return __real__ _M_value; }
1192 
1193  const double& real() const
1194  { return __real__ _M_value; }
1195 
1196  double& imag()
1197  { return __imag__ _M_value; }
1198 
1199  const double& imag() const
1200  { return __imag__ _M_value; }
1201 #endif
1202 
1203  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1204  // DR 387. std::complex over-encapsulated.
1205  void real(double __val)
1206  { __real__ _M_value = __val; }
1207 
1208  void imag(double __val)
1209  { __imag__ _M_value = __val; }
1210 
1211  complex<double>&
1212  operator=(double __d)
1213  {
1214  __real__ _M_value = __d;
1215  __imag__ _M_value = 0.0;
1216  return *this;
1217  }
1218 
1219  complex<double>&
1220  operator+=(double __d)
1221  {
1222  __real__ _M_value += __d;
1223  return *this;
1224  }
1225 
1226  complex<double>&
1227  operator-=(double __d)
1228  {
1229  __real__ _M_value -= __d;
1230  return *this;
1231  }
1232 
1233  complex<double>&
1234  operator*=(double __d)
1235  {
1236  _M_value *= __d;
1237  return *this;
1238  }
1239 
1240  complex<double>&
1241  operator/=(double __d)
1242  {
1243  _M_value /= __d;
1244  return *this;
1245  }
1246 
1247  // The compiler will synthesize this, efficiently.
1248  // complex& operator=(const complex&);
1249 
1250  template<typename _Tp>
1251  complex<double>&
1252  operator=(const complex<_Tp>& __z)
1253  {
1254  __real__ _M_value = __z.real();
1255  __imag__ _M_value = __z.imag();
1256  return *this;
1257  }
1258 
1259  template<typename _Tp>
1260  complex<double>&
1261  operator+=(const complex<_Tp>& __z)
1262  {
1263  __real__ _M_value += __z.real();
1264  __imag__ _M_value += __z.imag();
1265  return *this;
1266  }
1267 
1268  template<typename _Tp>
1269  complex<double>&
1270  operator-=(const complex<_Tp>& __z)
1271  {
1272  __real__ _M_value -= __z.real();
1273  __imag__ _M_value -= __z.imag();
1274  return *this;
1275  }
1276 
1277  template<typename _Tp>
1278  complex<double>&
1279  operator*=(const complex<_Tp>& __z)
1280  {
1281  _ComplexT __t;
1282  __real__ __t = __z.real();
1283  __imag__ __t = __z.imag();
1284  _M_value *= __t;
1285  return *this;
1286  }
1287 
1288  template<typename _Tp>
1289  complex<double>&
1290  operator/=(const complex<_Tp>& __z)
1291  {
1292  _ComplexT __t;
1293  __real__ __t = __z.real();
1294  __imag__ __t = __z.imag();
1295  _M_value /= __t;
1296  return *this;
1297  }
1298 
1299  const _ComplexT& __rep() const { return _M_value; }
1300 
1301  private:
1302  _ComplexT _M_value;
1303  };
1304 
1305  // 26.2.3 complex specializations
1306  // complex<long double> specialization
1307  template<>
1308  struct complex<long double>
1309  {
1310  typedef long double value_type;
1311  typedef __complex__ long double _ComplexT;
1312 
1313  complex(_ComplexT __z) : _M_value(__z) { }
1314 
1315  complex(long double __r = 0.0L, long double __i = 0.0L)
1316  {
1317  __real__ _M_value = __r;
1318  __imag__ _M_value = __i;
1319  }
1320 
1321  complex(const complex<float>& __z)
1322  : _M_value(__z.__rep()) { }
1323 
1324  complex(const complex<double>& __z)
1325  : _M_value(__z.__rep()) { }
1326 
1327 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1328  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1329  // DR 387. std::complex over-encapsulated.
1330  long double real() const
1331  { return __real__ _M_value; }
1332 
1333  long double imag() const
1334  { return __imag__ _M_value; }
1335 #else
1336  long double& real()
1337  { return __real__ _M_value; }
1338 
1339  const long double& real() const
1340  { return __real__ _M_value; }
1341 
1342  long double& imag()
1343  { return __imag__ _M_value; }
1344 
1345  const long double& imag() const
1346  { return __imag__ _M_value; }
1347 #endif
1348 
1349  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1350  // DR 387. std::complex over-encapsulated.
1351  void real(long double __val)
1352  { __real__ _M_value = __val; }
1353 
1354  void imag(long double __val)
1355  { __imag__ _M_value = __val; }
1356 
1357  complex<long double>&
1358  operator=(long double __r)
1359  {
1360  __real__ _M_value = __r;
1361  __imag__ _M_value = 0.0L;
1362  return *this;
1363  }
1364 
1365  complex<long double>&
1366  operator+=(long double __r)
1367  {
1368  __real__ _M_value += __r;
1369  return *this;
1370  }
1371 
1372  complex<long double>&
1373  operator-=(long double __r)
1374  {
1375  __real__ _M_value -= __r;
1376  return *this;
1377  }
1378 
1379  complex<long double>&
1380  operator*=(long double __r)
1381  {
1382  _M_value *= __r;
1383  return *this;
1384  }
1385 
1386  complex<long double>&
1387  operator/=(long double __r)
1388  {
1389  _M_value /= __r;
1390  return *this;
1391  }
1392 
1393  // The compiler knows how to do this efficiently
1394  // complex& operator=(const complex&);
1395 
1396  template<typename _Tp>
1397  complex<long double>&
1398  operator=(const complex<_Tp>& __z)
1399  {
1400  __real__ _M_value = __z.real();
1401  __imag__ _M_value = __z.imag();
1402  return *this;
1403  }
1404 
1405  template<typename _Tp>
1406  complex<long double>&
1407  operator+=(const complex<_Tp>& __z)
1408  {
1409  __real__ _M_value += __z.real();
1410  __imag__ _M_value += __z.imag();
1411  return *this;
1412  }
1413 
1414  template<typename _Tp>
1415  complex<long double>&
1416  operator-=(const complex<_Tp>& __z)
1417  {
1418  __real__ _M_value -= __z.real();
1419  __imag__ _M_value -= __z.imag();
1420  return *this;
1421  }
1422 
1423  template<typename _Tp>
1424  complex<long double>&
1425  operator*=(const complex<_Tp>& __z)
1426  {
1427  _ComplexT __t;
1428  __real__ __t = __z.real();
1429  __imag__ __t = __z.imag();
1430  _M_value *= __t;
1431  return *this;
1432  }
1433 
1434  template<typename _Tp>
1435  complex<long double>&
1436  operator/=(const complex<_Tp>& __z)
1437  {
1438  _ComplexT __t;
1439  __real__ __t = __z.real();
1440  __imag__ __t = __z.imag();
1441  _M_value /= __t;
1442  return *this;
1443  }
1444 
1445  const _ComplexT& __rep() const { return _M_value; }
1446 
1447  private:
1448  _ComplexT _M_value;
1449  };
1450 
1451  // These bits have to be at the end of this file, so that the
1452  // specializations have all been defined.
1453  inline
1454  complex<float>::complex(const complex<double>& __z)
1455  : _M_value(__z.__rep()) { }
1456 
1457  inline
1458  complex<float>::complex(const complex<long double>& __z)
1459  : _M_value(__z.__rep()) { }
1460 
1461  inline
1462  complex<double>::complex(const complex<long double>& __z)
1463  : _M_value(__z.__rep()) { }
1464 
1465  // Inhibit implicit instantiations for required instantiations,
1466  // which are defined via explicit instantiations elsewhere.
1467  // NB: This syntax is a GNU extension.
1468 #if _GLIBCXX_EXTERN_TEMPLATE
1469  extern template istream& operator>>(istream&, complex<float>&);
1470  extern template ostream& operator<<(ostream&, const complex<float>&);
1471  extern template istream& operator>>(istream&, complex<double>&);
1472  extern template ostream& operator<<(ostream&, const complex<double>&);
1473  extern template istream& operator>>(istream&, complex<long double>&);
1474  extern template ostream& operator<<(ostream&, const complex<long double>&);
1475 
1476 #ifdef _GLIBCXX_USE_WCHAR_T
1477  extern template wistream& operator>>(wistream&, complex<float>&);
1478  extern template wostream& operator<<(wostream&, const complex<float>&);
1479  extern template wistream& operator>>(wistream&, complex<double>&);
1480  extern template wostream& operator<<(wostream&, const complex<double>&);
1481  extern template wistream& operator>>(wistream&, complex<long double>&);
1482  extern template wostream& operator<<(wostream&, const complex<long double>&);
1483 #endif
1484 #endif
1485 
1486  // @} group complex_numbers
1487 
1488 _GLIBCXX_END_NAMESPACE
1489 
1490 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
1491 
1492  // See ext/type_traits.h for the primary template.
1493  template<typename _Tp, typename _Up>
1494  struct __promote_2<std::complex<_Tp>, _Up>
1495  {
1496  public:
1498  };
1499 
1500  template<typename _Tp, typename _Up>
1501  struct __promote_2<_Tp, std::complex<_Up> >
1502  {
1503  public:
1505  };
1506 
1507  template<typename _Tp, typename _Up>
1508  struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
1509  {
1510  public:
1512  };
1513 
1514 _GLIBCXX_END_NAMESPACE
1515 
1516 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1517 # if defined(_GLIBCXX_INCLUDE_AS_TR1)
1518 # error C++0x header cannot be included from TR1 header
1519 # endif
1520 # if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
1521 # include <tr1_impl/complex>
1522 # else
1523 # define _GLIBCXX_INCLUDE_AS_CXX0X
1524 # define _GLIBCXX_BEGIN_NAMESPACE_TR1
1525 # define _GLIBCXX_END_NAMESPACE_TR1
1526 # define _GLIBCXX_TR1
1527 # include <tr1_impl/complex>
1528 # undef _GLIBCXX_TR1
1529 # undef _GLIBCXX_END_NAMESPACE_TR1
1530 # undef _GLIBCXX_BEGIN_NAMESPACE_TR1
1531 # undef _GLIBCXX_INCLUDE_AS_CXX0X
1532 # endif
1533 
1534 _GLIBCXX_BEGIN_NAMESPACE(std)
1535 
1536  // Forward declarations.
1537  // DR 781.
1538  template<typename _Tp> std::complex<_Tp> proj(const std::complex<_Tp>&);
1539 
1540  template<typename _Tp>
1541  std::complex<_Tp>
1542  __complex_proj(const std::complex<_Tp>& __z)
1543  {
1544  const _Tp __den = (__z.real() * __z.real()
1545  + __z.imag() * __z.imag() + _Tp(1.0));
1546 
1547  return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den,
1548  (_Tp(2.0) * __z.imag()) / __den);
1549  }
1550 
1551 #if _GLIBCXX_USE_C99_COMPLEX
1552  inline __complex__ float
1553  __complex_proj(__complex__ float __z)
1554  { return __builtin_cprojf(__z); }
1555 
1556  inline __complex__ double
1557  __complex_proj(__complex__ double __z)
1558  { return __builtin_cproj(__z); }
1559 
1560  inline __complex__ long double
1561  __complex_proj(const __complex__ long double& __z)
1562  { return __builtin_cprojl(__z); }
1563 
1564  template<typename _Tp>
1565  inline std::complex<_Tp>
1566  proj(const std::complex<_Tp>& __z)
1567  { return __complex_proj(__z.__rep()); }
1568 #else
1569  template<typename _Tp>
1570  inline std::complex<_Tp>
1571  proj(const std::complex<_Tp>& __z)
1572  { return __complex_proj(__z); }
1573 #endif
1574 
1575  template<typename _Tp>
1577  proj(_Tp __x)
1578  {
1579  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1580  return std::proj(std::complex<__type>(__x));
1581  }
1582 
1583 _GLIBCXX_END_NAMESPACE
1584 
1585 #endif
1586 
1587 #endif /* _GLIBCXX_COMPLEX */
fmtflags flags() const
Access to format flags.
Definition: ios_base.h:555
__string_type str() const
Copying out the string buffer.
Definition: sstream:450
complex< _Tp > log(const complex< _Tp > &)
Return complex natural logarithm of z.
Definition: complex:782
complex< _Tp > cos(const complex< _Tp > &)
Return complex cosine of z.
Definition: complex:699
complex< _Tp > sqrt(const complex< _Tp > &)
Return complex square root of z.
Definition: complex:891
complex< _Tp > operator+(const complex< _Tp > &__x)
Return x.
Definition: complex:438
complex< _Tp > & operator-=(const _Tp &__t)
Subtract t from this complex number.
Definition: complex:188
complex< _Tp > pow(const _Tp &, const complex< _Tp > &)
Return x to the y'th power.
Definition: complex:1009
void setstate(iostate __state)
Sets additional flags in the error state.
Definition: basic_ios.h:147
const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:209
complex< _Tp > log10(const complex< _Tp > &)
Return complex base 10 logarithm of z.
Definition: complex:787
basic_istream< _CharT, _Traits > & operator>>(basic_istream< _CharT, _Traits > &__is, complex< _Tp > &__x)
Extraction operator for complex values.
Definition: complex:486
complex< _Tp > tan(const complex< _Tp > &)
Return complex tangent of z.
Definition: complex:918
_Tp arg(const complex< _Tp > &)
Return phase angle of z.
Definition: complex:621
complex< _Tp > sinh(const complex< _Tp > &)
Return complex hyperbolic sine of z.
Definition: complex:847
complex< _Tp > cosh(const complex< _Tp > &)
Return complex hyperbolic cosine of z.
Definition: complex:729
streamsize precision() const
Flags access.
Definition: ios_base.h:625
complex< _Tp > operator*(const _Tp &__x, const complex< _Tp > &__y)
Return new complex value x times y.
Definition: complex:397
basic_ostream< wchar_t > wostream
One of the I/O .
Definition: iosfwd:145
complex< _Tp > & operator+=(const _Tp &__t)
Add t to this complex number.
Definition: complex:179
basic_istream< char > istream
One of the I/O .
Definition: iosfwd:129
locale imbue(const locale &__loc)
Moves to a new locale.
Definition: basic_ios.tcc:113
_Tp value_type
Value typedef.
Definition: complex:125
basic_ostream< char > ostream
One of the I/O .
Definition: iosfwd:130
complex< _Tp > sin(const complex< _Tp > &)
Return complex sine of z.
Definition: complex:817
Controlling output for std::string.This class supports writing to objects of type std::basic_string...
Definition: iosfwd:71
complex< _Tp > pow(const complex< _Tp > &, const _Tp &)
Return x to the y'th power.
Definition: complex:964
complex< _Tp > tanh(const complex< _Tp > &)
Return complex hyperbolic tangent of z.
Definition: complex:946
basic_istream< wchar_t > wistream
One of the I/O .
Definition: iosfwd:144
complex< _Tp > conj(const complex< _Tp > &)
Return complex conjugate of z.
Definition: complex:667
bool operator!=(const _Tp &__x, const complex< _Tp > &__y)
Return false if x is equal to y.
Definition: complex:479
complex< _Tp > operator/(const _Tp &__x, const complex< _Tp > &__y)
Return new complex value x divided by y.
Definition: complex:427
_Tp norm(const complex< _Tp > &)
Return z magnitude squared.
Definition: complex:654
__istream_type & putback(char_type __c)
Unextracting a single character.
Definition: istream.tcc:661
complex(const complex< _Up > &__z)
Copy constructor.
Definition: complex:136
_Tp abs(const complex< _Tp > &)
Return magnitude of z.
Definition: complex:594
Controlling input.This is the base class for all input streams. It provides text formatting of all bu...
Definition: iosfwd:53
complex< _Tp > operator-(const complex< _Tp > &__x)
Return complex negation of x.
Definition: complex:444
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:129
complex< _Tp > polar(const _Tp &, const _Tp &=0)
Return complex with magnitude rho and angle theta.
Definition: complex:662
complex< _Tp > exp(const complex< _Tp > &)
Return complex base e exponential of z.
Definition: complex:755
bool operator==(const _Tp &__x, const complex< _Tp > &__y)
Return true if x is equal to y.
Definition: complex:461