libstdc++-v3/include/std/complex

   1 // The template and inlines for the -*- C++ -*- complex number classes.
   2
   3 // Copyright (C) 1997-2014 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file include/complex
  26  *  This is a Standard C++ Library header.
  27  */
  28
  29 //
  30 // ISO C++ 14882: 26.2  Complex Numbers
  31 // Note: this is not a conforming implementation.
  32 // Initially implemented by Ulrich Drepper <drepper@cygnus.com>
  33 // Improved by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
  34 //
  35
  36 #ifndef _GLIBCXX_COMPLEX
  37 #define _GLIBCXX_COMPLEX 1
  38
  39 #pragma GCC system_header
  40
  41 #include <bits/c++config.h>
  42 #include <bits/cpp_type_traits.h>
  43 #include <ext/type_traits.h>
  44 #include <cmath>
  45 #include <sstream>
  46
  47 // Get rid of a macro possibly defined in <complex.h>
  48 #undef complex
  49
  50 namespace std _GLIBCXX_VISIBILITY(default)
  51 {
  52 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  53
  54   /**
  55    * @defgroup complex_numbers Complex Numbers
  56    * @ingroup numerics
  57    *
  58    * Classes and functions for complex numbers.
  59    * @{
  60    */
  61
  62   // Forward declarations.
  63   template<typename _Tp> class complex;
  64   template<> class complex<float>;
  65   template<> class complex<double>;
  66   template<> class complex<long double>;
  67
  68   ///  Return magnitude of @a z.
  69   template<typename _Tp> _Tp abs(const complex<_Tp>&);
  70   ///  Return phase angle of @a z.
  71   template<typename _Tp> _Tp arg(const complex<_Tp>&);
  72   ///  Return @a z magnitude squared.
  73   template<typename _Tp> _Tp norm(const complex<_Tp>&);
  74
  75   ///  Return complex conjugate of @a z.
  76   template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
  77   ///  Return complex with magnitude @a rho and angle @a theta.
  78   template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
  79
  80   // Transcendentals:
  81   /// Return complex cosine of @a z.
  82   template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
  83   /// Return complex hyperbolic cosine of @a z.
  84   template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
  85   /// Return complex base e exponential of @a z.
  86   template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
  87   /// Return complex natural logarithm of @a z.
  88   template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
  89   /// Return complex base 10 logarithm of @a z.
  90   template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
  91   /// Return @a x to the @a y'th power.
  92   template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
  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       _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
 130       : _M_real(__r), _M_imag(__i) { }
 131
 132       // Let the compiler synthesize the copy constructor
 133 #if __cplusplus >= 201103L
 134       constexpr complex(const complex&) = default;
 135 #endif
 136
 137       ///  Converting constructor.
 138       template<typename _Up>
 139         _GLIBCXX_CONSTEXPR complex(const complex<_Up>& __z)
 140         : _M_real(__z.real()), _M_imag(__z.imag()) { }
 141
 142 #if __cplusplus >= 201103L
 143       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 144       // DR 387. std::complex over-encapsulated.
 145       _GLIBCXX_ABI_TAG_CXX11
 146       constexpr _Tp
 147       real() { return _M_real; }
 148
 149       _GLIBCXX_ABI_TAG_CXX11
 150       constexpr _Tp
 151       imag() { return _M_imag; }
 152 #else
 153       ///  Return real part of complex number.
 154       _Tp&
 155       real() { return _M_real; }
 156
 157       ///  Return real part of complex number.
 158       const _Tp&
 159       real() const { return _M_real; }
 160
 161       ///  Return imaginary part of complex number.
 162       _Tp&
 163       imag() { return _M_imag; }
 164
 165       ///  Return imaginary part of complex number.
 166       const _Tp&
 167       imag() const { return _M_imag; }
 168 #endif
 169
 170       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 171       // DR 387. std::complex over-encapsulated.
 172       void
 173       real(_Tp __val) { _M_real = __val; }
 174
 175       void
 176       imag(_Tp __val) { _M_imag = __val; }
 177
 178       /// Assign a scalar to this complex number.
 179       complex<_Tp>& operator=(const _Tp&);
 180
 181       /// Add a scalar to this complex number.
 182       // 26.2.5/1
 183       complex<_Tp>&
 184       operator+=(const _Tp& __t)
 185       {
 186         _M_real += __t;
 187         return *this;
 188       }
 189
 190       /// Subtract a scalar from this complex number.
 191       // 26.2.5/3
 192       complex<_Tp>&
 193       operator-=(const _Tp& __t)
 194       {
 195         _M_real -= __t;
 196         return *this;
 197       }
 198
 199       /// Multiply this complex number by a scalar.
 200       complex<_Tp>& operator*=(const _Tp&);
 201       /// Divide this complex number by a scalar.
 202       complex<_Tp>& operator/=(const _Tp&);
 203
 204       // Let the compiler synthesize the copy assignment operator
 205 #if __cplusplus >= 201103L
 206       complex& operator=(const complex&) = default;
 207 #endif
 208
 209       /// Assign another complex number to this one.
 210       template<typename _Up>
 211         complex<_Tp>& operator=(const complex<_Up>&);
 212       /// Add another complex number to this one.
 213       template<typename _Up>
 214         complex<_Tp>& operator+=(const complex<_Up>&);
 215       /// Subtract another complex number from this one.
 216       template<typename _Up>
 217         complex<_Tp>& operator-=(const complex<_Up>&);
 218       /// Multiply this complex number by another.
 219       template<typename _Up>
 220         complex<_Tp>& operator*=(const complex<_Up>&);
 221       /// Divide this complex number by another.
 222       template<typename _Up>
 223         complex<_Tp>& operator/=(const complex<_Up>&);
 224
 225       _GLIBCXX_CONSTEXPR complex __rep() const
 226       { return *this; }
 227
 228     private:
 229       _Tp _M_real;
 230       _Tp _M_imag;
 231     };
 232
 233   template<typename _Tp>
 234     complex<_Tp>&
 235     complex<_Tp>::operator=(const _Tp& __t)
 236     {
 237      _M_real = __t;
 238      _M_imag = _Tp();
 239      return *this;
 240     }
 241
 242   // 26.2.5/5
 243   template<typename _Tp>
 244     complex<_Tp>&
 245     complex<_Tp>::operator*=(const _Tp& __t)
 246     {
 247       _M_real *= __t;
 248       _M_imag *= __t;
 249       return *this;
 250     }
 251
 252   // 26.2.5/7
 253   template<typename _Tp>
 254     complex<_Tp>&
 255     complex<_Tp>::operator/=(const _Tp& __t)
 256     {
 257       _M_real /= __t;
 258       _M_imag /= __t;
 259       return *this;
 260     }
 261
 262   template<typename _Tp>
 263     template<typename _Up>
 264     complex<_Tp>&
 265     complex<_Tp>::operator=(const complex<_Up>& __z)
 266     {
 267       _M_real = __z.real();
 268       _M_imag = __z.imag();
 269       return *this;
 270     }
 271
 272   // 26.2.5/9
 273   template<typename _Tp>
 274     template<typename _Up>
 275     complex<_Tp>&
 276     complex<_Tp>::operator+=(const complex<_Up>& __z)
 277     {
 278       _M_real += __z.real();
 279       _M_imag += __z.imag();
 280       return *this;
 281     }
 282
 283   // 26.2.5/11
 284   template<typename _Tp>
 285     template<typename _Up>
 286     complex<_Tp>&
 287     complex<_Tp>::operator-=(const complex<_Up>& __z)
 288     {
 289       _M_real -= __z.real();
 290       _M_imag -= __z.imag();
 291       return *this;
 292     }
 293
 294   // 26.2.5/13
 295   // XXX: This is a grammar school implementation.
 296   template<typename _Tp>
 297     template<typename _Up>
 298     complex<_Tp>&
 299     complex<_Tp>::operator*=(const complex<_Up>& __z)
 300     {
 301       const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
 302       _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
 303       _M_real = __r;
 304       return *this;
 305     }
 306
 307   // 26.2.5/15
 308   // XXX: This is a grammar school implementation.
 309   template<typename _Tp>
 310     template<typename _Up>
 311     complex<_Tp>&
 312     complex<_Tp>::operator/=(const complex<_Up>& __z)
 313     {
 314       const _Tp __r =  _M_real * __z.real() + _M_imag * __z.imag();
 315       const _Tp __n = std::norm(__z);
 316       _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
 317       _M_real = __r / __n;
 318       return *this;
 319     }
 320
 321   // Operators:
 322   //@{
 323   ///  Return new complex value @a x plus @a y.
 324   template<typename _Tp>
 325     inline complex<_Tp>
 326     operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
 327     {
 328       complex<_Tp> __r = __x;
 329       __r += __y;
 330       return __r;
 331     }
 332
 333   template<typename _Tp>
 334     inline complex<_Tp>
 335     operator+(const complex<_Tp>& __x, const _Tp& __y)
 336     {
 337       complex<_Tp> __r = __x;
 338       __r += __y;
 339       return __r;
 340     }
 341
 342   template<typename _Tp>
 343     inline complex<_Tp>
 344     operator+(const _Tp& __x, const complex<_Tp>& __y)
 345     {
 346       complex<_Tp> __r = __y;
 347       __r += __x;
 348       return __r;
 349     }
 350   //@}
 351
 352   //@{
 353   ///  Return new complex value @a x minus @a y.
 354   template<typename _Tp>
 355     inline complex<_Tp>
 356     operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
 357     {
 358       complex<_Tp> __r = __x;
 359       __r -= __y;
 360       return __r;
 361     }
 362
 363   template<typename _Tp>
 364     inline complex<_Tp>
 365     operator-(const complex<_Tp>& __x, const _Tp& __y)
 366     {
 367       complex<_Tp> __r = __x;
 368       __r -= __y;
 369       return __r;
 370     }
 371
 372   template<typename _Tp>
 373     inline complex<_Tp>
 374     operator-(const _Tp& __x, const complex<_Tp>& __y)
 375     {
 376       complex<_Tp> __r(__x, -__y.imag());
 377       __r -= __y.real();
 378       return __r;
 379     }
 380   //@}
 381
 382   //@{
 383   ///  Return new complex value @a x times @a y.
 384   template<typename _Tp>
 385     inline complex<_Tp>
 386     operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
 387     {
 388       complex<_Tp> __r = __x;
 389       __r *= __y;
 390       return __r;
 391     }
 392
 393   template<typename _Tp>
 394     inline complex<_Tp>
 395     operator*(const complex<_Tp>& __x, const _Tp& __y)
 396     {
 397       complex<_Tp> __r = __x;
 398       __r *= __y;
 399       return __r;
 400     }
 401
 402   template<typename _Tp>
 403     inline complex<_Tp>
 404     operator*(const _Tp& __x, const complex<_Tp>& __y)
 405     {
 406       complex<_Tp> __r = __y;
 407       __r *= __x;
 408       return __r;
 409     }
 410   //@}
 411
 412   //@{
 413   ///  Return new complex value @a x divided by @a y.
 414   template<typename _Tp>
 415     inline complex<_Tp>
 416     operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
 417     {
 418       complex<_Tp> __r = __x;
 419       __r /= __y;
 420       return __r;
 421     }
 422
 423   template<typename _Tp>
 424     inline complex<_Tp>
 425     operator/(const complex<_Tp>& __x, const _Tp& __y)
 426     {
 427       complex<_Tp> __r = __x;
 428       __r /= __y;
 429       return __r;
 430     }
 431
 432   template<typename _Tp>
 433     inline complex<_Tp>
 434     operator/(const _Tp& __x, const complex<_Tp>& __y)
 435     {
 436       complex<_Tp> __r = __x;
 437       __r /= __y;
 438       return __r;
 439     }
 440   //@}
 441
 442   ///  Return @a x.
 443   template<typename _Tp>
 444     inline complex<_Tp>
 445     operator+(const complex<_Tp>& __x)
 446     { return __x; }
 447
 448   ///  Return complex negation of @a x.
 449   template<typename _Tp>
 450     inline complex<_Tp>
 451     operator-(const complex<_Tp>& __x)
 452     {  return complex<_Tp>(-__x.real(), -__x.imag()); }
 453
 454   //@{
 455   ///  Return true if @a x is equal to @a y.
 456   template<typename _Tp>
 457     inline _GLIBCXX_CONSTEXPR bool
 458     operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
 459     { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
 460
 461   template<typename _Tp>
 462     inline _GLIBCXX_CONSTEXPR bool
 463     operator==(const complex<_Tp>& __x, const _Tp& __y)
 464     { return __x.real() == __y && __x.imag() == _Tp(); }
 465
 466   template<typename _Tp>
 467     inline _GLIBCXX_CONSTEXPR bool
 468     operator==(const _Tp& __x, const complex<_Tp>& __y)
 469     { return __x == __y.real() && _Tp() == __y.imag(); }
 470   //@}
 471
 472   //@{
 473   ///  Return false if @a x is equal to @a y.
 474   template<typename _Tp>
 475     inline _GLIBCXX_CONSTEXPR bool
 476     operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
 477     { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
 478
 479   template<typename _Tp>
 480     inline _GLIBCXX_CONSTEXPR bool
 481     operator!=(const complex<_Tp>& __x, const _Tp& __y)
 482     { return __x.real() != __y || __x.imag() != _Tp(); }
 483
 484   template<typename _Tp>
 485     inline _GLIBCXX_CONSTEXPR bool
 486     operator!=(const _Tp& __x, const complex<_Tp>& __y)
 487     { return __x != __y.real() || _Tp() != __y.imag(); }
 488   //@}
 489
 490   ///  Extraction operator for complex values.
 491   template<typename _Tp, typename _CharT, class _Traits>
 492     basic_istream<_CharT, _Traits>&
 493     operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
 494     {
 495       _Tp __re_x, __im_x;
 496       _CharT __ch;
 497       __is >> __ch;
 498       if (__ch == '(')
 499         {
 500           __is >> __re_x >> __ch;
 501           if (__ch == ',')
 502             {
 503               __is >> __im_x >> __ch;
 504               if (__ch == ')')
 505                 __x = complex<_Tp>(__re_x, __im_x);
 506               else
 507                 __is.setstate(ios_base::failbit);
 508             }
 509           else if (__ch == ')')
 510             __x = __re_x;
 511           else
 512             __is.setstate(ios_base::failbit);
 513         }
 514       else
 515         {
 516           __is.putback(__ch);
 517           __is >> __re_x;
 518           __x = __re_x;
 519         }
 520       return __is;
 521     }
 522
 523   ///  Insertion operator for complex values.
 524   template<typename _Tp, typename _CharT, class _Traits>
 525     basic_ostream<_CharT, _Traits>&
 526     operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
 527     {
 528       basic_ostringstream<_CharT, _Traits> __s;
 529       __s.flags(__os.flags());
 530       __s.imbue(__os.getloc());
 531       __s.precision(__os.precision());
 532       __s << '(' << __x.real() << ',' << __x.imag() << ')';
 533       return __os << __s.str();
 534     }
 535
 536   // Values
 537 #if __cplusplus >= 201103L
 538   template<typename _Tp>
 539     constexpr _Tp
 540     real(const complex<_Tp>& __z)
 541     { return __z.real(); }
 542
 543   template<typename _Tp>
 544     constexpr _Tp
 545     imag(const complex<_Tp>& __z)
 546     { return __z.imag(); }
 547 #else
 548   template<typename _Tp>
 549     inline _Tp&
 550     real(complex<_Tp>& __z)
 551     { return __z.real(); }
 552
 553   template<typename _Tp>
 554     inline const _Tp&
 555     real(const complex<_Tp>& __z)
 556     { return __z.real(); }
 557
 558   template<typename _Tp>
 559     inline _Tp&
 560     imag(complex<_Tp>& __z)
 561     { return __z.imag(); }
 562
 563   template<typename _Tp>
 564     inline const _Tp&
 565     imag(const complex<_Tp>& __z)
 566     { return __z.imag(); }
 567 #endif
 568
 569   // 26.2.7/3 abs(__z):  Returns the magnitude of __z.
 570   template<typename _Tp>
 571     inline _Tp
 572     __complex_abs(const complex<_Tp>& __z)
 573     {
 574       _Tp __x = __z.real();
 575       _Tp __y = __z.imag();
 576       const _Tp __s = std::max(abs(__x), abs(__y));
 577       if (__s == _Tp())  // well ...
 578         return __s;
 579       __x /= __s;
 580       __y /= __s;
 581       return __s * sqrt(__x * __x + __y * __y);
 582     }
 583
 584 #if _GLIBCXX_USE_C99_COMPLEX
 585   inline float
 586   __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
 587
 588   inline double
 589   __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
 590
 591   inline long double
 592   __complex_abs(const __complex__ long double& __z)
 593   { return __builtin_cabsl(__z); }
 594
 595   template<typename _Tp>
 596     inline _Tp
 597     abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
 598 #else
 599   template<typename _Tp>
 600     inline _Tp
 601     abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
 602 #endif
 603
 604
 605   // 26.2.7/4: arg(__z): Returns the phase angle of __z.
 606   template<typename _Tp>
 607     inline _Tp
 608     __complex_arg(const complex<_Tp>& __z)
 609     { return  atan2(__z.imag(), __z.real()); }
 610
 611 #if _GLIBCXX_USE_C99_COMPLEX
 612   inline float
 613   __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
 614
 615   inline double
 616   __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
 617
 618   inline long double
 619   __complex_arg(const __complex__ long double& __z)
 620   { return __builtin_cargl(__z); }
 621
 622   template<typename _Tp>
 623     inline _Tp
 624     arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
 625 #else
 626   template<typename _Tp>
 627     inline _Tp
 628     arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
 629 #endif
 630
 631   // 26.2.7/5: norm(__z) returns the squared magnitude of __z.
 632   //     As defined, norm() is -not- a norm is the common mathematical
 633   //     sense used in numerics.  The helper class _Norm_helper<> tries to
 634   //     distinguish between builtin floating point and the rest, so as
 635   //     to deliver an answer as close as possible to the real value.
 636   template<bool>
 637     struct _Norm_helper
 638     {
 639       template<typename _Tp>
 640         static inline _Tp _S_do_it(const complex<_Tp>& __z)
 641         {
 642           const _Tp __x = __z.real();
 643           const _Tp __y = __z.imag();
 644           return __x * __x + __y * __y;
 645         }
 646     };
 647
 648   template<>
 649     struct _Norm_helper<true>
 650     {
 651       template<typename _Tp>
 652         static inline _Tp _S_do_it(const complex<_Tp>& __z)
 653         {
 654           _Tp __res = std::abs(__z);
 655           return __res * __res;
 656         }
 657     };
 658
 659   template<typename _Tp>
 660     inline _Tp
 661     norm(const complex<_Tp>& __z)
 662     {
 663       return _Norm_helper<__is_floating<_Tp>::__value
 664         && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
 665     }
 666
 667   template<typename _Tp>
 668     inline complex<_Tp>
 669     polar(const _Tp& __rho, const _Tp& __theta)
 670     { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
 671
 672   template<typename _Tp>
 673     inline complex<_Tp>
 674     conj(const complex<_Tp>& __z)
 675     { return complex<_Tp>(__z.real(), -__z.imag()); }
 676
 677   // Transcendentals
 678
 679   // 26.2.8/1 cos(__z):  Returns the cosine of __z.
 680   template<typename _Tp>
 681     inline complex<_Tp>
 682     __complex_cos(const complex<_Tp>& __z)
 683     {
 684       const _Tp __x = __z.real();
 685       const _Tp __y = __z.imag();
 686       return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
 687     }
 688
 689 #if _GLIBCXX_USE_C99_COMPLEX
 690   inline __complex__ float
 691   __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
 692
 693   inline __complex__ double
 694   __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
 695
 696   inline __complex__ long double
 697   __complex_cos(const __complex__ long double& __z)
 698   { return __builtin_ccosl(__z); }
 699
 700   template<typename _Tp>
 701     inline complex<_Tp>
 702     cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
 703 #else
 704   template<typename _Tp>
 705     inline complex<_Tp>
 706     cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
 707 #endif
 708
 709   // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
 710   template<typename _Tp>
 711     inline complex<_Tp>
 712     __complex_cosh(const complex<_Tp>& __z)
 713     {
 714       const _Tp __x = __z.real();
 715       const _Tp __y = __z.imag();
 716       return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
 717     }
 718
 719 #if _GLIBCXX_USE_C99_COMPLEX
 720   inline __complex__ float
 721   __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
 722
 723   inline __complex__ double
 724   __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
 725
 726   inline __complex__ long double
 727   __complex_cosh(const __complex__ long double& __z)
 728   { return __builtin_ccoshl(__z); }
 729
 730   template<typename _Tp>
 731     inline complex<_Tp>
 732     cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
 733 #else
 734   template<typename _Tp>
 735     inline complex<_Tp>
 736     cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
 737 #endif
 738
 739   // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
 740   template<typename _Tp>
 741     inline complex<_Tp>
 742     __complex_exp(const complex<_Tp>& __z)
 743     { return std::polar<_Tp>(exp(__z.real()), __z.imag()); }
 744
 745 #if _GLIBCXX_USE_C99_COMPLEX
 746   inline __complex__ float
 747   __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
 748
 749   inline __complex__ double
 750   __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
 751
 752   inline __complex__ long double
 753   __complex_exp(const __complex__ long double& __z)
 754   { return __builtin_cexpl(__z); }
 755
 756   template<typename _Tp>
 757     inline complex<_Tp>
 758     exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
 759 #else
 760   template<typename _Tp>
 761     inline complex<_Tp>
 762     exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
 763 #endif
 764
 765   // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z.
 766   //                    The branch cut is along the negative axis.
 767   template<typename _Tp>
 768     inline complex<_Tp>
 769     __complex_log(const complex<_Tp>& __z)
 770     { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
 771
 772 #if _GLIBCXX_USE_C99_COMPLEX
 773   inline __complex__ float
 774   __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
 775
 776   inline __complex__ double
 777   __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
 778
 779   inline __complex__ long double
 780   __complex_log(const __complex__ long double& __z)
 781   { return __builtin_clogl(__z); }
 782
 783   template<typename _Tp>
 784     inline complex<_Tp>
 785     log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
 786 #else
 787   template<typename _Tp>
 788     inline complex<_Tp>
 789     log(const complex<_Tp>& __z) { return __complex_log(__z); }
 790 #endif
 791
 792   template<typename _Tp>
 793     inline complex<_Tp>
 794     log10(const complex<_Tp>& __z)
 795     { return std::log(__z) / log(_Tp(10.0)); }
 796
 797   // 26.2.8/10 sin(__z): Returns the sine of __z.
 798   template<typename _Tp>
 799     inline complex<_Tp>
 800     __complex_sin(const complex<_Tp>& __z)
 801     {
 802       const _Tp __x = __z.real();
 803       const _Tp __y = __z.imag();
 804       return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
 805     }
 806
 807 #if _GLIBCXX_USE_C99_COMPLEX
 808   inline __complex__ float
 809   __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
 810
 811   inline __complex__ double
 812   __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
 813
 814   inline __complex__ long double
 815   __complex_sin(const __complex__ long double& __z)
 816   { return __builtin_csinl(__z); }
 817
 818   template<typename _Tp>
 819     inline complex<_Tp>
 820     sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
 821 #else
 822   template<typename _Tp>
 823     inline complex<_Tp>
 824     sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
 825 #endif
 826
 827   // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
 828   template<typename _Tp>
 829     inline complex<_Tp>
 830     __complex_sinh(const complex<_Tp>& __z)
 831     {
 832       const _Tp __x = __z.real();
 833       const _Tp  __y = __z.imag();
 834       return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
 835     }
 836
 837 #if _GLIBCXX_USE_C99_COMPLEX
 838   inline __complex__ float
 839   __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
 840
 841   inline __complex__ double
 842   __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
 843
 844   inline __complex__ long double
 845   __complex_sinh(const __complex__ long double& __z)
 846   { return __builtin_csinhl(__z); }
 847
 848   template<typename _Tp>
 849     inline complex<_Tp>
 850     sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
 851 #else
 852   template<typename _Tp>
 853     inline complex<_Tp>
 854     sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
 855 #endif
 856
 857   // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
 858   //                     The branch cut is on the negative axis.
 859   template<typename _Tp>
 860     complex<_Tp>
 861     __complex_sqrt(const complex<_Tp>& __z)
 862     {
 863       _Tp __x = __z.real();
 864       _Tp __y = __z.imag();
 865
 866       if (__x == _Tp())
 867         {
 868           _Tp __t = sqrt(abs(__y) / 2);
 869           return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
 870         }
 871       else
 872         {
 873           _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
 874           _Tp __u = __t / 2;
 875           return __x > _Tp()
 876             ? complex<_Tp>(__u, __y / __t)
 877             : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
 878         }
 879     }
 880
 881 #if _GLIBCXX_USE_C99_COMPLEX
 882   inline __complex__ float
 883   __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
 884
 885   inline __complex__ double
 886   __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
 887
 888   inline __complex__ long double
 889   __complex_sqrt(const __complex__ long double& __z)
 890   { return __builtin_csqrtl(__z); }
 891
 892   template<typename _Tp>
 893     inline complex<_Tp>
 894     sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
 895 #else
 896   template<typename _Tp>
 897     inline complex<_Tp>
 898     sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
 899 #endif
 900
 901   // 26.2.8/14 tan(__z):  Return the complex tangent of __z.
 902
 903   template<typename _Tp>
 904     inline complex<_Tp>
 905     __complex_tan(const complex<_Tp>& __z)
 906     { return std::sin(__z) / std::cos(__z); }
 907
 908 #if _GLIBCXX_USE_C99_COMPLEX
 909   inline __complex__ float
 910   __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
 911
 912   inline __complex__ double
 913   __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
 914
 915   inline __complex__ long double
 916   __complex_tan(const __complex__ long double& __z)
 917   { return __builtin_ctanl(__z); }
 918
 919   template<typename _Tp>
 920     inline complex<_Tp>
 921     tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
 922 #else
 923   template<typename _Tp>
 924     inline complex<_Tp>
 925     tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
 926 #endif
 927
 928
 929   // 26.2.8/15 tanh(__z):  Returns the hyperbolic tangent of __z.
 930
 931   template<typename _Tp>
 932     inline complex<_Tp>
 933     __complex_tanh(const complex<_Tp>& __z)
 934     { return std::sinh(__z) / std::cosh(__z); }
 935
 936 #if _GLIBCXX_USE_C99_COMPLEX
 937   inline __complex__ float
 938   __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
 939
 940   inline __complex__ double
 941   __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
 942
 943   inline __complex__ long double
 944   __complex_tanh(const __complex__ long double& __z)
 945   { return __builtin_ctanhl(__z); }
 946
 947   template<typename _Tp>
 948     inline complex<_Tp>
 949     tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
 950 #else
 951   template<typename _Tp>
 952     inline complex<_Tp>
 953     tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
 954 #endif
 955
 956
 957   // 26.2.8/9  pow(__x, __y): Returns the complex power base of __x
 958   //                          raised to the __y-th power.  The branch
 959   //                          cut is on the negative axis.
 960   template<typename _Tp>
 961     complex<_Tp>
 962     __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
 963     {
 964       complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
 965
 966       while (__n >>= 1)
 967         {
 968           __x *= __x;
 969           if (__n % 2)
 970             __y *= __x;
 971         }
 972
 973       return __y;
 974     }
 975
 976   // In C++11 mode we used to implement the resolution of
 977   // DR 844. complex pow return type is ambiguous.
 978   // thus the following overload was disabled in that mode.  However, doing
 979   // that causes all sorts of issues, see, for example:
 980   //   http://gcc.gnu.org/ml/libstdc++/2013-01/msg00058.html
 981   // and also PR57974.
 982   template<typename _Tp>
 983     inline complex<_Tp>
 984     pow(const complex<_Tp>& __z, int __n)
 985     {
 986       return __n < 0
 987         ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -(unsigned)__n)
 988         : std::__complex_pow_unsigned(__z, __n);
 989     }
 990
 991   template<typename _Tp>
 992     complex<_Tp>
 993     pow(const complex<_Tp>& __x, const _Tp& __y)
 994     {
 995 #ifndef _GLIBCXX_USE_C99_COMPLEX
 996       if (__x == _Tp())
 997         return _Tp();
 998 #endif
 999       if (__x.imag() == _Tp() && __x.real() > _Tp())
1000         return pow(__x.real(), __y);
1001
1002       complex<_Tp> __t = std::log(__x);
1003       return std::polar<_Tp>(exp(__y * __t.real()), __y * __t.imag());
1004     }
1005
1006   template<typename _Tp>
1007     inline complex<_Tp>
1008     __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1009     { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
1010
1011 #if _GLIBCXX_USE_C99_COMPLEX
1012   inline __complex__ float
1013   __complex_pow(__complex__ float __x, __complex__ float __y)
1014   { return __builtin_cpowf(__x, __y); }
1015
1016   inline __complex__ double
1017   __complex_pow(__complex__ double __x, __complex__ double __y)
1018   { return __builtin_cpow(__x, __y); }
1019
1020   inline __complex__ long double
1021   __complex_pow(const __complex__ long double& __x,
1022                 const __complex__ long double& __y)
1023   { return __builtin_cpowl(__x, __y); }
1024
1025   template<typename _Tp>
1026     inline complex<_Tp>
1027     pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1028     { return __complex_pow(__x.__rep(), __y.__rep()); }
1029 #else
1030   template<typename _Tp>
1031     inline complex<_Tp>
1032     pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1033     { return __complex_pow(__x, __y); }
1034 #endif
1035
1036   template<typename _Tp>
1037     inline complex<_Tp>
1038     pow(const _Tp& __x, const complex<_Tp>& __y)
1039     {
1040       return __x > _Tp() ? std::polar<_Tp>(pow(__x, __y.real()),
1041                                            __y.imag() * log(__x))
1042                          : std::pow(complex<_Tp>(__x), __y);
1043     }
1044
1045   /// 26.2.3  complex specializations
1046   /// complex<float> specialization
1047   template<>
1048     struct complex<float>
1049     {
1050       typedef float value_type;
1051       typedef __complex__ float _ComplexT;
1052
1053       _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1054
1055       _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f)
1056 #if __cplusplus >= 201103L
1057       : _M_value{ __r, __i } { }
1058 #else
1059       {
1060         __real__ _M_value = __r;
1061         __imag__ _M_value = __i;
1062       }
1063 #endif
1064
1065       explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&);
1066       explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1067
1068 #if __cplusplus >= 201103L
1069       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1070       // DR 387. std::complex over-encapsulated.
1071       __attribute ((__abi_tag__ ("cxx11")))
1072       constexpr float
1073       real() const { return __real__ _M_value; }
1074
1075       __attribute ((__abi_tag__ ("cxx11")))
1076       constexpr float
1077       imag() const { return __imag__ _M_value; }
1078 #else
1079       float&
1080       real() { return __real__ _M_value; }
1081
1082       const float&
1083       real() const { return __real__ _M_value; }
1084
1085       float&
1086       imag() { return __imag__ _M_value; }
1087
1088       const float&
1089       imag() const { return __imag__ _M_value; }
1090 #endif
1091
1092       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1093       // DR 387. std::complex over-encapsulated.
1094       void
1095       real(float __val) { __real__ _M_value = __val; }
1096
1097       void
1098       imag(float __val) { __imag__ _M_value = __val; }
1099
1100       complex&
1101       operator=(float __f)
1102       {
1103         _M_value = __f;
1104         return *this;
1105       }
1106
1107       complex&
1108       operator+=(float __f)
1109       {
1110         _M_value += __f;
1111         return *this;
1112       }
1113
1114       complex&
1115       operator-=(float __f)
1116       {
1117         _M_value -= __f;
1118         return *this;
1119       }
1120
1121       complex&
1122       operator*=(float __f)
1123       {
1124         _M_value *= __f;
1125         return *this;
1126       }
1127
1128       complex&
1129       operator/=(float __f)
1130       {
1131         _M_value /= __f;
1132         return *this;
1133       }
1134
1135       // Let the compiler synthesize the copy and assignment
1136       // operator.  It always does a pretty good job.
1137       // complex& operator=(const complex&);
1138
1139       template<typename _Tp>
1140         complex&
1141         operator=(const complex<_Tp>&  __z)
1142         {
1143           __real__ _M_value = __z.real();
1144           __imag__ _M_value = __z.imag();
1145           return *this;
1146         }
1147
1148       template<typename _Tp>
1149         complex&
1150         operator+=(const complex<_Tp>& __z)
1151         {
1152           __real__ _M_value += __z.real();
1153           __imag__ _M_value += __z.imag();
1154           return *this;
1155         }
1156
1157       template<class _Tp>
1158         complex&
1159         operator-=(const complex<_Tp>& __z)
1160         {
1161           __real__ _M_value -= __z.real();
1162           __imag__ _M_value -= __z.imag();
1163           return *this;
1164         }
1165
1166       template<class _Tp>
1167         complex&
1168         operator*=(const complex<_Tp>& __z)
1169         {
1170           _ComplexT __t;
1171           __real__ __t = __z.real();
1172           __imag__ __t = __z.imag();
1173           _M_value *= __t;
1174           return *this;
1175         }
1176
1177       template<class _Tp>
1178         complex&
1179         operator/=(const complex<_Tp>& __z)
1180         {
1181           _ComplexT __t;
1182           __real__ __t = __z.real();
1183           __imag__ __t = __z.imag();
1184           _M_value /= __t;
1185           return *this;
1186         }
1187
1188       _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1189
1190     private:
1191       _ComplexT _M_value;
1192     };
1193
1194   /// 26.2.3  complex specializations
1195   /// complex<double> specialization
1196   template<>
1197     struct complex<double>
1198     {
1199       typedef double value_type;
1200       typedef __complex__ double _ComplexT;
1201
1202       _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1203
1204       _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0)
1205 #if __cplusplus >= 201103L
1206       : _M_value{ __r, __i } { }
1207 #else
1208       {
1209         __real__ _M_value = __r;
1210         __imag__ _M_value = __i;
1211       }
1212 #endif
1213
1214       _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1215       : _M_value(__z.__rep()) { }
1216
1217       explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1218
1219 #if __cplusplus >= 201103L
1220       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1221       // DR 387. std::complex over-encapsulated.
1222       __attribute ((__abi_tag__ ("cxx11")))
1223       constexpr double
1224       real() const { return __real__ _M_value; }
1225
1226       __attribute ((__abi_tag__ ("cxx11")))
1227       constexpr double
1228       imag() const { return __imag__ _M_value; }
1229 #else
1230       double&
1231       real() { return __real__ _M_value; }
1232
1233       const double&
1234       real() const { return __real__ _M_value; }
1235
1236       double&
1237       imag() { return __imag__ _M_value; }
1238
1239       const double&
1240       imag() const { return __imag__ _M_value; }
1241 #endif
1242
1243       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1244       // DR 387. std::complex over-encapsulated.
1245       void
1246       real(double __val) { __real__ _M_value = __val; }
1247
1248       void
1249       imag(double __val) { __imag__ _M_value = __val; }
1250
1251       complex&
1252       operator=(double __d)
1253       {
1254         _M_value = __d;
1255         return *this;
1256       }
1257
1258       complex&
1259       operator+=(double __d)
1260       {
1261         _M_value += __d;
1262         return *this;
1263       }
1264
1265       complex&
1266       operator-=(double __d)
1267       {
1268         _M_value -= __d;
1269         return *this;
1270       }
1271
1272       complex&
1273       operator*=(double __d)
1274       {
1275         _M_value *= __d;
1276         return *this;
1277       }
1278
1279       complex&
1280       operator/=(double __d)
1281       {
1282         _M_value /= __d;
1283         return *this;
1284       }
1285
1286       // The compiler will synthesize this, efficiently.
1287       // complex& operator=(const complex&);
1288
1289       template<typename _Tp>
1290         complex&
1291         operator=(const complex<_Tp>& __z)
1292         {
1293           __real__ _M_value = __z.real();
1294           __imag__ _M_value = __z.imag();
1295           return *this;
1296         }
1297
1298       template<typename _Tp>
1299         complex&
1300         operator+=(const complex<_Tp>& __z)
1301         {
1302           __real__ _M_value += __z.real();
1303           __imag__ _M_value += __z.imag();
1304           return *this;
1305         }
1306
1307       template<typename _Tp>
1308         complex&
1309         operator-=(const complex<_Tp>& __z)
1310         {
1311           __real__ _M_value -= __z.real();
1312           __imag__ _M_value -= __z.imag();
1313           return *this;
1314         }
1315
1316       template<typename _Tp>
1317         complex&
1318         operator*=(const complex<_Tp>& __z)
1319         {
1320           _ComplexT __t;
1321           __real__ __t = __z.real();
1322           __imag__ __t = __z.imag();
1323           _M_value *= __t;
1324           return *this;
1325         }
1326
1327       template<typename _Tp>
1328         complex&
1329         operator/=(const complex<_Tp>& __z)
1330         {
1331           _ComplexT __t;
1332           __real__ __t = __z.real();
1333           __imag__ __t = __z.imag();
1334           _M_value /= __t;
1335           return *this;
1336         }
1337
1338       _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1339
1340     private:
1341       _ComplexT _M_value;
1342     };
1343
1344   /// 26.2.3  complex specializations
1345   /// complex<long double> specialization
1346   template<>
1347     struct complex<long double>
1348     {
1349       typedef long double value_type;
1350       typedef __complex__ long double _ComplexT;
1351
1352       _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1353
1354       _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L,
1355                                  long double __i = 0.0L)
1356 #if __cplusplus >= 201103L
1357       : _M_value{ __r, __i } { }
1358 #else
1359       {
1360         __real__ _M_value = __r;
1361         __imag__ _M_value = __i;
1362       }
1363 #endif
1364
1365       _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1366       : _M_value(__z.__rep()) { }
1367
1368       _GLIBCXX_CONSTEXPR complex(const complex<double>& __z)
1369       : _M_value(__z.__rep()) { }
1370
1371 #if __cplusplus >= 201103L
1372       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1373       // DR 387. std::complex over-encapsulated.
1374       __attribute ((__abi_tag__ ("cxx11")))
1375       constexpr long double
1376       real() const { return __real__ _M_value; }
1377
1378       __attribute ((__abi_tag__ ("cxx11")))
1379       constexpr long double
1380       imag() const { return __imag__ _M_value; }
1381 #else
1382       long double&
1383       real() { return __real__ _M_value; }
1384
1385       const long double&
1386       real() const { return __real__ _M_value; }
1387
1388       long double&
1389       imag() { return __imag__ _M_value; }
1390
1391       const long double&
1392       imag() const { return __imag__ _M_value; }
1393 #endif
1394
1395       // _GLIBCXX_RESOLVE_LIB_DEFECTS
1396       // DR 387. std::complex over-encapsulated.
1397       void
1398       real(long double __val) { __real__ _M_value = __val; }
1399
1400       void
1401       imag(long double __val) { __imag__ _M_value = __val; }
1402
1403       complex&
1404       operator=(long double __r)
1405       {
1406         _M_value = __r;
1407         return *this;
1408       }
1409
1410       complex&
1411       operator+=(long double __r)
1412       {
1413         _M_value += __r;
1414         return *this;
1415       }
1416
1417       complex&
1418       operator-=(long double __r)
1419       {
1420         _M_value -= __r;
1421         return *this;
1422       }
1423
1424       complex&
1425       operator*=(long double __r)
1426       {
1427         _M_value *= __r;
1428         return *this;
1429       }
1430
1431       complex&
1432       operator/=(long double __r)
1433       {
1434         _M_value /= __r;
1435         return *this;
1436       }
1437
1438       // The compiler knows how to do this efficiently
1439       // complex& operator=(const complex&);
1440
1441       template<typename _Tp>
1442         complex&
1443         operator=(const complex<_Tp>& __z)
1444         {
1445           __real__ _M_value = __z.real();
1446           __imag__ _M_value = __z.imag();
1447           return *this;
1448         }
1449
1450       template<typename _Tp>
1451         complex&
1452         operator+=(const complex<_Tp>& __z)
1453         {
1454           __real__ _M_value += __z.real();
1455           __imag__ _M_value += __z.imag();
1456           return *this;
1457         }
1458
1459       template<typename _Tp>
1460         complex&
1461         operator-=(const complex<_Tp>& __z)
1462         {
1463           __real__ _M_value -= __z.real();
1464           __imag__ _M_value -= __z.imag();
1465           return *this;
1466         }
1467
1468       template<typename _Tp>
1469         complex&
1470         operator*=(const complex<_Tp>& __z)
1471         {
1472           _ComplexT __t;
1473           __real__ __t = __z.real();
1474           __imag__ __t = __z.imag();
1475           _M_value *= __t;
1476           return *this;
1477         }
1478
1479       template<typename _Tp>
1480         complex&
1481         operator/=(const complex<_Tp>& __z)
1482         {
1483           _ComplexT __t;
1484           __real__ __t = __z.real();
1485           __imag__ __t = __z.imag();
1486           _M_value /= __t;
1487           return *this;
1488         }
1489
1490       _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1491
1492     private:
1493       _ComplexT _M_value;
1494     };
1495
1496   // These bits have to be at the end of this file, so that the
1497   // specializations have all been defined.
1498   inline _GLIBCXX_CONSTEXPR
1499   complex<float>::complex(const complex<double>& __z)
1500   : _M_value(__z.__rep()) { }
1501
1502   inline _GLIBCXX_CONSTEXPR
1503   complex<float>::complex(const complex<long double>& __z)
1504   : _M_value(__z.__rep()) { }
1505
1506   inline _GLIBCXX_CONSTEXPR
1507   complex<double>::complex(const complex<long double>& __z)
1508   : _M_value(__z.__rep()) { }
1509
1510   // Inhibit implicit instantiations for required instantiations,
1511   // which are defined via explicit instantiations elsewhere.
1512   // NB:  This syntax is a GNU extension.
1513 #if _GLIBCXX_EXTERN_TEMPLATE
1514   extern template istream& operator>>(istream&, complex<float>&);
1515   extern template ostream& operator<<(ostream&, const complex<float>&);
1516   extern template istream& operator>>(istream&, complex<double>&);
1517   extern template ostream& operator<<(ostream&, const complex<double>&);
1518   extern template istream& operator>>(istream&, complex<long double>&);
1519   extern template ostream& operator<<(ostream&, const complex<long double>&);
1520
1521 #ifdef _GLIBCXX_USE_WCHAR_T
1522   extern template wistream& operator>>(wistream&, complex<float>&);
1523   extern template wostream& operator<<(wostream&, const complex<float>&);
1524   extern template wistream& operator>>(wistream&, complex<double>&);
1525   extern template wostream& operator<<(wostream&, const complex<double>&);
1526   extern template wistream& operator>>(wistream&, complex<long double>&);
1527   extern template wostream& operator<<(wostream&, const complex<long double>&);
1528 #endif
1529 #endif
1530
1531   // @} group complex_numbers
1532
1533 _GLIBCXX_END_NAMESPACE_VERSION
1534 } // namespace
1535
1536 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
1537 {
1538 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1539
1540   // See ext/type_traits.h for the primary template.
1541   template<typename _Tp, typename _Up>
1542     struct __promote_2<std::complex<_Tp>, _Up>
1543     {
1544     public:
1545       typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1546     };
1547
1548   template<typename _Tp, typename _Up>
1549     struct __promote_2<_Tp, std::complex<_Up> >
1550     {
1551     public:
1552       typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1553     };
1554
1555   template<typename _Tp, typename _Up>
1556     struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
1557     {
1558     public:
1559       typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1560     };
1561
1562 _GLIBCXX_END_NAMESPACE_VERSION
1563 } // namespace
1564
1565 #if __cplusplus >= 201103L
1566
1567 namespace std _GLIBCXX_VISIBILITY(default)
1568 {
1569 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1570
1571   // Forward declarations.
1572   template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
1573   template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
1574   template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
1575
1576   template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
1577   template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
1578   template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
1579   // DR 595.
1580   template<typename _Tp> _Tp               fabs(const std::complex<_Tp>&);
1581
1582   template<typename _Tp>
1583     inline std::complex<_Tp>
1584     __complex_acos(const std::complex<_Tp>& __z)
1585     {
1586       const std::complex<_Tp> __t = std::asin(__z);
1587       const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
1588       return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
1589     }
1590
1591 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1592   inline __complex__ float
1593   __complex_acos(__complex__ float __z)
1594   { return __builtin_cacosf(__z); }
1595
1596   inline __complex__ double
1597   __complex_acos(__complex__ double __z)
1598   { return __builtin_cacos(__z); }
1599
1600   inline __complex__ long double
1601   __complex_acos(const __complex__ long double& __z)
1602   { return __builtin_cacosl(__z); }
1603
1604   template<typename _Tp>
1605     inline std::complex<_Tp>
1606     acos(const std::complex<_Tp>& __z)
1607     { return __complex_acos(__z.__rep()); }
1608 #else
1609   /// acos(__z) [8.1.2].
1610   //  Effects:  Behaves the same as C99 function cacos, defined
1611   //            in subclause 7.3.5.1.
1612   template<typename _Tp>
1613     inline std::complex<_Tp>
1614     acos(const std::complex<_Tp>& __z)
1615     { return __complex_acos(__z); }
1616 #endif
1617
1618   template<typename _Tp>
1619     inline std::complex<_Tp>
1620     __complex_asin(const std::complex<_Tp>& __z)
1621     {
1622       std::complex<_Tp> __t(-__z.imag(), __z.real());
1623       __t = std::asinh(__t);
1624       return std::complex<_Tp>(__t.imag(), -__t.real());
1625     }
1626
1627 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1628   inline __complex__ float
1629   __complex_asin(__complex__ float __z)
1630   { return __builtin_casinf(__z); }
1631
1632   inline __complex__ double
1633   __complex_asin(__complex__ double __z)
1634   { return __builtin_casin(__z); }
1635
1636   inline __complex__ long double
1637   __complex_asin(const __complex__ long double& __z)
1638   { return __builtin_casinl(__z); }
1639
1640   template<typename _Tp>
1641     inline std::complex<_Tp>
1642     asin(const std::complex<_Tp>& __z)
1643     { return __complex_asin(__z.__rep()); }
1644 #else
1645   /// asin(__z) [8.1.3].
1646   //  Effects:  Behaves the same as C99 function casin, defined
1647   //            in subclause 7.3.5.2.
1648   template<typename _Tp>
1649     inline std::complex<_Tp>
1650     asin(const std::complex<_Tp>& __z)
1651     { return __complex_asin(__z); }
1652 #endif
1653
1654   template<typename _Tp>
1655     std::complex<_Tp>
1656     __complex_atan(const std::complex<_Tp>& __z)
1657     {
1658       const _Tp __r2 = __z.real() * __z.real();
1659       const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
1660
1661       _Tp __num = __z.imag() + _Tp(1.0);
1662       _Tp __den = __z.imag() - _Tp(1.0);
1663
1664       __num = __r2 + __num * __num;
1665       __den = __r2 + __den * __den;
1666
1667       return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
1668                                _Tp(0.25) * log(__num / __den));
1669     }
1670
1671 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1672   inline __complex__ float
1673   __complex_atan(__complex__ float __z)
1674   { return __builtin_catanf(__z); }
1675
1676   inline __complex__ double
1677   __complex_atan(__complex__ double __z)
1678   { return __builtin_catan(__z); }
1679
1680   inline __complex__ long double
1681   __complex_atan(const __complex__ long double& __z)
1682   { return __builtin_catanl(__z); }
1683
1684   template<typename _Tp>
1685     inline std::complex<_Tp>
1686     atan(const std::complex<_Tp>& __z)
1687     { return __complex_atan(__z.__rep()); }
1688 #else
1689   /// atan(__z) [8.1.4].
1690   //  Effects:  Behaves the same as C99 function catan, defined
1691   //            in subclause 7.3.5.3.
1692   template<typename _Tp>
1693     inline std::complex<_Tp>
1694     atan(const std::complex<_Tp>& __z)
1695     { return __complex_atan(__z); }
1696 #endif
1697
1698   template<typename _Tp>
1699     std::complex<_Tp>
1700     __complex_acosh(const std::complex<_Tp>& __z)
1701     {
1702       // Kahan's formula.
1703       return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
1704                                  + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
1705     }
1706
1707 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1708   inline __complex__ float
1709   __complex_acosh(__complex__ float __z)
1710   { return __builtin_cacoshf(__z); }
1711
1712   inline __complex__ double
1713   __complex_acosh(__complex__ double __z)
1714   { return __builtin_cacosh(__z); }
1715
1716   inline __complex__ long double
1717   __complex_acosh(const __complex__ long double& __z)
1718   { return __builtin_cacoshl(__z); }
1719
1720   template<typename _Tp>
1721     inline std::complex<_Tp>
1722     acosh(const std::complex<_Tp>& __z)
1723     { return __complex_acosh(__z.__rep()); }
1724 #else
1725   /// acosh(__z) [8.1.5].
1726   //  Effects:  Behaves the same as C99 function cacosh, defined
1727   //            in subclause 7.3.6.1.
1728   template<typename _Tp>
1729     inline std::complex<_Tp>
1730     acosh(const std::complex<_Tp>& __z)
1731     { return __complex_acosh(__z); }
1732 #endif
1733
1734   template<typename _Tp>
1735     std::complex<_Tp>
1736     __complex_asinh(const std::complex<_Tp>& __z)
1737     {
1738       std::complex<_Tp> __t((__z.real() - __z.imag())
1739                             * (__z.real() + __z.imag()) + _Tp(1.0),
1740                             _Tp(2.0) * __z.real() * __z.imag());
1741       __t = std::sqrt(__t);
1742
1743       return std::log(__t + __z);
1744     }
1745
1746 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1747   inline __complex__ float
1748   __complex_asinh(__complex__ float __z)
1749   { return __builtin_casinhf(__z); }
1750
1751   inline __complex__ double
1752   __complex_asinh(__complex__ double __z)
1753   { return __builtin_casinh(__z); }
1754
1755   inline __complex__ long double
1756   __complex_asinh(const __complex__ long double& __z)
1757   { return __builtin_casinhl(__z); }
1758
1759   template<typename _Tp>
1760     inline std::complex<_Tp>
1761     asinh(const std::complex<_Tp>& __z)
1762     { return __complex_asinh(__z.__rep()); }
1763 #else
1764   /// asinh(__z) [8.1.6].
1765   //  Effects:  Behaves the same as C99 function casin, defined
1766   //            in subclause 7.3.6.2.
1767   template<typename _Tp>
1768     inline std::complex<_Tp>
1769     asinh(const std::complex<_Tp>& __z)
1770     { return __complex_asinh(__z); }
1771 #endif
1772
1773   template<typename _Tp>
1774     std::complex<_Tp>
1775     __complex_atanh(const std::complex<_Tp>& __z)
1776     {
1777       const _Tp __i2 = __z.imag() * __z.imag();
1778       const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
1779
1780       _Tp __num = _Tp(1.0) + __z.real();
1781       _Tp __den = _Tp(1.0) - __z.real();
1782
1783       __num = __i2 + __num * __num;
1784       __den = __i2 + __den * __den;
1785
1786       return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
1787                                _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
1788     }
1789
1790 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1791   inline __complex__ float
1792   __complex_atanh(__complex__ float __z)
1793   { return __builtin_catanhf(__z); }
1794
1795   inline __complex__ double
1796   __complex_atanh(__complex__ double __z)
1797   { return __builtin_catanh(__z); }
1798
1799   inline __complex__ long double
1800   __complex_atanh(const __complex__ long double& __z)
1801   { return __builtin_catanhl(__z); }
1802
1803   template<typename _Tp>
1804     inline std::complex<_Tp>
1805     atanh(const std::complex<_Tp>& __z)
1806     { return __complex_atanh(__z.__rep()); }
1807 #else
1808   /// atanh(__z) [8.1.7].
1809   //  Effects:  Behaves the same as C99 function catanh, defined
1810   //            in subclause 7.3.6.3.
1811   template<typename _Tp>
1812     inline std::complex<_Tp>
1813     atanh(const std::complex<_Tp>& __z)
1814     { return __complex_atanh(__z); }
1815 #endif
1816
1817   template<typename _Tp>
1818     inline _Tp
1819     /// fabs(__z) [8.1.8].
1820     //  Effects:  Behaves the same as C99 function cabs, defined
1821     //            in subclause 7.3.8.1.
1822     fabs(const std::complex<_Tp>& __z)
1823     { return std::abs(__z); }
1824
1825   /// Additional overloads [8.1.9].
1826   template<typename _Tp>
1827     inline typename __gnu_cxx::__promote<_Tp>::__type
1828     arg(_Tp __x)
1829     {
1830       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1831 #if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
1832       return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
1833                                : __type();
1834 #else
1835       return std::arg(std::complex<__type>(__x));
1836 #endif
1837     }
1838
1839   template<typename _Tp>
1840     inline typename __gnu_cxx::__promote<_Tp>::__type
1841     imag(_Tp)
1842     { return _Tp(); }
1843
1844   template<typename _Tp>
1845     inline typename __gnu_cxx::__promote<_Tp>::__type
1846     norm(_Tp __x)
1847     {
1848       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1849       return __type(__x) * __type(__x);
1850     }
1851
1852   template<typename _Tp>
1853     inline typename __gnu_cxx::__promote<_Tp>::__type
1854     real(_Tp __x)
1855     { return __x; }
1856
1857   template<typename _Tp, typename _Up>
1858     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1859     pow(const std::complex<_Tp>& __x, const _Up& __y)
1860     {
1861       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1862       return std::pow(std::complex<__type>(__x), __type(__y));
1863     }
1864
1865   template<typename _Tp, typename _Up>
1866     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1867     pow(const _Tp& __x, const std::complex<_Up>& __y)
1868     {
1869       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1870       return std::pow(__type(__x), std::complex<__type>(__y));
1871     }
1872
1873   template<typename _Tp, typename _Up>
1874     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1875     pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
1876     {
1877       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1878       return std::pow(std::complex<__type>(__x),
1879                       std::complex<__type>(__y));
1880     }
1881
1882   // Forward declarations.
1883   // DR 781.
1884   template<typename _Tp> std::complex<_Tp> proj(const std::complex<_Tp>&);
1885
1886   template<typename _Tp>
1887     std::complex<_Tp>
1888     __complex_proj(const std::complex<_Tp>& __z)
1889     {
1890       const _Tp __den = (__z.real() * __z.real()
1891                          + __z.imag() * __z.imag() + _Tp(1.0));
1892
1893       return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den,
1894                                (_Tp(2.0) * __z.imag()) / __den);
1895     }
1896
1897 #if _GLIBCXX_USE_C99_COMPLEX
1898   inline __complex__ float
1899   __complex_proj(__complex__ float __z)
1900   { return __builtin_cprojf(__z); }
1901
1902   inline __complex__ double
1903   __complex_proj(__complex__ double __z)
1904   { return __builtin_cproj(__z); }
1905
1906   inline __complex__ long double
1907   __complex_proj(const __complex__ long double& __z)
1908   { return __builtin_cprojl(__z); }
1909
1910   template<typename _Tp>
1911     inline std::complex<_Tp>
1912     proj(const std::complex<_Tp>& __z)
1913     { return __complex_proj(__z.__rep()); }
1914 #else
1915   template<typename _Tp>
1916     inline std::complex<_Tp>
1917     proj(const std::complex<_Tp>& __z)
1918     { return __complex_proj(__z); }
1919 #endif
1920
1921   // DR 1137.
1922   template<typename _Tp>
1923     inline typename __gnu_cxx::__promote<_Tp>::__type
1924     proj(_Tp __x)
1925     { return __x; }
1926
1927   template<typename _Tp>
1928     inline typename __gnu_cxx::__promote<_Tp>::__type
1929     conj(_Tp __x)
1930     { return __x; }
1931
1932 #if __cplusplus > 201103L
1933
1934 inline namespace literals {
1935 inline namespace complex_literals {
1936
1937 #define __cpp_lib_complex_udls 201309
1938
1939   constexpr std::complex<float>
1940   operator""if(long double __num)
1941   { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
1942
1943   constexpr std::complex<float>
1944   operator""if(unsigned long long __num)
1945   { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
1946
1947   constexpr std::complex<double>
1948   operator""i(long double __num)
1949   { return std::complex<double>{0.0, static_cast<double>(__num)}; }
1950
1951   constexpr std::complex<double>
1952   operator""i(unsigned long long __num)
1953   { return std::complex<double>{0.0, static_cast<double>(__num)}; }
1954
1955   constexpr std::complex<long double>
1956   operator""il(long double __num)
1957   { return std::complex<long double>{0.0L, __num}; }
1958
1959   constexpr std::complex<long double>
1960   operator""il(unsigned long long __num)
1961   { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }
1962
1963 } // inline namespace complex_literals
1964 } // inline namespace literals
1965
1966 #endif // C++14
1967
1968 _GLIBCXX_END_NAMESPACE_VERSION
1969 } // namespace
1970
1971 #endif  // C++11
1972
1973 #endif  /* _GLIBCXX_COMPLEX */