Home | History | Annotate | Download | only in include
      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 (a] cygnus.com>
     35 // Improved by Gabriel Dos Reis <dosreis (a] 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>
    206         complex<_Tp>& operator=(const complex<_Up>&);
    207       /// Add @a z to this complex number.
    208       template<typename _Up>
    209         complex<_Tp>& operator+=(const complex<_Up>&);
    210       /// Subtract @a z from this complex number.
    211       template<typename _Up>
    212         complex<_Tp>& operator-=(const complex<_Up>&);
    213       /// Multiply this complex number by @a z.
    214       template<typename _Up>
    215         complex<_Tp>& operator*=(const complex<_Up>&);
    216       /// Divide this complex number by @a z.
    217       template<typename _Up>
    218         complex<_Tp>& operator/=(const complex<_Up>&);
    219 
    220       _GLIBCXX_USE_CONSTEXPR complex __rep() const
    221       { return *this; }
    222 
    223     private:
    224       _Tp _M_real;
    225       _Tp _M_imag;
    226     };
    227 
    228   template<typename _Tp>
    229     complex<_Tp>&
    230     complex<_Tp>::operator=(const _Tp& __t)
    231     {
    232      _M_real = __t;
    233      _M_imag = _Tp();
    234      return *this;
    235     } 
    236 
    237   // 26.2.5/5
    238   template<typename _Tp>
    239     complex<_Tp>&
    240     complex<_Tp>::operator*=(const _Tp& __t)
    241     {
    242       _M_real *= __t;
    243       _M_imag *= __t;
    244       return *this;
    245     }
    246 
    247   // 26.2.5/7
    248   template<typename _Tp>
    249     complex<_Tp>&
    250     complex<_Tp>::operator/=(const _Tp& __t)
    251     {
    252       _M_real /= __t;
    253       _M_imag /= __t;
    254       return *this;
    255     }
    256 
    257   template<typename _Tp>
    258     template<typename _Up>
    259     complex<_Tp>&
    260     complex<_Tp>::operator=(const complex<_Up>& __z)
    261     {
    262       _M_real = __z.real();
    263       _M_imag = __z.imag();
    264       return *this;
    265     }
    266 
    267   // 26.2.5/9
    268   template<typename _Tp>
    269     template<typename _Up>
    270     complex<_Tp>&
    271     complex<_Tp>::operator+=(const complex<_Up>& __z)
    272     {
    273       _M_real += __z.real();
    274       _M_imag += __z.imag();
    275       return *this;
    276     }
    277 
    278   // 26.2.5/11
    279   template<typename _Tp>
    280     template<typename _Up>
    281     complex<_Tp>&
    282     complex<_Tp>::operator-=(const complex<_Up>& __z)
    283     {
    284       _M_real -= __z.real();
    285       _M_imag -= __z.imag();
    286       return *this;
    287     }
    288 
    289   // 26.2.5/13
    290   // XXX: This is a grammar school implementation.
    291   template<typename _Tp>
    292     template<typename _Up>
    293     complex<_Tp>&
    294     complex<_Tp>::operator*=(const complex<_Up>& __z)
    295     {
    296       const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
    297       _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
    298       _M_real = __r;
    299       return *this;
    300     }
    301 
    302   // 26.2.5/15
    303   // XXX: This is a grammar school implementation.
    304   template<typename _Tp>
    305     template<typename _Up>
    306     complex<_Tp>&
    307     complex<_Tp>::operator/=(const complex<_Up>& __z)
    308     {
    309       const _Tp __r =  _M_real * __z.real() + _M_imag * __z.imag();
    310       const _Tp __n = std::norm(__z);
    311       _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
    312       _M_real = __r / __n;
    313       return *this;
    314     }
    315     
    316   // Operators:
    317   //@{
    318   ///  Return new complex value @a x plus @a y.
    319   template<typename _Tp>
    320     inline complex<_Tp>
    321     operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
    322     {
    323       complex<_Tp> __r = __x;
    324       __r += __y;
    325       return __r;
    326     }
    327 
    328   template<typename _Tp>
    329     inline complex<_Tp>
    330     operator+(const complex<_Tp>& __x, const _Tp& __y)
    331     {
    332       complex<_Tp> __r = __x;
    333       __r += __y;
    334       return __r;
    335     }
    336 
    337   template<typename _Tp>
    338     inline complex<_Tp>
    339     operator+(const _Tp& __x, const complex<_Tp>& __y)
    340     {
    341       complex<_Tp> __r = __y;
    342       __r += __x;
    343       return __r;
    344     }
    345   //@}
    346 
    347   //@{
    348   ///  Return new complex value @a x minus @a y.
    349   template<typename _Tp>
    350     inline complex<_Tp>
    351     operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
    352     {
    353       complex<_Tp> __r = __x;
    354       __r -= __y;
    355       return __r;
    356     }
    357     
    358   template<typename _Tp>
    359     inline complex<_Tp>
    360     operator-(const complex<_Tp>& __x, const _Tp& __y)
    361     {
    362       complex<_Tp> __r = __x;
    363       __r -= __y;
    364       return __r;
    365     }
    366 
    367   template<typename _Tp>
    368     inline complex<_Tp>
    369     operator-(const _Tp& __x, const complex<_Tp>& __y)
    370     {
    371       complex<_Tp> __r(__x, -__y.imag());
    372       __r -= __y.real();
    373       return __r;
    374     }
    375   //@}
    376 
    377   //@{
    378   ///  Return new complex value @a x times @a y.
    379   template<typename _Tp>
    380     inline complex<_Tp>
    381     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
    382     {
    383       complex<_Tp> __r = __x;
    384       __r *= __y;
    385       return __r;
    386     }
    387 
    388   template<typename _Tp>
    389     inline complex<_Tp>
    390     operator*(const complex<_Tp>& __x, const _Tp& __y)
    391     {
    392       complex<_Tp> __r = __x;
    393       __r *= __y;
    394       return __r;
    395     }
    396 
    397   template<typename _Tp>
    398     inline complex<_Tp>
    399     operator*(const _Tp& __x, const complex<_Tp>& __y)
    400     {
    401       complex<_Tp> __r = __y;
    402       __r *= __x;
    403       return __r;
    404     }
    405   //@}
    406 
    407   //@{
    408   ///  Return new complex value @a x divided by @a y.
    409   template<typename _Tp>
    410     inline complex<_Tp>
    411     operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
    412     {
    413       complex<_Tp> __r = __x;
    414       __r /= __y;
    415       return __r;
    416     }
    417     
    418   template<typename _Tp>
    419     inline complex<_Tp>
    420     operator/(const complex<_Tp>& __x, const _Tp& __y)
    421     {
    422       complex<_Tp> __r = __x;
    423       __r /= __y;
    424       return __r;
    425     }
    426 
    427   template<typename _Tp>
    428     inline complex<_Tp>
    429     operator/(const _Tp& __x, const complex<_Tp>& __y)
    430     {
    431       complex<_Tp> __r = __x;
    432       __r /= __y;
    433       return __r;
    434     }
    435   //@}
    436 
    437   ///  Return @a x.
    438   template<typename _Tp>
    439     inline complex<_Tp>
    440     operator+(const complex<_Tp>& __x)
    441     { return __x; }
    442 
    443   ///  Return complex negation of @a x.
    444   template<typename _Tp>
    445     inline complex<_Tp>
    446     operator-(const complex<_Tp>& __x)
    447     {  return complex<_Tp>(-__x.real(), -__x.imag()); }
    448 
    449   //@{
    450   ///  Return true if @a x is equal to @a y.
    451   template<typename _Tp>
    452     inline _GLIBCXX_CONSTEXPR bool
    453     operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
    454     { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
    455 
    456   template<typename _Tp>
    457     inline _GLIBCXX_CONSTEXPR bool
    458     operator==(const complex<_Tp>& __x, const _Tp& __y)
    459     { return __x.real() == __y && __x.imag() == _Tp(); }
    460 
    461   template<typename _Tp>
    462     inline _GLIBCXX_CONSTEXPR bool
    463     operator==(const _Tp& __x, const complex<_Tp>& __y)
    464     { return __x == __y.real() && _Tp() == __y.imag(); }
    465   //@}
    466 
    467   //@{
    468   ///  Return false if @a x is equal to @a y.
    469   template<typename _Tp>
    470     inline _GLIBCXX_CONSTEXPR bool
    471     operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
    472     { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
    473 
    474   template<typename _Tp>
    475     inline _GLIBCXX_CONSTEXPR bool
    476     operator!=(const complex<_Tp>& __x, const _Tp& __y)
    477     { return __x.real() != __y || __x.imag() != _Tp(); }
    478 
    479   template<typename _Tp>
    480     inline _GLIBCXX_CONSTEXPR bool
    481     operator!=(const _Tp& __x, const complex<_Tp>& __y)
    482     { return __x != __y.real() || _Tp() != __y.imag(); }
    483   //@}
    484 
    485   ///  Extraction operator for complex values.
    486   template<typename _Tp, typename _CharT, class _Traits>
    487     basic_istream<_CharT, _Traits>&
    488     operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
    489     {
    490       _Tp __re_x, __im_x;
    491       _CharT __ch;
    492       __is >> __ch;
    493       if (__ch == '(') 
    494 	{
    495 	  __is >> __re_x >> __ch;
    496 	  if (__ch == ',') 
    497 	    {
    498 	      __is >> __im_x >> __ch;
    499 	      if (__ch == ')') 
    500 		__x = complex<_Tp>(__re_x, __im_x);
    501 	      else
    502 		__is.setstate(ios_base::failbit);
    503 	    }
    504 	  else if (__ch == ')') 
    505 	    __x = __re_x;
    506 	  else
    507 	    __is.setstate(ios_base::failbit);
    508 	}
    509       else 
    510 	{
    511 	  __is.putback(__ch);
    512 	  __is >> __re_x;
    513 	  __x = __re_x;
    514 	}
    515       return __is;
    516     }
    517 
    518   ///  Insertion operator for complex values.
    519   template<typename _Tp, typename _CharT, class _Traits>
    520     basic_ostream<_CharT, _Traits>&
    521     operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
    522     {
    523       basic_ostringstream<_CharT, _Traits> __s;
    524       __s.flags(__os.flags());
    525       __s.imbue(__os.getloc());
    526       __s.precision(__os.precision());
    527       __s << '(' << __x.real() << ',' << __x.imag() << ')';
    528       return __os << __s.str();
    529     }
    530 
    531   // Values
    532 #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:
   1541       typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
   1542     };
   1543 
   1544   template<typename _Tp, typename _Up>
   1545     struct __promote_2<_Tp, std::complex<_Up> >
   1546     {
   1547     public:
   1548       typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
   1549     };
   1550   
   1551   template<typename _Tp, typename _Up>
   1552     struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
   1553     {
   1554     public:
   1555       typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
   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>
   1610     acos(const std::complex<_Tp>& __z)
   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>
   1646     asin(const std::complex<_Tp>& __z)
   1647     { return __complex_asin(__z); }
   1648 #endif
   1649   
   1650   template<typename _Tp>
   1651     std::complex<_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>
   1690     atan(const std::complex<_Tp>& __z)
   1691     { return __complex_atan(__z); }
   1692 #endif
   1693 
   1694   template<typename _Tp>
   1695     std::complex<_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>
   1726     acosh(const std::complex<_Tp>& __z)
   1727     { return __complex_acosh(__z); }
   1728 #endif
   1729 
   1730   template<typename _Tp>
   1731     std::complex<_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>
   1765     asinh(const std::complex<_Tp>& __z)
   1766     { return __complex_asinh(__z); }
   1767 #endif
   1768 
   1769   template<typename _Tp>
   1770     std::complex<_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>
   1809     atanh(const std::complex<_Tp>& __z)
   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.
   1818     fabs(const std::complex<_Tp>& __z)
   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>
   1854     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
   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>
   1862     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
   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>
   1870     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
   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>
   1883     std::complex<_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 */
   1934