Home | History | Annotate | Download | only in 4.4.3
      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 (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 _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>&
    258     complex<_Tp>::operator=(const complex<_Up>& __z)
    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>&
    269     complex<_Tp>::operator+=(const complex<_Up>& __z)
    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>&
    280     complex<_Tp>::operator-=(const complex<_Up>& __z)
    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>&
    292     complex<_Tp>::operator*=(const complex<_Up>& __z)
    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>&
    305     complex<_Tp>::operator/=(const complex<_Up>& __z)
    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>
    438     operator+(const complex<_Tp>& __x)
    439     { return __x; }
    440 
    441   ///  Return complex negation of @a x.
    442   template<typename _Tp>
    443     inline complex<_Tp>
    444     operator-(const complex<_Tp>& __x)
    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>&
    486     operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
    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     {
    521       basic_ostringstream<_CharT, _Traits> __s;
    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:
   1497       typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
   1498     };
   1499 
   1500   template<typename _Tp, typename _Up>
   1501     struct __promote_2<_Tp, std::complex<_Up> >
   1502     {
   1503     public:
   1504       typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
   1505     };
   1506   
   1507   template<typename _Tp, typename _Up>
   1508     struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
   1509     {
   1510     public:
   1511       typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
   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>
   1576     inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
   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 */
   1588