libstdc++-v3/include/std/std_complex.h

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